+Mon Sep 6 22:44:47 1999 Jeffrey A Law (law@cygnus.com)
+
+ * Merge from gcc2 snapshot Jan 9, 1999. See FSFChangeLog for
+ details.
+
Mon Sep 6 22:31:28 1999 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
* c-aux-info.c (concat): Don't define.
(ix86_mark_machine_status): New function.
(override_options): Set mark_machine_status.
+>>>>>>> 1.4290
Mon Sep 6 15:26:23 1999 Bernd Schmidt <bernds@cygnus.co.uk>
* tree.c (copy_node): Copy node contents also if doing GC.
Mon Sep 6 02:42:36 1999 Jeffrey A Law (law@cygnus.com)
+>>>>>>> 1.4287
* collect2.c (scan_libraries): Fix thinko.
* cse.c (delete_trivially_dead_insns): Do not skip the last
+Sat Jan 9 08:19:14 1999 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * toplev.c (rest_of_compilation): Set cse_not_expected earlier.
+
+ * optabs.c (emit_conditional_move): Undo canonicalization previously
+ done by get_condition.
+
+ * jump.c (jump_optimize): Move simple optimizations in front
+ of complex ones.
+ Reset NEXT whenever deleting an insn in case NEXT was deleted.
+ Disable some conditional move optimizations if have
+ conditional arithmetic or if CSE not run yet.
+ Add new optimization to conditionalize code if have conditional
+ arithmetic.
+ (can_reverse_comparison_p): Check REVERSIBLE_CC_MODE.
+ (condjump{,_in_parallel}_p): Simplify.
+
+Thu Jan 7 09:25:51 1999 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * jump.c (delete_computation): Don't trust location of REG_DEAD
+ note within a basic block.
+
+Sat Dec 26 06:31:43 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * cse.c (cse_insn): Always make SET a nop if dest is hard regster and
+ src is equivalent.
+
+ * flow.c (print_rtl_with_bb): Write insns in epilogue delay list.
+
+ * combine.c (simplify_set): Update SET_SRC after force_to_mode call.
+ If HAVE_conditional_arithmetic, make conditional if comparison
+ operator is arg of arithmetic.
+
+ * genconfig.c (have_cond_arith_flag): New variable.
+ (walk_insn_part, case IF_THEN_ELSE): Set it.
+ (main): Define HAVE_conditional_arithmetic if have_cond_arith_flag.
+
+ * reorg.c (optimize_skip): Count insns in delay slots for epilogue
+ as being after a conditional return.
+
+Wed Dec 23 07:30:22 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * mips.md (movdf [mips4]): Remove '=' in constraint when not output.
+
+ * toplev.c (fatal_function): New static variable.
+ (set_fatal_function): New function.
+ (vfatal): If fatal_function nonzero, call it.
+
+Thu Dec 10 07:21:44 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * expr.c (move_by_pieces_1): Give inner arg types of function passed
+ as first operand.
+
+ * aclocal.m4 (GCC_HEADER_INTTYPES, GCC_CHECK_STRINGIFY): New macros.
+ * configure.in: Use them instead of inline text.
+ (malloc.h): Check for presence.
+ (free, malloc, calloc, realloc): Include malloc.h to see if need decl.
+ * system.h (malloc.h): Conditionally include.
+ (free, malloc, calloc, realloc): Conditionally declare.
+ * xm-mn10200.h (free, malloc, realloc, calloc): Remove redundant decls.
+ * xm-mn10300.h, rs6000/xm-sysv4.h, xm-v850.h: Likewise.
+ * xm-alpha.h: Likewise.
+ (string.h): Remove reundant #include.
+ * rtl.h (free): Remove declaration.
+ * tree.h (free): Likewise.
+
+ * gcov.c (fatal): New function.
+
+Wed Dec 9 06:25:12 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * protoize.c: Remove extraneous #endif.
+ Remove redundant declarations and includes.
+ (fatal): New function, from gen*.c.
+
+Wed Dec 9 06:16:26 1998 Craig Burley (burley@gnu.ai.mit.edu)
+
+ * fold-const.c (multiple_of_p): New function.
+ (fold): Turn some cases of *_DIV_EXPR into EXACT_DIV_EXPR.
+
+Wed Dec 9 04:42:23 1998 H.J. Lu (hjl@gnu.ai.mit.edu)
+
+ * expr.h, real.h: Add more prototypes.
+
+Tue Dec 8 06:04:19 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * c-typeck.c (c_expand_asm_operands): Fix text of error message
+ and handle conversion as lvalue.
+
+Mon Dec 7 21:35:31 1998 Paul Eggert <eggert@twinsun.com>
+
+ * dwarf2out.c (dyn-string.h): Fix patching error.
+ * toplev.c (<sys/times.h>): Include if HAVE_SYS_TIMES_H is defined.
+
+Sun Dec 6 01:14:46 1998 Paul Eggert <eggert@twinsun.com>
+
+ * collect2.c (mktemp): Remove unused decl.
+
+Sat Dec 5 21:02:13 1998 Paul Eggert <eggert@twinsun.com>
+
+ * cccp.c (fwrite): New VMS macro.
+ (VMS_fwrite): New VMS function.
+ (strerror): Declare only if NEED_DECLARATION_STRERROR.
+ (warn_white_space): New var.
+ (do_warning): Remove.
+ (directive_table): Use do_error to print warnings.
+ (eprint_string): Remove. All callers now use fwrite instead.
+ (check_white_space): New function.
+ (fatal): Now extern.
+ (main): Add new option --White-space, implied by -Wall.
+ If DEPENDENCIES_OUTPUT has the form `FILE TARGET', have TARGET depend
+ on source file as well as files it includes.
+ (newline_fix, name_newline_fix): Assume that *BP == '\\',
+ but don't assume that BP[1] == '\n'; all callers changed.
+ (rescan): Warn about white space at end of line in string.
+ Fix bug with counting newlines in strings as result of macro-expanding.
+ (expand_to_temp_buffer): Do not stomp on the output buffer length;
+ all callers changed.
+ (handle_directive): No need to check bp < limit if *bp == '\n'.
+ Allocate a larger directive buffer; expand newline to
+ backslash-'n' in string literals.
+ (timestamp): Don't assume that localtime succeeds.
+ (finclude): Add call to check_white_space in included file.
+ (collect_expansion): No need to check for p < limit at backslash.
+ (do_line): Allow nulls in file name.
+ (do_error): Also do warnings.
+ (do_pragma): Handle escapes in strings correctly.
+ (skip_quoted_string): Don't say ``Unterminated string or character''
+ if it's known to be a character.
+ Warn about white space at end of line in string.
+ (struct argdata): New member expand_size.
+ Rename member stringified_length to stringified_length_bound.
+ All uses changed.
+ (macroexpand): Record expand_size separately from expand_length.
+ Generate nothing for backslash-newline in a string.
+ Escape newlines in strings.
+ (macarg): Have macarg1 count newlines. Escape newlines in strings.
+ (macarg1): Skip backslash-newline in strings.
+ (change_newlines): Now takes struct argdata * (not U_CHAR * and int)
+ returns void, not int. Modify the arg in-place.
+ (change_newlines, make_definition): In strings, replace
+ backslash-newline with nothing, and non-backslashed newline
+ with backslash-'n'.
+
+ * cexp.y (fatal): New decl (exported by cccp.c).
+ (yylex): Allow multiple-char constants like 'abcde' that are longer
+ than long; draft C9x requires this. Don't treat (char)-1 like EOF.
+ (parse_escape): Return -2 if backslash-newline is seen.
+ Parse backslash-newline in numeric escapes.
+ Parse \x using unsigned, not signed, for proper overflow detection.
+
+Fri Dec 4 16:24:36 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * Defer some __builtin_constant_p elaborations until after cse;
+ original idea from rth@cygnus.com
+ * rtl.def (CONSTANT_P_RTX): New RTL code.
+ * expr.c (expand_builtin, case BUILT_IN_CONSTANT_P): Rework to
+ consider constant CONSTRUCTOR constant and to defer some cases to cse.
+ * cse.c (fold_rtx, case CONST): Add handling for CONSTANT_P_RTX.
+ * regclass.c (reg_scan_mark_refs, case CONST): Likewise.
+
+Tue Dec 1 09:35:45 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * Makefile.in (C_AND_OBJC_OBJS): Add mbchar.o.
+ (c-lex.o, cexp.o, cccp.o): Depend on mbchar.h.
+ (mbchar.o): New rule.
+ (CCCP_OBJS, CPPMAIN_OBJS): Include mbchar.o.
+ * po/POTFILES.in (mbchar.[ch]): Add.
+
+Tue Dec 1 09:32:27 1998 Dave Brolley <brolley@cygnus.com>
+
+ * mbchar.[ch]: New files for multibyte character handling.
+ * configure.in (enable_c_mbchar): New configure option.
+ * cexp.y (mbchar.h): #include it.
+ (yylex): Handle Multibyte characters in character literals.
+ * cccp.c (mbchar.h): #include it.
+ (main): Set character set based on LANG environment variable.
+ (rescan): Handle multibyte characters in comments.
+ (skip_if_group, validate_else, skip_to_end_of_comment): Likewise.
+ (macarg1, discard_comments): Likewise.
+ (rescan): Handle multibyte characters in string and character literals.
+ (collect_expansion, skip_quoted_string, macroexpand): Likewise.
+ (macarg1, discard_comments, change_newlines): Likewise.
+ * c-lex.c (mbchar.h): #include it.
+ (GET_ENVIRONMENT): New macro.
+ (init_lex): Set character set based on LANG environment variable.
+ (yylex): Handle multibyte characters in character and string literals.
+
+Mon Nov 30 08:25:35 1998 Mark Mitchell <mark@markmitchell.com>
+
+ * dyn-string.h: New file.
+ * dyn-string.c: Likewise.
+ * Makefile.in (OBJS): Add dyn-string.o.
+ (dwarf2out.o): Add dyn-string.h dependency.
+ (dyn-string.o): New rule.
+ * dwarf2out.c (dyn-string.h): Include.
+ (ASM_NAME_TO_STRING): Use dyn_string_append, rather than strcpy.
+ (addr_const_to_string): Take a dyn_string_t, not a char * as a
+ prototype. Use dyn_string_append rather than strcat, throughout.
+ (addr_to_string): Use dyn_string_t.
+
+Mon Nov 30 06:57:49 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * po/POTFILES.in (dyn-string.[ch]): New files.
+
+ * sched.c (swap_sort): Fix typo in last change.
+
+Sun Nov 29 21:02:34 1998 Paul Eggert <eggert@twinsun.com>
+
+ * po/POTFILES.in: Add gengenrtl.c, system.h.
+
+Sun Nov 29 16:36:59 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * expmed.c (emit_store_flag): Don't try to negate STORE_FLAG_VALUE.
+
+ * configure.in: Remove inadvertently added duplicate tests.
+
+ * reload1.c (emit_reload_insns): Fix typos in preserve death note code.
+
+ * Makefile.in (c-lex.o): Depends on $(RTL_H).
+
+ * genattr.c (fatal): No longer static.
+ * genattrtab.c, gencodes.c, genconfig.c, genemit.c: Likewise.
+ * genextract.c, genflags.c, gengenrtl.c, genopinit.c: Likewise.
+ * genoutput.c, genpeep.c, genrecog.c: Likewise.
+
+ * 1750a.c: Use gen_rtx_FOO and GEN_INT, not gen_rtx; include system.h.
+ * a29k.c, alpha.c, arc.c, arm.c, clipper.c, convex.c: Likewise.
+ * dsp16xx.c, fx80.c, gmicro.c, h8300.c, i386.c, i860.c: Likewise.
+ * i960.c, m32r.c, m68k.c, m88k.c, mips.c, mn10200.c: Likewise.
+ * mn10300.c, ns32k.c, pa.c, pdp11.c, pyr.c, romp.c: Likewise.
+ * rs6000.c, sh.c, sparc.c, spur.c, tahoe.c, v850.c: Likewise.
+ * vax.c, we32k.c: Likewise.
+ * elxsi.c, i370.c: Include system.h
+ * gofast.h: Use gen_rtx_FOO and GEN_INT instead of gen_rtx.
+ * 1750a.{md,h}, a29k{md,h}, alpha.{md,h}, alpha/vms.h: Likewise.
+ * arc.{md,h}, arm.{md,h}, clipper.{md,h}, convex.{md,h}: Likewise.
+ * dsp16xx.{md,h}, elxsi.h, fx80.{md,h}, gmicro.{md,h}: Likewise.
+ * h8300.h, i370.{md,h}, i386.{md,h}, i386/cygwin32.h: Likewise.
+ * i386/osfrose.h, i386/win-nt.h, i860.{md,h}, i960.{md,h}: Likewise.
+ * m32r.{md,h}, m68k.{md,h}, m68k/a-ux.h, m68k/crds.h: Likewise.
+ * m68k/isi.h, m68k/linux.h, m68k/lynx.h, m68k/m68kemb.h: Likewise.
+ * m68k/m68kv4.h, m68k/mot3300.h, m68k/news.h, m68k/sun3.h: Likewise.
+ * m88k.{md,h}, mips.{md,h}, mips/abi64.h, mn10200.{md,h}: Likewise.
+ * mn10300.{md,h}, ns32k.{md,h}, pa.{md,h}, pyr.{md,h}: Likewise.
+ * romp.{md,h}, rs6000.{md,h}, sh.{md,h}, sparc.{md.h}: Likewise.
+ * spur{md,h}, tahoe.{md,h}, v850.{md,h}, vax.{md,h}: Likewise.
+ * we32k.{md,h}: Likewise.
+
+Sat Nov 28 19:32:33 1998 Jeffrey A Law (law@cygnus.com)
+
+ * rtl.def (INLINE_HEADER): Fix type error found by gen_rtx_FOO changes.
+
+ * configure.in: If host != build, run autoconf to generate auto
+ build.h for the build machine and include it in build_xm_files.
+
+Sat Nov 28 19:20:06 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * bc-emit.c, caller-save.c, calls.c, combine.c: Call gen_rtx_FOO.
+ * cse.c, dwarf2out.c, emit-rtl.c, except.c, explow.c: Likewise.
+ * expmed.c expr.c, final.c, function.c, genpeep.c, halfpic.c: Likewise.
+ * integrate.c, jump.c, local-alloc.c, loop.c, optabs.c: Likewise.
+ * profile.c, recog.c, reg-stack.c, regclass.c, regmove.c: Likewise.
+ * reload.c, reload1.c, reorg.c, sched.c, stmt.c, stupid.c: Likewise.
+ * unroll.c, varasm.c: Likewise.
+
+ * Makefile.in (*.o): Depend on system.h.
+ * system.h (ANSI_PROTOTYPES): Add definition.
+ * *.c, c-parse.in, cexp.y: Include system.h and delete any
+ non-redundant includes, macro definitions, or declarations.
+ * gen*.c, bc-emit.c, calls.c, cccp.c, combine.c, emit-rtl.c:
+ Use ANSI_PROTOTYPES, not __STDC__ to select varargs vs. stdargs.
+ * gcc.c, mips-tfile.c, prefix.c, toplev.c, tree.c: Likewise.
+ * gen*.c (fatal): Fix error in varargs case.
+ * genattrtab.c (fatal): Make same as other gen programs.
+ * genattrtab.c: Write #include for system.h in output.
+ * genemit.c, genextract.c, genoutput.c, genpeep.c: Likewise.
+ * genrecog.c: Likewise.
+
+Sat Nov 28 06:01:525 1998 John F. Carr <jfc@mit.edu>
+
+ * emit-rtl.c (const_int_rtx): Now array of rtx_def, not rtx.
+
+Sat Nov 28 05:53:45 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * rtl.h (obstack_alloc_rtx): New declaration.
+ * rtl.c (rtx_alloc): Try to clear as integer or HOST_WIDE_INT indirect.
+ (obstack_alloc_rtx): New function.
+
+Sat Nov 28 05:46:41 1998 Richard Henderson <rth@cygnus.com>
+
+ * gengenrtl.c: New file.
+ * Makefile.in (OBJS): Add genrtl.c.
+ (GEN): Add gengenrtl.
+ (STAGESTUFF): Add s-genrtl and gengenrtl$(exeext);
+ (RTL_BASE_H): New, from RTL_H.
+ (RTL_H): Contains RTL_BASE_H and genrtl.h
+ (genrtl.o, genrtl.c, s-genrtl, gengenrtl): New rules.
+ * emit-rtl.c (gen_rtx_{CONST_INT,REG,MEM}): New functions.
+ (gen_rtx): Call them.
+ * genemit.c (gen_exp, gen_insn): Call gen_rtx_FOO for constant FOO.
+ * rtl.h (genrtl.h): Include ifndef NO_GENRTL_H.
+ (gen_rtx_{CONST_INT,REG,MEM}): New declarations.
+ (GEN_INT): Call gen_rtx_CONST_INT.
+
+Fri Nov 27 20:16:12 1998 Michael Meissner <meissner@cygnus.com>
+
+ * configure.in (AC_CHECK_FUNCS): Check for strchr and strrchr.
+
+Fri Nov 27 20:13:36 1998 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * system.h: New file.
+
+ * configure.in (AC_CHECK_FUNCS): Remove check for vprintf.
+ Add check for isascii and strsignal.
+ Collapse multiple calls.
+ (GCC_NEED_DECLARATIONS): Likewise, from GCC_NEED_DECLARATION.
+ Check for bcopy, bcmp, bzero, strerror, atof, getcwd,
+ strsignal and getwd.
+ Add checks for getrlimit and setrlimit; search in sys/resource.h.
+ (GCC_FUNC_PRINTF_PTR, GCC_C_VOLATILE, GCC_FUNC_VFPRINTF_DOPRNT): Call.
+ (GCC_HEADER_STRING, AC_FUNC_VFORK, AC_HEADER_SYS_WAIT): Likewise.
+
+ * acconfig.h (NEED_DECLARATION_{STRERROR,GETCWD,GETWD,BZERO}: Add.
+ (NEED_DECLARATION_{{G,S}ETRLIMIT,STRSIGNAL,BCOPY,BCMP}): Likewise.
+ (STRING_WITH_STRINGS, HAVE_VOLATILE, HOST_PTR_PRINTF): Likewise.
+
+ * aclocal.m4 (GCC_NEED_DECLARATION): Accept optional second arg.
+ Test STRING_WITH_STRINGS when deciding which headers to search for
+ function declarations.
+ (GCC_NEED_DECLARATIONS, GCC_HEADER_STRING): New autoconf test.
+ (GCC_FUNC_{VFPRINTF_DOPRNT,PRINTF_PTR}, GCC_C_VOLATILE): Likewise.
+
+Fri Nov 27 20:10:42 1998 Richard Henderson <rth@cygnus.com>
+
+ * configure.in: Add cpp stringify test.
+ (AC_CHECK_FUNCS): Check for sbrk.
+ * acconfig.h (HAVE_CPP_STRINGIFY): New tag.
+
+Fri Nov 27 20:09:27 1998 Manfred Hollstein <manfred@s-direktnet.de>
+
+ * configure.in (AC_CHECK_FUNCS): Check for getrlimit and setrlimit.
+
+Fri Nov 27 19:48:27 1998 Jeffrey A Law <law@cygnus.com>
+
+ * configure.in (AC_CHECK_FUNCS): Add gettimeofday, atoq, atoll,
+ strerror, stroul, abort and bsearch.
+ * acconfig.h (NEED_DECLARATION_{ATOL,ABORT}): New tags.
+
+Fri Nov 27 19:46:09 1998 Jim Wilson <wilson@cygnus.com>
+
+ * acconfig.h (HAVE_INTTYPES_H): New tag.
+ * configure.in (inttypes.h): Check for conflicts between sys/types.h
+ and inttypes.h and verify that intmax_t is defined.
+
+Fri Nov 27 08:07:53 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * alpha.c (sext_add_operand): Use reg_not_elim_operand.
+ (reg_not_elim_or_8bit_operand): New function.
+ * alpha.h (PREDICATE_CODE): Add new entry and alphabetize.
+ * alpha.md (mult patterns): Ensure eliminable reg not any input.
+
+ * Makefile.in (STAGESTUFF): Remove s-ver.
+ (s-ver): Remove rule and revert back to version.c as target.
+
+Fri Nov 27 02:39:36 1998 Paul Eggert <eggert@twinsun.com>
+
+ * cccp.c (main): Make `-I -' equivalent to `-I-'.
+
+Fri Nov 27 02:39:36 1998 Sam Kendall <kendall@init.com>
+
+ * cccp.c (main): Avoid `++i' and `i' in same expression.
+
+Thu Nov 26 19:42:02 1998 Stephen L Moshier <moshier@mediaone.net>
+
+ * real.c (ereal_atof): New function for hexadecimal floating constants.
+ * real.h (REAL_VALUE_HTOF): New macro for hex float conversion.
+ * c-lex.c (yylex): Use it and check syntax of hex floats.
+ * fold-const.c (real_hex_to_f): New function reads hex float
+ if no REAL_ARITHMETIC.
+
+Thu Nov 26 18:51:51 1998 Richard Henderson <rth@cygnus.com>
+
+ * alpha.c (reg_not_elim_operand): New function.
+ * alpha.h (PREDICATE_CODES): Add it.
+ * alpha.md: Remove reload-only patterns for (plus (plus (mult ...))).
+ (s[48]{add,sub}q): Use new function as predicate for multiplicand.
+
+Thu Nov 26 09:13:35 1998 Hans Cappelle <cappelle@imec.be>
+
+ * reorg.c (fill_simple_delay_slots): Fix typo in sets_cc0_p call.
+
+Thu Nov 26 06:15:46 1998 Paul Edwards <avon@matra.com.au>
+
+ * genattr.c (fatal): Use vprintf if available.
+ * genattrtab.c, gencodes.c, genconfig.c, genemit.c: Likewise.
+ * genextract.c, genflags.c, genopinit.c, genoutput.c: Likewise.
+ * genpeep.c: Likewise.
+
+Wed Nov 25 08:02:23 1998 Ken Raeburn <raeburn@cygnus.com>
+
+ * Makefile.in (version.c): Truncate tmp-version.c when writing to
+ it, instead of appending. Use timestamp file s-ver to prevent
+ repeated rebuilding of file with unchanged contents.
+ (STAGESTUFF): Add s-ver.
+
+Wed Nov 25 07:53:24 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * reload.h (form_sum): Add new parm, DIFF_P.
+ * reload.c (form_sum): Likewise.
+ (subst_indexed_address): Call it with new parm.
+ * reload1.c (eliminate_regs, case MINUS): Make common with PLUS.
+ (eliminate_regs_in_insn): Re-recognize if was MINUS.
+ * alpha.md: Add patterns for (plus (minus (mult ..) ...) ...).
+
+ * libgcc2.c (__bb_init_prg): Avoid use of bzero.
+
+ * combine.c (make_extraction): Make extraction even if may
+ span if INNER is not MEM.
+
+Wed Nov 25 07:30:28 1998 David Addison <addy@quadrics.com>
+
+ * sparc.h (SPARC_INCOMING_INT_ARG_FIRST): Respect TARGET_FLAT.
+
+Mon Nov 23 07:00:57 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * function.c (purge_addressof_1): If validate_change fails, try
+ validate_replace_rtx.
+
+ * expr.c (expand_expr, case ADDR_EXPR): Non-constant can be ADDRESSOF.
+
+ * expr.c (store_constructor_{,field}): New parameter ALIGN and
+ use it when making recursive calls and clearing memory.
+ (expand_expr, case CONSTRUCTOR): Call with new parameter.
+
+ * mips/abi64.h (FUNCTION_ARG_PASS_BY_REFERENCE): Remove ABI_EABI test.
+ * mips.c (function_arg_pass_by_reference): Return 1 if would
+ otherwise pass both in registers and on stack.
+
+Fri Nov 13 06:56:24 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * alpha/vms.h (struct avms_arg_info): Use int for num_args.
+
+Mon Nov 2 07:35:26 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * sched.c ({true,anti,output}_dependence): Volatile conflicts with
+ anything where MEM_IN_STRUCT_P doesn't match.
+
+Fri Oct 30 14:05:32 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * expr.c (struct move_by_pieces): New fields {to,from}_readonly.
+ (move_by_pieces): Initialize them.
+ (move_by_pieces_1): Use them.
+
+
+Sun Oct 25 06:12:33 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * optabs.c (emit_no_conflict_block): Allow insn of just USE or SET.
+
+ * explow.c (allocate_dynamic_stack_space): If operand 1 has VOIDmode,
+ use Pmode.
+
+ * configure.in (AC_CHECK_HEADERS): Fix typo with sys/stat.h.
+
+ * Makefile.in (config.status): Use $(srcdir) for configure.
+
+ * sparc.md (*sethi_di_medium_pic): Add CLOBBER of register 1.
+
+ * x-alpha (CLIB): Add -lexc.
+
+ * i386/mingw32.h (OUTPUT_QUOTED_STRING): Don't use Cygwin format
+ for drive letter.
+
+ * cccp.c (handle_directive): Complete support for #undef when -dM.
+
+ * configure.in (alpha*-*-vxworks*): Set MASK_SUPPORT_ARCH from host.
+
+ * m68k.md (adddi3, subdi3, anddi3, iordi3, xordi3): Use split_double.
+
+Sat Oct 24 13:41:06 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * local-alloc.c (alloc_qty_for_scratch, requires_inout): Allow
+ matching up to operand number 9.
+ * recog.c (constrain_operands): Likewise.
+ * reg-stack.c (constrain_asm_operands): Likewise.
+ * regclass.c (record_reg_classes): Likewise.
+ * regmove.c (find_matches): Likewise.
+ * reload.c (find_reloads): Likewise.
+ * reload1.c (reload_cse_simplify_operands): Likewise.
+
+Sat Oct 24 09:27:30 1998 David Edelsohn <edelsohn@mhpcc.edu>
+
+ * regclass.c (record_reg_classes): Skip modifiers when looking
+ for constraint that just matches a previous operand.
+ Initialize classes[i] before handling matching operand.
+
+Fri Oct 23 07:05:52 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * fold-const.c (fold_range_test, fold): Use global_bindings_p,
+ not checking current_function_decl, to see if in function.
+
+Mon Oct 12 06:21:08 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * function.c (gen_mem_addressof): Copy REG_USERVAR_P to new reg.
+
+Sun Oct 11 14:40:24 1998 Ken Raeburn <raeburn@cygnus.com>
+
+ * calls.c (store_one_arg): Use ARGS_SIZE_RTX to get size of argument
+ when emitting chkr_set_right_libfunc call.
+
+Mon Oct 5 18:28:33 1998 Hans-Peter Nilsson <hp@axis.se>
+
+ * Makefile.in (version.c): Apply basename when using VERSION_DEP.
+
+Mon Oct 5 18:08:31 1998 Ken Raeburn <raeburn@cygnus.com>
+
+ * rs6000.c (rs6000_stack_info): Remove extra paren.
+ (print_operand): Cast -1 to HOST_WIDE_INT before shifting it.
+ * optabs.c (init_optabs): Create Checker symbols in Pmode.
+
+Mon Oct 5 06:23:27 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * function.c (purge_addressof_1): Add new parm IN_DEST.
+ If have different modes and IN_DEST, try making STRICT_LOW_PART.
+
+ * regmove.c (regmove_profitable_p): Put obfree at right place.
+
+Sun Oct 4 08:37:36 1998 Paul Edwards <avon@matra.com.au>
+
+ * configure.in (AC_CHECK_HEADERS): Add sys/types.h and sys/stat.h.
+ * gcc.c (sys/types.h, sys/stat.h): Only include if exist.
+ * cccp.c, toplev.c: Likewise.
+
+Sun Oct 4 07:11:34 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.eu>
+
+ * calls.c (expand_call): Don't call emit_group_store if target
+ is the same as VALREG.
+
+ * loop.c (strength_reduce): Track maybe_multiple on giv scan.
+ (find_mem_givs, record_giv): New argument maybe_multiple.
+
+ * reorg.c (fill_{simple,eager}_delay_slots): If insn no longer needs
+ delay slots, just skip instead of aborting.
+
+Sat Oct 3 08:04:28 1998 Ken Raeburn <raeburn@cygnus.com>
+
+ * tree.h (DECL_NO_CHECK_MEMORY_USAGE): New macro.
+ (struct tree_decl): New field no_check_memory_usage.
+ * c-common.c (enum attrs): Add A_NO_CHECK_MEMORY_USAGE.
+ (init_attributes): Register it as a new attribute.
+ (decl_attributes): Set flags on functions given that attribute.
+ * c-decl.c (duplicate_decls): Merge new attribute.
+ * expr.h (current_function_check_memory_usage): Declare.
+ * calls.c, expr.c, function.c, stmt.c: Replace uses of
+ flag_check_memory_usage with current_function_check_memory_usage.
+ * alpha.c, clipper.c, m88k.c, pa.c, sparc.c: Likewise.
+ * function.h (struct function): New field check_memory_usage.
+ * function.c (current_function_check_memory_usage): Define it.
+ (push_function_context_to, pop_function_context_from): Save and
+ restore it.
+ (expand_function_start): Set it, based on global flag and function
+ attribute.
+
+ * expr.c (expand_expr, case VAR_DECL): In memory-checking code, do
+ check non-automatic variables.
+
+Sat Oct 3 07:20:28 1998 Stephen L Moshier <moshier@world.std.com>
+
+ * emit-rtl.c (gen_lowpart_common): Disable optimization of
+ initialized float-int union if the value is a NaN.
+
+Sat Oct 3 06:58:53 1998 David Edelsohn <edelsohn@mhpcc.edu>
+
+ * rs6000.h (ASM_OUTPUT_ADDR_DIFF_ELT): Remove extraneous parameter.
+
+Sat Oct 3 06:53:43 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * regmove.c (regmove_profitable_p): Free allocated mem if we return 1.
+
+ * rs6000.h (CPP_PREDEFINES): Add -D_LONG_LONG.
+
+Fri Oct 2 11:02:41 1998 Klaus Espenlaub <kespenla@student.informatik.uni-ulm.de>
+
+ * Makefile.in (stmp-fixinc, stmp-fixproto, install-multilib):
+ Fix directory permissions.
+ * objc/Makefile.in (copy-headers): Likewise.
+
+Fri Oct 2 10:39:08 1998 Hans-Peter Nilsson <hp@axis.se>
+
+ * expr.c (expand_expr, case CONSTRUCTOR): Change ">" to ">="
+ making MOVE_RATIO use consistent.
+
+Fri Oct 2 08:22:01 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * h8300.c (get_shift_alg): Fix typo in asm string; "n" should be "\n".
+
+Wed Sep 30 15:53:17 1998 Klaus Espenlaub <kespenla@student.informatik.uni-ulm.de>
+
+ * rs6000.h (ASM_OUTPUT_CONSTRUCTOR, ASM_OUTPUT_DESTRUCTOR): Delete.
+
Wed Sep 30 14:27:49 1998 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
* function.c (assign_parms): Undo change of June 9.
+Wed Sep 30 14:21:39 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+
+ * c-typeck.c (c_expand_asm_operands): Give error if non-lvalue for
+ output operand.
+
+ * libgcc2.c (__bb_init_prg): Properly zero bb_hashbuckets.
+
+Wed Sep 30 11:31:23 1998 Walter Gadeyne <gadeynew@sebb.bel.alcatel.be>
+
+ * combine.c (num_sign_bit_copies, case UDIV): Return 1.
+
+Wed Sep 30 10:44:15 1998 Tristan Gingold <gingold@gavroche.enst.fr>
+
+ * c-decl.c (finish_decl): Set the assembler name to the current
+ decl if it was specified.
+ (finish_function): Use assembler name for constructor and
+ destructor name.
+ (duplicate_decls): Copy the assembler name.
+
+Wed Sep 30 10:42:49 1998 Jim Wilson <wilson@cygnus.com>
+
+ * regmove.c (struct match): Change char to int.
+
Tue Sep 29 09:57:26 1998 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
+ * regmove.c (regmove_profitable_p): For shift, use 1 as third arg.
+
+ * function.c (find_fixup_replacement): Consider equivalent if
+ rtx_equal_p, not just same rtx.
+
+ * reload.h (last_output_reload_regno): New declaration.
+ * reload.c (find_reloads): No longer make it static and get last value.
+ * reload1.c (last_output_reload_regno): New definition.
+ (reload): Initialize it before each scan.
+ (reload_as_needed): Likewise, and also when insn has no reloads.
+
+ * combine.c (simplify_comparison, case AND): Properly check for
+ SUBREG of a low part and exclude paradoxcal SUBREG, not low part,
+ for non-WORD_REGISTER_OPERATIONS machines.
+
* expr.c (get_inner_reference): Fix typo in last change.
Mon Sep 27 21:34:00 1998 Paul Eggert <eggert@twinsun.com>
Sun Aug 2 01:10:15 1998 Paul Eggert <eggert@twinsun.com>
Add Native Language Support.
-
- * intl/, ABOUT-NLS, mkinstalldirs, po/Makefile.in.in: New
- subdirectory and files. They should be kept identical to the
- corresponding items from the GNU gettext distribution.
-
- * ABOUT-GCC-NLS, exgettext, intl.c, intl.h, po/POTFILES.in,
- po/en_UK.po: New files.
-
- * Makefile.in (AWK, datadir, localedir, top_builddir, USE_NLS,
- INTLLIBS, POSUB, INTL_SUBDIRS, HOST_INTLLIBS,
- PREPEND_DOTDOT_TO_RELATIVE_PATHS, SUBDIR_FLAGS_TO_PASS, GCC_OBJS,
- COLLECT2_OBJS, CCCP_OBJS, CPPMAIN_OBJS, PROTO_OBJS, GCOV_OBJS,
- INTL_DISTCLEAN, GEN_PROTOS_OBJS): New vars.
+ * intl/*, mkinstalldirs, po/*, exgettext, intl.c, intl.h: New files.
+ * Makefile.in (AWK, datadir, localedir, top_builddir): New variables.
+ (USE_NLS, INTLLIBS, POSUB, INTL_SUBDIRS, HOST_INTLLIBS): Likewise.
+ (PREPEND_DOTDOT_TO_RELATIVE_PATHS, SUBDIR_FLAGS_TO_PASS): Likewise.
+ (GCC_OBJS, COLLECT2_OBJS, CCCP_OBJS, CPPMAIN_OBJS): Likewise.
+ (PROTO_OBJS, GCOV_OBJS, INTL_DISTCLEAN, GEN_PROTOS_OBJS): Likewise.
(LIBDEPS, LIBS): Add $(INTLLIBS).
(HOST_LIBDEPS, HOST_LIBS): Add $(HOST_INTLLIBS).
(LIBS): Add @LIBS@.
(GEN): Add gencheck.
(STAGESTUFF): Add tree-check.h, gencheck$(exeext).
(native): Depend on intl.all.
- (xgcc, collect2, cccp, cppmain, protoize, unprotoize, gcov): Link
- intl.o.
- (c-typeck.o, c-lex.o, collect2.o, gcc.o, toplev.o, integrate.o,
- final.o, cccp.o, cppmain.o, cpplib.o, cpperror.o, s-proto,
- gcov.o): Depend on intl.h.
- (gencheck): Depend on $(HOST_LIBDEPS) instead of tree.h and
- tree.def.
- (gencheck.o, intl.o, $(top_builddir)/intl/libintl.a,
- $(srcdir)/cp/parse.c, intl.all, intl.install, intl.uninstall,
- intl.distdir, intl.mostlyclean, intl.clean, intl.distclean,
- intl.maintainer-clean, intl.distdir-fixup, distdir-check): New
- rules.
+ (xgcc, collect2, cccp, cppmain, {,un}protoize, gcov): Link intl.o.
+ (c-typeck.o, c-lex.o, collect2.o, gcc.o, toplev.o): Depend on intl.h.
+ (integrate.o, final.o, cccp.o, cppmain.o, cpplib.o): Likewise.
+ (cpperror.o, s-proto, gcov.o): Likewise.
+ (gencheck): Depend on $(HOST_LIBDEPS) instead of tree.h and tree.def.
+ (gencheck.o, intl.o, $(top_builddir)/intl/libintl.a): New rules.
+ ($(srcdir)/cp/parse.c, intl.all, intl.install): Likewise.
+ (intl.uninstall, intl.distdir, intl.mostlyclean, intl.clean): Likewise.
+ (intl.distclean, intl.maintainer-clean, intl.distdir-fixup): Likewise.
+ (distdir-check): Likewise.
(gen-protos): Link cpperror.o, cppexp.o, cpphash.o, cpplib.o,
prefix.o, version.o; needed for `cpp_notice'.
(mostlyclean): Depend on intl.mostlyclean.
(clean): Depend on intl.clean.
(distclean): Depend on intl.disclean, unless the invoker defines
- INTL_DISTCLEAN to be empty. Remove intl/libintl.h and libintl.h
- (created by configure).
+ INTL_DISTCLEAN to be empty. Remove intl/libintl.h and libintl.h.
(maintainer-clean): Make intl.maintainer-clean, but define
INTL_DISTCLEAN to be empty.
(install-normal): Depend on intl.install.
Use $(AWK), not awk. Make tmp/intl and tmp/po directories.
(distdir-finish): Make distdir-check at the end.
(distdir): Depend on intl.distdir, intl.distdir-fixup.
- (compare, compare3, gnucompare, gnucompare3, stage1-start,
- stage2-start, stage3-start, stage4-start): Handle intl
- subdirectory.
-
- * acconfig.h (ENABLE_NLS, HAVE_CATGETS, HAVE_GETTEXT,
- HAVE_LC_MESSAGES, HAVE_STPCPY, PACKAGE, VERSION): New macros.
+ (compare, compare3, gnucompare, gnucompare3): Handle intl subdirectory.
+ (stage1-start, stage2-start, stage3-start, stage4-start): Likewise.
- * aclocal.m4 (AC_ISC_POSIX, AM_WITH_NLS, AM_GNU_GETTEXT,
- AM_LC_MESSAGES, AM_PATH_PROG_WITH_TEST): New functions; taken from
- gettext distribution.
+ * acconfig.h (ENABLE_NLS, HAVE_CATGETS, HAVE_GETTEXT): New macros.
+ (HAVE_LC_MESSAGES, HAVE_STPCPY, PACKAGE, VERSION): Likewise.
+ * aclocal.m4 (AC_ISC_POSIX, AM_WITH_NLS): New functions.
+ (AM_GNU_GETTEXT, AM_LC_MESSAGES, AM_PATH_PROG_WITH_TEST): Likewise.
* bi-arity.c, bi-opcode.c, bi-opname.c: Include config file first.
-
* c-common.c: Don't include <ctype.h>.
(tfaff): Now a function, not a string. All users changed.
(check_format_info): Use is_C_digit, not isdigit.
Reword messages to ease localization.
-
- * c-decl.c (redeclaration_error_message): Now returns int, not
- message.
+ * c-decl.c (redeclaration_error_message): Now returns int, not message.
(poplevel, duplicate_decls, pushdecl): Revamp to pass explicit
strings to diagnostic generators.
(duplicate_decls, parmlist_tags_warning, finish_struct): Reword
messages to ease localization.
-
* c-iterate.c (prdecl): Reword messages so that they do not require
localization.
-
* c-lex.c: Include limits.h if available.
Include intl.h.
Include ctype.h only if MAP_CHARACTER is defined.
(init_lex): Initialize it.
(yyerror): Localize msgid arg.
(yylex): Use is_C_alnum and is_C_digit, not isalnum and isdigit.
-
* c-lex.h (C_alnum_array): New decl.
(is_C_alnum, is_C_digit): New macros.
-
* c-typeck.c: Include intl.h.
(warning_init): Now takes just one arg.
- (incomplete_type_error, build_unary_op, lvalue_or_else,
- readonly_warning, build_modify_expr): Reword messages to ease
- localization.
+ (incomplete_type_error): Reword messages to ease localization.
+ (build_unary_op, lvalue_or_else, readonly_warning): Likewise.
+ (build_modify_expr): Likewise.
(build_unary_op, readonly_warning): Revamp to pass explicit
strings to diagnostic generators.
(build_modify_expr, warn_for_assignment, c_expand_return):
Translate strings passed to functions expecting translated
strings.
(get_spelling): Remove; it was a no-op. All callers changed.
- (error_init, pedwarn_init): Now takes just one arg. All callers
- and decls changed. This makes it easier to localize.
-
+ (error_init, pedwarn_init): Now takes one arg. All callers changed.
+ * c-tree.h (error_init, pedwarn_init): Likewise.
* cccp.c: Include intl.h.
(char_name): Remove.
- (check_macro_name): Now takes int 2nd arg, not char *. All
- callers changed.
+ (check_macro_name): 2nd arg now int, not char *. All callers changed.
(macarg): Now returns int, not char *. All callers changed.
(notice, vnotice, pedwarn_strange_white_space): New functions.
(verror): Now extern; used by cexp.y.
- (main): Set message locale, and defer memory allocation until
- after.
+ (main): Set message locale, and defer memory allocation until after.
(main, do_include, print_containing_files): Invoke `notice' to
localize notices.
(handle_directive): Invoke pedwarn_strange_white_space instead of
using char_name.
- (do_include, check_macro_name): Reword messages to ease
- localization.
- (my_strerror): Reword message so that it does not require
- localization.
- (verror, vwarning, verror_with_line, vwarning_with_line,
- pedwarn_with_file_and_line, fatal): Invoke vnotice to localize
- msgid.
+ (do_include, check_macro_name): Reword messages to ease localization.
+ (my_strerror): Likewise.
+ (verror, vwarning): Invoke vnotice to localize msgid.
+ (verror_with_line, vwarning_with_line): Likewise.
+ (pedwarn_with_file_and_line, fatal): Likewise.
(initialize_char_syntax): No need to initialize char_name.
-
* cexp.y (yyerror): Now takes msgid format and args, not just string.
(verror): New decl.
- (parse_number, yylex): Reword messages to ease
- localization.
+ (parse_number, yylex): Reword messages to ease localization.
(verror): New test function.
(pedwarn, warning): Translate msgid arg.
-
* collect2.c: Include intl.h.
- (my_strerror, main, collect_execute, scan_prog_file,
- scan_libraries, read_file, end_file): Reword messages so that they
- do not require localization.
- (notice): Nwe function.
- (fatal, error, main, collect_execute, maybe_unlink,
- write_c_file_stat, locatelib, scan_libraries, scan_prog_file,
- add_func_table): Use it to translate msgid strings.
- (main): Set message locale, and defer memory allocation until
- after.
+ (my_strerror): Reword messages so they do not require localization.
+ (main, collect_execute, scan_prog_file, scan_libraries): Likewise.
+ (read_file, end_file): Likewise.
+ (notice): New function.
+ (fatal, error, main): Use it to translate msgid strings.
+ (collect_execute, maybe_unlink, write_c_file_stat): Likewise.
+ (locatelib, scan_libraries, scan_prog_file, add_func_table): Likewise.
+ (main): Set message locale, and defer memory allocation until after.
(collect_wait): Reword messages to ease localization.
- (bad_header): Revamp to pass explicit strings to diagnostic
- generators.
-
+ (bad_header): Revamp to pass explicit strings to diagnostic generators.
* combine.c (dump_combine_stats, dump_combine_total_stats):
Use fnotice to translate diagnostic messages.
-
- * config/1750a/1750a.c (memop_valid): Don't use `valid' as an
- identifier; it runs afoul of SunOS 4.1.4 <locale.h>.
-
- * config/arc/initfini.c (__do_global_dtors): Put backslash before
- newline in strings, to pacify xgettext.
-
- * config/dsp16xx/dsp16xx.c, config/dsp16xx/dsp16xx.h
- (dsp16xx_invalid_register_for_compare): New function.
- * config/dsp16xx/dsp16xx.md: Use it to report invalid registers.
-
- * config/i370/i370.h: Include <ctype.h>.
-
- * config/i386/i386.c: Include config.h first.
-
- * config/m32r/initfini.c (__do_global_dtors): Put backslash before
- newline in strings, to pacify xgettext.
- * config/m88k/dguxbcs.h (CPP_SPEC): Likewise.
-
- * config/rs6000/rs6000.c: Include config.h first.
- * config/rs6000/rs6000.c, config/rs6000/rs6000.h
- (rs6000_fatal_bad_address): New function.
- * config/rs6000/rs6000.md: Use it to report bad addresses.
-
- * config/v850/v850.c: Include config.h first.
-
- * configure.in: When generating config.h and mentioning a file
- taken from the config directory, surround it with #ifdef IN_GCC,
- so that programs compiled without IN_GCC -- notably in the intl
- subdirectory -- don't need to be compiled with -Iconfig.
- (PACKAGE, VERSION, ALL_LINGUAS): New vars.
- (AC_ARG_ENABLE): Add --enable-nls.
- (AM_GNU_GETTEXT): Add. Override XGETTEXT so that we use exgettext
- instead of xgettext to extract strings.
- (all_outputs): Add intl/Makefile, po/Makefile.in.
- Do not use the shell variable 'l'; it runs afoul of gettext's
- aclocal mechanism!
- If libintl.h is created, echo '#include "intl/libintl.h"'
- >libintl.h so that we don't have to futz with our include paths.
-
- * cp/Make-lang.in (g++.o): Depend on gansidecl.h, intl.h, Makefile;
- do not depend on config.status.
- (GXX_OBJS): New var.
- (g++$(exeext)): Link intl.o.
-
- * cp/Makefile.in (top_builddir, INTLLIBS): New vars.
- (LIBS): Add $(INTLLIBS).
-
* cppalloc.c (memory_full): Use `cpp_notice' to print diagnostic.
-
* cpperror.c: Include intl.h.
(cpp_print_containing_files): Use cpp_notice to translate messages.
(cpp_message): is_error is -1 for notices. Translate "warning:".
(cpp_fatal): Translate msgid arg.
-
- * cppexp.c (cpp_lex): Revamp to pass explicit strings to
- diagnostic generators.
+ * cppexp.c (cpp_lex): Pass explicit strings to diagnostic generators.
(cpp_parse_expr): Use cpp_error, not fprintf, to report
unimplemented operators.
-
* cpplib.c: Include intl.h.
- (check_macro_name): Now takes int 2nd arg, not char *. All
- callers changed.
- (check_macro_name, do_define): Reword messages to ease
- localization.
- (do_define): Revamp to pass explicit strings to diagnostic
- generators.
+ (check_macro_name): 2nd arg now int, not char *. All callers changed.
+ (check_macro_name, do_define): Reword messages to ease localization.
+ (do_define): Pass explicit strings to diagnostic generators.
(do_define, cpp_start_read, cpp_handle_options): Use cpp_notice to
translate messages.
- (cpp_error, cpp_warning, cpp_warning_with_line,
- cpp_pedwarn_with_file_and_line): Translate msgid arg.
+ (cpp_error, cpp_warning, cpp_warning_with_line): Translate msgid arg.
+ (cpp_pedwarn_with_file_and_line): Likewise.
(cpp_notice): New function.
- (my_strerror): Reword message so that it does not require
- localization.
-
+ (my_strerror): Reword message so it does not require localization.
* cpplib.h (cpp_notice): New decl.
-
* cppmain.c: Include intl.h.
(main): Set message locale.
-
* cse.c (cse_main): Use fnotice to print diagnostic.
-
* final.c: Include intl.h; do not include ctype.h.
(output_operand_lossage): Translate msgid arg.
-
* fold-const.c (optimize_bit_field_compare, fold_truthop): Reword
messages to ease localization.
-
* gcc.c: Include intl.h.
- (my_strerror, snapshot_warning): Reword messages so that they do
- not require localization.
- (init_spec, set_spec, read_specs, execute, do_spec_1, main,
- snapshot_warning): Invoke `notice' to localize notices.
- (struct switchstr): Don't use `valid' as an identifier; it runs
- afoul of SunOS 4.1.4 <locale.h>. All uses changed.
+ (my_strerror, snapshot_warning): Reword messages so they do not
+ require localization.
+ (init_spec, set_spec): Invoke `notice' to localize notices.
+ (read_specs, execute, do_spec_1, main, snapshot_warning): Likewise.
+ (struct switchstr): Don't use `valid' as identifier.
(do_spec_1): Treat %e string as msgid format, which needs
translation.
(main): Set message locale.
- (pfatal_with_name): Invoke perror_with_name, not fatal, so that we
- don't have to translate "%s: %s".
- (perror_with_name): Invoke printf, not error, so that we don't
- have to translate "%s: %s".
- (pfatal_pexecute): Invoke pfatal_with_name, not fatal, so that we
- don't have to translate "%s: %s".
+ (pfatal_with_name): Invoke perror_with_name, not fatal.
+ (perror_with_name): Invoke printf, not error.
+ (pfatal_pexecute): Invoke pfatal_with_name, not fatal.
(fatal, error): Translate msgid arg.
(notice): New function.
-
* gcov.c: Include intl.h; include stdarg.h if __STDC__ is defined.
(main): Set message locale.
(fnotice): New function.
- (xmalloc, fancy_abort, print_usage, open_files, read_files,
- function_summary, output_data): Use it to to print diagnostics.
-
- * install.texi: Explain new configure options --enable-nls,
- --with-included-gettext, --with-catgets.
-
+ (xmalloc, fancy_abort, print_usage): Use it to to print diagnostics.
+ (open_files, read_files, function_summary, output_data): Likewise.
* integrate.c: Include intl.h.
(function_cannot_inline_p): Mark msgids with N_.
-
- * invoke.texi: Describe environment variables affecting locale.
-
* pexecute.c: Include libintl.h if ENABLE_NLS, otherwise define
gettext to be a noop.
(_, N_): New macros.
(install_error_msg): Wrap inside N_.
(pexecute): Translate diagnostics.
-
* protoize.c: Include intl.h.
(__attribute__): New macro.
(notice): New function.
- (my_strerror): Reword message so that it does not require
- localization.
- (xmalloc, xrealloc, fancy_abort, safe_write, usage,
- file_normally_convertible, abspath, find_file, aux_info_corrupted,
- save_def_or_dec, gen_aux_info_file, process_aux_info_file,
- rename_c_file, find_extern_def, find_static_definition,
- declare_source_confusing, edit_fn_declaration, edit_formals_lists,
- add_local_decl, add_global_decls, edit_fn_definition,
- scan_for_missed_items, edit_file, main): Use `notice' to print
- diagnostic.
+ (my_strerror): Reword message so it does not require localization.
+ (xmalloc, xrealloc, fancy_abort): Use `notice' to print diagnostic.
+ (safe_write, usage, file_normally_convertible, abspath): Likewise.
+ (find_file, aux_info_corrupted, save_def_or_dec): Likewise.
+ (gen_aux_info_file, process_aux_info_file, rename_c_file): Likewise.
+ (find_extern_def, find_static_definition): Likewise.
+ (declare_source_confusing, edit_fn_declaration): Likewise.
+ (edit_formals_lists, add_local_decl, add_global_decls): Likewise.
+ (edit_fn_definition, scan_for_missed_items, edit_file, main): Likewise.
(main): Set message locale.
-
* real.c (NMSGS, ermsg): Remove.
- (mtherr): Revamp to pass explicit strings to diagnostic
- generators. Abort on invalid operations.
-
+ (mtherr): Pass explicit strings to diagnostic generators.
+ Abort on invalid operations.
* regclass.c (fix_register): Reword messages to ease localization.
-
* toplev.c: Include intl.h; do not include ctype.h.
(v_really_sorry, really_sorry): Remove unused functions.
(count_error, fatal_io_error): Translate strings.
- (default_print_error_function, report_error_function, main,
- print_version): Reword messages to ease localization. Use
- `notice' to translate diagnostics.
+ (default_print_error_function): Reword messages to ease localization.
+ Use `notice' to translate diagnostics.
+ (report_error_function, main, print_version): Likewise.
(vnotice, notice, fnotice): New functions.
(vmessage): Remove.
- (v_message_with_file_and_line, vsorry): Translate msgid with
- vnotice.
+ (v_message_with_file_and_line, vsorry): Translate msgid with vnotice.
(v_message_with_file_and_line, v_message_with_decl): Use
report_file_and_line. Now takes int warning flag, not prefix;
this is easier to localize. All callers changed.
(v_message_with_decl): Abort if first format spec is neither %%
nor %s. Translate "((anonymous))".
(main): Set message locale.
- (set_target_switch): Don't use `valid' as an identifier; it runs
- afoul of SunOS 4.1.4 <locale.h>.
- (__VERSION__): Reword message so that it does not require
- localization.
- (print_switch_values): Translate "options passed" and "options
- enabled".
-
- * tree.c (valid_machine_attribute): Don't use `valid' as an
- identifier; it runs afoul of SunOS 4.1.4 <locale.h>.
-
+ (set_target_switch): Don't use `valid' as an identifier.
+ (__VERSION__): Reword message so it does not require localization.
+ (print_switch_values): Translate "options passed" and "enabled".
+ * tree.c (valid_machine_attribute): Don't use `valid' as identifier.
* xcoffout.c (xcoff_output_standard_types): Use `error' to
output diagnostic, so that it gets translated.
+ * 1750a.c (memop_valid): Don't use `valid' as an identifier.
+ * arc/initfini.c (__do_global_dtors): Put backslash before
+ newline in strings, to pacify xgettext.
+ * dsp16xx.c (dsp16xx_invalid_register_for_compare): New function.
+ * dsp16xx.h: Declare it.
+ * dsp16xx.md: Use it to report invalid registers.
+ * i370.h: Include <ctype.h>.
+ * i386.c: Include config.h first.
+ * m32r/initfini.c (__do_global_dtors): Put backslash before
+ newline in strings, to pacify xgettext.
+ * m88k/dguxbcs.h (CPP_SPEC): Likewise.
+ * rs6000.c: Include config.h first.
+ (rs6000_fatal_bad_address): New function.
+ * rs6000.h: Declare it.
+ * rs6000.md: Use it to report bad addresses.
+ * v850.c: Include config.h first.
+
+ * configure.in: When generating config.h and mentioning file from
+ the config directory, surround it with #ifdef IN_GCC.
+ (AC_ARG_ENABLE): Add --enable-nls.
+ (AM_GNU_GETTEXT): Add. Override XGETTEXT so that we use exgettext
+ instead of xgettext to extract strings.
+ (all_outputs): Add intl/Makefile, po/Makefile.in.
+ Do not use the shell variable 'l'.
+ If libintl.h is created, echo '#include "intl/libintl.h"' >libintl.h.
+ * cp/Make-lang.in (g++.o): Depend on gansidecl.h, intl.h, Makefile;
+ do not depend on config.status.
+ (GXX_OBJS): New var.
+ (g++$(exeext)): Link intl.o.
+ * cp/Makefile.in (top_builddir, INTLLIBS): New vars.
+ (LIBS): Add $(INTLLIBS).
* patch-apollo-includes: Remove; this is part of README.APOLLO.
STAGESTUFF = *$(objext) insn-flags.h insn-config.h insn-codes.h \
insn-output.c insn-recog.c insn-emit.c insn-extract.c insn-peep.c \
insn-attr.h insn-attrtab.c insn-opinit.c tree-check.h \
- s-flags s-config s-codes s-mlib s-under\
+ s-flags s-config s-codes s-mlib s-unders s-genrtl \
s-output s-recog s-emit s-extract s-peep s-check \
s-attr s-attrtab s-opinit s-crt s-crtS s-crt0 \
genemit$(build_exeext) genoutput$(build_exeext) genrecog$(build_exeext) \
.SUFFIXES:
.SUFFIXES: .c .o
+$(srcdir)/version.c: $(VERSION_DEP)
+ (cd $(srcdir); cvs log -h `basename $?`) >tmp-ver
+ tag=`sed '1,/^sym/d;s/ *gcc-//;s/:.*$$//;q' tmp-ver`; \
+ ver=`echo $${tag} | sed 's/-.*//' | sed 's/_/./g'`; \
+ date=`echo $${tag} | sed 's/.*-//'`; \
+ if [ $${date} != RELEASE ]; then ver="testgcc-$${ver} $${date} experimental"; fi; \
+ echo "char *version_string = \"$${ver}\";" >tmp-version.c
+ rm -f tmp-ver
+ $(srcdir)/move-if-change tmp-version.c $(srcdir)/version.c
+
Makefile: $(srcdir)/Makefile.in config.status $(srcdir)/version.c \
$(xmake_file) $(tmake_file) $(LANG_MAKEFILES)
$(SHELL) $(srcdir)/configure.frag $(srcdir) "$(SUBDIRS)" \
# Really, really stupid make features, such as SUN's KEEP_STATE, may force
# a target to build even if it is up-to-date. So we must verify that
# config.status does not exist before failing.
-config.status: configure version.c
+config.status: $(srcdir)/configure version.c
@if [ ! -f config.status ] ; then \
echo You must configure gcc. Look at the INSTALL file for details.; \
false; \
-DPREFIX=\"$(prefix)\" \
-c `echo $(srcdir)/prefix.c | sed 's,^\./,,'`
-convert.o: convert.c $(CONFIG_H) $(TREE_H) flags.h convert.h toplev.h
+convert.o: convert.c $(CONFIG_H) system.h $(TREE_H) flags.h convert.h toplev.h
tree.o : tree.c $(CONFIG_H) system.h $(TREE_H) flags.h function.h toplev.h \
ggc.h
function.h $(REGS_H) insn-config.h $(RECOG_H) real.h ggc.h \
$(EXPR_H) $(srcdir)/../include/obstack.h hard-reg-set.h bitmap.h toplev.h
real.o : real.c $(CONFIG_H) system.h $(TREE_H) toplev.h
-
integrate.o : integrate.c $(CONFIG_H) system.h $(RTL_H) $(TREE_H) flags.h \
integrate.h insn-flags.h insn-config.h $(EXPR_H) real.h $(REGS_H) \
intl.h function.h output.h $(RECOG_H) except.h toplev.h
-
jump.o : jump.c $(CONFIG_H) system.h $(RTL_H) flags.h hard-reg-set.h $(REGS_H) \
insn-config.h insn-flags.h $(RECOG_H) $(EXPR_H) real.h except.h function.h \
toplev.h insn-attr.h
global.o : global.c $(CONFIG_H) system.h $(RTL_H) flags.h reload.h function.h \
$(BASIC_BLOCK_H) $(REGS_H) hard-reg-set.h insn-config.h output.h toplev.h
varray.o : varray.c $(CONFIG_H) system.h varray.h $(RTL_H) $(TREE_H) bitmap.h
-
reload.o : reload.c $(CONFIG_H) system.h $(RTL_H) flags.h output.h $(EXPR_H) \
reload.h $(RECOG_H) hard-reg-set.h insn-config.h insn-codes.h $(REGS_H) \
function.h real.h toplev.h
@true # force gnu make to recheck modification times.
s-genrtl: gengenrtl $(srcdir)/move-if-change $(RTL_BASE_H)
- ./gengenrtl tmp-genrtl.h tmp-genrtl.c
+ ./gengenrtl -h >tmp-genrtl.h
$(srcdir)/move-if-change tmp-genrtl.h genrtl.h
+ ./gengenrtl >tmp-genrtl.c
$(srcdir)/move-if-change tmp-genrtl.c genrtl.c
touch s-genrtl
-
#\f
# Compile the programs that generate insn-* from the machine description.
# They are compiled with $(HOST_CC), and associated libraries,
gengenrtl.o : gengenrtl.c $(RTL_BASE_H) system.h
$(HOST_CC) -c $(HOST_CFLAGS) $(HOST_CPPFLAGS) $(INCLUDES) $(srcdir)/gengenrtl.c
-
#\f
# Compile the libraries to be used by gen*.
# If we are not cross-building, gen* use the same .o's that cc1 will use,
CCCP_OBJS = cccp.o cexp.o intl.o prefix.o version.o @extra_cpp_objs@ mbchar.o
cccp$(exeext): $(CCCP_OBJS) $(LIBDEPS)
$(CC) $(ALL_CFLAGS) $(LDFLAGS) -o $@ $(CCCP_OBJS) $(LIBS)
-cexp.o: $(srcdir)/cexp.c $(CONFIG_H) system.h
+cexp.o: $(srcdir)/cexp.c $(CONFIG_H) system.h mbchar.h
$(CC) $(ALL_CFLAGS) $(ALL_CPPFLAGS) $(INCLUDES) -c $(srcdir)/cexp.c
$(srcdir)/cexp.c: $(srcdir)/cexp.y
cd $(srcdir); $(BISON) -o cexp.c cexp.y
# Build fixed copies of system files.
stmp-fixinc: fixinc.sh gsyslimits.h
rm -rf include; mkdir include
+ -chmod a+rx include
TARGET_MACHINE=$(target); srcdir=`cd $(srcdir); pwd`; \
INSTALL_ASSERT_H=$(INSTALL_ASSERT_H); SHELL=$(SHELL) ;\
export TARGET_MACHINE srcdir INSTALL_ASSERT_H SHELL ; \
# if it has already been run on the files in `include'.
stmp-fixproto: fixhdr.ready fixproto stmp-headers
@echo "Various warnings and error messages from fixproto are normal"
- -if [ -d include ] ; then true; else mkdir include; fi
+ -if [ -d include ] ; then true; else mkdir include; chmod a+rx include; fi
-if [ -f include/fixed ] ; then true; \
else \
: This line works around a 'make' bug in BSDI 1.1.; \
install-multilib: stmp-multilib installdirs
for i in `$(GCC_FOR_TARGET) --print-multi-lib`; do \
dir=`echo $$i | sed -e 's/;.*$$//'`; \
- if [ -d $(libsubdir)/$${dir} ]; then true; else mkdir $(libsubdir)/$${dir}; fi; \
+ if [ -d $(libsubdir)/$${dir} ]; then true; else mkdir $(libsubdir)/$${dir}; chmod a+rx $(libsubdir)/$${dir}; fi; \
for f in libgcc.a $(EXTRA_MULTILIB_PARTS); do \
rm -f $(libsubdir)/$${dir}/$${f}; \
$(INSTALL_DATA) $${dir}/$${f} $(libsubdir)/$${dir}/$${f}; \
/* Obstack to allocate bitmap elements from. */
static struct obstack bitmap_obstack;
static int bitmap_obstack_init = FALSE;
-
\f
#ifndef INLINE
#ifndef __GNUC__
but what kind of conversions it does will depend on the language. */
#include "config.h"
+#include "system.h"
#include "tree.h"
#include "flags.h"
#include "convert.h"
if (DECL_SECTION_NAME (newdecl) == NULL_TREE)
DECL_SECTION_NAME (newdecl) = DECL_SECTION_NAME (olddecl);
+ /* Copy the assembler name.
+ Currently, it can only be defined in the prototype. */
+ DECL_ASSEMBLER_NAME (newdecl) = DECL_ASSEMBLER_NAME (olddecl);
+
if (TREE_CODE (newdecl) == FUNCTION_DECL)
{
DECL_STATIC_CONSTRUCTOR(newdecl) |= DECL_STATIC_CONSTRUCTOR(olddecl);
{
DECL_BUILT_IN (decl) = 0;
DECL_RTL (decl) = 0;
+ DECL_ASSEMBLER_NAME (decl) = get_identifier (asmspec);
}
/* Output the assembler code and/or RTL code for variables and functions,
static_ctors = perm_tree_cons (NULL_TREE, fndecl, static_ctors);
else
#endif
- assemble_constructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
+ assemble_constructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
+
}
if (DECL_STATIC_DESTRUCTOR (fndecl))
{
static_dtors = perm_tree_cons (NULL_TREE, fndecl, static_dtors);
else
#endif
- assemble_destructor (IDENTIFIER_POINTER (DECL_NAME (fndecl)));
+ assemble_destructor (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fndecl)));
}
if (! nested)
-/* C code produced by gperf version 2.7 */
-/* Command-line: gperf -L C -F , 0, 0 -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ ../../../egcs/gcc/c-parse.gperf */
+/* C code produced by gperf version 2.7.1 (19981006 egcs) */
+/* Command-line: gperf -L C -F , 0, 0 -p -j1 -i 1 -g -o -t -G -N is_reserved_word -k1,3,$ /home/law/egcs/egcs/gcc/c-parse.gperf */
/* Command-line: gperf -L KR-C -F ', 0, 0' -p -j1 -i 1 -g -o -t -N is_reserved_word -k1,3,$ c-parse.gperf */
struct resword { const char *name; short token; enum rid rid; };
/* Build expressions with type checking for C compiler.
- Copyright (C) 1987, 88, 89, 92, 93, 96, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 89, 92-97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "mbchar.h"
#include <locale.h>
#endif /* MULTIBYTE_CHARS */
+#ifndef GET_ENVIRONMENT
+#define GET_ENVIRONMENT(ENV_VALUE,ENV_NAME) ((ENV_VALUE) = getenv (ENV_NAME))
+#endif
#if USE_CPPLIB
#include "cpplib.h"
#ifdef MULTIBYTE_CHARS
/* Change to the native locale for multibyte conversions. */
setlocale (LC_CTYPE, "");
- literal_codeset = getenv ("LANG");
+ GET_ENVIRONMENT (literal_codeset, "LANG");
#endif
maxtoken = 40;
#define TOTAL_PARTS ((HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR) * 2)
unsigned int parts[TOTAL_PARTS];
- enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON }
+ enum anon1 { NOT_FLOAT, AFTER_POINT, TOO_MANY_POINTS, AFTER_EXPON}
floatflag = NOT_FLOAT;
for (count = 0; count < TOTAL_PARTS; count++)
int max_chars;
#ifdef MULTIBYTE_CHARS
int longest_char = local_mb_cur_max ();
- local_mbtowc (NULL_PTR, NULL_PTR, 0);
+ (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
#endif
max_chars = TYPE_PRECISION (integer_type_node) / width;
}
if (c != '\'')
- error ("malformatted character constant");
+ error ("malformed character constant");
else if (chars_seen == 0)
error ("empty character constant");
else if (num_chars > max_chars)
: TYPE_PRECISION (char_type_node);
#ifdef MULTIBYTE_CHARS
int longest_char = local_mb_cur_max ();
- local_mbtowc (NULL_PTR, NULL_PTR, 0);
+ (void) local_mbtowc (NULL_PTR, NULL_PTR, 0);
#endif
-
c = token_getch ();
p = token_buffer + 1;
/* A Bison parser, made from c-parse.y
- by GNU Bison version 1.27
+ by GNU Bison version 1.25
*/
#define YYBISON 1 /* Identify Bison output. */
-#define IDENTIFIER 257
-#define TYPENAME 258
-#define SCSPEC 259
-#define TYPESPEC 260
-#define TYPE_QUAL 261
-#define CONSTANT 262
-#define STRING 263
-#define ELLIPSIS 264
-#define SIZEOF 265
-#define ENUM 266
-#define STRUCT 267
-#define UNION 268
-#define IF 269
-#define ELSE 270
-#define WHILE 271
-#define DO 272
-#define FOR 273
-#define SWITCH 274
-#define CASE 275
-#define DEFAULT 276
-#define BREAK 277
-#define CONTINUE 278
-#define RETURN 279
-#define GOTO 280
-#define ASM_KEYWORD 281
-#define TYPEOF 282
-#define ALIGNOF 283
-#define ATTRIBUTE 284
-#define EXTENSION 285
-#define LABEL 286
-#define REALPART 287
-#define IMAGPART 288
-#define VA_ARG 289
-#define END_OF_LINE 290
-#define ASSIGN 291
-#define OROR 292
-#define ANDAND 293
-#define EQCOMPARE 294
-#define ARITHCOMPARE 295
-#define LSHIFT 296
-#define RSHIFT 297
-#define UNARY 298
-#define PLUSPLUS 299
-#define MINUSMINUS 300
-#define HYPERUNARY 301
-#define POINTSAT 302
-#define INTERFACE 303
-#define IMPLEMENTATION 304
-#define END 305
-#define SELECTOR 306
-#define DEFS 307
-#define ENCODE 308
-#define CLASSNAME 309
-#define PUBLIC 310
-#define PRIVATE 311
-#define PROTECTED 312
-#define PROTOCOL 313
-#define OBJECTNAME 314
-#define CLASS 315
-#define ALIAS 316
-#define OBJC_STRING 317
+#define IDENTIFIER 258
+#define TYPENAME 259
+#define SCSPEC 260
+#define TYPESPEC 261
+#define TYPE_QUAL 262
+#define CONSTANT 263
+#define STRING 264
+#define ELLIPSIS 265
+#define SIZEOF 266
+#define ENUM 267
+#define STRUCT 268
+#define UNION 269
+#define IF 270
+#define ELSE 271
+#define WHILE 272
+#define DO 273
+#define FOR 274
+#define SWITCH 275
+#define CASE 276
+#define DEFAULT 277
+#define BREAK 278
+#define CONTINUE 279
+#define RETURN 280
+#define GOTO 281
+#define ASM_KEYWORD 282
+#define TYPEOF 283
+#define ALIGNOF 284
+#define ATTRIBUTE 285
+#define EXTENSION 286
+#define LABEL 287
+#define REALPART 288
+#define IMAGPART 289
+#define VA_ARG 290
+#define END_OF_LINE 291
+#define ASSIGN 292
+#define OROR 293
+#define ANDAND 294
+#define EQCOMPARE 295
+#define ARITHCOMPARE 296
+#define LSHIFT 297
+#define RSHIFT 298
+#define UNARY 299
+#define PLUSPLUS 300
+#define MINUSMINUS 301
+#define HYPERUNARY 302
+#define POINTSAT 303
+#define INTERFACE 304
+#define IMPLEMENTATION 305
+#define END 306
+#define SELECTOR 307
+#define DEFS 308
+#define ENCODE 309
+#define CLASSNAME 310
+#define PUBLIC 311
+#define PRIVATE 312
+#define PROTECTED 313
+#define PROTOCOL 314
+#define OBJECTNAME 315
+#define CLASS 316
+#define ALIAS 317
+#define OBJC_STRING 318
#line 33 "c-parse.y"
#define YYFLAG -32768
#define YYNTBASE 86
-#define YYTRANSLATE(x) ((unsigned)(x) <= 317 ? yytranslate[x] : 244)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 318 ? yytranslate[x] : 244)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 1, 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, 32, 33, 34, 35, 36,
- 37, 41, 42, 46, 47, 48, 49, 55, 56, 57,
- 58, 59, 63, 64, 65, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77
+ 2, 2, 2, 2, 2, 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, 32, 33, 34, 35,
+ 36, 37, 41, 42, 46, 47, 48, 49, 55, 56,
+ 57, 58, 59, 63, 64, 65, 66, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 76, 77
};
#if YYDEBUG != 0
53, 54
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/lib/bison.simple"
-/* This file comes from bison-1.27. */
+#line 3 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
-/* This is the parser code that is written into each bison parser
- when the %semantic_parser declaration is not specified in the grammar.
- It was written by Richard Stallman by simplifying the hairy parser
- used when %semantic_parser is specified. */
-
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
+#ifndef alloca
#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#else /* not GNU C. */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C. */
-/* This used to test MSDOS, but that is a bad idea
- since that symbol is in the user namespace. */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
- instead, just don't use alloca. */
+#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
-#endif
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
- So I turned it off. rms, 2 May 1997. */
-/* #include <malloc.h> */
+#include <malloc.h>
#pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
- and on HPUX 10. Eventually we can turn this on. */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
+#else /* not MSDOS, __TURBOC__, or _AIX */
+#ifdef __hpux
+#ifdef __cplusplus
+extern "C" {
+void *alloca (unsigned int);
+};
+#else /* not __cplusplus */
+void *alloca ();
+#endif /* not __cplusplus */
#endif /* __hpux */
-#endif
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
+#endif /* not sparc. */
+#endif /* not GNU C. */
+#endif /* alloca not defined. */
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
-#else
-#define YYSTACK_ALLOC malloc
-#endif
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
+#define YYACCEPT return(0)
+#define YYABORT return(1)
#define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
-\f
-/* Define __yy_memcpy. Note that the size argument
- should be passed with type unsigned int, because that is what the non-GCC
- definitions require. With GCC, __builtin_memcpy takes an arg
- of type size_t, but it can handle unsigned int. */
+/* Prevent warning if -Wstrict-prototypes. */
+#ifdef __GNUC__
+int yyparse (void);
+#endif
+\f
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
__yy_memcpy (to, from, count)
char *to;
char *from;
- unsigned int count;
+ int count;
{
register char *f = from;
register char *t = to;
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
-__yy_memcpy (char *to, char *from, unsigned int count)
+__yy_memcpy (char *to, char *from, int count)
{
- register char *t = to;
register char *f = from;
+ register char *t = to;
register int i = count;
while (i-- > 0)
#endif
#endif
\f
-#line 216 "/usr/lib/bison.simple"
+#line 196 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */
-/* Prevent warning if -Wstrict-prototypes. */
-#ifdef __GNUC__
-#ifdef YYPARSE_PARAM
-int yyparse (void *);
-#else
-int yyparse (void);
-#endif
-#endif
-
int
yyparse(YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
#endif
int yystacksize = YYINITDEPTH;
- int yyfree_stacks = 0;
#ifdef YYPURE
int yychar;
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
- yyfree_stacks = 1;
-#endif
- yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
- __yy_memcpy ((char *)yyss, (char *)yyss1,
- size * (unsigned int) sizeof (*yyssp));
- yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
- __yy_memcpy ((char *)yyvs, (char *)yyvs1,
- size * (unsigned int) sizeof (*yyvsp));
+ yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+ __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
+ yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+ __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
- yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
- __yy_memcpy ((char *)yyls, (char *)yyls1,
- size * (unsigned int) sizeof (*yylsp));
+ yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+ __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 542 "/usr/lib/bison.simple"
+#line 498 "/usr/cygnus/TBD-TBD/share/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
yystate = yyn;
goto yynewstate;
-
- yyacceptlab:
- /* YYACCEPT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 0;
-
- yyabortlab:
- /* YYABORT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 1;
}
#line 2254 "c-parse.y"
typedef union {long itype; tree ttype; enum tree_code code;
char *filename; int lineno; int ends_in_label; } YYSTYPE;
-#define IDENTIFIER 257
-#define TYPENAME 258
-#define SCSPEC 259
-#define TYPESPEC 260
-#define TYPE_QUAL 261
-#define CONSTANT 262
-#define STRING 263
-#define ELLIPSIS 264
-#define SIZEOF 265
-#define ENUM 266
-#define STRUCT 267
-#define UNION 268
-#define IF 269
-#define ELSE 270
-#define WHILE 271
-#define DO 272
-#define FOR 273
-#define SWITCH 274
-#define CASE 275
-#define DEFAULT 276
-#define BREAK 277
-#define CONTINUE 278
-#define RETURN 279
-#define GOTO 280
-#define ASM_KEYWORD 281
-#define TYPEOF 282
-#define ALIGNOF 283
-#define ATTRIBUTE 284
-#define EXTENSION 285
-#define LABEL 286
-#define REALPART 287
-#define IMAGPART 288
-#define VA_ARG 289
-#define END_OF_LINE 290
-#define ASSIGN 291
-#define OROR 292
-#define ANDAND 293
-#define EQCOMPARE 294
-#define ARITHCOMPARE 295
-#define LSHIFT 296
-#define RSHIFT 297
-#define UNARY 298
-#define PLUSPLUS 299
-#define MINUSMINUS 300
-#define HYPERUNARY 301
-#define POINTSAT 302
-#define INTERFACE 303
-#define IMPLEMENTATION 304
-#define END 305
-#define SELECTOR 306
-#define DEFS 307
-#define ENCODE 308
-#define CLASSNAME 309
-#define PUBLIC 310
-#define PRIVATE 311
-#define PROTECTED 312
-#define PROTOCOL 313
-#define OBJECTNAME 314
-#define CLASS 315
-#define ALIAS 316
-#define OBJC_STRING 317
+#define IDENTIFIER 258
+#define TYPENAME 259
+#define SCSPEC 260
+#define TYPESPEC 261
+#define TYPE_QUAL 262
+#define CONSTANT 263
+#define STRING 264
+#define ELLIPSIS 265
+#define SIZEOF 266
+#define ENUM 267
+#define STRUCT 268
+#define UNION 269
+#define IF 270
+#define ELSE 271
+#define WHILE 272
+#define DO 273
+#define FOR 274
+#define SWITCH 275
+#define CASE 276
+#define DEFAULT 277
+#define BREAK 278
+#define CONTINUE 279
+#define RETURN 280
+#define GOTO 281
+#define ASM_KEYWORD 282
+#define TYPEOF 283
+#define ALIGNOF 284
+#define ATTRIBUTE 285
+#define EXTENSION 286
+#define LABEL 287
+#define REALPART 288
+#define IMAGPART 289
+#define VA_ARG 290
+#define END_OF_LINE 291
+#define ASSIGN 292
+#define OROR 293
+#define ANDAND 294
+#define EQCOMPARE 295
+#define ARITHCOMPARE 296
+#define LSHIFT 297
+#define RSHIFT 298
+#define UNARY 299
+#define PLUSPLUS 300
+#define MINUSMINUS 301
+#define HYPERUNARY 302
+#define POINTSAT 303
+#define INTERFACE 304
+#define IMPLEMENTATION 305
+#define END 306
+#define SELECTOR 307
+#define DEFS 308
+#define ENCODE 309
+#define CLASSNAME 310
+#define PUBLIC 311
+#define PRIVATE 312
+#define PROTECTED 313
+#define PROTOCOL 314
+#define OBJECTNAME 315
+#define CLASS 316
+#define ALIAS 317
+#define OBJC_STRING 318
extern YYSTYPE yylval;
#include "config.h"
#include "system.h"
#include <setjmp.h>
-
#include "tree.h"
#include "input.h"
#include "c-lex.h"
const char *msgid;
{
int win = lvalue_p (ref);
+
if (! win)
error (msgid);
+
return win;
}
/* Handle (a, b) used as an "lvalue". */
case COMPOUND_EXPR:
pedantic_lvalue_warning (COMPOUND_EXPR);
- newrhs = build_modify_expr (TREE_OPERAND (lhs, 1),
- modifycode, rhs);
+ newrhs = build_modify_expr (TREE_OPERAND (lhs, 1), modifycode, rhs);
if (TREE_CODE (newrhs) == ERROR_MARK)
return error_mark_node;
return build (COMPOUND_EXPR, lhstype,
/* Record the contents of OUTPUTS before it is modified. */
for (i = 0, tail = outputs; tail; tail = TREE_CHAIN (tail), i++)
- o[i] = TREE_VALUE (tail);
+ {
+ tree output = TREE_VALUE (tail);
+
+ /* We can remove conversions that just change the type, not the mode. */
+ STRIP_NOPS (output);
+ o[i] = output;
+
+ /* Allow conversions as LHS here. build_modify_expr as called below
+ will do the right thing with them. */
+ while (TREE_CODE (output) == NOP_EXPR
+ || TREE_CODE (output) == CONVERT_EXPR
+ || TREE_CODE (output) == FLOAT_EXPR
+ || TREE_CODE (output) == FIX_TRUNC_EXPR
+ || TREE_CODE (output) == FIX_FLOOR_EXPR
+ || TREE_CODE (output) == FIX_ROUND_EXPR
+ || TREE_CODE (output) == FIX_CEIL_EXPR)
+ output = TREE_OPERAND (output, 1);
+
+ lvalue_or_else (o[i], "invalid lvalue in asm statement");
+ }
/* Perform default conversions on array and function inputs. */
/* Don't do this for other types--
/* Save and restore call-clobbered registers which are live across a call.
- Copyright (C) 1989, 1992, 94-95, 97, 98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1989, 92, 94, 95, 97, 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
preserve_temp_slots (target);
}
- emit_group_store (target, valreg, bytes,
- TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
+ if (! rtx_equal_p (target, valreg))
+ emit_group_store (target, valreg, bytes,
+ TYPE_ALIGN (TREE_TYPE (exp)) / BITS_PER_UNIT);
}
else if (target && GET_MODE (target) == TYPE_MODE (TREE_TYPE (exp))
&& GET_MODE (target) == GET_MODE (valreg))
= mode_for_size (argvec[argnum].size.constant * BITS_PER_UNIT,
MODE_INT, 1);
rtx stack_area
- = gen_rtx_MEM (save_mode,
- memory_address (save_mode,
- plus_constant (argblock, argvec[argnum].offset.constant)));
+ = gen_rtx_MEM
+ (save_mode,
+ memory_address
+ (save_mode,
+ plus_constant (argblock,
+ argvec[argnum].offset.constant)));
+
argvec[argnum].save_area = gen_reg_rtx (save_mode);
emit_move_insn (argvec[argnum].save_area, stack_area);
}
enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
rtx stack_area
= gen_rtx_MEM (save_mode,
- memory_address (save_mode,
- plus_constant (argblock, argvec[count].offset.constant)));
+ memory_address
+ (save_mode,
+ plus_constant (argblock,
+ argvec[count].offset.constant)));
emit_move_insn (stack_area, argvec[count].save_area);
}
= mode_for_size (argvec[argnum].size.constant * BITS_PER_UNIT,
MODE_INT, 1);
rtx stack_area
- = gen_rtx_MEM (save_mode,
- memory_address (save_mode,
- plus_constant (argblock,
- argvec[argnum].offset.constant)));
+ = gen_rtx_MEM
+ (save_mode,
+ memory_address
+ (save_mode,
+ plus_constant (argblock,
+ argvec[argnum].offset.constant)));
argvec[argnum].save_area = gen_reg_rtx (save_mode);
+
emit_move_insn (argvec[argnum].save_area, stack_area);
}
#endif
enum machine_mode save_mode = GET_MODE (argvec[count].save_area);
rtx stack_area
= gen_rtx_MEM (save_mode,
- memory_address (save_mode, plus_constant (argblock,
- argvec[count].offset.constant)));
+ memory_address
+ (save_mode,
+ plus_constant (argblock,
+ argvec[count].offset.constant)));
emit_move_insn (stack_area, argvec[count].save_area);
}
if (arg->value == arg->stack)
{
- /* If the value is already in the stack slot, we are done moving
- data. */
+ /* If the value is already in the stack slot, we are done. */
if (current_function_check_memory_usage && GET_CODE (arg->stack) == MEM)
{
emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
#define fopen(fname,mode) VMS_fopen (fname,mode)
#define freopen(fname,mode,ofile) VMS_freopen (fname,mode,ofile)
#define fstat(fd,stbuf) VMS_fstat (fd,stbuf)
+#define fwrite(ptr,size,nitems,stream) VMS_fwrite (ptr,size,nitems,stream)
static int VMS_fstat (), VMS_stat ();
static int VMS_open ();
static FILE *VMS_fopen ();
static FILE *VMS_freopen ();
-static int hack_vms_include_specification ();
+static size_t VMS_fwrite ();
+static void hack_vms_include_specification ();
#define INO_T_EQ(a, b) (!bcmp((char *) &(a), (char *) &(b), sizeof (a)))
#define INO_T_HASH(a) 0
#define INCLUDE_LEN_FUDGE 12 /* leave room for VMS syntax conversion */
static int warn_undef;
+/* Nonzero means warn if we find white space where it doesn't belong. */
+
+static int warn_white_space;
+
/* Nonzero means warn if #import is used. */
static int warn_import = 1;
#endif
static int do_unassert DO_PROTO;
static int do_undef DO_PROTO;
-static int do_warning DO_PROTO;
static int do_xifdef DO_PROTO;
/* Here is the actual list of #-directives, most-often-used first. */
{ 6, do_include, "import", T_IMPORT},
{ 5, do_undef, "undef", T_UNDEF},
{ 5, do_error, "error", T_ERROR},
- { 7, do_warning, "warning", T_WARNING},
+ { 7, do_error, "warning", T_WARNING},
#ifdef SCCS_DIRECTIVE
{ 4, do_sccs, "sccs", T_SCCS},
#endif
\f
static int safe_read PROTO((int, char *, int));
static void safe_write PROTO((int, char *, int));
-static void eprint_string PROTO((const char *, size_t));
int main PROTO((int, char **));
static U_CHAR *index0 PROTO((U_CHAR *, int, size_t));
static void trigraph_pcp PROTO((FILE_BUF *));
+static void check_white_space PROTO((FILE_BUF *));
static void newline_fix PROTO((U_CHAR *));
static void name_newline_fix PROTO((U_CHAR *));
static int discard_comments PROTO((U_CHAR *, int, int));
-static int change_newlines PROTO((U_CHAR *, int));
+static void change_newlines PROTO((struct argdata *));
static void notice PVPROTO((const char *, ...)) ATTRIBUTE_PRINTF_1;
static void vnotice PROTO((const char *, va_list));
}
}
-/* Print a string to stderr, with extra handling in case it contains
- embedded NUL characters. Any present are written as is.
-
- Using fwrite for this purpose produces undesireable results on VMS
- when stderr happens to be a record oriented file, such as a batch log
- file, rather than a stream oriented one. */
-
-static void
-eprint_string (string, length)
- const char *string;
- size_t length;
-{
- size_t segment_length;
-
- do {
- fprintf(stderr, "%s", string);
- length -= (segment_length = strlen(string));
- if (length > 0)
- {
- fputc('\0', stderr);
- length -= 1;
- /* Advance past the portion which has already been printed. */
- string += segment_length + 1;
- }
- } while (length > 0);
-}
-
\f
static void
print_help ()
case 'i':
if (!strcmp (argv[i], "-include")) {
- int temp = i;
-
if (i + 1 == argc)
fatal ("Filename missing after `-include' option");
- else
- simplify_filename (pend_includes[temp] = argv[++i]);
+ else {
+ simplify_filename (pend_includes[i] = argv[i]);
+ i++;
+ }
}
if (!strcmp (argv[i], "-imacros")) {
- int temp = i;
-
if (i + 1 == argc)
fatal ("Filename missing after `-imacros' option");
- else
- simplify_filename (pend_files[temp] = argv[++i]);
+ else {
+ simplify_filename (pend_files[i] = argv[i]);
+ i++;
+ }
}
if (!strcmp (argv[i], "-iprefix")) {
if (i + 1 == argc)
warn_stringify = 1;
else if (!strcmp (argv[i], "-Wno-traditional"))
warn_stringify = 0;
+ else if (!strcmp (argv[i], "-Wwhite-space"))
+ warn_white_space = 1;
+ else if (!strcmp (argv[i], "-Wno-white-space"))
+ warn_white_space = 0;
else if (!strcmp (argv[i], "-Wundef"))
warn_undef = 1;
else if (!strcmp (argv[i], "-Wno-undef"))
{
warn_trigraphs = 1;
warn_comments = 1;
+ warn_white_space = 1;
}
break;
case 'I': /* Add directory to path for includes. */
{
struct file_name_list *dirtmp;
+ char *dir = argv[i][2] ? argv[i] + 2 : argv[++i];
- if (! ignore_srcdir && !strcmp (argv[i] + 2, "-")) {
+ if (! ignore_srcdir && !strcmp (dir, "-")) {
ignore_srcdir = 1;
/* Don't use any preceding -I directories for #include <...>. */
first_bracket_include = 0;
}
else {
- dirtmp = new_include_prefix (last_include, NULL_PTR, "",
- argv[i][2] ? argv[i] + 2 : argv[++i]);
+ dirtmp = new_include_prefix (last_include, NULL_PTR, "", dir);
append_include_chain (dirtmp, dirtmp);
}
}
else
print_deps = 1;
- s = spec;
/* Find the space before the DEPS_TARGET, if there is one. */
- /* This should use index. (mrs) */
- while (*s != 0 && *s != ' ') s++;
- if (*s != 0) {
+ s = index (spec, ' ');
+ if (s) {
deps_target = s + 1;
output_file = xmalloc (s - spec + 1);
bcopy (spec, output_file, s - spec);
output_file[s - spec] = 0;
- }
- else {
+ } else {
deps_target = 0;
output_file = spec;
}
strcpy (q, OBJECT_SUFFIX);
deps_output (p, ':');
- deps_output (in_fname, ' ');
}
+
+ deps_output (in_fname, ' ');
}
/* Scan the -imacros files before the main input.
if (!no_trigraphs)
trigraph_pcp (fp);
+ if (warn_white_space)
+ check_white_space (fp);
+
/* Now that we know the input file is valid, open the output. */
if (!out_fname || !strcmp (out_fname, ""))
warning_with_line (0, "%lu trigraph(s) encountered",
(unsigned long) (fptr - bptr) / 2);
}
+
+/* Warn about white space between backslash and end of line. */
+
+static void
+check_white_space (buf)
+ FILE_BUF *buf;
+{
+ register U_CHAR *sptr = buf->buf;
+ register U_CHAR *lptr = sptr + buf->length;
+ register U_CHAR *nptr;
+ int line = 0;
+
+ nptr = sptr = buf->buf;
+ lptr = sptr + buf->length;
+ for (nptr = sptr;
+ (nptr = index0 (nptr, '\n', (size_t) (lptr - nptr))) != NULL;
+ nptr ++) {
+ register U_CHAR *p = nptr;
+ line++;
+ for (p = nptr; sptr < p; p--) {
+ if (! is_hor_space[p[-1]]) {
+ if (p[-1] == '\\' && p != nptr)
+ warning_with_line (line,
+ "`\\' followed by white space at end of line");
+ break;
+ }
+ }
+ }
+}
\f
/* Move all backslash-newline pairs out of embarrassing places.
Exchange all such pairs following BP
with any potentially-embarrassing characters that follow them.
Potentially-embarrassing characters are / and *
(because a backslash-newline inside a comment delimiter
- would cause it not to be recognized). */
+ would cause it not to be recognized).
+ We assume that *BP == '\\'. */
static void
newline_fix (bp)
register U_CHAR *p = bp;
/* First count the backslash-newline pairs here. */
-
- while (p[0] == '\\' && p[1] == '\n')
+ do {
+ if (p[1] != '\n')
+ break;
p += 2;
+ } while (*p == '\\');
/* What follows the backslash-newlines is not embarrassing. */
if (*p != '/' && *p != '*')
+ /* What follows the backslash-newlines is not embarrassing. */
return;
/* Copy all potentially embarrassing characters
that follow the backslash-newline pairs
down to where the pairs originally started. */
-
- while (*p == '*' || *p == '/')
+ do
*bp++ = *p++;
+ while (*p == '*' || *p == '/');
/* Now write the same number of pairs after the embarrassing chars. */
while (bp < p) {
register U_CHAR *p = bp;
/* First count the backslash-newline pairs here. */
- while (p[0] == '\\' && p[1] == '\n')
+ do {
+ if (p[1] != '\n')
+ break;
p += 2;
+ } while (*p == '\\');
/* What follows the backslash-newlines is not embarrassing. */
if (!is_idchar[*p])
+ /* What follows the backslash-newlines is not embarrassing. */
return;
/* Copy all potentially embarrassing characters
that follow the backslash-newline pairs
down to where the pairs originally started. */
-
- while (is_idchar[*p])
+ do
*bp++ = *p++;
+ while (is_idchar[*p]);
/* Now write the same number of pairs after the embarrassing chars. */
while (bp < p) {
* If OUTPUT_MARKS is nonzero, keep Newline markers found in the input
* and insert them when appropriate. This is set while scanning macro
* arguments before substitution. It is zero when scanning for final output.
- * There are three types of Newline markers:
+ * There are two types of Newline markers:
* * Newline - follows a macro name that was not expanded
* because it appeared inside an expansion of the same macro.
* This marker prevents future expansion of that identifier.
*obp++ = *ibp;
switch (*ibp++) {
case '\n':
+ if (warn_white_space && ip->fname && is_hor_space[ibp[-2]])
+ warning ("white space at end of line in string");
++ip->lineno;
++op->lineno;
/* Traditionally, end of line ends a string constant with no error.
keep the line counts correct. But if we are reading
from a macro, keep the backslash newline, since backslash
newlines have already been processed. */
- if (ip->macro)
+ if (ip->macro) {
*obp++ = '\n';
- else
+ ++op->lineno;
+ } else
--obp;
++ibp;
++ip->lineno;
is *not* prevented from combining with a newline. */
if (!ip->macro) {
while (*ibp == '\\' && ibp[1] == '\n') {
- ibp += 2;
+ *obp++ = *ibp++;
+ *obp++ = *ibp++;
++ip->lineno;
+ ++op->lineno;
}
}
*obp++ = *ibp++;
case '/':
if (ip->macro != 0)
goto randomchar;
- if (*ibp == '\\' && ibp[1] == '\n')
+ if (*ibp == '\\')
newline_fix (ibp);
if (*ibp != '*'
&& !(cplusplus_comments && *ibp == '/'))
case '*':
if (ibp[-2] == '/' && warn_comments)
warning ("`/*' within comment");
- if (*ibp == '\\' && ibp[1] == '\n')
+ if (*ibp == '\\')
newline_fix (ibp);
if (*ibp == '/')
goto comment_end;
break;
else if (*ibp == '/') {
/* If a comment, copy it unchanged or discard it. */
- if (ibp[1] == '\\' && ibp[2] == '\n')
+ if (ibp[1] == '\\')
newline_fix (ibp + 1);
if (ibp[1] == '*') {
if (put_out_comments) {
/* We need not worry about newline-marks,
since they are never found in comments. */
if (ibp[0] == '*') {
- if (ibp[1] == '\\' && ibp[2] == '\n')
+ if (ibp[1] == '\\')
newline_fix (ibp + 1);
if (ibp[1] == '/') {
ibp += 2;
if (indepth != odepth)
abort ();
- /* Record the output. */
- obuf.length = obuf.bufp - obuf.buf;
-
assertions_flag = save_assertions_flag;
return obuf;
}
pedwarn_strange_white_space (*bp);
bp++;
} else if (*bp == '/') {
- if (bp[1] == '\\' && bp[2] == '\n')
+ if (bp[1] == '\\')
newline_fix (bp + 1);
if (! (bp[1] == '*' || (cplusplus_comments && bp[1] == '/')))
break;
if (is_idchar[*cp])
cp++;
else {
- if (*cp == '\\' && cp[1] == '\n')
+ if (*cp == '\\')
name_newline_fix (cp);
if (is_idchar[*cp])
cp++;
register U_CHAR c = *bp++;
switch (c) {
case '\\':
- if (bp < limit) {
- if (*bp == '\n') {
- ip->lineno++;
- copy_directive = 1;
- bp++;
- } else if (traditional)
- bp++;
- }
+ if (*bp == '\n') {
+ ip->lineno++;
+ copy_directive = 1;
+ bp++;
+ } else if (traditional && bp < limit)
+ bp++;
break;
case '"':
break;
case '/':
- if (*bp == '\\' && bp[1] == '\n')
+ if (*bp == '\\')
newline_fix (bp);
if (*bp == '*'
|| (cplusplus_comments && *bp == '/')) {
register U_CHAR *xp = buf;
/* Need to copy entire directive into temp buffer before dispatching */
- cp = (U_CHAR *) alloca (bp - buf + 5); /* room for directive plus
- some slop */
+ /* room for directive plus some slop */
+ cp = (U_CHAR *) alloca (2 * (bp - buf) + 5);
buf = cp;
/* Copy to the new buffer, deleting comments
- and backslash-newlines (and whitespace surrounding the latter). */
+ and backslash-newlines (and whitespace surrounding the latter
+ if outside of char and string constants). */
while (xp < bp) {
register U_CHAR c = *xp++;
directives through. */
if (!no_output && already_output == 0
- && (kt->type == T_DEFINE ? (int) dump_names <= (int) dump_macros
+ && ((kt->type == T_DEFINE || kt->type == T_UNDEF)
+ ? (int) dump_names <= (int) dump_macros
: IS_INCLUDE_DIRECTIVE_TYPE (kt->type) ? dump_includes
: kt->type == T_PRAGMA)) {
int len;
bcopy (buf, (char *) op->bufp, len);
}
op->bufp += len;
- } /* Don't we need a newline or #line? */
+ }
/* Call the appropriate directive handler. buf now points to
either the appropriate place in the input buffer, or to
static struct tm *
timestamp ()
{
- static struct tm *timebuf;
- if (!timebuf) {
+ static struct tm tmbuf;
+ if (! tmbuf.tm_mday) {
time_t t = time ((time_t *) 0);
- timebuf = localtime (&t);
+ struct tm *tm = localtime (&t);
+ if (tm)
+ tmbuf = *tm;
+ else {
+ /* Use 0000-01-01 00:00:00 if local time is not available. */
+ tmbuf.tm_year = -1900;
+ tmbuf.tm_mday = 1;
+ }
}
- return timebuf;
+ return &tmbuf;
}
static char *monthnames[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
if (!no_trigraphs)
trigraph_pcp (fp);
+ if (warn_white_space)
+ check_white_space (fp);
+
output_line_directive (fp, op, 0, enter_file);
rescan (op, 0);
tmpbuf = expand_to_temp_buffer (string_start, cp++, 0, 0);
/* Lineno is already set in the precompiled file */
str->contents = tmpbuf.buf;
- str->len = tmpbuf.length;
+ str->len = tmpbuf.bufp - tmpbuf.buf;
str->writeflag = 0;
str->filename = name;
str->output_mark = outbuf.bufp - outbuf.buf;
for (; nkeys--; free (tmpbuf.buf), cp = endofthiskey + 1) {
KEYDEF *kp = (KEYDEF *) (GENERIC_PTR) cp;
HASHNODE *hp;
+ U_CHAR *bp;
/* It starts with a KEYDEF structure */
cp += sizeof (KEYDEF);
/* Expand the key, and enter it into the hash table. */
tmpbuf = expand_to_temp_buffer (cp, endofthiskey, 0, 0);
- tmpbuf.bufp = tmpbuf.buf;
+ bp = tmpbuf.buf;
- while (is_hor_space[*tmpbuf.bufp])
- tmpbuf.bufp++;
- if (!is_idstart[*tmpbuf.bufp]
- || tmpbuf.bufp == tmpbuf.buf + tmpbuf.length) {
+ while (is_hor_space[*bp])
+ bp++;
+ if (!is_idstart[*bp] || bp == tmpbuf.bufp) {
str->writeflag = 1;
continue;
}
- hp = lookup (tmpbuf.bufp, -1, -1);
+ hp = lookup (bp, -1, -1);
if (hp == NULL) {
kp->chain = 0;
- install (tmpbuf.bufp, -1, T_PCSTRING, (char *) kp, -1);
+ install (bp, -1, T_PCSTRING, (char *) kp, -1);
}
else if (hp->type == T_PCSTRING) {
kp->chain = hp->value.keydef;
break;
case '\\':
- if (p < limit && expected_delimiter) {
+ if (expected_delimiter) {
/* In a string, backslash goes through
and makes next char ordinary. */
*exp_p++ = *p++;
/* Point to macroexpanded line, which is null-terminated now. */
bp = tem.buf;
+ limit = tem.bufp;
SKIP_WHITE_SPACE (bp);
if (!ISDIGIT (*bp)) {
p = bp;
for (;;)
switch ((*p++ = *bp++)) {
- case '\0':
- error ("invalid format `#line' directive");
- return 0;
-
case '\\':
if (! ignore_escape_flag)
{
return 0;
}
\f
+
/* Report an error detected by the program we are processing.
- Use the text of the line in the error message.
- (We use error because it prints the filename & line#.) */
+ Use the text of the line in the error message. */
static int
do_error (buf, limit, op, keyword)
U_CHAR *buf, *limit;
FILE_BUF *op ATTRIBUTE_UNUSED;
- struct directive *keyword ATTRIBUTE_UNUSED;
+ struct directive *keyword;
{
int length = limit - buf;
U_CHAR *copy = (U_CHAR *) alloca (length + 1);
bcopy ((char *) buf, (char *) copy, length);
copy[length] = 0;
SKIP_WHITE_SPACE (copy);
- error ("#error %s", copy);
- return 0;
-}
-/* Report a warning detected by the program we are processing.
- Use the text of the line in the warning message, then continue.
- (We use error because it prints the filename & line#.) */
+ switch (keyword->type) {
+ case T_ERROR:
+ error ("#error %s", copy);
+ break;
-static int
-do_warning (buf, limit, op, keyword)
- U_CHAR *buf, *limit;
- FILE_BUF *op ATTRIBUTE_UNUSED;
- struct directive *keyword ATTRIBUTE_UNUSED;
-{
- int length = limit - buf;
- U_CHAR *copy = (U_CHAR *) alloca (length + 1);
- bcopy ((char *) buf, (char *) copy, length);
- copy[length] = 0;
- SKIP_WHITE_SPACE (copy);
+ case T_WARNING:
+ if (pedantic && !instack[indepth].system_header_p)
+ pedwarn ("ANSI C does not allow `#warning'");
+ warning ("#warning %s", copy);
+ break;
- if (pedantic && !instack[indepth].system_header_p)
- pedwarn ("ANSI C does not allow `#warning'");
+ default:
+ abort ();
+ }
- /* Use `pedwarn' not `warning', because #warning isn't in the C Standard;
- if -pedantic-errors is given, #warning should cause an error. */
- pedwarn ("#warning %s", copy);
return 0;
}
-
/* Remember the name of the current file being read from so that we can
avoid ever including it again. */
return 0;
fname = p + 1;
- if ((p = (U_CHAR *) index ((char *) fname, '\"')))
- *p = '\0';
+ p = skip_quoted_string (p, limit, 0, NULL_PTR, NULL_PTR, NULL_PTR);
+ if (p[-1] == '"')
+ *--p = '\0';
for (h = 0; h < INCLUDE_HASHSIZE; h++) {
struct include_file *inc;
&& !bcmp (if_stack->fname, ip->nominal_fname,
if_stack->fname_len))) {
fprintf (stderr, ", file ");
- eprint_string (if_stack->fname, if_stack->fname_len);
+ fwrite (if_stack->fname, sizeof if_stack->fname[0],
+ if_stack->fname_len, stderr);
}
fprintf (stderr, ")\n");
}
pcp_inside_if = 0;
delete_macro (save_defined); /* clean up special symbol */
- temp_obuf.buf[temp_obuf.length] = '\n';
+ *temp_obuf.bufp = '\n';
value = parse_c_expression ((char *) temp_obuf.buf,
warn_undef && !instack[indepth].system_header_p);
while (bp < endb) {
switch (*bp++) {
case '/': /* possible comment */
- if (*bp == '\\' && bp[1] == '\n')
+ if (*bp == '\\')
newline_fix (bp);
if (*bp == '*'
|| (cplusplus_comments && *bp == '/')) {
else if (*bp == '\\' && bp[1] == '\n')
bp += 2;
else if (*bp == '/') {
- if (bp[1] == '\\' && bp[2] == '\n')
+ if (bp[1] == '\\')
newline_fix (bp + 1);
if (bp[1] == '*') {
for (bp += 2; ; bp++) {
else if (*bp == '*') {
if (bp[-1] == '/' && warn_comments)
warning ("`/*' within comment");
- if (bp[1] == '\\' && bp[2] == '\n')
+ if (bp[1] == '\\')
newline_fix (bp + 1);
if (bp[1] == '/')
break;
if (is_idchar[*bp])
bp++;
else {
- if (*bp == '\\' && bp[1] == '\n')
+ if (*bp == '\\')
name_newline_fix (bp);
if (is_idchar[*bp])
bp++;
&& !bcmp (if_stack->fname, ip->nominal_fname,
if_stack->fname_len))) {
fprintf (stderr, ", file ");
- eprint_string (if_stack->fname, if_stack->fname_len);
+ fwrite (if_stack->fname, sizeof if_stack->fname[0],
+ if_stack->fname_len, stderr);
}
fprintf (stderr, ")\n");
}
case '*':
if (bp[-2] == '/' && !nowarn && warn_comments)
warning ("`/*' within comment");
- if (*bp == '\\' && bp[1] == '\n')
+ if (*bp == '\\')
newline_fix (bp);
if (*bp == '/') {
if (op)
The input stack state is not changed.
If COUNT_NEWLINES is nonzero, it points to an int to increment
- for each newline passed.
+ for each newline passed; also, warn about any white space
+ just before line end.
If BACKSLASH_NEWLINES_P is nonzero, store 1 thru it
if we pass a backslash-newline.
}
if (match == '\'') {
error_with_line (line_for_error (start_line),
- "unterminated string or character constant");
+ "unterminated character constant");
bp--;
if (eofp)
*eofp = 1;
break;
}
/* If not traditional, then allow newlines inside strings. */
- if (count_newlines)
+ if (count_newlines) {
+ if (warn_white_space && is_hor_space[bp[-2]])
+ warning ("white space at end of line in string");
++*count_newlines;
+ }
if (multiline_string_line == 0) {
if (pedantic)
pedwarn_with_line (line_for_error (start_line),
/* This structure represents one parsed argument in a macro call.
`raw' points to the argument text as written (`raw_length' is its length).
`expanded' points to the argument's macro-expansion
- (its length is `expand_length').
- `stringified_length' is the length the argument would have
- if stringified.
+ (its length is `expand_length', and its allocated size is `expand_size').
+ `stringified_length_bound' is an upper bound on the length
+ the argument would have if stringified.
`use_count' is the number of times this macro arg is substituted
into the macro. If the actual use count exceeds 10,
the value stored is 10.
struct argdata {
U_CHAR *raw, *expanded;
- int raw_length, expand_length;
- int stringified_length;
+ int raw_length, expand_length, expand_size;
+ int stringified_length_bound;
U_CHAR *free1, *free2;
char newlines;
char use_count;
for (i = 0; i < nargs; i++) {
args[i].raw = (U_CHAR *) "";
args[i].expanded = 0;
- args[i].raw_length = args[i].expand_length
- = args[i].stringified_length = 0;
+ args[i].raw_length = args[i].expand_length = args[i].expand_size
+ = args[i].stringified_length_bound = 0;
args[i].free1 = args[i].free2 = 0;
args[i].use_count = 0;
}
xbuf_len = defn->length;
for (ap = defn->pattern; ap != NULL; ap = ap->next) {
if (ap->stringify)
- xbuf_len += args[ap->argno].stringified_length;
+ xbuf_len += args[ap->argno].stringified_length_bound;
else if (ap->raw_before != 0 || ap->raw_after != 0 || traditional)
/* Add 4 for two newline-space markers to prevent
token concatenation. */
1, 0);
args[ap->argno].expanded = obuf.buf;
- args[ap->argno].expand_length = obuf.length;
+ args[ap->argno].expand_length = obuf.bufp - obuf.buf;
+ args[ap->argno].expand_size = obuf.length;
args[ap->argno].free2 = obuf.buf;
- }
+ xbuf_len += args[ap->argno].expand_length;
+ } else {
+ /* If the arg appears more than once, its later occurrences
+ may have newline turned into backslash-'n', which is a
+ factor of 2 expansion. */
+ xbuf_len += 2 * args[ap->argno].expand_length;
+ }
/* Add 4 for two newline-space markers to prevent
token concatenation. */
- xbuf_len += args[ap->argno].expand_length + 4;
+ xbuf_len += 4;
}
if (args[ap->argno].use_count < 10)
args[ap->argno].use_count++;
for (; i < arglen; i++) {
c = arg->raw[i];
- if (! in_string) {
- /* Special markers Newline Space
+ if (in_string) {
+ /* Generate nothing for backslash-newline in a string. */
+ if (c == '\\' && arg->raw[i + 1] == '\n') {
+ i++;
+ continue;
+ }
+ } else {
+ /* Special markers
generate nothing for a stringified argument. */
- if (c == '\n' && arg->raw[i+1] != '\n') {
+ if (c == '\n') {
i++;
continue;
}
/* Internal sequences of whitespace are replaced by one space
- except within an string or char token. */
- if (c == '\n' ? arg->raw[i+1] == '\n' : is_space[c]) {
- while (1) {
- /* Note that Newline Space does occur within whitespace
- sequences; consider it part of the sequence. */
- if (c == '\n' && is_space[arg->raw[i+1]])
- i += 2;
- else if (c != '\n' && is_space[c])
- i++;
- else break;
- c = arg->raw[i];
- }
+ except within a string or char token. */
+ if (is_space[c]) {
+ i++;
+ while (is_space[(c = arg->raw[i])])
+ /* Newline markers can occur within a whitespace sequence;
+ consider them part of the sequence. */
+ i += (c == '\n') + 1;
i--;
c = ' ';
}
in_string = c;
}
- /* Escape these chars */
- if (c == '\"' || (in_string && c == '\\'))
+ /* Escape double-quote, and backslashes in strings.
+ Newlines in strings are best escaped as \n, since
+ otherwise backslash-backslash-newline-newline is
+ mishandled. The C Standard doesn't allow newlines in
+ strings, so we can escape newlines as we please. */
+ if (c == '\"'
+ || (in_string
+ && (c == '\\'
+ || (c == '\n' ? (c = 'n', 1) : 0))))
xbuf[totlen++] = '\\';
/* We used to output e.g. \008 for control characters here,
but this doesn't conform to the C Standard.
/* Don't bother doing change_newlines for subsequent
uses of arg. */
arg->use_count = 1;
- arg->expand_length
- = change_newlines (arg->expanded, arg->expand_length);
+ change_newlines (arg);
}
}
{
FILE_BUF *ip = &instack[indepth];
int paren = 0;
- int newlines = 0;
+ int lineno0 = ip->lineno;
int comments = 0;
int result = 0;
/* Try to parse as much of the argument as exists at this
input stack level. */
U_CHAR *bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro,
- &paren, &newlines, &comments, rest_args);
+ &paren, &ip->lineno, &comments, rest_args);
/* If we find the end of the argument at this level,
set up *ARGPTR to point at it in the input stack. */
- if (!(ip->fname != 0 && (newlines != 0 || comments != 0))
+ if (!(ip->fname != 0 && (ip->lineno != lineno0 || comments != 0))
&& bp != ip->buf + ip->length) {
if (argptr != 0) {
argptr->raw = ip->bufp;
argptr->raw_length = bp - ip->bufp;
- argptr->newlines = newlines;
+ argptr->newlines = ip->lineno - lineno0;
}
ip->bufp = bp;
} else {
Therefore, we must allocate a temporary buffer and copy
the macro argument into it. */
int bufsize = bp - ip->bufp;
- int extra = newlines;
+ int extra = ip->lineno - lineno0;
U_CHAR *buffer = (U_CHAR *) xmalloc (bufsize + extra + 1);
int final_start = 0;
bcopy ((char *) ip->bufp, (char *) buffer, bufsize);
ip->bufp = bp;
- ip->lineno += newlines;
while (bp == ip->buf + ip->length) {
if (instack[indepth].macro == 0) {
if (ip->free_ptr)
free (ip->free_ptr);
ip = &instack[--indepth];
- newlines = 0;
+ lineno0 = ip->lineno;
comments = 0;
bp = macarg1 (ip->bufp, ip->buf + ip->length, ip->macro, &paren,
- &newlines, &comments, rest_args);
+ &ip->lineno, &comments, rest_args);
final_start = bufsize;
bufsize += bp - ip->bufp;
- extra += newlines;
+ extra += ip->lineno - lineno0;
buffer = (U_CHAR *) xrealloc (buffer, bufsize + extra + 1);
bcopy ((char *) ip->bufp, (char *) (buffer + bufsize - (bp - ip->bufp)),
bp - ip->bufp);
ip->bufp = bp;
- ip->lineno += newlines;
}
/* Now, if arg is actually wanted, record its raw form,
argptr->raw = buffer;
argptr->raw_length = bufsize;
argptr->free1 = buffer;
- argptr->newlines = newlines;
- if ((newlines || comments) && ip->fname != 0)
+ argptr->newlines = ip->lineno - lineno0;
+ if ((argptr->newlines || comments) && ip->fname != 0)
argptr->raw_length
= final_start +
discard_comments (argptr->raw + final_start,
argptr->raw_length - final_start,
- newlines);
+ argptr->newlines);
argptr->raw[argptr->raw_length] = 0;
if (argptr->raw_length > bufsize + extra)
abort ();
SKIP_ALL_WHITE_SPACE (buf);
else
#endif
- if (c == '\"' || c == '\\') /* escape these chars */
+ if (c == '\"' || c == '\\' || c == '\n') /* escape these chars */
totlen++;
}
- argptr->stringified_length = totlen;
+ argptr->stringified_length_bound = totlen;
}
return result;
}
case '/':
if (macro)
break;
- if (bp[1] == '\\' && bp[2] == '\n')
+ if (bp[1] == '\\')
newline_fix (bp + 1);
if (bp[1] == '*') {
*comments = 1;
else if (*bp == '*') {
if (bp[-1] == '/' && warn_comments)
warning ("`/*' within comment");
- if (bp[1] == '\\' && bp[2] == '\n')
+ if (bp[1] == '\\')
newline_fix (bp + 1);
if (bp[1] == '/') {
bp++;
case '\"':
{
int quotec;
- for (quotec = *bp++; bp + 1 < limit && *bp != quotec; bp++) {
+ for (quotec = *bp++; bp < limit && *bp != quotec; bp++) {
if (*bp == '\\') {
bp++;
if (*bp == '\n')
++*newlines;
- if (!macro) {
- while (*bp == '\\' && bp[1] == '\n') {
- bp += 2;
- ++*newlines;
- }
+ while (*bp == '\\' && bp[1] == '\n') {
+ bp += 2;
+ ++*newlines;
}
} else if (*bp == '\n') {
+ if (warn_white_space && is_hor_space[bp[-1]] && ! macro)
+ warning ("white space at end of line in string");
++*newlines;
if (quotec == '\'')
break;
break;
case '/':
- if (*ibp == '\\' && ibp[1] == '\n')
+ if (*ibp == '\\')
newline_fix (ibp);
/* Delete any comment. */
if (cplusplus_comments && ibp[0] == '/') {
obp[-1] = ' ';
while (++ibp < limit) {
if (ibp[0] == '*') {
- if (ibp[1] == '\\' && ibp[2] == '\n')
+ if (ibp[1] == '\\')
newline_fix (ibp + 1);
if (ibp[1] == '/') {
ibp += 2;
return obp - start;
}
\f
-/* Turn newlines to spaces in the string of length LENGTH at START,
- except inside of string constants.
- The string is copied into itself with its beginning staying fixed. */
+/* Turn newlines to spaces in the macro argument ARG.
+ Remove backslash-newline from string constants,
+ and turn other newlines in string constants to backslash-'n'. */
-static int
-change_newlines (start, length)
- U_CHAR *start;
- int length;
+static void
+change_newlines (arg)
+ struct argdata *arg;
{
+ U_CHAR *start = arg->expanded;
+ int length = arg->expand_length;
register U_CHAR *ibp;
register U_CHAR *obp;
register U_CHAR *limit;
}
}
- return obp - start;
+ arg->expand_length = obp - arg->expanded;
+
+ if (start != arg->expanded)
+ free (start);
}
\f
/* notice - output message to stderr */
}
if (ip != NULL) {
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, ":%d: ", ip->lineno);
}
vnotice (msgid, args);
}
if (ip != NULL) {
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, ":%d: ", ip->lineno);
}
}
if (ip != NULL) {
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, ":%d: ", ip->lineno);
}
notice ("warning: ");
}
if (ip != NULL) {
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, ":%d: ", line);
}
vnotice (msgid, args);
}
if (ip != NULL) {
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, line ? ":%d: " : ": ", line);
}
notice ("warning: ");
#endif
if (file) {
- eprint_string (file, file_len);
+ fwrite (file, sizeof file[0], file_len, stderr);
fprintf (stderr, ":%d: ", line);
}
if (pedantic_errors)
notice (",\n from ");
}
- eprint_string (ip->nominal_fname, ip->nominal_fname_len);
+ fwrite (ip->nominal_fname, sizeof ip->nominal_fname[0],
+ ip->nominal_fname_len, stderr);
fprintf (stderr, ":%d", ip->lineno);
}
if (! first)
NULL_PTR, NULL_PTR, &unterminated);
if (unterminated)
return;
- while (p != p1)
- *q++ = *p++;
+ while (p != p1) {
+ if (*p == '\\' && p[1] == '\n')
+ p += 2;
+ else if (*p == '\n')
+ {
+ *q++ = '\\';
+ *q++ = 'n';
+ p++;
+ }
+ else
+ *q++ = *p++;
+ }
} else if (*p == '\\' && p[1] == '\n')
p += 2;
/* Change newline chars into newline-markers. */
return result;
}
+
+static size_t
+VMS_fwrite (ptr, size, nitems, stream)
+ void const *ptr;
+ size_t size;
+ size_t nitems;
+ FILE *stream;
+{
+ /* VMS fwrite has undesirable results
+ if STREAM happens to be a record oriented file.
+ Work around this problem by writing each character individually. */
+ char const *p = ptr;
+ size_t bytes = size * nitems;
+ char *lim = p + bytes;
+
+ while (p < lim)
+ if (putc (*p++, stream) == EOF)
+ return 0;
+
+ return bytes;
+}
#endif /* VMS */
26, 27, 23, 24, 25, 26, 27, 0, 9
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/tmp/sky/share/bison.simple"
+#line 3 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
#endif
#endif
\f
-#line 196 "/tmp/sky/share/bison.simple"
+#line 196 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 498 "/tmp/sky/share/bison.simple"
+#line 498 "/usr/cygnus/TBD-TBD/share/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
#include "config.h"
#include "system.h"
-#include "rtl.h" /* stdio.h must precede rtl.h for FFS. */
+#include "rtl.h"
#include "flags.h"
#include "regs.h"
#include "hard-reg-set.h"
? gen_rtx_SET (VOIDmode, i1dest, i1src) : PATTERN (i1));
if (added_sets_2)
- {
- /* If there is no I1, use I2's body as is. We used to also not do
- the subst call below if I2 was substituted into I3,
- but that could lose a simplification. */
- if (i1 == 0)
- XVECEXP (newpat, 0, --total_sets) = i2pat;
- else
- /* See comment where i2pat is assigned. */
- XVECEXP (newpat, 0, --total_sets)
- = subst (i2pat, i1dest, i1src, 0, 0);
- }
+ {
+ /* If there is no I1, use I2's body as is. We used to also not do
+ the subst call below if I2 was substituted into I3,
+ but that could lose a simplification. */
+ if (i1 == 0)
+ XVECEXP (newpat, 0, --total_sets) = i2pat;
+ else
+ /* See comment where i2pat is assigned. */
+ XVECEXP (newpat, 0, --total_sets)
+ = subst (i2pat, i1dest, i1src, 0, 0);
+ }
}
/* We come here when we are replacing a destination in I2 with the
|| (REG_N_SETS (REGNO (i2dest)) == 1 && ! added_sets_2
&& ! REG_USERVAR_P (i2dest))))
ni2dest = gen_rtx_REG (GET_MODE (SET_DEST (newpat)),
- REGNO (i2dest));
-
- m_split = split_insns
- (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2, newpat,
- gen_rtx_CLOBBER (VOIDmode,
- ni2dest))),
- i3);
+ REGNO (i2dest));
+
+ m_split = split_insns (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2, newpat,
+ gen_rtx_CLOBBER (VOIDmode,
+ ni2dest))),
+ i3);
}
if (m_split && GET_CODE (m_split) == SEQUENCE
low-order bits. */
if (GET_MODE_CLASS (mode) == MODE_INT)
- src = force_to_mode (src, mode, GET_MODE_MASK (mode), NULL_RTX, 0);
+ {
+ src = force_to_mode (src, mode, GET_MODE_MASK (mode), NULL_RTX, 0);
+ SUBST (SET_SRC (x), src);
+ }
/* If we are setting CC0 or if the source is a COMPARE, look for the use of
the comparison result and try to simplify it unless we already have used
src = SET_SRC (x);
}
+#ifdef HAVE_conditional_arithmetic
+ /* If we have conditional arithmetic and the operand of a SET is
+ a conditional expression, replace this with an IF_THEN_ELSE.
+ We can either have a conditional expression or a MULT of that expression
+ with a constant. */
+ if ((GET_RTX_CLASS (GET_CODE (src)) == '1'
+ || GET_RTX_CLASS (GET_CODE (src)) == '2'
+ || GET_RTX_CLASS (GET_CODE (src)) == 'c')
+ && (GET_RTX_CLASS (GET_CODE (XEXP (src, 0))) == '<'
+ || (GET_CODE (XEXP (src, 0)) == MULT
+ && GET_RTX_CLASS (GET_CODE (XEXP (XEXP (src, 0), 0))) == '<'
+ && GET_CODE (XEXP (XEXP (src, 0), 1)) == CONST_INT)))
+ {
+ rtx cond = XEXP (src, 0);
+ rtx true_val = const1_rtx;
+ rtx false_arm, true_arm;
+
+ if (GET_CODE (cond) == MULT)
+ {
+ true_val = XEXP (cond, 1);
+ cond = XEXP (cond, 0);
+ }
+
+ if (GET_RTX_CLASS (GET_CODE (src)) == '1')
+ {
+ true_arm = gen_unary (GET_CODE (src), GET_MODE (src),
+ GET_MODE (XEXP (src, 0)), true_val);
+ false_arm = gen_unary (GET_CODE (src), GET_MODE (src),
+ GET_MODE (XEXP (src, 0)), const0_rtx);
+ }
+ else
+ {
+ true_arm = gen_binary (GET_CODE (src), GET_MODE (src),
+ true_val, XEXP (src, 1));
+ false_arm = gen_binary (GET_CODE (src), GET_MODE (src),
+ const0_rtx, XEXP (src, 1));
+ }
+
+ /* Canonicalize if true_arm is the simpler one. */
+ if (GET_RTX_CLASS (GET_CODE (true_arm)) == 'o'
+ && GET_RTX_CLASS (GET_CODE (false_arm)) != 'o'
+ && reversible_comparison_p (cond))
+ {
+ rtx temp = true_arm;
+
+ true_arm = false_arm;
+ false_arm = temp;
+
+ cond = gen_rtx_combine (reverse_condition (GET_CODE (cond)),
+ GET_MODE (cond), XEXP (cond, 0),
+ XEXP (cond, 1));
+ }
+
+ src = gen_rtx_combine (IF_THEN_ELSE, GET_MODE (src),
+ gen_rtx_combine (GET_CODE (cond), VOIDmode,
+ XEXP (cond, 0),
+ XEXP (cond, 1)),
+ true_arm, false_arm);
+ SUBST (SET_SRC (x), src);
+ }
+#endif
+
/* If either SRC or DEST is a CLOBBER of (const_int 0), make this
whole thing fail. */
if (GET_CODE (src) == CLOBBER && XEXP (src, 0) == const0_rtx)
+ (UNITS_PER_WORD - 1)) / UNITS_PER_WORD)))
{
x = gen_rtx_SET (VOIDmode, SUBREG_REG (SET_DEST (x)),
- gen_lowpart_for_combine (GET_MODE (SUBREG_REG (SET_DEST (x))),
- SET_SRC (x)));
+ gen_lowpart_for_combine
+ (GET_MODE (SUBREG_REG (SET_DEST (x))),
+ SET_SRC (x)));
continue;
}
else
/* Now compute the equivalent expression. Make a copy of INNER
for the SET_DEST in case it is a MEM into which we will substitute;
we don't want shared RTL in that case. */
- x = gen_rtx_SET (VOIDmode, copy_rtx (inner),
- gen_binary (IOR, compute_mode,
- gen_binary (AND, compute_mode,
- gen_unary (NOT, compute_mode,
- compute_mode,
- gen_binary (ASHIFT,
- compute_mode,
- mask, pos)),
- inner),
- gen_binary (ASHIFT, compute_mode,
- gen_binary (AND, compute_mode,
- gen_lowpart_for_combine
- (compute_mode,
- SET_SRC (x)),
- mask),
- pos)));
+ x = gen_rtx_SET
+ (VOIDmode, copy_rtx (inner),
+ gen_binary (IOR, compute_mode,
+ gen_binary (AND, compute_mode,
+ gen_unary (NOT, compute_mode,
+ compute_mode,
+ gen_binary (ASHIFT,
+ compute_mode,
+ mask, pos)),
+ inner),
+ gen_binary (ASHIFT, compute_mode,
+ gen_binary (AND, compute_mode,
+ gen_lowpart_for_combine
+ (compute_mode, SET_SRC (x)),
+ mask),
+ pos)));
}
return x;
if (tmode != inner_mode)
new = gen_rtx_SUBREG (tmode, inner,
(WORDS_BIG_ENDIAN
- && GET_MODE_SIZE (inner_mode) > UNITS_PER_WORD
+ && (GET_MODE_SIZE (inner_mode)
+ > UNITS_PER_WORD)
? (((GET_MODE_SIZE (inner_mode)
- GET_MODE_SIZE (tmode))
/ UNITS_PER_WORD)
&& ! in_compare && ! spans_byte && unsignedp)
return 0;
- /* Unless we are allowed to span bytes, reject this if we would be
- spanning bytes or if the position is not a constant and the length
- is not 1. In all other cases, we would only be going outside
- out object in cases when an original shift would have been
+ /* Unless we are allowed to span bytes or INNER is not MEM, reject this if
+ we would be spanning bytes or if the position is not a constant and the
+ length is not 1. In all other cases, we would only be going outside
+ our object in cases when an original shift would have been
undefined. */
- if (! spans_byte
+ if (! spans_byte && GET_CODE (inner) == MEM
&& ((pos_rtx == 0 && pos + len > GET_MODE_BITSIZE (is_mode))
|| (pos_rtx != 0 && len != 1)))
return 0;
{
rtx newpat = gen_rtx_PARALLEL (VOIDmode,
gen_rtvec (GET_CODE (pat) == PARALLEL
- ? XVECLEN (pat, 0) + num_clobbers_to_add
+ ? (XVECLEN (pat, 0)
+ + num_clobbers_to_add)
: num_clobbers_to_add + 1));
if (GET_CODE (pat) == PARALLEL)
if (WORDS_BIG_ENDIAN)
offset = (MAX (GET_MODE_SIZE (GET_MODE (x)), UNITS_PER_WORD)
- MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
+
if (BYTES_BIG_ENDIAN)
{
/* Adjust the address so that the address-after-the-data is
represents the low part, permute the SUBREG and the AND and
try again. */
if (GET_CODE (XEXP (op0, 0)) == SUBREG
- && ((mode_width
- >= GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (XEXP (op0, 0)))))
+ && (0
#ifdef WORD_REGISTER_OPERATIONS
- || subreg_lowpart_p (XEXP (op0, 0))
+ || ((mode_width
+ > (GET_MODE_BITSIZE
+ (GET_MODE (SUBREG_REG (XEXP (op0, 0))))))
+ && mode_width <= BITS_PER_WORD)
#endif
- )
+ || ((mode_width
+ <= (GET_MODE_BITSIZE
+ (GET_MODE (SUBREG_REG (XEXP (op0, 0))))))
+ && subreg_lowpart_p (XEXP (op0, 0))))
#ifndef WORD_REGISTER_OPERATIONS
/* It is unsafe to commute the AND into the SUBREG if the SUBREG
is paradoxical and WORD_REGISTER_OPERATIONS is not defined.
if (! find_regno_note (tem, REG_UNUSED,
REGNO (XEXP (note, 0))))
REG_NOTES (tem)
- = gen_rtx_EXPR_LIST (REG_UNUSED,
- XEXP (note, 0),
+ = gen_rtx_EXPR_LIST (REG_UNUSED, XEXP (note, 0),
REG_NOTES (tem));
}
else
&& ! reg_bitfield_target_p (piece,
PATTERN (place)))
REG_NOTES (place)
- = gen_rtx_EXPR_LIST (REG_DEAD,
- piece, REG_NOTES (place));
+ = gen_rtx_EXPR_LIST (REG_DEAD, piece,
+ REG_NOTES (place));
}
place = 0;
#define __datalbl
#include "config.h"
-#include <stdio.h>
-#include <string.h>
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "function.h"
else
size = GET_MODE_SIZE (mode);
if (cum + size < 12)
- return gen_rtx (REG, mode, cum);
+ return gen_rtx_REG (mode, cum);
else
return (rtx) 0;
}
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx(REG,TYPE_MODE(VALTYPE),0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* 1750 note: no libcalls yet */
#define LIBCALL_VALUE(MODE) printf("LIBCALL_VALUE called!\n"), \
- gen_rtx(REG,MODE,0)
+ gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) printf("INITIALIZE_TRAMPO called\n")
/* { \
- emit_move_insn (gen_rtx (MEM, QImode, plus_constant (TRAMP, 1)), CXT); \
- emit_move_insn (gen_rtx (MEM, QImode, plus_constant (TRAMP, 6)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (QImode, plus_constant (TRAMP, 1)), CXT); \
+ emit_move_insn (gen_rtx_MEM (QImode, plus_constant (TRAMP, 6)), FNADDR); \
} */
;;- Machine description for GNU compiler
;;- MIL-STD-1750A version.
-;; Copyright (C) 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
;; Contributed by O.M.Kellogg, DASA (oliver.kellogg@space.otn.dasa.de).
;; This file is part of GNU CC.
(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])));
+ 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;
")
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
""
"ANYCALL %0")
-
-; (define_insn "return"
-; [(return)]
-; ""
-; "*
-; {
-; rtx oprnd = GEN_INT (get_frame_size());
-; output_asm_insn(\"ret.m %0\",&oprnd);
-; return \"\;\";
-; } ")
-
(define_insn "indirect_jump"
[(set (pc) (match_operand:QI 0 "address_operand" "p"))]
""
/* Subroutines used for code generation on AMD Am29000.
- Copyright (C) 1987, 88, 90-94, 1995, 1997, 1999 Free Software
+ Copyright (C) 1987, 88, 90-95, 1997, 1998, 1999 Free Software
Foundation, Inc.
Contributed by Richard Kenner (kenner@nyu.edu)
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
for (i = R_LR (2); i < high_regno; i++)
CALL_INSN_FUNCTION_USAGE (insn)
- = gen_rtx (EXPR_LIST, VOIDmode,
- gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, SImode, i)),
- CALL_INSN_FUNCTION_USAGE (insn));
+ = gen_rtx_EXPR_LIST (VOIDmode,
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx (REG, SImode, i)),
+ CALL_INSN_FUNCTION_USAGE (insn));
}
\f
/* These routines are used in finding insns to fill delay slots in the
On 29k the value is found in gr96. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), R_GR (96))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), R_GR (96))
/* 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, R_GR (96))
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, R_GR (96))
/* 1 if N is a possible register number for a function value
as seen by the caller.
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((CUM) < 16 && (NAMED) && ! MUST_PASS_IN_STACK (MODE, TYPE) \
- ? gen_rtx(REG, (MODE), R_LR (2) + (CUM)) : 0)
+ ? gen_rtx_REG ((MODE), R_LR (2) + (CUM)) : 0)
/* Define where a function finds its arguments.
This is different from FUNCTION_ARG because of register windows.
#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
((CUM) < 16 && (NAMED) && ! MUST_PASS_IN_STACK (MODE, TYPE) \
- ? gen_rtx (REG, MODE, \
- incoming_reg (CUM, A29K_ARG_SIZE (MODE, TYPE, NAMED))) \
+ ? gen_rtx_REG (MODE, \
+ incoming_reg (CUM, A29K_ARG_SIZE (MODE, TYPE, NAMED))) \
: 0)
/* This indicates that an argument is to be passed with an invisible reference
if (! (NO_RTL) && first_reg_offset != 16) \
move_block_from_reg \
(R_AR (0) + first_reg_offset, \
- gen_rtx (MEM, BLKmode, virtual_incoming_args_rtx), \
+ gen_rtx_MEM (BLKmode, virtual_incoming_args_rtx), \
16 - first_reg_offset, (16 - first_reg_offset) * UNITS_PER_WORD); \
PRETEND_SIZE = (16 - first_reg_offset) * UNITS_PER_WORD; \
} \
rtx _val = force_reg (SImode, VALUE); \
\
_addr = memory_address (QImode, plus_constant (TRAMP, (CONST) + 3)); \
- emit_move_insn (gen_rtx (MEM, QImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (QImode, _addr), \
gen_lowpart (QImode, _val)); \
\
_temp = expand_shift (RSHIFT_EXPR, SImode, _val, \
build_int_2 (8, 0), 0, 1); \
_addr = memory_address (QImode, plus_constant (TRAMP, (CONST) + 1)); \
- emit_move_insn (gen_rtx (MEM, QImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (QImode, _addr), \
gen_lowpart (QImode, _temp)); \
\
_temp = expand_shift (RSHIFT_EXPR, SImode, _temp, \
build_int_2 (8, 0), _temp, 1); \
_addr = memory_address (QImode, plus_constant (TRAMP, (CONSTH) + 3)); \
- emit_move_insn (gen_rtx (MEM, QImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (QImode, _addr), \
gen_lowpart (QImode, _temp)); \
\
_temp = expand_shift (RSHIFT_EXPR, SImode, _temp, \
build_int_2 (8, 0), _temp, 1); \
_addr = memory_address (QImode, plus_constant (TRAMP, (CONSTH) + 1)); \
- emit_move_insn (gen_rtx (MEM, QImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (QImode, _addr), \
gen_lowpart (QImode, _temp)); \
}
\f
;;- Machine description for AMD Am29000 for GNU C compiler
-;; Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1991, 1992, 1994, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
;; This file is part of GNU CC.
later be inlined into another function. */
if (! TARGET_SMALL_MEMORY
&& GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
- operands[0] = gen_rtx (MEM, SImode,
- force_reg (Pmode, XEXP (operands[0], 0)));
+ operands[0] = gen_rtx_MEM (SImode,
+ force_reg (Pmode, XEXP (operands[0], 0)));
}")
(define_expand "call_value"
later be inlined into another function. */
if (! TARGET_SMALL_MEMORY
&& GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
- operands[1] = gen_rtx (MEM, SImode,
- force_reg (Pmode, XEXP (operands[1], 0)));
-
+ operands[1] = gen_rtx_MEM (SImode,
+ force_reg (Pmode, XEXP (operands[1], 0)));
}")
(define_insn ""
if (size != 8 || (pos != 8 && pos != 16))
FAIL;
- operands[3] = gen_rtx (ASHIFT, PSImode,
- force_reg (PSImode, GEN_INT (pos / 8)),
- GEN_INT (3));
+ operands[3] = gen_rtx_ASHIFT (PSImode,
+ force_reg (PSImode, GEN_INT (pos / 8)),
+ GEN_INT (3));
}")
if ((size != 8 && size != 16) || pos % size != 0)
FAIL;
- operands[2] = gen_rtx (ASHIFT, PSImode,
- force_reg (PSImode, GEN_INT (pos / 8)),
- GEN_INT (3));
+ operands[2] = gen_rtx_ASHIFT (PSImode,
+ force_reg (PSImode, GEN_INT (pos / 8)),
+ GEN_INT (3));
}")
\f
;; LOAD (also used by move insn).
/* CR gets set to the number of registers minus one. */
operands[2] = GEN_INT(count - 1);
- operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 2));
+ operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 2));
from = memory_address (SImode, XEXP (operands[1], 0));
- XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
- gen_rtx (REG, SImode, regno),
- gen_rtx (MEM, SImode, from));
+ XVECEXP (operands[3], 0, 0) = gen_rtx_SET (VOIDmode,
+ gen_rtx_REG (SImode, regno),
+ gen_rtx_MEM (SImode, from));
operands[4] = gen_reg_rtx (PSImode);
- XVECEXP (operands[3], 0, 1) = gen_rtx (USE, VOIDmode, operands[4]);
- XVECEXP (operands[3], 0, 2) = gen_rtx (CLOBBER, VOIDmode, operands[4]);
+ XVECEXP (operands[3], 0, 1) = gen_rtx_USE (VOIDmode, operands[4]);
+ XVECEXP (operands[3], 0, 2) = gen_rtx_CLOBBER (VOIDmode, operands[4]);
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 2)
- = gen_rtx (SET, VOIDmode, gen_rtx (REG, SImode, regno + i),
- gen_rtx (MEM, SImode, plus_constant (from, i * 4)));
+ = gen_rtx_SET (VOIDmode, gen_rtx (REG, SImode, regno + i),
+ gen_rtx_MEM (SImode, plus_constant (from, i * 4)));
}")
;; Indicate that CR is used and is then clobbered.
/* CR gets set to the number of registers minus one. */
operands[2] = GEN_INT(count - 1);
- operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 2));
+ operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 2));
from = memory_address (SImode, XEXP (operands[0], 0));
- XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
- gen_rtx (MEM, SImode, from),
- gen_rtx (REG, SImode, regno));
+ XVECEXP (operands[3], 0, 0) = gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (SImode, from),
+ gen_rtx_REG (SImode, regno));
operands[4] = gen_reg_rtx (PSImode);
- XVECEXP (operands[3], 0, 1) = gen_rtx (USE, VOIDmode, operands[4]);
- XVECEXP (operands[3], 0, 2) = gen_rtx (CLOBBER, VOIDmode, operands[4]);
+ XVECEXP (operands[3], 0, 1) = gen_rtx_USE (VOIDmode, operands[4]);
+ XVECEXP (operands[3], 0, 2) = gen_rtx_CLOBBER (VOIDmode, operands[4]);
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 2)
- = gen_rtx (SET, VOIDmode,
- gen_rtx (MEM, SImode, plus_constant (from, i * 4)),
- gen_rtx (REG, SImode, regno + i));
+ = gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (SImode, plus_constant (from, i * 4)),
+ gen_rtx_REG (SImode, regno + i));
}")
(define_expand "store_multiple_bug"
count = INTVAL (operands[2]);
regno = REGNO (operands[1]);
- operands[3] = gen_rtx (PARALLEL, VOIDmode, rtvec_alloc (count + 1));
+ operands[3] = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (count + 1));
from = memory_address (SImode, XEXP (operands[0], 0));
- XVECEXP (operands[3], 0, 0) = gen_rtx (SET, VOIDmode,
- gen_rtx (MEM, SImode, from),
- gen_rtx (REG, SImode, regno));
+ XVECEXP (operands[3], 0, 0) = gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (SImode, from),
+ gen_rtx_REG (SImode, regno));
XVECEXP (operands[3], 0, 1)
- = gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, PSImode));
+ = gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (PSImode));
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 1)
- = gen_rtx (SET, VOIDmode,
- gen_rtx (MEM, SImode, plus_constant (from, i * 4)),
- gen_rtx (REG, SImode, regno + i));
+ = gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (SImode, plus_constant (from, i * 4)),
+ gen_rtx_REG (SImode, regno + i));
}")
(define_insn ""
"
{ rtx seq = gen_loadhi (gen_lowpart (SImode, operands[0]),
a29k_get_reloaded_address (operands[1]),
- gen_rtx (REG, SImode, R_TAV),
+ gen_rtx_REG (SImode, R_TAV),
operands[2]);
a29k_set_memflags (seq, operands[1]);
{ rtx (*fcn) () = TARGET_BYTE_WRITES ? gen_storehihww : gen_storehinhww;
rtx seq = (*fcn) (a29k_get_reloaded_address (operands[0]),
gen_lowpart (SImode, operands[1]),
- gen_rtx (REG, SImode, R_TAV), operands[2]);
+ gen_rtx_REG (SImode, R_TAV), operands[2]);
a29k_set_memflags (seq, operands[0]);
emit_insn (seq);
"
{ rtx seq = gen_loadqi (gen_lowpart (SImode, operands[0]),
a29k_get_reloaded_address (operands[1]),
- gen_rtx (REG, SImode, R_TAV),
+ gen_rtx_REG (SImode, R_TAV),
operands[2]);
a29k_set_memflags (seq, operands[1]);
{ rtx (*fcn) () = TARGET_BYTE_WRITES ? gen_storeqihww : gen_storeqinhww;
rtx seq = (*fcn) (a29k_get_reloaded_address (operands[0]),
gen_lowpart (SImode, operands[1]),
- gen_rtx (REG, SImode, R_TAV), operands[2]);
+ gen_rtx_REG (SImode, R_TAV), operands[2]);
a29k_set_memflags (seq, operands[0]);
emit_insn (seq);
if (REGNO (operands[0]) >= REGNO (operands[1]) + 1
&& REGNO (operands[0]) <= REGNO (operands[1]) + 3)
{
- operands[3] = gen_rtx (REG, SImode, REGNO (operands[0]) + 3);
- operands[4] = gen_rtx (REG, SImode, REGNO (operands[1]) + 3);
- operands[5] = gen_rtx (REG, SImode, REGNO (operands[0]) + 2);
- operands[6] = gen_rtx (REG, SImode, REGNO (operands[1]) + 2);
- operands[7] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
- operands[8] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
- operands[9] = gen_rtx (REG, SImode, REGNO (operands[0]));
- operands[10] = gen_rtx (REG, SImode, REGNO (operands[1]));
+ operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]) + 3);
+ operands[4] = gen_rtx_REG (SImode, REGNO (operands[1]) + 3);
+ operands[5] = gen_rtx_REG (SImode, REGNO (operands[0]) + 2);
+ operands[6] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
+ operands[7] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
+ operands[8] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
+ operands[9] = gen_rtx_REG (SImode, REGNO (operands[0]));
+ operands[10] = gen_rtx_REG (SImode, REGNO (operands[1]));
}
else
{
- operands[3] = gen_rtx (REG, SImode, REGNO (operands[0]));
- operands[4] = gen_rtx (REG, SImode, REGNO (operands[1]));
- operands[5] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
- operands[6] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
- operands[7] = gen_rtx (REG, SImode, REGNO (operands[0]) + 2);
- operands[8] = gen_rtx (REG, SImode, REGNO (operands[1]) + 2);
- operands[9] = gen_rtx (REG, SImode, REGNO (operands[0]) + 3);
- operands[10] = gen_rtx (REG, SImode, REGNO (operands[1]) + 3);
+ operands[3] = gen_rtx_REG (SImode, REGNO (operands[0]));
+ operands[4] = gen_rtx_REG (SImode, REGNO (operands[1]));
+ operands[5] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
+ operands[6] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
+ operands[7] = gen_rtx_REG (SImode, REGNO (operands[0]) + 2);
+ operands[8] = gen_rtx_REG (SImode, REGNO (operands[1]) + 2);
+ operands[9] = gen_rtx_REG (SImode, REGNO (operands[0]) + 3);
+ operands[10] = gen_rtx_REG (SImode, REGNO (operands[1]) + 3);
}
}")
{
operands[1] = gen_reg_rtx (SImode);
if (a29k_compare_fp_p)
- operands[2] = gen_rtx (GT, SImode, a29k_compare_op1, a29k_compare_op0);
+ operands[2] = gen_rtx_GT (SImode, a29k_compare_op1, a29k_compare_op0);
else
- operands[2] = gen_rtx (LT, SImode, a29k_compare_op0, a29k_compare_op1);
+ operands[2] = gen_rtx_LT (SImode, a29k_compare_op0, a29k_compare_op1);
}")
;; Similarly for "le".
{
operands[1] = gen_reg_rtx (SImode);
if (a29k_compare_fp_p)
- operands[2] = gen_rtx (GE, SImode, a29k_compare_op1, a29k_compare_op0);
+ operands[2] = gen_rtx_GE (SImode, a29k_compare_op1, a29k_compare_op0);
else
- operands[2] = gen_rtx (LE, SImode, a29k_compare_op0, a29k_compare_op1);
+ operands[2] = gen_rtx_LE (SImode, a29k_compare_op0, a29k_compare_op1);
}")
(define_expand "bltu"
"
{
if (a29k_compare_fp_p)
- operands[1] = gen_rtx (GT, SImode, a29k_compare_op1, a29k_compare_op0);
+ operands[1] = gen_rtx_GT (SImode, a29k_compare_op1, a29k_compare_op0);
else
- operands[1] = gen_rtx (LT, SImode, a29k_compare_op0, a29k_compare_op1);
+ operands[1] = gen_rtx_LT (SImode, a29k_compare_op0, a29k_compare_op1);
}")
;; Similarly for "le"
"
{
if (a29k_compare_fp_p)
- operands[1] = gen_rtx (GE, SImode, a29k_compare_op1, a29k_compare_op0);
+ operands[1] = gen_rtx_GE (SImode, a29k_compare_op1, a29k_compare_op0);
else
- operands[1] = gen_rtx (LE, SImode, a29k_compare_op0, a29k_compare_op1);
+ operands[1] = gen_rtx_LE (SImode, a29k_compare_op0, a29k_compare_op1);
}")
(define_expand "sltu"
return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
|| CONST_OK_FOR_LETTER_P (INTVAL (op), 'O'));
- return register_operand (op, mode);
+ return reg_not_elim_operand (op, mode);
}
/* Return 1 if OP is the constant 4 or 8. */
/* Store function address and CXT. */
addr = memory_address (mode, plus_constant (tramp, fnofs));
- emit_move_insn (gen_rtx (MEM, mode, addr), fnaddr);
+ emit_move_insn (gen_rtx_MEM (mode, addr), fnaddr);
addr = memory_address (mode, plus_constant (tramp, cxtofs));
- emit_move_insn (gen_rtx (MEM, mode, addr), cxt);
+ emit_move_insn (gen_rtx_MEM (mode, addr), cxt);
/* This has been disabled since the hint only has a 32k range, and in
no existing OS is the stack within 32k of the text segment. */
/* Merge in the hint. */
addr = memory_address (SImode, plus_constant (tramp, jmpofs));
- temp1 = force_reg (SImode, gen_rtx (MEM, SImode, addr));
+ temp1 = force_reg (SImode, gen_rtx_MEM (SImode, addr));
temp1 = expand_and (temp1, GEN_INT (0xffffc000), NULL_RTX);
temp1 = expand_binop (SImode, ior_optab, temp1, temp, temp1, 1,
OPTAB_WIDEN);
- emit_move_insn (gen_rtx (MEM, SImode, addr), temp1);
+ emit_move_insn (gen_rtx_MEM (SImode, addr), temp1);
}
#ifdef TRANSFER_FROM_TRAMPOLINE
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__enable_execute_stack"),
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"),
0, VOIDmode, 1, addr, Pmode);
#endif
On Alpha the value is found in $0 for integer functions and
$f0 for floating-point functions. */
-#define FUNCTION_VALUE(VALTYPE, FUNC) \
+#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx_REG (((INTEGRAL_TYPE_P (VALTYPE) \
- && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) \
- || POINTER_TYPE_P (VALTYPE)) \
+ && TYPE_PRECISION (VALTYPE) < BITS_PER_WORD) \
+ || POINTER_TYPE_P (VALTYPE)) \
? word_mode : TYPE_MODE (VALTYPE), \
((TARGET_FPREGS \
- && (TREE_CODE (VALTYPE) == REAL_TYPE \
+ && (TREE_CODE (VALTYPE) == REAL_TYPE \
|| TREE_CODE (VALTYPE) == COMPLEX_TYPE)) \
- ? 32 : 0))
+ ? 32 : 0))
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
-#define LIBCALL_VALUE(MODE) \
+#define LIBCALL_VALUE(MODE) \
gen_rtx_REG (MODE, \
- (TARGET_FPREGS \
- && (GET_MODE_CLASS (MODE) == MODE_FLOAT \
+ (TARGET_FPREGS \
+ && (GET_MODE_CLASS (MODE) == MODE_FLOAT \
|| GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT) \
- ? 32 : 0))
+ ? 32 : 0))
/* The definition of this macro implies that there are cases where
a scalar value cannot be returned in registers.
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((CUM) < 6 && ! MUST_PASS_IN_STACK (MODE, TYPE) \
- ? gen_rtx(REG, (MODE), \
- (CUM) + 16 + ((TARGET_FPREGS \
- && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
- || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
- * 32)) \
+ ? gen_rtx_REG ((MODE), \
+ (CUM) + 16 \
+ + ((TARGET_FPREGS \
+ && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
+ || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
+ * 32)) \
: 0)
/* Specify the padding direction of arguments.
(define_split
[(set (match_operand:DI 0 "register_operand" "")
(sign_extend:DI
- (plus:SI (match_operand:SI 1 "register_operand" "")
+ (plus:SI (match_operand:SI 1 "reg_not_elim_operand" "")
(match_operand:SI 2 "const_int_operand" ""))))
(clobber (match_operand:SI 3 "reg_not_elim_operand" ""))]
"! sext_add_operand (operands[2], SImode) && INTVAL (operands[2]) > 0
[(match_operand 2 "" "")
(match_operand 3 "" "")])
(match_operand:SI 4 "const48_operand" ""))
- (match_operand:SI 5 "add_operand" ""))))
+ (match_operand:SI 5 "sext_add_operand" ""))))
(clobber (match_operand:DI 6 "reg_not_elim_operand" ""))]
""
[(set (match_dup 6) (match_dup 7))
s%2addq %1,%3,%0
s%2subq %1,%n3,%0")
-;; These variants of the above insns can occur if the third operand
-;; is the frame pointer. This is a kludge, but there doesn't
-;; seem to be a way around it. Only recognize them while reloading.
-
-(define_insn ""
- [(set (match_operand:DI 0 "some_operand" "=&r")
- (plus:DI (plus:DI (match_operand:DI 1 "some_operand" "r")
- (match_operand:DI 2 "some_operand" "r"))
- (match_operand:DI 3 "some_operand" "rIOKL")))]
- "reload_in_progress"
- "#")
-
-(define_split
- [(set (match_operand:DI 0 "register_operand" "")
- (plus:DI (plus:DI (match_operand:DI 1 "register_operand" "")
- (match_operand:DI 2 "register_operand" ""))
- (match_operand:DI 3 "add_operand" "")))]
- "reload_completed"
- [(set (match_dup 0) (plus:DI (match_dup 1) (match_dup 2)))
- (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 3)))]
- "")
-
-(define_insn ""
- [(set (match_operand:SI 0 "some_operand" "=&r")
- (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "some_operand" "rJ")
- (match_operand:SI 2 "const48_operand" "I"))
- (match_operand:SI 3 "some_operand" "r"))
- (match_operand:SI 4 "some_operand" "rIOKL")))]
- "reload_in_progress"
- "#")
-
-(define_split
- [(set (match_operand:SI 0 "register_operand" "r")
- (plus:SI (plus:SI (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
- (match_operand:SI 2 "const48_operand" ""))
- (match_operand:SI 3 "register_operand" ""))
- (match_operand:SI 4 "add_operand" "rIOKL")))]
- "reload_completed"
- [(set (match_dup 0)
- (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
- (set (match_dup 0) (plus:SI (match_dup 0) (match_dup 4)))]
- "")
-
-(define_insn ""
- [(set (match_operand:DI 0 "some_operand" "=&r")
- (sign_extend:DI
- (plus:SI (plus:SI
- (mult:SI (match_operand:SI 1 "some_operand" "rJ")
- (match_operand:SI 2 "const48_operand" "I"))
- (match_operand:SI 3 "some_operand" "r"))
- (match_operand:SI 4 "some_operand" "rIOKL"))))]
- "reload_in_progress"
- "#")
-
-(define_split
- [(set (match_operand:DI 0 "register_operand" "")
- (sign_extend:DI
- (plus:SI (plus:SI
- (mult:SI (match_operand:SI 1 "reg_or_0_operand" "")
- (match_operand:SI 2 "const48_operand" ""))
- (match_operand:SI 3 "register_operand" ""))
- (match_operand:SI 4 "add_operand" ""))))]
- "reload_completed"
- [(set (match_dup 5)
- (plus:SI (mult:SI (match_dup 1) (match_dup 2)) (match_dup 3)))
- (set (match_dup 0) (sign_extend:DI (plus:SI (match_dup 5) (match_dup 4))))]
- "operands[5] = gen_lowpart (SImode, operands[0]);")
-
-(define_insn ""
- [(set (match_operand:DI 0 "some_operand" "=&r")
- (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "some_operand" "rJ")
- (match_operand:DI 2 "const48_operand" "I"))
- (match_operand:DI 3 "some_operand" "r"))
- (match_operand:DI 4 "some_operand" "rIOKL")))]
- "reload_in_progress"
- "#")
-
-(define_split
- [(set (match_operand:DI 0 "register_operand" "=")
- (plus:DI (plus:DI (mult:DI (match_operand:DI 1 "reg_or_0_operand" "")
- (match_operand:DI 2 "const48_operand" ""))
- (match_operand:DI 3 "register_operand" ""))
- (match_operand:DI 4 "add_operand" "")))]
- "reload_completed"
- [(set (match_dup 0)
- (plus:DI (mult:DI (match_dup 1) (match_dup 2)) (match_dup 3)))
- (set (match_dup 0) (plus:DI (match_dup 0) (match_dup 4)))]
- "")
-
(define_insn "negsi2"
[(set (match_operand:SI 0 "register_operand" "=r")
(neg:SI (match_operand:SI 1 "reg_or_8bit_operand" "rI")))]
Thus 6 or more means all following args should go on the stack. */
enum avms_arg_type {I64, FF, FD, FG, FS, FT};
-typedef struct {char num_args; enum avms_arg_type atypes[6];} avms_arg_info;
+typedef struct {int num_args; enum avms_arg_type atypes[6];} avms_arg_info;
#undef CUMULATIVE_ARGS
#define CUMULATIVE_ARGS avms_arg_info
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
((MODE) == VOIDmode ? alpha_arg_info_reg_val (CUM) \
: ((CUM.num_args) < 6 && ! MUST_PASS_IN_STACK (MODE, TYPE) \
- ? gen_rtx(REG, (MODE), \
- ((CUM).num_args + 16 \
- + ((TARGET_FPREGS \
- && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
- || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
- * 32))) \
+ ? gen_rtx_REG ((MODE), \
+ ((CUM).num_args + 16 \
+ + ((TARGET_FPREGS \
+ && (GET_MODE_CLASS (MODE) == MODE_COMPLEX_FLOAT \
+ || GET_MODE_CLASS (MODE) == MODE_FLOAT)) \
+ * 32))) \
: 0))
#undef FUNCTION_ARG_ADVANCE
{ \
if (! (NO_RTL)) \
{ \
- emit_move_insn (gen_rtx (REG, DImode, 1), \
+ emit_move_insn (gen_rtx_REG (DImode, 1), \
virtual_incoming_args_rtx); \
emit_insn (gen_arg_home ()); \
} \
-CLIB=-lmld
+CLIB=-lmld -lexc
EXTRA_HEADERS = $(srcdir)/config/alpha/va_list.h
/* Configuration for GNU C-compiler for DEC Alpha.
- Copyright (C) 1990, 1992, 1993, 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1990, 92, 93, 94, 95, 1998 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu).
This file is part of GNU CC.
#define ONLY_INT_FIELDS
#endif
-/* Declare some functions needed for this machine. We don't want to
- include these in the sources since other machines might define them
- differently. */
-
-extern void *malloc (), *realloc (), *calloc ();
-
-#ifndef inhibit_libc
-#include "string.h"
-#endif
-
/* OSF/1 is POSIX.1 compliant. */
#define POSIX
/* Subroutines used for code generation on the Argonaut ARC cpu.
- Copyright (C) 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* ??? This is an old port, and is undoubtedly suffering from bit rot. */
-#include <stdio.h>
#include "config.h"
+#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "regs.h"
enum machine_mode mode = SELECT_CC_MODE (code, x, y);
rtx cc_reg;
- cc_reg = gen_rtx (REG, mode, 61);
+ cc_reg = gen_rtx_REG (mode, 61);
- emit_insn (gen_rtx (SET, VOIDmode, cc_reg,
- gen_rtx (COMPARE, mode, x, y)));
+ emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
+ gen_rtx_COMPARE (mode, x, y)));
return cc_reg;
}
int align_slop = size & 1;
rtx regblock;
- regblock = gen_rtx (MEM, BLKmode,
- plus_constant (arg_pointer_rtx,
- FIRST_PARM_OFFSET (0)
- + align_slop * UNITS_PER_WORD));
+ regblock = gen_rtx_MEM (BLKmode,
+ plus_constant (arg_pointer_rtx,
+ FIRST_PARM_OFFSET (0)
+ + align_slop * UNITS_PER_WORD));
MEM_ALIAS_SET (regblock) = get_varargs_alias_set ();
-
move_block_from_reg (first_reg_offset, regblock,
MAX_ARC_PARM_REGS - first_reg_offset,
((MAX_ARC_PARM_REGS - first_reg_offset)
farther back is at [%fp,4]. */
#if 0 /* The default value should work. */
#define RETURN_ADDR_RTX(COUNT, FRAME) \
-(((COUNT) == -1) \
- ? gen_rtx (REG, Pmode, 31) \
- : copy_to_reg (gen_rtx (MEM, Pmode, \
- memory_address (Pmode, plus_constant ((FRAME), UNITS_PER_WORD)))))
+(((COUNT) == -1) \
+ ? gen_rtx_REG (Pmode, 31) \
+ : copy_to_reg (gen_rtx_MEM (Pmode, \
+ memory_address (Pmode, \
+ plus_constant ((FRAME), \
+ UNITS_PER_WORD)))))
#endif
/* Register to use for pushing function arguments. */
and the rest are pushed. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
(PASS_IN_REG_P ((CUM), (MODE), (TYPE), (NAMED)) \
- ? gen_rtx (REG, (MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
+ ? gen_rtx_REG ((MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
: 0)
/* A C expression for the number of words, at the beginning of an
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 FUNCTION_VALUE(VALTYPE, FUNC) gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+#define FUNCTION_VALUE(VALTYPE, FUNC) gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* 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, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value
as seen by the caller. */
CXT is an RTX for the static chain value for the function. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
do { \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 4)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 12)), FNADDR); \
- emit_insn (gen_flush_icache (validize_mem (gen_rtx (MEM, SImode, TRAMP)))); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 4)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 12)), FNADDR); \
+ emit_insn (gen_flush_icache (validize_mem (gen_rtx_MEM (SImode, TRAMP)))); \
} while (0)
\f
/* Library calls. */
;; Machine description of the Argonaut ARC cpu for GNU C compiler
-;; Copyright (C) 1994, 1997, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1997, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
;{
; /* Flow doesn't understand that this is effectively a DFmode move.
; It doesn't know that all of `operands[0]' is set. */
-; emit_insn (gen_rtx (CLOBBER, VOIDmode, operands[0]));
+; emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
;
; /* Emit insns that movsi_insn can handle. */
; emit_insn (gen_movsi (operand_subword (operands[0], 0, 0, DImode),
;{
; /* Flow doesn't understand that this is effectively a DFmode move.
; It doesn't know that all of `operands[0]' is set. */
-; emit_insn (gen_rtx (CLOBBER, VOIDmode, operands[0]));
+; emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
;
; /* Emit insns that movsi_insn can handle. */
; emit_insn (gen_movsi (operand_subword (operands[0], 0, 0, DFmode),
"
{
enum rtx_code code = GET_CODE (operands[1]);
- rtx ccreg = gen_rtx (REG,
- SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
- 61);
+ rtx ccreg
+ = gen_rtx_REG (SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
+ 61);
operands[1] = gen_rtx (code, VOIDmode, ccreg, const0_rtx);
}")
; "
;{
; enum rtx_code code = GET_CODE (operands[1]);
-; rtx ccreg = gen_rtx (REG,
-; SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
-; 61);
+; rtx ccreg
+; = gen_rtx_REG (SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
+; 61);
;
; operands[1] = gen_rtx (code, VOIDmode, ccreg, const0_rtx);
-;}")
-
+}")
(define_expand "movsfcc"
+
[(set (match_operand:SF 0 "register_operand" "")
(if_then_else (match_operand 1 "comparison_operator" "")
(match_operand:SF 2 "nonmemory_operand" "")
"
{
enum rtx_code code = GET_CODE (operands[1]);
- rtx ccreg = gen_rtx (REG,
- SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
- 61);
+ rtx ccreg
+ = gen_rtx_REG (SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
+ 61);
operands[1] = gen_rtx (code, VOIDmode, ccreg, const0_rtx);
}")
; "0 /* ??? can generate less efficient code if constants involved */"
; "
;{
-; enum rtx_code code = GET_CODE (operands[1]);
-; rtx ccreg = gen_rtx (REG,
-; SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
-; 61);
+; enum rtx_code code = GET_CODE (operands[1]);
+; rtx ccreg
+; = gen_rtx_REG (SELECT_CC_MODE (code, arc_compare_op0, arc_compare_op1),
+; 61);
;
; operands[1] = gen_rtx (code, VOIDmode, ccreg, const0_rtx);
-;}")
+}")
(define_insn "*movsicc_insn"
[(set (match_operand:SI 0 "register_operand" "=r")
{
if (! TARGET_SHIFTER)
{
- emit_insn (gen_rtx
- (PARALLEL, VOIDmode,
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
gen_rtvec (2,
- gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (ASHIFT, SImode, operands[1], operands[2])),
- gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, SImode, 0)))));
+ gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_ASHIFT (SImode, operands[1],
+ operands[2])),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (SImode)))));
DONE;
}
}")
{
if (! TARGET_SHIFTER)
{
- emit_insn (gen_rtx
- (PARALLEL, VOIDmode,
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
gen_rtvec (2,
- gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (ASHIFTRT, SImode, operands[1], operands[2])),
- gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, SImode, 0)))));
+ gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_ASHIFTRT (SImode,
+ operands[1],
+ operands[2])),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (SImode)))));
DONE;
}
}")
{
if (! TARGET_SHIFTER)
{
- emit_insn (gen_rtx
- (PARALLEL, VOIDmode,
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
gen_rtvec (2,
- gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (LSHIFTRT, SImode, operands[1], operands[2])),
- gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, SImode, 0)))));
+ gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_LSHIFTRT (SImode,
+ operands[1],
+ operands[2])),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (SImode)))));
DONE;
}
}")
/* Subroutines for insn-output.c for Clipper
- Copyright (C) 1987, 1988, 1991, 1997, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 91, 97, 98, 1999 Free Software Foundation, Inc.
Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
static int frame_size;
-/*
- * compute size of a clipper stack frame where 'lsize' is the required
- * space for local variables.
- */
+/* Compute size of a clipper stack frame where 'lsize' is the required
+ space for local variables. */
int
clipper_frame_size (lsize)
int lsize;
{
- int i,size; /* total size of frame */
+ int i, size; /* total size of frame */
int save_size;
save_size = 0; /* compute size for reg saves */
return size;
}
-/*
- * prologue and epilogue output
- * function is entered with pc pushed, i.e. stack is 32 bit aligned
- *
- * current_function_args_size == 0 means that the current function's args
- * are passed totally in registers i.e fp is not used as ap.
- * If frame_size is also 0 the current function does not push anything and
- * can run with misaligned stack -> subq $4,sp / add $4,sp on entry and exit
- * can be omitted.
- *
- */
+/* Prologue and epilogue output
+ Function is entered with pc pushed, i.e. stack is 32 bit aligned
+
+ current_function_args_size == 0 means that the current function's args
+ are passed totally in registers i.e fp is not used as ap.
+ If frame_size is also 0 the current function does not push anything and
+ can run with misaligned stack -> subq $4,sp / add $4,sp on entry and exit
+ can be omitted. */
+
void
output_function_prologue (file, lsize)
FILE *file;
/* Definitions of target machine for GNU compiler. Clipper version.
- Copyright (C) 1987, 88, 91, 93-96, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 91, 93-96, 1998, 1999 Free Software Foundation, Inc.
Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
This file is part of GNU CC.
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), ((TYPE_MODE (VALTYPE) == SFmode ||\
- TYPE_MODE (VALTYPE) == DFmode) ? \
- 16 : 0))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), ((TYPE_MODE (VALTYPE) == SFmode ||\
+ TYPE_MODE (VALTYPE) == DFmode) ? \
+ 16 : 0))
/* 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), ((MODE) == SFmode || (MODE) == DFmode ? 16 : 0))
+ gen_rtx_REG ((MODE), ((MODE) == SFmode || (MODE) == DFmode ? 16 : 0))
/* 1 if N is a possible register number for a function value
&& (GET_MODE_SIZE (MODE) <= 8) \
&& ((TYPE) == NULL || !AGGREGATE_TYPE_P(TYPE)) \
&& ((MODE) != DImode || (CUM).num == 0)) \
- ? gen_rtx (REG, (MODE), \
- GET_MODE_CLASS(MODE) == MODE_FLOAT ? (CUM).num+16 : (CUM).num) \
+ ? gen_rtx_REG ((MODE), \
+ GET_MODE_CLASS(MODE) == MODE_FLOAT \
+ ? (CUM).num+16 : (CUM).num) \
: 0)
/* If defined, a C expression that gives the alignment boundary, in bits,
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 24)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 28)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 24)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 28)), FNADDR); \
}
\f
/* Addressing modes, and classification of registers for them. */
;;- Machine description for GNU compiler, Clipper Version
-;; Copyright (C) 1987, 88, 91, 93, 94, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1987, 88, 91, 93, 94, 97, 98, 1999
+;; Free Software Foundation, Inc.
;; Contributed by Holger Teutsch (holger@hotbso.rhein-main.de)
;; This file is part of GNU CC.
{
rtx xops[4];
xops[0] = operands[0];
- xops[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xops[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xops[2] = operands[1];
xops[3] = adj_offsettable_operand (operands[1], 4);
output_asm_insn (\"loadw %2,%0\;loadw %3,%1\", xops);
{
rtx xops[4];
xops[0] = operands[0];
- xops[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xops[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xops[2] = operands[1];
- xops[3] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xops[3] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"movw %2,%0\;movw %3,%1\", xops);
return \"\";
}
xops[0] = operands[0]; /* r -> o */
xops[1] = adj_offsettable_operand (operands[0], 4);
xops[2] = operands[1];
- xops[3] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xops[3] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"storw %2,%0\;storw %3,%1\", xops);
return \"\";
}"
{
rtx xoperands[2],yoperands[2];
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (which_alternative == 0) /* r -> r */
{
output_asm_insn (\"movw %1,%0\", operands);
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"movw %1,%0\", xoperands);
return \"\";
}
xops[0] = operands[0];
xops[1] = adj_offsettable_operand (operands[0], 4);
xops[2] = operands[1];
- xops[3] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xops[3] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"storw %2,%0\;storw %3,%1\", xops);
return \"\";
}"
rtx xoperands[4];
xoperands[0] = operands[0];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xoperands[2] = operands[2];
- xoperands[3] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[3] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
output_asm_insn (\"addw %2,%0\;addwc %3,%1\", xoperands);
return \"\";
}"
rtx xoperands[4];
xoperands[0] = operands[0];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xoperands[2] = operands[2];
- xoperands[3] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[3] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
output_asm_insn (\"subw %2,%0\;subwc %3,%1\", xoperands);
return \"\";
}"
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
/* Subroutines for insn-output.c for Convex.
- Copyright (C) 1988, 1993, 1994, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1988, 93, 94, 97, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "regs.h"
dest = change_address (dest, mode, 0);
/* Make load and store patterns for this piece */
- load = gen_rtx (SET, VOIDmode, reg, src);
- store = gen_rtx (SET, VOIDmode, dest, reg);
+ load = gen_rtx_SET (VOIDmode, reg, src);
+ store = gen_rtx_SET (VOIDmode, dest, reg);
/* Emit the load and the store from last time.
When we emit a store, we can reuse its temp reg. */
expand_movstr_call (operands)
rtx *operands;
{
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "memcpy"), 0,
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "memcpy"), 0,
VOIDmode, 3,
XEXP (operands[0], 0), Pmode,
XEXP (operands[1], 0), Pmode,
;;- Machine description for GNU compiler, Convex Version
-;; Copyright (C) 1988, 1994, 1995 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 1995, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
}
else
{
- output_cmp (gen_rtx (REG, SImode, 7), constm1_rtx, 'W');
+ output_cmp (gen_rtx_REG (SImode, 7), constm1_rtx, 'W');
return \"psh.w s7\;ld.w %0,s7\;add.w #-1,s7\;st.w s7,%0\;pop.w s7\";
}
}")
}
else
{
- output_cmp (gen_rtx (REG, SImode, 7), const0_rtx, 'W');
+ output_cmp (gen_rtx_REG (SImode, 7), const0_rtx, 'W');
return \"psh.w s7\;ld.w %0,s7\;add.w #-1,s7\;st.w s7,%0\;pop.w s7\";
}
}")
}
else
{
- output_cmp (gen_rtx (REG, HImode, 7), constm1_rtx, 'H');
+ 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\";
}
}")
}
else
{
- output_cmp (gen_rtx (REG, HImode, 7), const0_rtx, 'H');
+ 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\";
}
}")
/* Some output-actions in dsp1600.md need these. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
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_INT (16))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (shift_op, mode,
+ first_shift_emitted
+ ? operands[0] : operands[1],
+ GEN_INT (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_INT (8))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (shift_op, mode,
+ first_shift_emitted
+ ? operands[0] : operands[1],
+ GEN_INT (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_INT (4))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (shift_op, mode,
+ first_shift_emitted
+ ? operands[0] : operands[1],
+ GEN_INT (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_INT (1))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (shift_op, mode,
+ first_shift_emitted
+ ? operands[0] : operands[1],
+ GEN_INT (1))));
first_shift_emitted = 1;
}
}
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);
+ return gen_rtx_REG (mode, args_so_far + FIRST_REG_FOR_FUNCTION_ARG);
else
return (struct rtx_def *) 0;
}
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)))));
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2, gen_rtx_SET (VOIDmode, cc0_rtx, x),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)))));
}
else if (mode == HImode)
- emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, x));
+ emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx, x));
else
fatal ("Invalid mode for gen_tst_reg");
if (mode == QImode)
{
- if (code == GTU || code == GEU ||
- code == LTU || code == LEU)
+ 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)))));
+ 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)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)))));
}
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)))));
+ 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)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)))));
}
}
else if (mode == HImode)
{
- if (code == GTU || code == GEU ||
- code == LTU || code == LEU)
+ 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)))));
+ 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)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)))));
#else
if (!dsp16xx_ucmphi2_libcall)
- dsp16xx_ucmphi2_libcall = gen_rtx (SYMBOL_REF, Pmode, 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))));
+ emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx,
+ gen_rtx_COMPARE (VOIDmode,
+ force_reg (HImode, x),
+ force_reg (HImode,y))));
}
else
fatal ("Invalid mode for integer comparison in gen_compare_reg");
if (GET_CODE(operands[1]) == REG)
{
- if (REGNO (operands[1]) == REG_Y ||
- REGNO (operands[1]) == REG_PROD)
+ if (REGNO (operands[1]) == REG_Y
+ || REGNO (operands[1]) == REG_PROD)
{
output_asm_insn (\"a1=%1\", operands);
}
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]))));
+ 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;
}")
"
{
operands[2] = gen_reg_rtx (HImode);
- operands[3] = gen_rtx (SUBREG, QImode, operands[2], 1);
+ operands[3] = gen_rtx_SUBREG (QImode, operands[2], 1);
}")
;;(define_insn "extendqihi2"
"
{
operands[2] = gen_reg_rtx (HImode);
- operands[3] = gen_rtx (SUBREG, QImode, operands[2], 1);
+ operands[3] = gen_rtx_SUBREG (QImode, operands[2], 1);
}")
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_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
/* 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));
+ emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
DONE;
}
}")
#if 0
if (!dsp16xx_ashrhi3_libcall)
- dsp16xx_ashrhi3_libcall = gen_rtx_SYMBOL_REF (Pmode, ASHRHI3_LIBCALL);
+ dsp16xx_ashrhi3_libcall
+ = gen_rtx_SYMBOL_REF (Pmode, ASHRHI3_LIBCALL);
emit_library_call (dsp16xx_ashrhi3_libcall, 1, HImode, 2,
operands[1], HImode,
rtx label2 = gen_label_rtx ();
#if 0
if (!dsp16xx_lshrhi3_libcall)
- dsp16xx_lshrhi3_libcall = gen_rtx_SYMBOL_REF (Pmode, LSHRHI3_LIBCALL);
+ dsp16xx_lshrhi3_libcall
+ = gen_rtx_SYMBOL_REF (Pmode, LSHRHI3_LIBCALL);
emit_library_call (dsp16xx_lshrhi3_libcall, 1, HImode, 2,
operands[1], HImode,
rtx label2 = gen_label_rtx ();
#if 0
if (!dsp16xx_ashlhi3_libcall)
- dsp16xx_ashlhi3_libcall = gen_rtx_SYMBOL_REF (Pmode, 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);
+ operands[1], HImode, operands[2], QImode);
emit_move_insn (operands[0], hard_libcall_value(HImode));
DONE;
#else
{
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)));
+ operands[0] = gen_rtx_MEM (GET_MODE (operands[0]),
+ force_reg (Pmode, XEXP (operands[0], 0)));
}")
(define_insn ""
{
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)));
+ operands[1] = gen_rtx_MEM (GET_MODE (operands[1]),
+ force_reg (Pmode, XEXP (operands[1], 0)));
}")
(define_insn ""
/* Subroutines for insn-output.c for GNU compiler. Elxsi version.
- Copyright (C) 1987, 1992, 1997 Free Software Foundation, Inc
- This port, done by Mike Stump <mrs@cygnus.com> in 1988, and is the first
+ Copyright (C) 1987, 1992, 1998, 1999 Free Software Foundation, Inc
+ Contributrd by Mike Stump <mrs@cygnus.com> in 1988 and is the first
64 bit port of GNU CC.
Based upon the VAX port.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "function.h"
/* Definitions of target machine for GNU compiler. Elxsi version.
- Copyright (C) 1987, 1988, 1992, 1995, 1996 Free Software Foundation, Inc.
- This port, contributed by Mike Stump <mrs@cygnus.com> in 1988, is the first
+ Copyright (C) 1987, 88, 92, 95, 96, 1998, 1999 Free Software Foundation, Inc.
+ Contributed by Mike Stump <mrs@cygnus.com> in 1988. This is the first
64 bit port of GNU CC.
Based upon the VAX port.
/* On the Vax the return value is in R0 regardless. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* On the Vax the return value is in R0 regardless. */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* Define this if PCC uses the nonreentrant convention for returning
structure and union values. */
else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 0) == frame_pointer_rtx) \
{ rtx other_reg = XEXP (ADDR, 1); \
offset = 0; \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 1) == frame_pointer_rtx) \
{ rtx other_reg = XEXP (ADDR, 0); \
offset = 0; \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
if (offset >= 0) \
{ int regno; \
extern char call_used_regs[]; \
/* Subroutines for insn-output.c for Alliant FX computers.
- Copyright (C) 1989, 1991, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* Some output-actions in alliant.md need these. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
{
operands[0] = XEXP (XEXP (operands[0], 0), 0);
output_asm_insn ("subq%.l %#8,%0", operands);
- operands[0] = gen_rtx (MEM, DImode, operands[0]);
+ 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 ("subq%.l %#8,%1", operands);
- operands[1] = gen_rtx (MEM, DImode, operands[1]);
+ operands[1] = gen_rtx_MEM (DImode, operands[1]);
optype1 = OFFSOP;
}
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
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]) + 1);
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else if (optype1 == OFFSOP)
latehalf[1] = adj_offsettable_operand (operands[1], 4);
else if (optype1 == CNSTOP)
/* Definitions of target machine for GNU compiler. Alliant FX version.
- Copyright (C) 1989, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 94, 95, 96, 1998, 1999 Free Software Foundation, Inc.
Adapted from m68k.h by Paul Petersen (petersen@uicsrd.csrd.uiuc.edu)
and Joe Weening (weening@gang-of-four.stanford.edu).
#define FUNCTION_VALUE(VALTYPE, FUNC) \
(TREE_CODE (VALTYPE) == REAL_TYPE \
- ? gen_rtx (REG, TYPE_MODE (VALTYPE), 16) \
- : gen_rtx (REG, TYPE_MODE (VALTYPE), 0))
+ ? gen_rtx_REG (TYPE_MODE (VALTYPE), 16) \
+ : gen_rtx_REG (TYPE_MODE (VALTYPE), 0))
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
#define LIBCALL_VALUE(MODE) \
(((MODE) == DFmode || (MODE) == SFmode) \
- ? gen_rtx (REG, MODE, 16) \
- : gen_rtx (REG, MODE, 0))
+ ? gen_rtx_REG (MODE, 16) \
+ : gen_rtx_REG (MODE, 0))
/* 1 if N is a possible register number for a function value.
On the Alliant, D0 and FP0 are the only registers thus used.
;;- Machine description for GNU C compiler for Alliant FX systems
-;; Copyright (C) 1989, 1994, 1996 Free Software Foundation, Inc.
+;; Copyright (C) 1989, 1994, 1996, 1998, 1999 Free Software Foundation, Inc.
;; Adapted from m68k.md by Paul Petersen (petersen@uicsrd.csrd.uiuc.edu)
;; and Joe Weening (weening@gang-of-four.stanford.edu).
{
xoperands[1] = operands[1];
xoperands[2]
- = gen_rtx (MEM, QImode,
- gen_rtx (PLUS, VOIDmode, stack_pointer_rtx, const1_rtx));
+ = gen_rtx_MEM (QImode, plus_constant (stack_pointer_rtx, 1));
xoperands[3] = stack_pointer_rtx;
/* Just pushing a byte puts it in the high byte of the halfword. */
/* We must put it in the low half, the second byte. */
xoperands[0] = operands[0];
xoperands[1] = operands[1];
xoperands[2]
- = gen_rtx (MEM, QImode,
- gen_rtx (PLUS, VOIDmode, stack_pointer_rtx, const1_rtx));
+ = gen_rtx_MEM (QImode, plus_constant (stack_pointer_rtx, 1));
xoperands[3] = stack_pointer_rtx;
output_asm_insn (\"mov%.w %1,%-\;mov%.b %2,%0\;addq%.w %#2,%3\", xoperands);
return \"\";
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"mov%.l %1,%-\", xoperands);
output_asm_insn (\"mov%.l %1,%-\", operands);
return \"fmove%.d %+,%0\";
if (REG_P (operands[0]))
{
output_asm_insn (\"fmove%.d %1,%-\;mov%.l %+,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"mov%.l %+,%0\";
}
return \"fmove%.d %1,%0\";
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"mov%.l %1,%-\", xoperands);
output_asm_insn (\"mov%.l %1,%-\", operands);
return \"fmove%.d %+,%0\";
if (REG_P (operands[0]))
{
output_asm_insn (\"fmove%.d %1,%-\;mov%.l %+,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"mov%.l %+,%0\";
}
return \"fmove%.d %1,%0\";
operands[1] = GEN_INT (logval);
else
{
- operands[0] = adj_offsettable_operand (operands[0], 3 - (logval / 8));
+ operands[0]
+ = adj_offsettable_operand (operands[0], 3 - (logval / 8));
operands[1] = GEN_INT (logval % 8);
}
return \"bset %1,%0\";
&& GET_CODE (operands[2]) == CONST_INT)
{
int width = GET_CODE (operands[0]) == REG ? 31 : 7;
- return output_btst (operands,
- GEN_INT (width - INTVAL (operands[2])),
- operands[0],
- insn, 1000);
+ return output_btst (operands, GEN_INT (width - INTVAL (operands[2])),
+ operands[0], insn, 1000);
/* Pass 1000 as SIGNPOS argument so that btst will
not think we are testing the sign bit for an `and'
and assume that nonzero implies a negative result. */
&& GET_CODE (operands[2]) == CONST_INT)
{
int width = GET_CODE (operands[0]) == REG ? 31 : 7;
- return output_btst (operands,
- GEN_INT (width - INTVAL (operands[2])),
- operands[0],
- insn, 1000);
+ return output_btst (operands, GEN_INT (width - INTVAL (operands[2])),
+ operands[0], insn, 1000);
/* Pass 1000 as SIGNPOS argument so that btst will
not think we are testing the sign bit for an `and'
and assume that nonzero implies a negative result. */
table_elt_addr
= memory_address_noforce
(HImode,
- gen_rtx (PLUS, Pmode,
- gen_rtx (MULT, Pmode, index_diff,
- GEN_INT (2)),
- gen_rtx (LABEL_REF, VOIDmode, operands[3])));
+ gen_rtx_PLUS (Pmode,
+ gen_rtx_MULT (Pmode, index_diff, GEN_INT (2)),
+ gen_rtx_LABEL_REF (Pmode, operands[3])));
/* Emit the last few insns. */
emit_insn (gen_casesi_2 (gen_reg_rtx (HImode), table_elt_addr, operands[3]));
DONE;
; "*
;{
; rtx xoperands[2];
-; xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+; xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
; output_asm_insn (\"mov%.l %1,%@\", xoperands);
; output_asm_insn (\"mov%.l %1,%-\", operands);
; return \"fmove%.d %+,%0\";
/* Subroutines for insn-output.c for the Gmicro.
- Ported by Masanobu Yuhara, Fujitsu Laboratories LTD.
+ Copyright (C) 1990, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Contributed by Masanobu Yuhara, Fujitsu Laboratories LTD.
(yuhara@flab.fujitsu.co.jp)
- Copyright (C) 1990, 1991, 1997 Free Software Foundation, Inc.
-
This file is part of GNU CC.
GNU CC is free software; you can redistribute it and/or modify
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
{
operands[0] = XEXP (XEXP (operands[0], 0), 0);
output_asm_insn ("sub.w %#8,%0", operands);
- operands[0] = gen_rtx (MEM, DImode, operands[0]);
+ 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.w %#8,%1", operands);
- operands[1] = gen_rtx (MEM, DImode, operands[1]);
+ operands[1] = gen_rtx_MEM (DImode, operands[1]);
optype1 = OFFSOP;
}
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
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]) + 1);
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else if (optype1 == OFFSOP)
latehalf[1] = adj_offsettable_operand (operands[1], 4);
else if (optype1 == CNSTOP)
else if (GREG_P (operands[0]))
{
rtx xoperands[2];
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xoperands[1] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
output_asm_insn ("mov.w %1,%0", xoperands);
operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
return "mov.w %1,%0";
}
else
- {
- return output_move_double (operands); /* ?????? */
- }
+ return output_move_double (operands); /* ?????? */
}
char *
/* Definitions of target machine for GNU compiler. Gmicro (TRON) version.
- Copyright (C) 1987, 88, 89, 95, 96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 89, 95-98, 1999 Free Software Foundation, Inc.
Contributed by Masanobu Yuhara, Fujitsu Laboratories LTD.
(yuhara@flab.fujitsu.co.jp)
/* 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), \
- ((TARGET_FPU && ((MODE) == SFmode || (MODE) == DFmode)) ? 16 : 0)))
+#define LIBCALL_VALUE(MODE) \
+ (gen_rtx_REG ((MODE), \
+ ((TARGET_FPU && ((MODE) == SFmode || (MODE) == DFmode)) \
+ ? 16 : 0)))
/* 1 if N is a possible register number for a function value.
It exists only to test register calling conventions. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
-((TARGET_REGPARM && (CUM) < 8) ? gen_rtx (REG, (MODE), (CUM) / 4) : 0)
+((TARGET_REGPARM && (CUM) < 8) ? gen_rtx_REG ((MODE), (CUM) / 4) : 0)
/* For an arg passed partly in registers and partly in memory,
this is the number of registers used.
else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 0) == frame_pointer_rtx) \
{ rtx other_reg = XEXP (ADDR, 1); \
offset = 0; \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
else if (GET_CODE (ADDR) == PLUS && XEXP (ADDR, 1) == frame_pointer_rtx) \
{ rtx other_reg = XEXP (ADDR, 0); \
offset = 0; \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
else if (GET_CODE (ADDR) == PLUS \
&& GET_CODE (XEXP (ADDR, 0)) == PLUS \
&& XEXP (XEXP (ADDR, 0), 0) == frame_pointer_rtx \
&& GET_CODE (XEXP (ADDR, 1)) == CONST_INT) \
{ rtx other_reg = XEXP (XEXP (ADDR, 0), 1); \
offset = INTVAL (XEXP (ADDR, 1)); \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
else if (GET_CODE (ADDR) == PLUS \
&& GET_CODE (XEXP (ADDR, 0)) == PLUS \
&& XEXP (XEXP (ADDR, 0), 1) == frame_pointer_rtx \
&& GET_CODE (XEXP (ADDR, 1)) == CONST_INT) \
{ rtx other_reg = XEXP (XEXP (ADDR, 0), 0); \
offset = INTVAL (XEXP (ADDR, 1)); \
- regs = gen_rtx (PLUS, Pmode, stack_pointer_rtx, other_reg); } \
+ regs = gen_rtx_PLUS (Pmode, stack_pointer_rtx, other_reg); } \
if (offset >= 0) \
{ int regno; \
extern char call_used_regs[]; \
;;- Machine description for GNU compiler, Fujitsu Gmicro Version
-;; Copyright (C) 1990, 1994, 1996 Free Software Foundation, Inc.
+;; Copyright (C) 1990, 1994, 1996, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by M.Yuhara, Fujitsu Laboratories LTD.
;; This file is part of GNU CC.
if (FPU_REG_P (operands[0]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"mov.w %1,%-\", xoperands);
output_asm_insn (\"mov.w %1,%-\", operands);
return \"fmov.d %+,%0\";
{
output_asm_insn (\"fmov.d %f1,%-\", operands);
output_asm_insn (\"mov.w %+,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"mov.w %+,%0\";
}
}
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"mov.w %1,%-\", xoperands);
output_asm_insn (\"mov.w %1,%-\", operands);
return \"fmov.d %+,%0\";
if (REG_P (operands[0]))
{
output_asm_insn (\"fmov.d %f1,%-\;mov.w %+,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"mov.w %+,%0\";
}
else
}
else
{
- operands[0] = adj_offsettable_operand (operands[0], 3 - (logval / 8));
+ operands[0]
+ = adj_offsettable_operand (operands[0], 3 - (logval / 8));
operands[1] = GEN_INT (7 - (logval % 8));
}
return \"bset.b %1,%0\";
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, HImode, negate_rtx (HImode, operands[2]));
+ operands[2] = gen_rtx_NEG (HImode, negate_rtx (HImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
output_asm_insn (\"mov.w %1,%0\", operands);
if (INTVAL (operands[3]) != 0)
output_asm_insn (\"shl.w %3,%0\", operands);
- operands[2] = GEN_INT (-(32 - INTVAL (operands[2])));
+ operands[2] = GEN_INT (- (32 - INTVAL (operands[2])));
return \"shl.w %3,%0\";
}")
"*
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"mov.w %1,@sp\", xoperands);
output_asm_insn (\"mov.w %1,%-\", operands);
return \"fmov.d %+,%0\";
/* US Software GOFAST floating point library support.
- Copyright (C) 1994 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
} while (0)
#define GOFAST_RENAME_LIBCALLS \
- add_optab->handlers[(int) SFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpadd"); \
- add_optab->handlers[(int) DFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpadd"); \
- sub_optab->handlers[(int) SFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpsub"); \
- sub_optab->handlers[(int) DFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpsub"); \
- smul_optab->handlers[(int) SFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpmul"); \
- smul_optab->handlers[(int) DFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpmul"); \
- flodiv_optab->handlers[(int) SFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpdiv"); \
- flodiv_optab->handlers[(int) DFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpdiv"); \
- cmp_optab->handlers[(int) SFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- cmp_optab->handlers[(int) DFmode].libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
+ add_optab->handlers[(int) SFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpadd"); \
+ add_optab->handlers[(int) DFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpadd"); \
+ sub_optab->handlers[(int) SFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpsub"); \
+ sub_optab->handlers[(int) DFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpsub"); \
+ smul_optab->handlers[(int) SFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpmul"); \
+ smul_optab->handlers[(int) DFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpmul"); \
+ flodiv_optab->handlers[(int) SFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpdiv"); \
+ flodiv_optab->handlers[(int) DFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpdiv"); \
+ cmp_optab->handlers[(int) SFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ cmp_optab->handlers[(int) DFmode].libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
\
- extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fptodp"); \
- truncdfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dptofp"); \
+ extendsfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fptodp"); \
+ truncdfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dptofp"); \
\
- eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- nesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- gtsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- gesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- ltsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
- lesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "fpcmp"); \
+ eqsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ nesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ gtsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ gesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ ltsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
+ lesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "fpcmp"); \
\
- eqdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
- nedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
- gtdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
- gedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
- ltdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
- ledf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "dpcmp"); \
+ eqdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
+ nedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
+ gtdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
+ gedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
+ ltdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
+ ledf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "dpcmp"); \
\
eqxf2_libfunc = NULL_RTX; \
nexf2_libfunc = NULL_RTX; \
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "regs.h"
/* Forward declarations. */
void print_operand_address ();
-char *index ();
static int h8300_interrupt_function_p PROTO ((tree));
static int h8300_monitor_function_p PROTO ((tree));
switch (cum->nbytes / UNITS_PER_WORD)
{
case 0:
- result = gen_rtx (REG, mode, 0);
+ result = gen_rtx_REG (mode, 0);
break;
case 1:
- result = gen_rtx (REG, mode, 1);
+ result = gen_rtx_REG (mode, 1);
break;
case 2:
- result = gen_rtx (REG, mode, 2);
+ result = gen_rtx_REG (mode, 2);
break;
case 3:
- result = gen_rtx (REG, mode, 3);
+ result = gen_rtx_REG (mode, 3);
break;
default:
result = 0;
/* need a loop to get all the bits we want - we generate the
code at emit time, but need to allocate a scratch reg now */
- emit_insn (gen_rtx
- (PARALLEL, VOIDmode,
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
gen_rtvec (2,
- gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (code, mode, operands[0], operands[2])),
- gen_rtx (CLOBBER, VOIDmode, gen_rtx (SCRATCH, QImode, 0)))));
+ gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (code, mode, operands[0],
+ operands[2])),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (QImode)))));
return 1;
}
/* Ok to have a memory dest. */
if (GET_CODE (operands[0]) == MEM && !EXTRA_CONSTRAINT (operands[0], 'U'))
{
- rtx mem;
- mem = gen_rtx (MEM, GET_MODE (operands[0]),
- copy_to_mode_reg (Pmode, XEXP (operands[0], 0)));
+ rtx mem = gen_rtx_MEM (GET_MODE (operands[0]),
+ copy_to_mode_reg (Pmode,
+ XEXP (operands[0], 0)));
RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (operands[0]);
MEM_COPY_ATTRIBUTES (mem, operands[0]);
operands[0] = mem;
if (GET_CODE (operands[1]) == MEM && !EXTRA_CONSTRAINT (operands[1], 'U'))
{
- rtx mem;
- mem = gen_rtx (MEM, GET_MODE (operands[1]),
- copy_to_mode_reg (Pmode, XEXP (operands[1], 0)));
+ rtx mem = gen_rtx_MEM (GET_MODE (operands[1]),
+ copy_to_mode_reg (Pmode,
+ XEXP (operands[1], 0)));
RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (operands[1]);
MEM_COPY_ATTRIBUTES (mem, operands[0]);
operands[1] = mem;
operands[1] = force_reg (QImode, operands[1]);
{
rtx res = gen_reg_rtx (QImode);
- emit_insn (gen_rtx (SET, VOIDmode, res, gen_rtx (type, QImode, operands[1], operands[2])));
- emit_insn (gen_rtx (SET, VOIDmode, operands[0], res));
+ emit_insn (gen_rtx_SET (VOIDmode, res,
+ gen_rtx (type, QImode, operands[1], operands[2])));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0], res));
}
return 1;
}
On the H8 the return value is in R0/R1. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* On the h8 the return value is in R0/R1 */
#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, MODE, 0)
+ gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value.
On the H8, R0 is the only register thus used. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
enum machine_mode mode = TARGET_H8300H || TARGET_H8300S? SImode : HImode; \
- emit_move_insn (gen_rtx (MEM, mode, plus_constant ((TRAMP), 2)), CXT); \
- emit_move_insn (gen_rtx (MEM, mode, plus_constant ((TRAMP), 6)), FNADDR); \
- if (TARGET_H8300H || TARGET_H8300S) \
- emit_move_insn (gen_rtx (MEM, QImode, plus_constant ((TRAMP), 6)), GEN_INT (0x5A)); \
+ emit_move_insn (gen_rtx_MEM (mode, plus_constant ((TRAMP), 2)), CXT); \
+ emit_move_insn (gen_rtx_MEM (mode, plus_constant ((TRAMP), 6)), FNADDR); \
+ if (TARGET_H8300H || TARGET_H8300S) \
+ emit_move_insn (gen_rtx_MEM (QImode, plus_constant ((TRAMP), 6)), \
+ GEN_INT (0x5A)); \
}
\f
/* Addressing modes, and classification of registers for them. */
#define INIT_TARGET_OPTABS \
do { \
smul_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, MULHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, MULHI3_LIBCALL); \
sdiv_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, DIVHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, DIVHI3_LIBCALL); \
udiv_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, UDIVHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, UDIVHI3_LIBCALL); \
smod_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, MODHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, MODHI3_LIBCALL); \
umod_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, UMODHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, UMODHI3_LIBCALL); \
} while (0)
#define MOVE_RATIO 3
/* Subroutines for insn-output.c for System/370.
- Copyright (C) 1989, 1993, 1995, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 95, 97, 98, 1999 Free Software Foundation, Inc.
Contributed by Jan Stein (jan@cd.chalmers.se).
Modified for OS/390 LanguageEnvironment C by Dave Pitts (dpitts@cozx.com)
Hacked for Linux-ELF/390 by Linas Vepstas (linas@linas.org)
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
-#include <string.h>
-#include <ctype.h>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <fcntl.h>
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "regs.h"
#include "function.h"
#include "flags.h"
#include "recog.h"
-#include <time.h>
extern FILE *asm_out_file;
/* Definitions of target machine for GNU compiler. System/370 version.
- Copyright (C) 1989, 1993, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 95, 96, 97, 1998, 1999 Free Software Foundation, Inc.
Contributed by Jan Stein (jan@cd.chalmers.se).
Modified for OS/390 LanguageEnvironment C by Dave Pitts (dpitts@cozx.com)
Hacked for Linux-ELF/390 by Linas Vepstas (linas@linas.org)
(((MODE) == DCmode || (MODE) == SCmode || (MODE) == TFmode || (MODE) == DFmode || (MODE) == SFmode) ? 16 : 15)
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx(REG, TYPE_MODE (VALTYPE), RET_REG(TYPE_MODE(VALTYPE)))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), RET_REG (TYPE_MODE (VALTYPE)))
#define RETURN_IN_MEMORY(VALTYPE) \
((DImode == TYPE_MODE (VALTYPE)) || (BLKmode == 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, RET_REG(MODE))
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, RET_REG (MODE))
/* 1 if N is a possible register number for a function value.
On the 370 under C/370, R15 and R16 are thus used. */
#define TRAMPOLINE_TEMPLATE(FILE) \
{ \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x05E0)); \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x5800 | \
- STATIC_CHAIN_REGNUM << 4)); \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0xE00A)); \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x58F0)); \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0xE00E)); \
- ASM_OUTPUT_SHORT (FILE, gen_rtx (CONST_INT, VOIDmode, 0x07FF)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x05E0)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x5800 | STATIC_CHAIN_REGNUM << 4)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0xE00A)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x58F0)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0xE00E)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x07FF)); \
ASM_OUTPUT_SHORT (FILE, const0_rtx); \
ASM_OUTPUT_SHORT (FILE, const0_rtx); \
ASM_OUTPUT_SHORT (FILE, const0_rtx); \
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 12)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 16)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 12)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 16)), FNADDR); \
}
/* Define EXIT_IGNORE_STACK if, when returning from a function, the stack
#define LEGITIMIZE_ADDRESS(X, OLDX, MODE, WIN) \
{ \
if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- copy_to_mode_reg (SImode, XEXP (X, 1))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ copy_to_mode_reg (SImode, XEXP (X, 1))); \
if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- copy_to_mode_reg (SImode, XEXP (X, 0))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ copy_to_mode_reg (SImode, XEXP (X, 0))); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ force_operand (XEXP (X, 0), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), 0)); \
if (memory_address_p (MODE, X)) \
goto WIN; \
}
gen_push (arg)
rtx arg;
{
- return gen_rtx (SET, VOIDmode,
- gen_rtx_MEM (SImode,
- gen_rtx (PRE_DEC, SImode,
- stack_pointer_rtx)),
- arg);
+ return gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (SImode,
+ gen_rtx_PRE_DEC (SImode,
+ stack_pointer_rtx)),
+ arg);
}
/* Compute the size of local storage taking into consideration the
&& (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));
+ 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
&& (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));
+ 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, 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));
+ x = gen_rtx_PLUS (Pmode,
+ gen_rtx_PLUS (Pmode, XEXP (x, 0),
+ XEXP (XEXP (x, 1), 0)),
+ XEXP (XEXP (x, 1), 1));
}
/* Canonicalize
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)));
+ 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)));
}
}
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
gen_rtx_REG (TYPE_MODE (VALTYPE), \
- VALUE_REGNO (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. */
/* Before the prologue, RA is at 0(%esp). */
#define INCOMING_RETURN_ADDR_RTX \
gen_rtx_MEM (VOIDmode, gen_rtx_REG (VOIDmode, STACK_POINTER_REGNUM))
-
+
/* After the prologue, RA is at -4(AP) in the current frame. */
#define RETURN_ADDR_RTX(COUNT, FRAME) \
((COUNT) == 0 \
- ? gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, arg_pointer_rtx, GEN_INT(-4)))\
- : gen_rtx_MEM (Pmode, gen_rtx_PLUS (Pmode, (FRAME), GEN_INT(4))))
+ ? gen_rtx_MEM (Pmode, plus_constant (arg_pointer_rtx, -4))\
+ : gen_rtx_MEM (Pmode, plus_constant (FRAME, 4)))
/* PC is dbx register 8; let's use that column for RA. */
#define DWARF_FRAME_RETURN_COLUMN 8
char c; \
\
putc ('\"', asm_file); \
- if (STRING[1] == ':' \
- && (STRING[2] == '/' || STRING[2] == '\\')) \
- { \
- putc ('/', asm_file); \
- putc ('/', asm_file); \
- putc (*string, asm_file); \
- string += 2; \
- } \
\
while ((c = *string++) != 0) \
{ \
/* Definitions of target machine for GNU compiler.
Intel 386 (OSF/1 with OSF/rose) version.
- Copyright (C) 1991, 1992, 1993, 1996, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 96, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
rtx symref; \
\
HALF_PIC_EXTERNAL ("_mcount_ptr"); \
- symref = HALF_PIC_PTR (gen_rtx (SYMBOL_REF, Pmode, \
- "_mcount_ptr")); \
+ symref = HALF_PIC_PTR (gen_rtx_SYMBOL_REF (Pmode, \
+ "_mcount_ptr")); \
\
fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \
fprintf (FILE, "\tmovl %s%s,%%eax\n", prefix, \
rtx symdef; \
\
HALF_PIC_EXTERNAL ("mcount"); \
- symdef = HALF_PIC_PTR (gen_rtx (SYMBOL_REF, Pmode, "mcount")); \
+ symdef = HALF_PIC_PTR (gen_rtx_SYMBOL_REF (Pmode, "mcount")); \
fprintf (FILE, "\tmovl $%sP%d,%%edx\n", lprefix, labelno); \
fprintf (FILE, "\tcall *%s%s\n", prefix, XSTR (symdef, 0)); \
} \
/* Operating system specific defines to be used when targeting GCC for
Windows NT 3.x on an i386.
- Copyright (C) 1994, 1995 Free Software Foundation, Inc.
+ Copyright (C) 1994, 1995, 1998, 1999 Free Software Foundation, Inc.
Contributed by Douglas B. Rupp (drupp@cs.washington.edu).
This file is part of GNU CC.
if (lookup_attribute ("stdcall", \
TYPE_ATTRIBUTES (TREE_TYPE (DECL)))) \
XEXP (DECL_RTL (DECL), 0) = \
- gen_rtx (SYMBOL_REF, Pmode, gen_stdcall_suffix (DECL)); \
+ gen_rtx_SYMBOL_REF (Pmode, gen_stdcall_suffix (DECL)); \
} \
while (0)
#endif
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "flags.h"
#include "rtl.h"
#include "tree.h"
rtx xoperands[2];
cc_status.flags &= ~CC_F0_IS_0;
- xoperands[0] = gen_rtx (REG, SFmode, 32);
+ xoperands[0] = gen_rtx_REG (SFmode, 32);
xoperands[1] = operands[1];
output_asm_insn (singlemove_string (xoperands), xoperands);
xoperands[1] = xoperands[0];
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
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]) + 1);
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else if (optype1 == OFFSOP)
latehalf[1] = adj_offsettable_operand (operands[1], 4);
else if (optype1 == CNSTOP)
xops[0] = latehalf[0];
xops[1] = operands[0];
output_asm_insn ("adds %1,%0,%1", xops);
- operands[1] = gen_rtx (MEM, DImode, operands[0]);
+ operands[1] = gen_rtx_MEM (DImode, operands[0]);
latehalf[1] = adj_offsettable_operand (operands[1], 4);
addreg1 = 0;
highest_first = 1;
/* If the source operand is any sort of zero, use f0 instead. */
if (operands[1] == CONST0_RTX (GET_MODE (operands[1])))
- operands[1] = gen_rtx (REG, DFmode, F0_REGNUM);
+ operands[1] = gen_rtx_REG (DFmode, F0_REGNUM);
if (FP_REG_P (operands[0]))
{
if (GET_CODE (operands[1]) == REG)
{
output_asm_insn ("ixfr %1,%0", operands);
- operands[0] = gen_rtx (REG, VOIDmode, REGNO (operands[0]) + 1);
- operands[1] = gen_rtx (REG, VOIDmode, REGNO (operands[1]) + 1);
+ operands[0] = gen_rtx_REG (VOIDmode, REGNO (operands[0]) + 1);
+ operands[1] = gen_rtx_REG (VOIDmode, REGNO (operands[1]) + 1);
return "ixfr %1,%0";
}
if (operands[1] == CONST0_RTX (DFmode))
if (GET_CODE (operands[0]) == REG)
{
output_asm_insn ("fxfr %1,%0", operands);
- operands[0] = gen_rtx (REG, VOIDmode, REGNO (operands[0]) + 1);
- operands[1] = gen_rtx (REG, VOIDmode, REGNO (operands[1]) + 1);
+ operands[0] = gen_rtx_REG (VOIDmode, REGNO (operands[0]) + 1);
+ operands[1] = gen_rtx_REG (VOIDmode, REGNO (operands[1]) + 1);
return "fxfr %1,%0";
}
if (CONSTANT_ADDRESS_P (XEXP (operands[0], 0)))
output_asm_insn ("sub %2,%1,%0", xoperands);
else
{
- xoperands[1]
- = GEN_INT (INTVAL (size) - INTVAL (align));
+ xoperands[1] = GEN_INT (INTVAL (size) - INTVAL (align));
cc_status.flags &= ~ CC_KNOW_HI_R31;
output_asm_insn ("mov %1,%0", xoperands);
}
else
{
int insn_code_number;
- rtx pat = gen_rtx (SET, VOIDmode, dest, src);
- rtx delay_insn = gen_rtx (INSN, VOIDmode, 0, 0, 0, pat, -1, 0, 0);
+ rtx pat = gen_rtx_SET (VOIDmode, dest, src);
+ rtx delay_insn = gen_rtx_INSN (VOIDmode, 0, 0, 0, pat, -1, 0, 0);
int i;
/* Output the branch instruction first. */
/* Definitions of target machine for GNU compiler, for Intel 860.
- Copyright (C) 1989, 91, 93, 95, 96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 91, 93, 95-98, 1999 Free Software Foundation, Inc.
Hacked substantially by Ron Guilmette (rfg@monkeys.com) to cater to
the whims of the System V Release 4 assembler.
/* On the i860, the value register depends on the mode. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), \
- (GET_MODE_CLASS (TYPE_MODE (VALTYPE)) == MODE_FLOAT \
- ? 40 : 16))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), \
+ (GET_MODE_CLASS (TYPE_MODE (VALTYPE)) == MODE_FLOAT \
+ ? 40 : 16))
/* 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, \
- (GET_MODE_CLASS ((MODE)) == MODE_FLOAT \
- ? 40 : 16))
+ gen_rtx_REG (MODE, \
+ (GET_MODE_CLASS ((MODE)) == MODE_FLOAT \
+ ? 40 : 16))
/* 1 if N is a possible register number for a function value
as seen by the caller. */
? 0 \
: GET_MODE_CLASS ((MODE)) == MODE_FLOAT || (MODE) == DImode \
? (ROUNDUP ((CUM).floats, GET_MODE_SIZE ((MODE))) < 32 \
- ? gen_rtx (REG, (MODE), \
- 40+(ROUNDUP ((CUM).floats, \
- GET_MODE_SIZE ((MODE))) \
- / 4)) \
+ ? gen_rtx_REG ((MODE), \
+ 40 + (ROUNDUP ((CUM).floats, \
+ GET_MODE_SIZE ((MODE))) \
+ / 4)) \
: 0) \
: GET_MODE_CLASS ((MODE)) == MODE_INT \
? (ROUNDUP ((CUM).ints, GET_MODE_SIZE ((MODE))) < 48 \
- ? gen_rtx (REG, (MODE), \
- 16+(ROUNDUP ((CUM).ints, \
- GET_MODE_SIZE ((MODE))) \
- / 4)) \
+ ? gen_rtx_REG ((MODE), \
+ 16 + (ROUNDUP ((CUM).ints, \
+ GET_MODE_SIZE ((MODE))) \
+ / 4)) \
: 0) \
: 0)
size_int (16), 0, 0); \
rtx hi_fn = expand_shift (RSHIFT_EXPR, SImode, fn, \
size_int (16), 0, 0); \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 16)), \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 16)), \
gen_lowpart (HImode, cxt)); \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 4)), \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 4)), \
gen_lowpart (HImode, fn)); \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 8)), \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 8)), \
gen_lowpart (HImode, hi_cxt)); \
- emit_move_insn (gen_rtx (MEM, HImode, plus_constant (TRAMP, 0)), \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 0)), \
gen_lowpart (HImode, hi_fn)); \
}
\f
#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \
{ if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ force_operand (XEXP (X, 0), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ force_operand (XEXP (X, 0), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) != REG \
&& GET_CODE (XEXP (X, 0)) != CONST_INT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- copy_to_mode_reg (SImode, XEXP (X, 0))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ copy_to_mode_reg (SImode, XEXP (X, 0))); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) != REG \
&& GET_CODE (XEXP (X, 1)) != CONST_INT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- copy_to_mode_reg (SImode, XEXP (X, 1))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ copy_to_mode_reg (SImode, XEXP (X, 1))); \
if (GET_CODE (x) == SYMBOL_REF) \
(X) = copy_to_reg (X); \
if (GET_CODE (x) == CONST) \
;;- Machine description for Intel 860 chip for GNU C compiler
-;; Copyright (C) 1989, 1990, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1989, 1990, 1997, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
"*
{
CC_STATUS_PARTIAL_INIT;
- operands[2] = GEN_INT ((INTVAL (operands[2]) << INTVAL (operands[1])));
+ operands[2] = GEN_INT (INTVAL (operands[2]) << INTVAL (operands[1]));
return \"and %2,%0,%?r0\";
}")
"*
{
CC_STATUS_PARTIAL_INIT;
- operands[2] = GEN_INT ((INTVAL (operands[2]) << INTVAL (operands[1])));
+ operands[2] = GEN_INT (INTVAL (operands[2]) << INTVAL (operands[1]));
return \"and %2,%0,%?r0\";
}")
\f
return \"and %2,%1,%0\";
if ((INTVAL (operands[2]) & 0xffff) == 0)
{
- operands[2] = GEN_INT ((unsigned) INTVAL (operands[2]) >> 16);
+ operands[2]
+ = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"andh %2,%1,%0\";
}
xop[0] = operands[0];
xop[1] = operands[1];
xop[2] = GEN_INT (~INTVAL (operands[2]) & 0xffff);
output_asm_insn (\"andnot %2,%1,%0\", xop);
- operands[2] = GEN_INT (~(unsigned) INTVAL (operands[2]) >> 16);
+ operands[2] = GEN_INT (~(unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"andnoth %2,%0,%0\";
}")
return \"andnot %1,%2,%0\";
if ((INTVAL (operands[1]) & 0xffff) == 0)
{
- operands[1] = GEN_INT ((unsigned) INTVAL (operands[1]) >> 16);
+ operands[1]
+ = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[1]) >> 16);
return \"andnoth %1,%2,%0\";
}
xop[0] = operands[0];
- xop[1] = GEN_INT ((INTVAL (operands[1]) & 0xffff));
+ xop[1] = GEN_INT (INTVAL (operands[1]) & 0xffff);
xop[2] = operands[2];
output_asm_insn (\"andnot %1,%2,%0\", xop);
- operands[1] = GEN_INT ((unsigned) INTVAL (operands[1]) >> 16);
+ operands[1] = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[1]) >> 16);
return \"andnoth %1,%0,%0\";
}")
return \"or %2,%1,%0\";
if ((INTVAL (operands[2]) & 0xffff) == 0)
{
- operands[2] = GEN_INT ((unsigned) INTVAL (operands[2]) >> 16);
+ operands[2]
+ = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"orh %2,%1,%0\";
}
xop[0] = operands[0];
xop[1] = operands[1];
- xop[2] = GEN_INT ((INTVAL (operands[2]) & 0xffff));
+ xop[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
output_asm_insn (\"or %2,%1,%0\", xop);
- operands[2] = GEN_INT ((unsigned) INTVAL (operands[2]) >> 16);
+ operands[2] = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"orh %2,%0,%0\";
}")
return \"xor %2,%1,%0\";
if ((INTVAL (operands[2]) & 0xffff) == 0)
{
- operands[2] = GEN_INT ((unsigned) INTVAL (operands[2]) >> 16);
+ operands[2]
+ = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"xorh %2,%1,%0\";
}
xop[0] = operands[0];
xop[1] = operands[1];
- xop[2] = GEN_INT ((INTVAL (operands[2]) & 0xffff));
+ xop[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
output_asm_insn (\"xor %2,%1,%0\", xop);
- operands[2] = GEN_INT ((unsigned) INTVAL (operands[2]) >> 16);
+ operands[2] = GEN_INT ((unsigned HOST_WIDE_INT) INTVAL (operands[2]) >> 16);
return \"xorh %2,%0,%0\";
}")
if (INTVAL (operands[1]) > 0)
{
emit_move_insn (arg_pointer_rtx, stack_pointer_rtx);
- emit_insn (gen_rtx (USE, VOIDmode, arg_pointer_rtx));
+ emit_insn (gen_rtx_USE (VOIDmode, arg_pointer_rtx));
}
}")
if (INTVAL (operands[2]) > 0)
{
emit_move_insn (arg_pointer_rtx, stack_pointer_rtx);
- emit_insn (gen_rtx (USE, VOIDmode, arg_pointer_rtx));
+ emit_insn (gen_rtx_USE (VOIDmode, arg_pointer_rtx));
}
}")
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
y = force_reg (SImode, y);
}
- cc_reg = gen_rtx (REG, ccmode, 36);
- emit_insn (gen_rtx (SET, VOIDmode, cc_reg,
- gen_rtx (COMPARE, ccmode, x, y)));
+ cc_reg = gen_rtx_REG (ccmode, 36);
+ emit_insn (gen_rtx_SET (VOIDmode, cc_reg,
+ gen_rtx_COMPARE (ccmode, x, y)));
return cc_reg;
}
&& REGNO (operands[1]) < FIRST_PSEUDO_REGISTER
&& ! HARD_REGNO_MODE_OK (REGNO (operands[1]), mode))
{
- emit_insn (gen_rtx (PARALLEL, VOIDmode,
- gen_rtvec (2,
- gen_rtx (SET, VOIDmode,
- operands[0], operands[1]),
- gen_rtx (CLOBBER, VOIDmode,
- gen_rtx (SCRATCH, Pmode)))));
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2,
+ gen_rtx_SET (VOIDmode, operands[0], operands[1]),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (Pmode)))));
return 1;
}
edge conditions. */
operands[0] = dst;
operands[1] = src;
- operands[2] = gen_rtx (REG, Pmode, REGNO (dst) + 1);
- operands[3] = gen_rtx (MEM, word_mode, operands[2]);
+ operands[2] = gen_rtx_REG (Pmode, REGNO (dst) + 1);
+ operands[3] = gen_rtx_MEM (word_mode, operands[2]);
operands[4] = adj_offsettable_operand (operands[3], UNITS_PER_WORD);
output_asm_insn ("lda %1,%2\n\tld %3,%0\n\tld %4,%D0", operands);
return "";
edge conditions. */
operands[0] = dst;
operands[1] = src;
- operands[2] = gen_rtx (REG, Pmode, REGNO (dst) + 3);
- operands[3] = gen_rtx (MEM, word_mode, operands[2]);
+ operands[2] = gen_rtx_REG (Pmode, REGNO (dst) + 3);
+ operands[3] = gen_rtx_MEM (word_mode, operands[2]);
operands[4] = adj_offsettable_operand (operands[3], UNITS_PER_WORD);
operands[5] = adj_offsettable_operand (operands[4], UNITS_PER_WORD);
operands[6] = adj_offsettable_operand (operands[5], UNITS_PER_WORD);
for (i = 0; i < 3; i++)
{
- operands[0] = gen_rtx (REG, SImode, REGNO (dst) + i);
+ operands[0] = gen_rtx_REG (SImode, REGNO (dst) + i);
operands[1] = GEN_INT (value_long[i]);
output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
operands);
output_asm_insn ("# ldconst %1,%0",operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (dst));
+ operands[0] = gen_rtx_REG (SImode, REGNO (dst));
operands[1] = first;
output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (dst) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (dst) + 1);
operands[1] = second;
output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
operands);
REAL_VALUE_TO_TARGET_SINGLE (d, value);
output_asm_insn ("# ldconst %1,%0",operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (dst));
+ operands[0] = gen_rtx_REG (SImode, REGNO (dst));
operands[1] = GEN_INT (value);
output_asm_insn (i960_output_ldconst (operands[0], operands[1]),
operands);
return "movl %1,%0";
/* Output the upper half with a recursive call. */
- xoperands[0] = gen_rtx (REG, SImode, REGNO (dst) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (dst) + 1);
xoperands[1] = upperhalf;
output_asm_insn (i960_output_ldconst (xoperands[0], xoperands[1]),
xoperands);
similar optimizations. */
if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
&& GET_CODE (XEXP (x, 1)) == PLUS)
- x = gen_rtx (PLUS, Pmode,
- gen_rtx (PLUS, Pmode, XEXP (x, 0), XEXP (XEXP (x, 1), 0)),
- XEXP (XEXP (x, 1), 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)). */
constant = 0;
if (constant)
- 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)));
+ 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)));
}
return x;
else
{
cum->ca_nregparms = ROUND_PARM (cum->ca_nregparms, align);
- ret = gen_rtx (REG, mode, cum->ca_nregparms);
+ ret = gen_rtx_REG (mode, cum->ca_nregparms);
}
return ret;
va_start assumes it. */
emit_insn (gen_cmpsi (arg_pointer_rtx, const0_rtx));
emit_jump_insn (gen_bne (label));
- emit_insn (gen_rtx (SET, VOIDmode, arg_pointer_rtx,
- stack_pointer_rtx));
- emit_insn (gen_rtx (SET, VOIDmode, stack_pointer_rtx,
- memory_address (SImode,
- plus_constant (stack_pointer_rtx,
- 48))));
+ emit_insn (gen_rtx_SET (VOIDmode, arg_pointer_rtx,
+ stack_pointer_rtx));
+ emit_insn (gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ memory_address (SImode,
+ plus_constant (stack_pointer_rtx,
+ 48))));
emit_label (label);
/* ??? Note that we unnecessarily store one extra register for stdarg
- fns. We could optimize this, but it's kept as-is for now. */
- regblock = gen_rtx (MEM, BLKmode,
+ fns. We could optimize this, but it's kept as for now. */
+ regblock = gen_rtx_MEM (BLKmode,
plus_constant (arg_pointer_rtx,
first_reg * 4));
MEM_ALIAS_SET (regblock) = get_varargs_alias_set ();
/* 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), 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG ((MODE), 0)
/* 1 if N is a possible register number for a function value
as seen by the caller.
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(TYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (TYPE), 0)
+ gen_rtx_REG (TYPE_MODE (TYPE), 0)
/* Force aggregates and objects larger than 16 bytes to be returned in memory,
since we only have 4 registers available for return values. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 4)), \
- FNADDR); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 12)), \
- CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 4)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 12)), CXT); \
}
/* Generate RTL to flush the register windows so as to make arbitrary frames
if (which_alternative == 0)
return i960_output_move_double (operands[0], operands[1]);
- operands[3] = gen_rtx (MEM, word_mode, operands[2]);
+ operands[3] = gen_rtx_MEM (word_mode, operands[2]);
operands[4] = adj_offsettable_operand (operands[3], UNITS_PER_WORD);
return \"lda %0,%2\;st %1,%3\;st %D1,%4\";
}"
if (which_alternative == 0)
return i960_output_move_quad (operands[0], operands[1]);
- operands[3] = gen_rtx (MEM, word_mode, operands[2]);
+ operands[3] = gen_rtx_MEM (word_mode, operands[2]);
operands[4] = adj_offsettable_operand (operands[3], UNITS_PER_WORD);
operands[5] = adj_offsettable_operand (operands[4], UNITS_PER_WORD);
operands[6] = adj_offsettable_operand (operands[5], UNITS_PER_WORD);
operand0 = SUBREG_REG (operand0);
}
if (GET_MODE (operand0) != SImode)
- operand0 = gen_rtx (SUBREG, SImode, operand0, op0_subreg_word);
+ operand0 = gen_rtx_SUBREG (SImode, operand0, op0_subreg_word);
emit_insn (gen_ashlsi3 (temp, operand1, shift_24));
emit_insn (gen_ashrsi3 (operand0, temp, shift_24));
operand0 = SUBREG_REG (operand0);
}
if (GET_MODE (operand0) != SImode)
- operand0 = gen_rtx (SUBREG, SImode, operand0, op0_subreg_word);
+ operand0 = gen_rtx_SUBREG (SImode, operand0, op0_subreg_word);
emit_insn (gen_ashlsi3 (temp, operand1, shift_24));
emit_insn (gen_lshrsi3 (operand0, temp, shift_24));
"
{
rtx temp = gen_reg_rtx (DImode);
- emit_insn (gen_rtx (SET, VOIDmode, temp,
- gen_rtx (UNSIGNED_FIX, DImode,
- gen_rtx (FIX, DFmode, operands[1]))));
- emit_insn (gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (SUBREG, SImode, temp, 0)));
+ emit_insn (gen_rtx_SET (VOIDmode, temp,
+ gen_rtx_UNSIGNED_FIX (DImode,
+ gen_rtx_FIX (DFmode,
+ operands[1]))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_SUBREG (SImode, temp, 0)));
DONE;
}")
"
{
rtx temp = gen_reg_rtx (DImode);
- emit_insn (gen_rtx (SET, VOIDmode, temp,
- gen_rtx (UNSIGNED_FIX, DImode,
- gen_rtx (FIX, SFmode, operands[1]))));
- emit_insn (gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (SUBREG, SImode, temp, 0)));
+ emit_insn (gen_rtx_SET (VOIDmode, temp,
+ gen_rtx_UNSIGNED_FIX (DImode,
+ gen_rtx_FIX (SFmode,
+ operands[1]))));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_SUBREG (SImode, temp, 0)));
DONE;
}")
\f
/* Subroutines used for code generation on the Mitsubishi M32R cpu.
- Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
than being susummed into the following branch instruction. */
rtx
-gen_compare (int_code, x, y, need_compare)
- int int_code;
- rtx x;
- rtx y;
- int need_compare;
+gen_compare (code, x, y, need_compare)
+ enum rtx_code code;
+ rtx x, y;
+ int need_compare;
{
- enum rtx_code code = (enum rtx_code)int_code;
- enum rtx_code compare_code;
- enum rtx_code branch_code;
- enum machine_mode mode = SELECT_CC_MODE (code, x, y);
- rtx cc_reg = gen_rtx (REG, mode, CARRY_REGNUM);
- int must_swap = 0;
+ enum machine_mode mode = SELECT_CC_MODE (code, x, y);
+ enum rtx_code compare_code, branch_code;
+ rtx cc_reg = gen_rtx_REG (mode, CARRY_REGNUM);
+ int swap_p = 0;
switch (code)
{
int size = M32R_MAX_PARM_REGS - first_reg_offset;
rtx regblock;
- regblock = gen_rtx (MEM, BLKmode,
- plus_constant (arg_pointer_rtx,
- FIRST_PARM_OFFSET (0)));
+ regblock = gen_rtx_MEM (BLKmode,
+ plus_constant (arg_pointer_rtx,
+ FIRST_PARM_OFFSET (0)));
MEM_ALIAS_SET (regblock) = get_varargs_alias_set ();
move_block_from_reg (first_reg_offset, regblock,
size, size * UNITS_PER_WORD);
/* Definitions of target machine for GNU compiler, Mitsubishi M32R cpu.
- Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* The current return address is in r14. */
#if 0 /* The default value should work. */
#define RETURN_ADDR_RTX(COUNT, FRAME) \
-(((COUNT) == -1) \
- ? gen_rtx (REG, Pmode, 14) \
- : copy_to_reg (gen_rtx (MEM, Pmode, \
- memory_address (Pmode, plus_constant ((FRAME), UNITS_PER_WORD)))))
+(((COUNT) == -1) \
+ ? gen_rtx_REG (Pmode, 14) \
+ : copy_to_reg (gen_rtx_MEM (Pmode, \
+ memory_address (Pmode, \
+ plus_constant ((FRAME), \
+ UNITS_PER_WORD)))))
#endif
/* Register to use for pushing function arguments. */
and the rest are pushed. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
(PASS_IN_REG_P ((CUM), (MODE), (TYPE), (NAMED)) \
- ? gen_rtx (REG, (MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
+ ? gen_rtx_REG ((MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
: 0)
/* ??? Quick hack to try to get varargs working the normal way. */
#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \
(((! current_function_varargs || (NAMED)) \
&& PASS_IN_REG_P ((CUM), (MODE), (TYPE), (NAMED))) \
- ? gen_rtx (REG, (MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
+ ? gen_rtx_REG ((MODE), ROUND_ADVANCE_CUM ((CUM), (MODE), (TYPE))) \
: 0)
/* A C expression for the number of words, at the beginning of an
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 FUNCTION_VALUE(VALTYPE, FUNC) gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+#define FUNCTION_VALUE(VALTYPE, FUNC) gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* 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, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value
as seen by the caller. */
CXT is an RTX for the static chain value for the function. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
do { \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 0)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 0)), \
plus_constant ((CXT), 0xe7000000)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 4)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 4)), \
plus_constant ((FNADDR), 0xe6000000)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 8)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 8)), \
GEN_INT (0x1fc67000)); \
- emit_insn (gen_flush_icache (validize_mem (gen_rtx (MEM, SImode, TRAMP)))); \
+ emit_insn (gen_flush_icache (validize_mem (gen_rtx_MEM (SImode, TRAMP)))); \
} while (0)
\f
/* Library calls. */
;; Machine description of the Mitsubishi M32R cpu for GNU C compiler
-;; Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+;; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
op0_subword = SUBREG_WORD (operand0);
operand0 = XEXP (operand0, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx (SUBREG, SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1,
+ op1_subword),
shift_24));
if (GET_MODE (operand0) != SImode)
- operand0 = gen_rtx (SUBREG, SImode, operand0, op0_subword);
+ operand0 = gen_rtx_SUBREG (SImode, operand0, op0_subword);
emit_insn (gen_ashrsi3 (operand0, temp, shift_24));
DONE;
}")
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx (SUBREG, SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_24));
emit_insn (gen_ashrsi3 (operand0, temp, shift_24));
DONE;
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx (SUBREG, SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_16));
emit_insn (gen_ashrsi3 (operand0, temp, shift_16));
DONE;
/* Definitions for Motorola 680x0 running A/UX
- Copyright (C) 1996, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#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), 16) \
: (POINTER_TYPE_P (VALTYPE) \
- ? gen_rtx (REG, TYPE_MODE (VALTYPE), 8) \
- : gen_rtx (REG, TYPE_MODE (VALTYPE), 0)))
+ ? gen_rtx_REG (TYPE_MODE (VALTYPE), 8) \
+ : gen_rtx_REG (TYPE_MODE (VALTYPE), 0)))
#undef LIBCALL_VALUE
#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), ((TARGET_68881 && \
+ gen_rtx_REG ((MODE), ((TARGET_68881 && \
((MODE) == SFmode || (MODE) == DFmode)) ? 16 : 0))
/* 1 if N is a possible register number for a function value.
#undef FINALIZE_TRAMPOLINE
#define FINALIZE_TRAMPOLINE(TRAMP) \
- emit_library_call(gen_rtx(SYMBOL_REF, Pmode, "__clear_cache"), \
- 0, VOIDmode, 2, TRAMP, Pmode, \
- plus_constant(TRAMP, TRAMPOLINE_SIZE), Pmode);
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__clear_cache"), \
+ 0, VOIDmode, 2, TRAMP, Pmode, \
+ plus_constant (TRAMP, TRAMPOLINE_SIZE), Pmode);
/* Clear the instruction cache from `beg' to `end'. This makes an
inline system call to SYS_sysm68k. The arguments are as follows:
/* Definitions of target machine for GNU compiler;
Charles River Data Systems UNiverse/32.
- Copyright (C) 1987, 1993, 1994, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1987, 93, 94, 96, 97, 1998, 1999 Free Software Foundation, Inc.
Contributed by Gary E. Miller (Gary_Edmunds_Miller@cup.portal.com)
This file is part of GNU CC.
#if 0
#define HAVE_probe 1
-#define gen_probe() gen_rtx(ASM_INPUT, VOIDmode, "tstb -2048(sp)\t;probe\n")
+#define gen_probe() gen_rtx_ASM_INPUT (VOIDmode, "tstb -2048(sp)\t;probe\n")
#else
#undef NEED_PROBE
#define NEED_PROBE (-2048)
/* unos uses ".comm c.sac" returns &c.sac in d0 */
/* make pointer to c.sac ?
#undef STRUCT_VALUE_REGNUM
-#define STRUCT_VALUE gen_rtx(MEM, Pmode, gen_rtx( , , ) )
+#define STRUCT_VALUE gen_rtx_MEM (Pmode, gen_rtx( , , ) )
*/
#define BSS_SECTION_ASM_OP ".bss"
/* Definitions of target machine for GNU compiler. ISI 68000/68020 version.
Intended only for use with GAS, and not ISI's assembler, which is buggy
- Copyright (C) 1988, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1988, 1996, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#define FUNCTION_VALUE(VALTYPE,FUNC) LIBCALL_VALUE (TYPE_MODE (VALTYPE))
#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), ((TARGET_68881 && ((MODE) == SFmode || (MODE) == DFmode)) ? 16 : 0))
+ gen_rtx_REG ((MODE), ((TARGET_68881 && ((MODE) == SFmode || (MODE) == DFmode)) ? 16 : 0))
/* 1 if N is a possible register number for a function value.
D0 may be used, and F0 as well if -m68881 is specified. */
/* Definitions for Motorola 68k running Linux-based GNU systems with
ELF format.
- Copyright (C) 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1995, 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#define LIBCALL_VALUE(MODE) \
((((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode) \
&& TARGET_68881) \
- ? gen_rtx_REG (MODE, 16) \
- : gen_rtx_REG (MODE, 0))
+ ? gen_rtx_REG ((MODE), 16) \
+ : gen_rtx_REG ((MODE), 0))
/* In m68k svr4, a symbol_ref rtx can be a valid PIC operand if it is
an operand of a function call. */
/* Definitions for Motorola 680x0 running LynxOS.
- Copyright (C) 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1993, 94, 95, 96, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#undef LIBCALL_VALUE
#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), \
- ((TARGET_68881 \
- && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)) \
+ gen_rtx_REG ((MODE), \
+ ((TARGET_68881 \
+ && ((MODE) == SFmode || (MODE) == DFmode \
+ || (MODE) == XFmode)) \
? 16 : 0))
#undef FUNCTION_VALUE_REGNO_P
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
-/* Some output-actions in m68k.md need these. */
#include "config.h"
#include "system.h"
#include "tree.h"
if (INTVAL (operands[2]) < 0
&& INTVAL (operands[2]) >= -8)
{
- operands[2] = GEN_INT (-INTVAL (operands[2]));
+ operands[2] = GEN_INT (- INTVAL (operands[2]));
return "subq%.l %2,%0";
}
/* On the CPU32 it is faster to use two addql instructions to
if (INTVAL (operands[2]) < -8
&& INTVAL (operands[2]) >= -16)
{
- operands[2] = GEN_INT (-INTVAL (operands[2]) - 8);
+ operands[2] = GEN_INT (- INTVAL (operands[2]) - 8);
return "subq%.l %#8,%0\n\tsubq%.l %2,%0";
}
}
"*
{
CC_STATUS_INIT;
- operands[2] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"moveq %#0,%0\;moveq %#0,%2\;move%.b %1,%2\";
}")
"*
{
CC_STATUS_INIT;
- operands[2] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[2] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"moveq %#0,%0\;moveq %#0,%2\;move%.w %1,%2\";
}")
return \"add%.l %R2,%R0\;addx%.l %2,%0\";
else if (GET_CODE (operands[2]) == MEM
&& GET_CODE (XEXP (operands[2], 0)) == POST_INC)
- {
- return \"move%.l %2,%3\;add%.l %2,%R0\;addx%.l %3,%0\";
- }
+ return \"move%.l %2,%3\;add%.l %2,%R0\;addx%.l %3,%0\";
else
{
+ rtx high, low;
rtx xoperands[2];
+
if (GET_CODE (operands[2]) == REG)
- operands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
- else if (GET_CODE (operands[2]) == CONST_DOUBLE)
{
- operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
- operands[2] = GEN_INT (CONST_DOUBLE_HIGH (operands[2]));
+ low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
+ high = operands[2];
}
- else if (GET_CODE (operands[2]) == CONST_INT)
+ else if (CONSTANT_P (operands[2]))
+ split_double (operands[2], &high, &low);
+ else
{
- operands[1] = operands[2];
- operands[2] = INTVAL (operands[2]) < 0 ? constm1_rtx : const0_rtx;
+ low = adj_offsettable_operand (operands[2], 4);
+ high = operands[2];
}
- else
- operands[1] = adj_offsettable_operand (operands[2], 4);
+
+ operands[1] = low, operands[2] = high;
xoperands[0] = operands[3];
if (GET_CODE (operands[1]) == CONST_INT
&& INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
else
xoperands[1] = operands[2];
+
output_asm_insn (output_move_simode (xoperands), xoperands);
if (GET_CODE (operands[1]) == CONST_INT)
{
CC_STATUS_INIT;
if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
{
- operands[1]
- = gen_rtx_MEM (SImode,
- gen_rtx_PLUS (VOIDmode, XEXP(operands[0], 0),
- GEN_INT (-8)));
+ operands[1] = gen_rtx_MEM (SImode,
+ plus_constant (XEXP(operands[0], 0), -8));
return \"move%.l %0,%3\;add%.l %R2,%0\;addx%.l %2,%3\;move%.l %3,%1\";
}
else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
if (INTVAL (operands[2]) < 0
&& INTVAL (operands[2]) >= -8)
{
- operands[2] = GEN_INT (-INTVAL (operands[2]));
+ operands[2] = GEN_INT (- INTVAL (operands[2]));
return \"subq%.w %2,%0\";
}
/* On the CPU32 it is faster to use two addqw instructions to
if (INTVAL (operands[2]) < -8
&& INTVAL (operands[2]) >= -16)
{
- operands[2] = GEN_INT (-INTVAL (operands[2]) - 8);
+ operands[2] = GEN_INT (- INTVAL (operands[2]) - 8);
return \"subq%.w %#8,%0\;subq%.w %2,%0\";
}
}
if (INTVAL (operands[1]) < 0
&& INTVAL (operands[1]) >= -8)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]));
+ operands[1] = GEN_INT (- INTVAL (operands[1]));
return \"subq%.w %1,%0\";
}
/* On the CPU32 it is faster to use two addqw instructions to
if (INTVAL (operands[1]) < -8
&& INTVAL (operands[1]) >= -16)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]) - 8);
+ operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
return \"subq%.w %#8,%0\;subq%.w %1,%0\";
}
}
if (INTVAL (operands[1]) < 0
&& INTVAL (operands[1]) >= -8)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]));
+ operands[1] = GEN_INT (- INTVAL (operands[1]));
return \"subq%.w %1,%0\";
}
/* On the CPU32 it is faster to use two addqw instructions to
if (INTVAL (operands[1]) < -8
&& INTVAL (operands[1]) >= -16)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]) - 8);
+ operands[1] = GEN_INT (- INTVAL (operands[1]) - 8);
return \"subq%.w %#8,%0\;subq%.w %1,%0\";
}
}
return \"addq%.b %2,%0\";
if (INTVAL (operands[2]) < 0 && INTVAL (operands[2]) >= -8)
{
- operands[2] = GEN_INT (-INTVAL (operands[2]));
+ operands[2] = GEN_INT (- INTVAL (operands[2]));
return \"subq%.b %2,%0\";
}
}
return \"addq%.b %1,%0\";
if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]));
+ operands[1] = GEN_INT (- INTVAL (operands[1]));
return \"subq%.b %1,%0\";
}
}
return \"addq%.b %1,%0\";
if (INTVAL (operands[1]) < 0 && INTVAL (operands[1]) >= -8)
{
- operands[1] = GEN_INT (-INTVAL (operands[1]));
+ operands[1] = GEN_INT (- INTVAL (operands[1]));
return \"subq%.b %1,%0\";
}
}
}
else
{
+ rtx high, low;
rtx xoperands[2];
+
if (GET_CODE (operands[2]) == REG)
- operands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
- else if (GET_CODE (operands[2]) == CONST_DOUBLE)
{
- operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
- operands[2] = GEN_INT (CONST_DOUBLE_HIGH (operands[2]));
+ low = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
+ high = operands[2];
}
- else if (GET_CODE (operands[2]) == CONST_INT)
+ else if (CONSTANT_P (operands[2]))
+ split_double (operands[2], &high, &low);
+ else
{
- operands[1] = operands[2];
- operands[2] = INTVAL (operands[2]) < 0 ? constm1_rtx : const0_rtx;
+ low = adj_offsettable_operand (operands[2], 4);
+ high = operands[2];
}
- else
- operands[1] = adj_offsettable_operand (operands[2], 4);
+
+ operands[1] = low, operands[2] = high;
xoperands[0] = operands[3];
if (GET_CODE (operands[1]) == CONST_INT
&& INTVAL (operands[1]) >= -8 && INTVAL (operands[1]) < 0)
xoperands[1] = GEN_INT (-INTVAL (operands[2]) - 1);
else
xoperands[1] = operands[2];
+
output_asm_insn (output_move_simode (xoperands), xoperands);
if (GET_CODE (operands[1]) == CONST_INT)
{
if (GET_CODE (XEXP (operands[0], 0)) == POST_INC)
{
operands[1]
- = gen_rtx_MEM (SImode,
- gen_rtx_PLUS (VOIDmode, XEXP(operands[0], 0),
- GEN_INT (-8)));
+ = gen_rtx_MEM (SImode, plus_constant (XEXP (operands[0], 0), -8));
return \"move%.l %0,%3\;sub%.l %R2,%0\;subx%.l %2,%3\;move%.l %3,%1\";
}
else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
{
CC_STATUS_INIT;
/* We can get CONST_DOUBLE, but also const1_rtx etc. */
- if (GET_CODE (operands[2]) == CONST_DOUBLE
- || GET_CODE (operands[2]) == CONST_INT)
+ if (CONSTANT_P (operands[2]))
{
rtx hi, lo;
- if (GET_CODE (operands[2]) == CONST_DOUBLE)
- {
- hi = GEN_INT (CONST_DOUBLE_HIGH (operands[2]));
- lo = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
- }
- else
- {
- lo = operands[2];
- hi = INTVAL (lo) < 0 ? constm1_rtx : const0_rtx;
- }
+ split_double (operands[2], &hi, &lo);
+
switch (INTVAL (hi))
{
case 0 :
CC_STATUS_INIT;
if (GET_CODE (operands[0]) == REG)
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else
operands[0] = adj_offsettable_operand (operands[0], 4);
if (GET_MODE (operands[1]) == SImode)
{
CC_STATUS_INIT;
/* We can get CONST_DOUBLE, but also const1_rtx etc. */
- if (GET_CODE (operands[2]) == CONST_DOUBLE
- || GET_CODE (operands[2]) == CONST_INT)
+ if (CONSTANT_P (operands[2]))
{
rtx hi, lo;
- if (GET_CODE (operands[2]) == CONST_DOUBLE)
- {
- hi = GEN_INT (CONST_DOUBLE_HIGH (operands[2]));
- lo = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
- }
- else
- {
- lo = operands[2];
- hi = INTVAL (lo) < 0 ? constm1_rtx : const0_rtx;
- }
+ split_double (operands[2], &hi, &lo);
+
switch (INTVAL (hi))
{
case 0 :
{
CC_STATUS_INIT;
/* We can get CONST_DOUBLE, but also const1_rtx etc. */
- if (GET_CODE (operands[2]) == CONST_DOUBLE
- || GET_CODE (operands[2]) == CONST_INT)
+
+ if (CONSTANT_P (operands[2]))
{
rtx hi, lo;
- if (GET_CODE (operands[2]) == CONST_DOUBLE)
- {
- hi = GEN_INT (CONST_DOUBLE_HIGH (operands[2]));
- lo = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
- }
- else
- {
- lo = operands[2];
- hi = INTVAL (lo) < 0 ? constm1_rtx : const0_rtx;
- }
+ split_double (operands[2], &hi, &lo);
+
switch (INTVAL (hi))
{
case 0 :
target = operand_subword_force (operands[0], 0, SFmode);
result = expand_binop (SImode, xor_optab,
operand_subword_force (operands[1], 0, SFmode),
- GEN_INT(0x80000000), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x80000000), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
target = operand_subword (operands[0], 0, 1, DFmode);
result = expand_binop (SImode, xor_optab,
operand_subword_force (operands[1], 0, DFmode),
- GEN_INT(0x80000000), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x80000000), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
target = operand_subword_force (operands[0], 0, SFmode);
result = expand_binop (SImode, and_optab,
operand_subword_force (operands[1], 0, SFmode),
- GEN_INT(0x7fffffff), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
target = operand_subword (operands[0], 0, 1, DFmode);
result = expand_binop (SImode, and_optab,
operand_subword_force (operands[1], 0, DFmode),
- GEN_INT(0x7fffffff), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
int width = GET_CODE (operands[0]) == REG ? 31 : 7;
return output_btst (operands,
GEN_INT (width - INTVAL (operands[2])),
- operands[0],
- insn, 1000);
+ operands[0], insn, 1000);
/* Pass 1000 as SIGNPOS argument so that btst will
not think we are testing the sign bit for an `and'
and assume that nonzero implies a negative result. */
&& GET_CODE (operands[2]) == CONST_INT)
{
int width = GET_CODE (operands[0]) == REG ? 31 : 7;
- return output_btst (operands,
- GEN_INT (width - INTVAL (operands[2])),
- operands[0],
- insn, 1000);
+ return output_btst (operands, GEN_INT (width - INTVAL (operands[2])),
+ operands[0], insn, 1000);
/* Pass 1000 as SIGNPOS argument so that btst will
not think we are testing the sign bit for an `and'
and assume that nonzero implies a negative result. */
"NEED_PROBE"
"*
{
- operands[0] = gen_rtx_PLUS (SImode, stack_pointer_rtx,
- GEN_INT (NEED_PROBE));
+ operands[0] = plus_constant (stack_pointer_rtx, NEED_PROBE);
return \"tstl %a0\";
}")
xoperands[1] = operands[1];
xoperands[2]
- = gen_rtx_MEM (QImode,
- gen_rtx_PLUS (VOIDmode, stack_pointer_rtx,
- GEN_INT (3)));
+ = gen_rtx_MEM (QImode, plus_constant (stack_pointer_rtx, 3));
xoperands[3] = stack_pointer_rtx;
if (!TARGET_5200)
output_asm_insn (\"subq%.w %#4,%3\;move%.b %1,%2\", xoperands);
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"move%.l %1,%-\", xoperands);
output_asm_insn (\"move%.l %1,%-\", operands);
return \"f%&move%.d %+,%0\";
target = operand_subword (operands[0], 0, 1, XFmode);
result = expand_binop (SImode, xor_optab,
operand_subword_force (operands[1], 0, XFmode),
- GEN_INT(0x80000000), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x80000000), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
target = operand_subword (operands[0], 0, 1, XFmode);
result = expand_binop (SImode, and_optab,
operand_subword_force (operands[1], 0, XFmode),
- GEN_INT(0x7fffffff), target, 0, OPTAB_WIDEN);
+ GEN_INT (0x7fffffff), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
/* Definitions of target machine for GNU compiler. "embedded" 68XXX.
This is meant to be included after m68k.h.
- Copyright (C) 1994, 1995 Free Software Foundation, Inc. */
+ Copyright (C) 1994, 1995, 1998, 1999 Free Software Foundation, Inc. */
#define PTRDIFF_TYPE "long int"
#define SIZE_TYPE "long unsigned int"
#define FUNCTION_VALUE(VALTYPE,FUNC) LIBCALL_VALUE (TYPE_MODE (VALTYPE))
#undef LIBCALL_VALUE
-#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), \
- ((TARGET_68881 \
- && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)) \
+#define LIBCALL_VALUE(MODE) \
+ gen_rtx_REG ((MODE), \
+ ((TARGET_68881 \
+ && ((MODE) == SFmode || (MODE) == DFmode \
+ || (MODE) == XFmode)) \
? 16 : 0))
#undef FUNCTION_VALUE_REGNO_P
/* Target definitions for GNU compiler for mc680x0 running System V.4
- Copyright (C) 1991, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1991, 93, 94, 95, 96, 1998, 1999 Free Software Foundation, Inc.
Contributed by Ron Guilmette (rfg@monkeys.com) and
Fred Fish (fnf@cygnus.com).
#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), 16) \
: (POINTER_TYPE_P (VALTYPE) \
- ? gen_rtx (REG, TYPE_MODE (VALTYPE), 8) \
- : gen_rtx (REG, TYPE_MODE (VALTYPE), 0)))
+ ? gen_rtx_REG (TYPE_MODE (VALTYPE), 8) \
+ : gen_rtx_REG (TYPE_MODE (VALTYPE), 0)))
/* For compatibility with the large body of existing code which does not
always properly declare external functions returning pointer types, the
#define LIBCALL_VALUE(MODE) \
((((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode) \
&& TARGET_68881) \
- ? gen_rtx (REG, (MODE), 16) \
- : gen_rtx (REG, (MODE), 0))
+ ? gen_rtx_REG ((MODE), 16) \
+ : gen_rtx_REG ((MODE), 0))
/* Boundary (in *bits*) on which stack pointer should be aligned.
The m68k/SVR4 convention is to keep the stack pointer longword aligned. */
#undef TRAMPOLINE_TEMPLATE
#define TRAMPOLINE_TEMPLATE(FILE) \
{ \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x227a)); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (8)); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x2f3a)); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (8)); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x4e75)); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x227a)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (8)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x2f3a)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (8)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x4e75)); \
+ ASM_OUTPUT_INT (FILE, const0_rtx); \
+ ASM_OUTPUT_INT (FILE, const0_rtx); \
}
/* Redefine since we are using a different trampoline */
#undef INITIALIZE_TRAMPOLINE
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 10)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 14)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 10)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 14)), FNADDR); \
}
/* Definitions of target machine for GNU compiler,
SysV68 Motorola 3300 Delta Series.
- Copyright (C) 1987, 93, 94, 95, 96, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 93-98, 1999 Free Software Foundation, Inc.
Contributed by Abramo and Roberto Bagnara (bagnara@dipisa.di.unipi.it)
based on Alex Crain's 3B1 definitions.
Maintained by Philippe De Muyter (phdm@info.ucl.ac.be).
/* sysV68 (brain damaged) cc convention support. */
#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), 16) \
: (POINTER_TYPE_P (VALTYPE) \
- ? gen_rtx (REG, TYPE_MODE (VALTYPE), 8) \
- : gen_rtx (REG, TYPE_MODE (VALTYPE), 0)))
+ ? gen_rtx_REG (TYPE_MODE (VALTYPE), 8) \
+ : gen_rtx_REG (TYPE_MODE (VALTYPE), 0)))
/* If TARGET_68881, SF and DF values are returned in fp0 instead of d0. */
/* Is LIBCALL_VALUE never called with a pointer ? */
#undef LIBCALL_VALUE
-#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), \
- ((TARGET_68881 \
- && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)) \
- ? 16 : 0))
+#define LIBCALL_VALUE(MODE) \
+ gen_rtx_REG ((MODE), \
+ ((TARGET_68881 \
+ && ((MODE) == SFmode || (MODE) == DFmode \
+ || (MODE) == XFmode)) \
+ ? 16 : 0))
/* 1 if N is a possible register number for a function value.
d0 may be used, and fp0 as well if -msoft-float is not specified. */
#undef FUNCTION_ARG
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
-(((CUM).libcall && (CUM).offset == 0) ? gen_rtx(REG, (MODE), 0)\
-: (TARGET_REGPARM && (CUM).offset < 8) ? gen_rtx (REG, (MODE), (CUM).offset / 4) : 0)
+(((CUM).libcall && (CUM).offset == 0) ? gen_rtx_REG ((MODE), 0)\
+: (TARGET_REGPARM && (CUM).offset < 8) ? gen_rtx_REG ((MODE), (CUM).offset / 4) : 0)
#undef FUNCTION_ARG_PARTIAL_NREGS
#define FUNCTION_ARG_PARTIAL_NREGS(CUM, MODE, TYPE, NAMED) \
if (!TARGET_68040) \
; \
else \
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__clear_insn_cache"), \
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__clear_insn_cache"), \
0, VOIDmode, 0)
/* Definitions of target machine for GNU compiler. SONY NEWS-OS 4 version.
- Copyright (C) 1987, 89, 93, 94, 96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1987, 89, 93, 94, 96-98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#define FUNCTION_VALUE(VALTYPE,FUNC) LIBCALL_VALUE (TYPE_MODE (VALTYPE))
-#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, (MODE), \
- ((TARGET_68881 \
- && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)) \
- ? 16 : 0))
+#define LIBCALL_VALUE(MODE) \
+ gen_rtx_REG ((MODE), \
+ ((TARGET_68881 \
+ && ((MODE) == SFmode || (MODE) == DFmode \
+ || (MODE) == XFmode)) \
+ ? 16 : 0))
#define ASM_OUTPUT_ALIGN(FILE,LOG) \
fprintf (FILE, "\t.align %d\n", (LOG))
/* Target definitions for GNU compiler for mc680x0 running NeXTSTEP
- Copyright (C) 1989, 90-94, 96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 90-94, 96, 97, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
#undef FINALIZE_TRAMPOLINE
#define FINALIZE_TRAMPOLINE(TRAMP) \
- emit_library_call(gen_rtx(SYMBOL_REF, Pmode, "__enable_execute_stack"), \
- 0, VOIDmode, 1, memory_address(SImode, (TRAMP)), Pmode)
+ emit_library_call(gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack"), \
+ 0, VOIDmode, 1, memory_address (SImode, (TRAMP)), Pmode)
/* A C expression used to clear the instruction cache from
address BEG to address END. On NeXTSTEP this i a system trap. */
/* Definitions of target machine for GNU compiler. Sun 68000/68020 version.
- Copyright (C) 1987, 1988, 1993, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 93, 95, 96, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* This is not a good idea. It prevents interoperation between
files compiled with -m68881 and those compiled with -msoft-float. */
#if 0
-#define FUNCTION_VALUEX(MODE) \
- gen_rtx (REG, (MODE), \
- ((TARGET_68881 \
- && ((MODE) == SFmode || (MODE) == DFmode || (MODE) == XFmode)) \
- ? 16 : 0))
+#define FUNCTION_VALUEX(MODE) \
+ gen_rtx_REG ((MODE), \
+ ((TARGET_68881 \
+ && ((MODE) == SFmode || (MODE) == DFmode \
+ || (MODE) == XFmode)) \
+ ? 16 : 0))
#undef FUNCTION_VALUE
#define FUNCTION_VALUE(VALTYPE,FUNC) FUNCTION_VALUEX (TYPE_MODE (VALTYPE))
/* Subroutines for insn-output.c for Motorola 88000.
- Copyright (C) 1988, 92, 93, 94, 95, 16, 1997, 1999 Free Software
+ Copyright (C) 1988, 92, 93, 94, 95, 96, 1997, 1998, 1999 Free Software
Foundation, Inc.
Contributed by Michael Tiemann (tiemann@mcc.com)
Currently maintained by (gcc@dg-rtp.dg.com)
Boston, MA 02111-1307, USA. */
#include "config.h"
-
-#include <stdio.h>
-#include <sys/types.h>
-#include <time.h>
-#include <ctype.h>
-
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "flags.h"
extern char *version_string;
-extern time_t time ();
-extern char *ctime ();
extern int flag_traditional;
extern FILE *asm_out_file;
|| GET_CODE (operand1) == MEM)
{
/* Run this case quickly. */
- emit_insn (gen_rtx (SET, VOIDmode, operand0, operand1));
+ emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
return 1;
}
}
|| (operand1 == const0_rtx && GET_MODE_SIZE (mode) <= UNITS_PER_WORD))
{
/* Run this case quickly. */
- emit_insn (gen_rtx (SET, VOIDmode, operand0, operand1));
+ emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
return 1;
}
if (! reload_in_progress && ! reload_completed)
&& symbolic_address_p (operand1),
operand1, temp, scratch);
if (mode != SImode)
- operands[1] = gen_rtx (SUBREG, mode, operands[1], 0);
+ operands[1] = gen_rtx_SUBREG (mode, operands[1], 0);
}
}
temp = ((reload_in_progress || reload_completed)
? reg : gen_reg_rtx (Pmode));
- emit_insn (gen_rtx (SET, VOIDmode, temp,
- gen_rtx (HIGH, SImode,
- gen_rtx (UNSPEC, SImode,
- gen_rtvec (1, addr),
- 0))));
- emit_insn (gen_rtx (SET, VOIDmode, temp,
- gen_rtx (LO_SUM, SImode, temp,
- gen_rtx (UNSPEC, SImode,
- gen_rtvec (1, addr),
- 0))));
+ emit_insn (gen_rtx_SET
+ (VOIDmode, temp,
+ gen_rtx_HIGH (SImode,
+ gen_rtx_UNSPEC (SImode,
+ gen_rtvec (1, addr),
+ 0))));
+
+ emit_insn (gen_rtx_SET
+ (VOIDmode, temp,
+ gen_rtx_LO_SUM (SImode, temp,
+ gen_rtx_UNSPEC (SImode,
+ gen_rtvec (1, addr),
+ 0))));
addr = temp;
}
- new = gen_rtx (MEM, Pmode,
- gen_rtx (PLUS, SImode,
- pic_offset_table_rtx, addr));
+
+ new = gen_rtx_MEM (Pmode,
+ gen_rtx_PLUS (SImode,
+ pic_offset_table_rtx, addr));
+
current_function_uses_pic_offset_table = 1;
RTX_UNCHANGING_P (new) = 1;
insn = emit_move_insn (reg, new);
/* Put a REG_EQUAL note on this insn, so that it can be optimized
by loop. */
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, orig,
- REG_NOTES (insn));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig,
+ REG_NOTES (insn));
new = reg;
}
else if (GET_CODE (addr) == CONST)
for this address. */
abort ();
}
- new = gen_rtx (PLUS, SImode, base, addr);
+ new = gen_rtx_PLUS (SImode, base, addr);
/* Should we set special REG_NOTEs here? */
}
}
reg = gen_reg_rtx (Pmode);
}
- emit_insn (gen_rtx (SET, VOIDmode,
- reg, gen_rtx (HIGH, SImode, addr)));
- new = gen_rtx (LO_SUM, SImode, reg, addr);
+ emit_insn (gen_rtx_SET (VOIDmode,
+ reg, gen_rtx_HIGH (SImode, addr)));
+ new = gen_rtx_LO_SUM (SImode, reg, addr);
}
if (new != orig
&& GET_CODE (orig) == MEM)
{
- new = gen_rtx (MEM, GET_MODE (orig), new);
+ new = gen_rtx_MEM (GET_MODE (orig), new);
RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (orig);
MEM_COPY_ATTRIBUTES (new, orig);
}
else
{
#ifdef TARGET_MEM_FUNCTIONS
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "memcpy"), 0,
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "memcpy"), 0,
VOIDmode, 3,
operands[0], Pmode,
operands[1], Pmode,
TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "bcopy"), 0,
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "bcopy"), 0,
VOIDmode, 3,
operands[1], Pmode,
operands[0], Pmode,
offset_rtx = GEN_INT (MOVSTR_LOOP + (1 - units) * align);
- value_rtx = gen_rtx (MEM, MEM_IN_STRUCT_P (src_mem) ? mode : BLKmode,
- gen_rtx (PLUS, Pmode,
- gen_rtx (REG, Pmode, 3),
- offset_rtx));
+ value_rtx = gen_rtx_MEM (MEM_IN_STRUCT_P (src_mem) ? mode : BLKmode,
+ gen_rtx_PLUS (Pmode,
+ gen_rtx_REG (Pmode, 3),
+ offset_rtx));
RTX_UNCHANGING_P (value_rtx) = RTX_UNCHANGING_P (src_mem);
MEM_COPY_ATTRIBUTES (value_rtx, src_mem);
emit_insn (gen_call_movstrsi_loop
- (gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (entry_name)),
+ (gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (entry_name)),
dest, src, offset_rtx, value_rtx,
- gen_rtx (REG, mode, ((units & 1) ? 4 : 5)),
+ gen_rtx_REG (mode, ((units & 1) ? 4 : 5)),
GEN_INT (count)));
if (remainder)
- block_move_sequence (gen_rtx (REG, Pmode, 2), dest_mem,
- gen_rtx (REG, Pmode, 3), src_mem,
+ block_move_sequence (gen_rtx_REG (Pmode, 2), dest_mem,
+ gen_rtx_REG (Pmode, 3), src_mem,
remainder, align, MOVSTR_LOOP + align);
}
offset_rtx = GEN_INT (most - (size - remainder));
- value_rtx = gen_rtx (MEM, MEM_IN_STRUCT_P (src_mem) ? mode : BLKmode,
- gen_rtx (PLUS, Pmode,
- gen_rtx (REG, Pmode, 3),
- offset_rtx));
+ value_rtx = gen_rtx_MEM (MEM_IN_STRUCT_P (src_mem) ? mode : BLKmode,
+ gen_rtx_PLUS (Pmode,
+ gen_rtx_REG (Pmode, 3),
+ offset_rtx));
+
RTX_UNCHANGING_P (value_rtx) = RTX_UNCHANGING_P (src_mem);
MEM_COPY_ATTRIBUTES (value_rtx, src_mem);
? (align == 8 ? 6 : 5) : 4);
emit_insn (gen_call_block_move
- (gen_rtx (SYMBOL_REF, Pmode, IDENTIFIER_POINTER (entry_name)),
+ (gen_rtx_SYMBOL_REF (Pmode, IDENTIFIER_POINTER (entry_name)),
dest, src, offset_rtx, value_rtx,
- gen_rtx (REG, mode, value_reg)));
+ gen_rtx_REG (mode, value_reg)));
if (remainder)
- block_move_sequence (gen_rtx (REG, Pmode, 2), dest_mem,
- gen_rtx (REG, Pmode, 3), src_mem,
+ block_move_sequence (gen_rtx_REG (Pmode, 2), dest_mem,
+ gen_rtx_REG (Pmode, 3), src_mem,
remainder, align, most);
}
temp[next] = gen_reg_rtx (mode[next]);
}
size -= amount[next];
- srcp = gen_rtx (MEM,
- MEM_IN_STRUCT_P (src_mem) ? mode[next] : BLKmode,
- gen_rtx (PLUS, Pmode, src,
- GEN_INT (offset_ld)));
+ srcp = gen_rtx_MEM (MEM_IN_STRUCT_P (src_mem) ? mode[next] : BLKmode,
+ plus_constant (src, offset_ld));
+
RTX_UNCHANGING_P (srcp) = RTX_UNCHANGING_P (src_mem);
MEM_COPY_ATTRIBUTES (srcp, src_mem);
- emit_insn (gen_rtx (SET, VOIDmode, temp[next], srcp));
+ emit_insn (gen_rtx_SET (VOIDmode, temp[next], srcp));
offset_ld += amount[next];
active[next] = TRUE;
}
if (active[phase])
{
active[phase] = FALSE;
- dstp = gen_rtx (MEM,
- MEM_IN_STRUCT_P (dest_mem) ? mode[phase] : BLKmode,
- gen_rtx (PLUS, Pmode, dest,
- GEN_INT (offset_st)));
+ dstp
+ = gen_rtx_MEM (MEM_IN_STRUCT_P (dest_mem) ? mode[phase] : BLKmode,
+ plus_constant (dest, offset_st));
+
RTX_UNCHANGING_P (dstp) = RTX_UNCHANGING_P (dest_mem);
MEM_COPY_ATTRIBUTES (dstp, dest_mem);
- emit_insn (gen_rtx (SET, VOIDmode, dstp, temp[phase]));
+ emit_insn (gen_rtx_SET (VOIDmode, dstp, temp[phase]));
offset_st += amount[phase];
}
}
}
/* Record the values to be computed later as "def name,high-low". */
- sb_name = gen_rtx (EXPR_LIST, VOIDmode, operands[0], sb_name);
- sb_high = gen_rtx (EXPR_LIST, VOIDmode, high, sb_high);
- sb_low = gen_rtx (EXPR_LIST, VOIDmode, low, sb_low);
+ sb_name = gen_rtx_EXPR_LIST (VOIDmode, operands[0], sb_name);
+ sb_high = gen_rtx_EXPR_LIST (VOIDmode, high, sb_high);
+ sb_low = gen_rtx_EXPR_LIST (VOIDmode, low, sb_low);
#endif /* Don't USE_GAS */
return last;
&& (u.s.exponent1 == 0x8 || u.s.exponent1 == 0x7) /* Exponent fits */
&& (temp = simplify_unary_operation (FLOAT_TRUNCATE, SFmode,
op, mode)) != 0)
- return gen_rtx (FLOAT_EXTEND, mode, force_reg (SFmode, temp));
+ return gen_rtx_FLOAT_EXTEND (mode, force_reg (SFmode, temp));
}
else if (register_operand (op, mode))
return op;
if (flag_pic && save_regs[PIC_OFFSET_TABLE_REGNUM])
{
- rtx return_reg = gen_rtx (REG, SImode, 1);
+ rtx return_reg = gen_rtx_REG (SImode, 1);
rtx label = gen_label_rtx ();
rtx temp_reg;
if (! save_regs[1])
{
- temp_reg = gen_rtx (REG, SImode, TEMP_REGNUM);
+ temp_reg = gen_rtx_REG (SImode, TEMP_REGNUM);
emit_move_insn (temp_reg, return_reg);
}
emit_insn (gen_locate1 (pic_offset_table_rtx, label));
int amount;
{
rtx incr = GEN_INT (abs (amount));
+
if (! ADD_INTVAL (amount))
{
- rtx temp = gen_rtx (REG, SImode, TEMP_REGNUM);
+ rtx temp = gen_rtx_REG (SImode, TEMP_REGNUM);
emit_move_insn (temp, incr);
incr = temp;
}
enum machine_mode mode;
int offset;
{
- rtx reg = gen_rtx (REG, mode, regno);
+ rtx reg = gen_rtx_REG (mode, regno);
rtx mem;
if (SMALL_INTVAL (offset))
{
- mem = gen_rtx (MEM, mode, plus_constant (stack_pointer_rtx, offset));
+ mem = gen_rtx_MEM (mode, plus_constant (stack_pointer_rtx, offset));
}
else
{
/* offset is too large for immediate index must use register */
rtx disp = GEN_INT (offset);
- rtx temp = gen_rtx (REG, SImode, TEMP_REGNUM);
- rtx regi = gen_rtx (PLUS, SImode, stack_pointer_rtx, temp);
+ rtx temp = gen_rtx_REG (SImode, TEMP_REGNUM);
+ rtx regi = gen_rtx_PLUS (SImode, stack_pointer_rtx, temp);
+
emit_move_insn (temp, disp);
- mem = gen_rtx (MEM, mode, regi);
+ mem = gen_rtx_MEM (mode, regi);
}
if (store_p)
|| bytes != UNITS_PER_WORD))
return (rtx) 0;
- return gen_rtx (REG,
- ((mode == BLKmode) ? TYPE_MODE (type) : mode),
- 2 + args_so_far);
+ return gen_rtx_REG (((mode == BLKmode) ? TYPE_MODE (type) : mode),
+ 2 + args_so_far);
}
\f
/* Do what is necessary for `va_start'. We look at the current function
rtx label;
{
if (m88k_compare_op1 == const0_rtx)
- emit_jump_insn( gen_bcnd (
- gen_rtx (op, VOIDmode,m88k_compare_op0, const0_rtx),
- label));
+ 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));
+ 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));
else
If the precise function being called is known, FUNC is its FUNCTION_DECL;
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, \
- TYPE_MODE (VALTYPE) == BLKmode ? SImode : TYPE_MODE (VALTYPE), \
- 2)
+ gen_rtx_REG (TYPE_MODE (VALTYPE) == BLKmode ? SImode : TYPE_MODE (VALTYPE), \
+ 2)
/* Define this if it differs from FUNCTION_VALUE. */
/* #define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) ... */
/* 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, 2)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 2)
/* True if N is a possible register number for a function value
as seen by the caller. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 40)), FNADDR); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 36)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 40)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 36)), CXT); \
}
/*** Library Subroutine Names ***/
#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \
{ \
if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- copy_to_mode_reg (SImode, XEXP (X, 1))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ copy_to_mode_reg (SImode, XEXP (X, 1))); \
if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- copy_to_mode_reg (SImode, XEXP (X, 0))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ copy_to_mode_reg (SImode, XEXP (X, 0))); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ force_operand (XEXP (X, 0), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS) \
- (X) = gen_rtx (PLUS, Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
- XEXP (X, 1)); \
+ (X) = gen_rtx_PLUS (Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
+ XEXP (X, 1)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS) \
- (X) = gen_rtx (PLUS, Pmode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), NULL_RTX)); \
+ (X) = gen_rtx_PLUS (Pmode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), NULL_RTX)); \
if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST \
|| GET_CODE (X) == LABEL_REF) \
(X) = legitimize_address (flag_pic, X, 0, 0); \
;;- Machine description for the Motorola 88000 for GNU C compiler
-;;; Copyright (C) 1988, 92-96, 1999 Free Software Foundation, Inc.
+;;; Copyright (C) 1988, 92-96, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by Michael Tiemann (tiemann@mcc.com)
;; Currently maintained by (gcc@dg-rtp.dg.com)
(match_dup 2)))
(set (match_dup 0)
(neg:SI (match_op_dup 1 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1]) == GET_CODE (operands[3]))
; /* The conditions match. */
else if (GET_CODE (operands[1])
== reverse_condition (GET_CODE (operands[3])))
/* Reverse the condition by complimenting the compare word. */
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);
else
{
/* Make the condition pairs line up by rotating the compare word. */
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[4] = gen_rtx (ROTATE, CCmode, operands[4],
- GEN_INT (((cv2 & ~1) - (cv1 & ~1)) & 0x1f));
+ operands[4] = gen_rtx_ROTATE (CCmode, operands[4],
+ GEN_INT (((cv2 & ~1) - (cv1 & ~1))
+ & 0x1f));
/* Reverse the condition if needed. */
if ((cv1 & 1) != (cv2 & 1))
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);
}")
(define_split
(match_dup 2)))
(set (match_dup 0)
(neg:SI (match_op_dup 1 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1]) == GET_CODE (operands[3]))
; /* The conditions match. */
else
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[4] = gen_rtx (ROTATE, CCmode, operands[4],
- GEN_INT ((cv2 - cv1) & 0x1f));
+ operands[4] = gen_rtx_ROTATE (CCmode, operands[4],
+ GEN_INT ((cv2 - cv1) & 0x1f));
}")
(define_split
(match_dup 4)))
(set (match_dup 0)
(neg:SI (match_op_dup 3 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1])
== reverse_condition (GET_CODE (operands[3])))
;
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[2] = gen_rtx (ROTATE, CCmode, operands[2],
- GEN_INT (((cv1 & ~1) - (cv2 & ~1)) & 0x1f));
+ operands[2] = gen_rtx_ROTATE (CCmode, operands[2],
+ GEN_INT (((cv1 & ~1) - (cv2 & ~1))
+ & 0x1f));
}")
(define_split
(match_dup 2)))
(set (match_dup 0)
(match_op_dup 1 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
/* Reverse the condition by complimenting the compare word. */
if (GET_CODE (operands[1]) != GET_CODE (operands[3]))
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);")
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);")
(define_split
[(set (match_operand:SI 0 "register_operand" "=r")
(match_dup 2)))
(set (match_dup 0)
(match_op_dup 1 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);")
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);")
(define_split
[(set (match_operand:SI 0 "register_operand" "=r")
(match_dup 2)))
(set (match_dup 0)
(match_op_dup 1 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);")
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);")
(define_split
[(set (match_operand:SI 0 "register_operand" "=r")
(match_dup 2)))
(set (match_dup 0)
(neg:SI (match_op_dup 1 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1]) == GET_CODE (operands[3]))
; /* The conditions match. */
else if (GET_CODE (operands[1])
== reverse_condition (GET_CODE (operands[3])))
/* Reverse the condition by complimenting the compare word. */
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);
else
{
/* Make the condition pairs line up by rotating the compare word. */
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[4] = gen_rtx (ROTATE, CCmode, operands[4],
- GEN_INT (((cv2 & ~1) - (cv1 & ~1)) & 0x1f));
+ operands[4] = gen_rtx_ROTATE (CCmode, operands[4],
+ GEN_INT (((cv2 & ~1) - (cv1 & ~1))
+ & 0x1f));
/* Reverse the condition if needed. */
if ((cv1 & 1) != (cv2 & 1))
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);
}")
(define_split
(match_dup 2)))
(set (match_dup 0)
(neg:SI (match_op_dup 1 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1]) == GET_CODE (operands[3]))
; /* The conditions match. */
else
/* Make the condition pairs line up by rotating the compare word. */
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[4] = gen_rtx (ROTATE, CCmode, operands[4],
- GEN_INT ((cv2 - cv1) & 0x1f));
+ operands[4] = gen_rtx_ROTATE (CCmode, operands[4],
+ GEN_INT ((cv2 - cv1) & 0x1f));
}")
(define_split
(match_dup 4)))
(set (match_dup 0)
(neg:SI (match_op_dup 3 [(match_dup 5) (const_int 0)])))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
if (GET_CODE (operands[1])
== reverse_condition (GET_CODE (operands[3])))
;
/* Make the condition pairs line up by rotating the compare word. */
int cv1 = condition_value (operands[1]);
int cv2 = condition_value (operands[3]);
- operands[2] = gen_rtx (ROTATE, CCmode, operands[2],
- GEN_INT (((cv1 & ~1) - (cv2 & ~1)) & 0x1f));
+ operands[2] = gen_rtx_ROTATE (CCmode, operands[2],
+ GEN_INT (((cv1 & ~1) - (cv2 & ~1))
+ & 0x1f));
}")
(define_split
(match_dup 2)))
(set (match_dup 0)
(match_op_dup 1 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);
/* Reverse the condition by complimenting the compare word. */
if (GET_CODE (operands[1]) != GET_CODE (operands[3]))
- operands[4] = gen_rtx (NOT, CCmode, operands[4]);")
+ operands[4] = gen_rtx_NOT (CCmode, operands[4]);")
(define_split
[(set (match_operand:SI 0 "register_operand" "=r")
(match_dup 2)))
(set (match_dup 0)
(match_op_dup 1 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);")
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);")
(define_split
[(set (match_operand:SI 0 "register_operand" "=r")
(match_dup 4)))
(set (match_dup 0)
(match_op_dup 3 [(match_dup 5) (const_int 0)]))]
- "operands[5] = gen_rtx(SUBREG, CCEVENmode, operands[5], 0);")
+ "operands[5] = gen_rtx_SUBREG (CCEVENmode, operands[5], 0);")
\f
;; Logical operations on compare words.
DONE;
/* We don't want the clobber emitted, so handle this ourselves. */
- emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
DONE;
}")
{
operands[1]
= legitimize_address (flag_pic, operands[1], 0, 0);
- emit_insn (gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (ZERO_EXTEND, SImode, operands[1])));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_ZERO_EXTEND (SImode, operands[1])));
DONE;
}
}")
if (TARGET_USE_DIV)
{
- emit_move_insn (op0, gen_rtx (DIV, SImode, op1, op2));
+ emit_move_insn (op0, gen_rtx_DIV (SImode, op1, op2));
if (TARGET_CHECK_ZERO_DIV && GET_CODE (op2) != CONST_INT)
{
rtx label = gen_label_rtx ();
emit_insn (gen_cmpsi (op2, const0_rtx));
emit_jump_insn (gen_bgt (label1));
/* constant / 0-or-negative */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, op1, neg_op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, op1, neg_op2));
if (!neg)
emit_insn (gen_negsi2 (op0, op0));
emit_barrier ();
emit_label (label1); /* constant / positive */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, op1, op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, op1, op2));
if (neg)
emit_insn (gen_negsi2 (op0, op0));
}
emit_insn (gen_cmpsi (op1, const0_rtx));
emit_jump_insn (gen_bge (label1));
/* 0-or-negative / constant */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, neg_op1, op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, neg_op1, op2));
if (!neg)
emit_insn (gen_negsi2 (op0, op0));
emit_barrier ();
emit_label (label1); /* positive / constant */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, op1, op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, op1, op2));
if (neg)
emit_insn (gen_negsi2 (op0, op0));
}
emit_insn (gen_cmpsi (op1, const0_rtx));
emit_jump_insn (gen_bge (label2));
/* negative / negative-or-0 */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, neg_op1, neg_op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, neg_op1, neg_op2));
if (TARGET_CHECK_ZERO_DIV)
{
emit_barrier ();
emit_label (label2); /* pos.-or-0 / neg.-or-0 */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, op1, neg_op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, op1, neg_op2));
if (TARGET_CHECK_ZERO_DIV)
{
emit_insn (gen_cmpsi (op1, const0_rtx));
emit_jump_insn (gen_bge (label3));
/* negative / positive */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, neg_op1, op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, neg_op1, op2));
emit_insn (gen_negsi2 (op0, op0));
emit_jump_insn (gen_jump (join_label));
emit_barrier ();
emit_label (label3); /* positive-or-0 / positive */
- emit_move_insn (op0, gen_rtx (UDIV, SImode, op1, op2));
+ emit_move_insn (op0, gen_rtx_UDIV (SImode, op1, op2));
}
emit_label (join_label);
else if (GET_CODE (op2) != CONST_INT && TARGET_CHECK_ZERO_DIV)
{
rtx label = gen_label_rtx ();
- emit_insn (gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (UDIV, SImode, operands[1], op2)));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_UDIV (SImode, operands[1], op2)));
emit_insn (gen_tcnd_divide_by_zero (op2, label));
emit_label (label);
emit_insn (gen_dummy (operands[0]));
{
register rtx index_diff = gen_reg_rtx (SImode);
register rtx low = GEN_INT (-INTVAL (operands[1]));
- register rtx label = gen_rtx (LABEL_REF, VOIDmode, operands[3]);
+ register rtx label = gen_rtx_LABEL_REF (Pmode, operands[3]);
register rtx base;
if (! CASE_VECTOR_INSNS)
{
if (GET_CODE (operands[0]) == MEM
&& ! call_address_operand (XEXP (operands[0], 0), SImode))
- operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
- force_reg (Pmode, XEXP (operands[0], 0)));
+ operands[0] = gen_rtx_MEM (GET_MODE (operands[0]),
+ force_reg (Pmode, XEXP (operands[0], 0)));
}")
(define_insn ""
{
if (GET_CODE (operands[1]) == MEM
&& ! call_address_operand (XEXP (operands[1], 0), SImode))
- operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
- force_reg (Pmode, XEXP (operands[1], 0)));
+ operands[1] = gen_rtx_MEM (GET_MODE (operands[1]),
+ force_reg (Pmode, XEXP (operands[1], 0)));
}")
(define_insn ""
/* Definitions of target machine for GNU compiler.
Motorola m88100 running the AT&T/Unisoft/Motorola V.3 reference port.
- Copyright (C) 1990, 1991, 1997, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1990, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Ray Essick (ressick@mot.com)
Enhanced by Tom Wood (Tom_Wood@NeXT.com)
#undef INITIALIZE_TRAMPOLINE
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 40)), FNADDR); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 36)), CXT); \
- emit_call_insn (gen_call (gen_rtx (MEM, SImode, \
- gen_rtx (SYMBOL_REF, Pmode, \
- "__enable_execute_stack")), \
- const0_rtx)); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 40)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 36)), CXT); \
+ emit_call_insn (gen_call \
+ (gen_rtx_MEM \
+ (SImode, \
+ gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack")), \
+ const0_rtx)); \
}
ptr = plus_constant (virtual_incoming_args_rtx, \
- (mips_save_gp_regs \
* UNITS_PER_WORD)); \
- mem = gen_rtx (MEM, BLKmode, ptr); \
+ mem = gen_rtx_MEM (BLKmode, ptr); \
/* va_arg is an array access in this case, which causes \
it to get MEM_IN_STRUCT_P set. We must set it here \
so that the insn scheduler won't assume that these \
for (i = 0; i < mips_save_fp_regs; i++) \
{ \
rtx tem = \
- gen_rtx (MEM, mode, \
- plus_constant (virtual_incoming_args_rtx, \
- off)); \
+ gen_rtx_MEM (mode, \
+ plus_constant (virtual_incoming_args_rtx, \
+ off)); \
emit_move_insn (tem, \
- gen_rtx (REG, mode, \
- ((CUM).fp_arg_words \
- + FP_ARG_FIRST \
- + i \
- + mips_fp_off))); \
+ gen_rtx_REG (mode, \
+ ((CUM).fp_arg_words \
+ + FP_ARG_FIRST \
+ + i \
+ + mips_fp_off))); \
off += size; \
if (! TARGET_FLOAT64 || TARGET_SINGLE_FLOAT) \
++i; \
argument itself. The pointer is passed in whatever way is appropriate
for passing a pointer to that type. */
#define FUNCTION_ARG_PASS_BY_REFERENCE(CUM, MODE, TYPE, NAMED) \
- (mips_abi == ABI_EABI \
- && function_arg_pass_by_reference (&CUM, MODE, TYPE, NAMED))
+ function_arg_pass_by_reference (&CUM, MODE, TYPE, NAMED)
/* A C expression that indicates when it is the called function's
responsibility to make a copy of arguments passed by invisible
#include "config.h"
#include "system.h"
#include <signal.h>
-
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "insn-codes.h"
#include "recog.h"
#include "toplev.h"
+#include "output.h"
+
#include "tree.h"
#include "function.h"
#include "expr.h"
mips_load_reg = set_reg;
if (GET_MODE_SIZE (mode)
> (FP_REG_P (REGNO (set_reg)) ? UNITS_PER_FPREG : UNITS_PER_WORD))
- mips_load_reg2 = gen_rtx (REG, SImode, REGNO (set_reg) + 1);
+ mips_load_reg2 = gen_rtx_REG (SImode, REGNO (set_reg) + 1);
else
mips_load_reg2 = 0;
if (type == DELAY_HILO)
{
- mips_load_reg3 = gen_rtx (REG, SImode, MD_REG_FIRST);
- mips_load_reg4 = gen_rtx (REG, SImode, MD_REG_FIRST+1);
+ mips_load_reg3 = gen_rtx_REG (SImode, MD_REG_FIRST);
+ mips_load_reg4 = gen_rtx_REG (SImode, MD_REG_FIRST+1);
}
else
{
pop_topmost_sequence ();
}
- return gen_rtx (CONST, Pmode,
- gen_rtx (MINUS, Pmode, x,
- XEXP (DECL_RTL (current_function_decl), 0)));
+ return
+ gen_rtx_CONST (Pmode,
+ gen_rtx_MINUS (Pmode, x,
+ XEXP (DECL_RTL (current_function_decl), 0)));
}
/* Return the appropriate instructions to move one operand to another. */
else if (test == ITEST_EQ)
{
reg2 = invert ? gen_reg_rtx (mode) : result;
- convert_move (reg2, gen_rtx (LTU, mode, reg, const1_rtx), 0);
+ convert_move (reg2, gen_rtx_LTU (mode, reg, const1_rtx), 0);
reg = reg2;
}
case CMP_SF:
case CMP_DF:
if (mips_isa < 4)
- reg = gen_rtx (REG, CCmode, FPSW_REGNUM);
+ reg = gen_rtx_REG (CCmode, FPSW_REGNUM);
else
reg = gen_reg_rtx (CCmode);
0 in the instruction built below. The MIPS FPU handles
inequality testing by testing for equality and looking for a
false result. */
- emit_insn (gen_rtx (SET, VOIDmode, reg,
- gen_rtx (test_code == NE ? EQ : test_code,
- CCmode, cmp0, cmp1)));
-
+ emit_insn (gen_rtx_SET (VOIDmode, reg,
+ gen_rtx (test_code == NE ? EQ : test_code,
+ CCmode, cmp0, cmp1)));
+
test_code = test_code == NE ? EQ : NE;
mode = CCmode;
cmp0 = reg;
/* Generate the branch. */
- label1 = gen_rtx (LABEL_REF, VOIDmode, operands[0]);
+ label1 = gen_rtx_LABEL_REF (VOIDmode, operands[0]);
label2 = pc_rtx;
if (invert)
label1 = pc_rtx;
}
- emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx,
- gen_rtx (IF_THEN_ELSE, VOIDmode,
- gen_rtx (test_code, mode, cmp0, cmp1),
- label1, label2)));
+ emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_IF_THEN_ELSE (VOIDmode,
+ gen_rtx (test_code, mode,
+ cmp0, cmp1),
+ label1, label2)));
}
/* Emit the common code for conditional moves. OPERANDS is the array
abort ();
cmp_reg = gen_reg_rtx (cmp_mode);
- emit_insn (gen_rtx (SET, cmp_mode, cmp_reg,
- gen_rtx (cmp_code, cmp_mode, op0, op1)));
-
- emit_insn (gen_rtx (SET, op_mode, operands[0],
- gen_rtx (IF_THEN_ELSE, op_mode,
- gen_rtx (move_code, VOIDmode,
- cmp_reg, CONST0_RTX (SImode)),
- operands[2], operands[3])));
+ emit_insn (gen_rtx_SET (cmp_mode, cmp_reg,
+ gen_rtx (cmp_code, cmp_mode, op0, op1)));
+
+ emit_insn (gen_rtx_SET (op_mode, operands[0],
+ gen_rtx_IF_THEN_ELSE (op_mode,
+ gen_rtx (move_code, VOIDmode,
+ cmp_reg,
+ CONST0_RTX (SImode)),
+ operands[2], operands[3])));
}
\f
/* Write a loop to move a constant number of bytes.
bytes_rtx = convert_to_mode (Pmode, bytes_rtx, 1);
#ifdef TARGET_MEM_FUNCTIONS
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "memcpy"), 0,
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "memcpy"), 0,
VOIDmode, 3, dest_reg, Pmode, src_reg, Pmode,
convert_to_mode (TYPE_MODE (sizetype), bytes_rtx,
TREE_UNSIGNED (sizetype)),
TYPE_MODE (sizetype));
#else
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "bcopy"), 0,
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "bcopy"), 0,
VOIDmode, 3, src_reg, Pmode, dest_reg, Pmode,
convert_to_mode (TYPE_MODE (integer_type_node), bytes_rtx,
TREE_UNSIGNED (integer_type_node)),
abort ();
if (GET_MODE (operands[i + 4]) != load_store[i].mode)
- operands[i + 4] = gen_rtx (REG, load_store[i].mode,
- REGNO (operands[i + 4]));
+ operands[i + 4] = gen_rtx_REG (load_store[i].mode,
+ REGNO (operands[i + 4]));
offset = load_store[i].offset;
xoperands[0] = operands[i + 4];
- xoperands[1] = gen_rtx (MEM, load_store[i].mode,
- plus_constant (src_reg, offset));
+ xoperands[1] = gen_rtx_MEM (load_store[i].mode,
+ plus_constant (src_reg, offset));
if (use_lwl_lwr)
{
int extra_offset
= GET_MODE_SIZE (load_store[i].mode) - 1;
- xoperands[2] = gen_rtx (MEM, load_store[i].mode,
- plus_constant (src_reg,
- extra_offset
- + offset));
+ xoperands[2] = gen_rtx_MEM (load_store[i].mode,
+ plus_constant (src_reg,
+ extra_offset
+ + offset));
}
output_asm_insn (load_store[i].load, xoperands);
int offset = load_store[i].offset;
xoperands[0] = operands[i + 4];
- xoperands[1] = gen_rtx (MEM, load_store[i].mode,
- plus_constant (dest_reg, offset));
+ xoperands[1] = gen_rtx_MEM (load_store[i].mode,
+ plus_constant (dest_reg, offset));
if (use_lwl_lwr)
{
int extra_offset = GET_MODE_SIZE (load_store[i].mode) - 1;
- xoperands[2] = gen_rtx (MEM, load_store[i].mode,
- plus_constant (dest_reg,
- extra_offset
- + offset));
+ xoperands[2] = gen_rtx_MEM (load_store[i].mode,
+ plus_constant (dest_reg,
+ extra_offset
+ + offset));
}
if (move_type == BLOCK_MOVE_NORMAL)
if (! type || TREE_CODE (type) != RECORD_TYPE || mips_abi == ABI_32
|| mips_abi == ABI_EABI || mips_abi == ABI_O64 || ! named)
- ret = gen_rtx (REG, mode, regbase + *arg_words + bias);
+ ret = gen_rtx_REG (mode, regbase + *arg_words + bias);
else
{
/* The Irix 6 n32/n64 ABIs say that if any 64 bit chunk of the
/* If the whole struct fits a DFmode register,
we don't need the PARALLEL. */
if (! field || mode == DFmode)
- ret = gen_rtx (REG, mode, regbase + *arg_words + bias);
+ ret = gen_rtx_REG (mode, regbase + *arg_words + bias);
else
{
/* Now handle the special case by returning a PARALLEL
/* assign_parms checks the mode of ENTRY_PARM, so we must
use the actual mode here. */
- ret = gen_rtx (PARALLEL, mode, rtvec_alloc (chunks));
+ ret = gen_rtx_PARALLEL (mode, rtvec_alloc (chunks));
bitpos = 0;
regno = regbase + *arg_words + bias;
&& TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)) == bitpos
&& TREE_CODE (TREE_TYPE (field)) == REAL_TYPE
&& TYPE_PRECISION (TREE_TYPE (field)) == BITS_PER_WORD)
- reg = gen_rtx (REG, DFmode,
- regno + FP_ARG_FIRST - GP_ARG_FIRST);
+ reg = gen_rtx_REG (DFmode,
+ regno + FP_ARG_FIRST - GP_ARG_FIRST);
else
- reg = gen_rtx (REG, word_mode, regno);
-
+ reg = gen_rtx_REG (word_mode, regno);
+
XVECEXP (ret, 0, i)
- = gen_rtx (EXPR_LIST, VOIDmode, reg,
- GEN_INT (bitpos / BITS_PER_UNIT));
+ = gen_rtx_EXPR_LIST (VOIDmode, reg,
+ GEN_INT (bitpos / BITS_PER_UNIT));
bitpos += 64;
regno++;
{
rtx amount = GEN_INT (BITS_PER_WORD
- int_size_in_bytes (type) * BITS_PER_UNIT);
- rtx reg = gen_rtx (REG, word_mode, regbase + *arg_words + bias);
+ rtx reg = gen_rtx_REG (word_mode, regbase + *arg_words + bias);
if (TARGET_64BIT)
cum->adjust[cum->num_adjusts++] = gen_ashldi3 (reg, reg, amount);
&& (unsigned HOST_WIDE_INT) (large_offset - gp_offset) < 32768
&& (unsigned HOST_WIDE_INT) (large_offset - end_offset) < 32768)
{
- base_reg_rtx = gen_rtx (REG, Pmode, MIPS_TEMP2_REGNUM);
+ base_reg_rtx = gen_rtx_REG (Pmode, MIPS_TEMP2_REGNUM);
base_offset = large_offset;
if (file == 0)
{
else
{
- base_reg_rtx = gen_rtx (REG, Pmode, MIPS_TEMP2_REGNUM);
+ base_reg_rtx = gen_rtx_REG (Pmode, MIPS_TEMP2_REGNUM);
base_offset = gp_offset;
if (file == 0)
{
&& (unsigned HOST_WIDE_INT) (large_offset - fp_offset) < 32768
&& (unsigned HOST_WIDE_INT) (large_offset - end_offset) < 32768)
{
- base_reg_rtx = gen_rtx (REG, Pmode, MIPS_TEMP2_REGNUM);
+ base_reg_rtx = gen_rtx_REG (Pmode, MIPS_TEMP2_REGNUM);
base_offset = large_offset;
if (file == 0)
{
else
{
- base_reg_rtx = gen_rtx (REG, Pmode, MIPS_TEMP2_REGNUM);
+ base_reg_rtx = gen_rtx_REG (Pmode, MIPS_TEMP2_REGNUM);
base_offset = fp_offset;
if (file == 0)
{
if (TARGET_ABICALLS && (mips_abi != ABI_32 && mips_abi != ABI_O64))
emit_insn (gen_loadgp (XEXP (DECL_RTL (current_function_decl), 0),
- gen_rtx (REG, DImode, 25)));
+ gen_rtx_REG (DImode, 25)));
}
/* If we are profiling, make sure no instructions are scheduled before
if (tsize > 32767 && ! TARGET_MIPS16)
{
- tmp_rtx = gen_rtx (REG, Pmode, MIPS_TEMP1_REGNUM);
+ tmp_rtx = gen_rtx_REG (Pmode, MIPS_TEMP1_REGNUM);
emit_move_insn (tmp_rtx, tsize_rtx);
tsize_rtx = tmp_rtx;
}
strictly necessary. */
enum machine_mode field_mode = TYPE_MODE (TREE_TYPE (fields[0]));
- return gen_rtx (PARALLEL, mode,
- gen_rtvec (1,
- gen_rtx (EXPR_LIST, VOIDmode,
- gen_rtx (REG, field_mode,
- FP_RETURN),
- const0_rtx)));
+ return gen_rtx_PARALLEL
+ (mode,
+ gen_rtvec (1,
+ gen_rtx_EXPR_LIST (VOIDmode,
+ gen_rtx_REG (field_mode,
+ FP_RETURN),
+ const0_rtx)));
}
else if (i == 2)
int second_offset
= TREE_INT_CST_LOW (DECL_FIELD_BITPOS (fields[1]));
- return gen_rtx (PARALLEL, mode,
- gen_rtvec (2,
- gen_rtx (EXPR_LIST, VOIDmode,
- gen_rtx (REG, first_mode,
- FP_RETURN),
- GEN_INT (first_offset
- / BITS_PER_UNIT)),
- gen_rtx (EXPR_LIST, VOIDmode,
- gen_rtx (REG, second_mode,
- FP_RETURN + 2),
- GEN_INT (second_offset
- / BITS_PER_UNIT))));
+ return gen_rtx_PARALLEL
+ (mode,
+ gen_rtvec (2,
+ gen_rtx_EXPR_LIST (VOIDmode,
+ gen_rtx_REG (first_mode,
+ FP_RETURN),
+ GEN_INT (first_offset
+ / BITS_PER_UNIT)),
+ gen_rtx_EXPR_LIST (VOIDmode,
+ gen_rtx_REG (second_mode,
+ FP_RETURN + 2),
+ GEN_INT (second_offset
+ / BITS_PER_UNIT))));
}
}
}
- return gen_rtx (REG, mode, reg);
+ return gen_rtx_REG (mode, reg);
}
/* The implementation of FUNCTION_ARG_PASS_BY_REFERENCE. Return
{
int size;
+ /* We must pass by reference if we would be both passing in registers
+ and the stack. This is because any subsequent partial arg would be
+ handled incorrectly in this case.
+
+ ??? This is really a kludge. We should either fix GCC so that such
+ a situation causes an abort and then do something in the MIPS port
+ to prevent it, or add code to function.c to properly handle the case. */
+ if (FUNCTION_ARG (*cum, mode, type, named) != 0
+ && MUST_PASS_IN_STACK (mode, type))
+ return 1;
+
+ /* Otherwise, we only do this if EABI is selected. */
if (mips_abi != ABI_EABI)
return 0;
#define DWARF_FRAME_RETURN_COLUMN (FP_REG_LAST + 1)
/* Before the prologue, RA lives in r31. */
-#define INCOMING_RETURN_ADDR_RTX gen_rtx (REG, VOIDmode, GP_REG_FIRST + 31)
+#define INCOMING_RETURN_ADDR_RTX gen_rtx_REG (VOIDmode, GP_REG_FIRST + 31)
/* Overrides for the COFF debug format. */
#define PUT_SDB_SCL(a) \
#define RETURN_ADDR_RTX(count, frame) \
((count == 0) \
- ? gen_rtx (MEM, Pmode, gen_rtx (REG, Pmode, RETURN_ADDRESS_POINTER_REGNUM))\
+ ? gen_rtx_MEM (Pmode, gen_rtx_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM))\
: (rtx) 0)
/* Structure to be filled in by compute_frame_size with register
rtx addr = ADDR; \
if (Pmode == DImode) \
{ \
- emit_move_insn (gen_rtx (MEM, DImode, plus_constant (addr, 32)), FUNC); \
- emit_move_insn (gen_rtx (MEM, DImode, plus_constant (addr, 40)), CHAIN);\
+ emit_move_insn (gen_rtx_MEM (DImode, plus_constant (addr, 32)), FUNC); \
+ emit_move_insn (gen_rtx_MEM (DImode, plus_constant (addr, 40)), CHAIN);\
} \
else \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (addr, 32)), FUNC); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (addr, 36)), CHAIN);\
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (addr, 32)), FUNC); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (addr, 36)), CHAIN);\
} \
\
/* Flush both caches. We need to flush the data cache in case \
the system has a write-back cache. */ \
/* ??? Should check the return value for errors. */ \
- emit_library_call (gen_rtx (SYMBOL_REF, Pmode, CACHE_FLUSH_FUNC), \
+ emit_library_call (gen_rtx_SYMBOL_REF (Pmode, CACHE_FLUSH_FUNC), \
0, VOIDmode, 3, addr, Pmode, \
GEN_INT (TRAMPOLINE_SIZE), TYPE_MODE (integer_type_node),\
GEN_INT (3), TYPE_MODE (integer_type_node)); \
if (mips_split_addresses && mips_check_split (X, MODE)) \
{ \
/* ??? Is this ever executed? */ \
- X = gen_rtx (LO_SUM, Pmode, \
- copy_to_mode_reg (Pmode, gen_rtx (HIGH, Pmode, X)), X); \
+ X = gen_rtx_LO_SUM (Pmode, \
+ copy_to_mode_reg (Pmode, \
+ gen_rtx (HIGH, Pmode, X)), \
+ X); \
goto WIN; \
} \
\
\
emit_move_insn (ptr_reg, XEXP (XEXP (xinsn, 0), 0)); \
\
- X = gen_rtx (PLUS, Pmode, ptr_reg, constant); \
+ X = gen_rtx_PLUS (Pmode, ptr_reg, constant); \
if (SMALL_INT (constant)) \
goto WIN; \
/* Otherwise we fall through so the code below will fix the \
emit_move_insn (int_reg, \
GEN_INT (INTVAL (xplus1) & ~ 0x7fff)); \
\
- emit_insn (gen_rtx (SET, VOIDmode, \
- ptr_reg, \
- gen_rtx (PLUS, Pmode, xplus0, int_reg))); \
+ emit_insn (gen_rtx_SET (VOIDmode, \
+ ptr_reg, \
+ gen_rtx_PLUS (Pmode, xplus0, int_reg))); \
\
- X = gen_rtx (PLUS, Pmode, ptr_reg, \
- GEN_INT (INTVAL (xplus1) & 0x7fff)); \
+ X = gen_rtx_PLUS (Pmode, ptr_reg, \
+ GEN_INT (INTVAL (xplus1) & 0x7fff)); \
goto WIN; \
} \
} \
;; Mips.md Machine Description for MIPS based processors
+;; Copyright (C) 1989, 90-98, 1999 Free Software Foundation, Inc.
;; Contributed by A. Lichnewsky, lich@inria.inria.fr
;; Changes by Michael Meissner, meissner@osf.org
;; 64 bit r4000 support by Ian Lance Taylor, ian@cygnus.com, and
;; Brendan Eich, brendan@microunity.com.
-;; Copyright (C) 1989, 90-98, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
rtx xoperands[10];
xoperands[0] = operands[0];
- xoperands[1] = gen_rtx (REG, SImode, LO_REGNUM);
+ xoperands[1] = gen_rtx_REG (SImode, LO_REGNUM);
output_asm_insn (\"mult\\t%1,%2\", operands);
output_asm_insn (mips_move_1word (xoperands, insn, FALSE), xoperands);
output_asm_insn (\"dmult\\t%0,%1,%2\", operands);
else
{
- rtx xoperands[10];
+ rtx xoperands[10];
- xoperands[0] = operands[0];
- xoperands[1] = gen_rtx (REG, DImode, LO_REGNUM);
+ xoperands[0] = operands[0];
+ xoperands[1] = gen_rtx_REG (DImode, LO_REGNUM);
- output_asm_insn (\"dmult\\t%1,%2\", operands);
- output_asm_insn (mips_move_1word (xoperands, insn, FALSE), xoperands);
+ output_asm_insn (\"dmult\\t%1,%2\", operands);
+ output_asm_insn (mips_move_1word (xoperands, insn, FALSE), xoperands);
}
return \"\";
}"
emit_jump_insn (gen_bge (label1));
emit_insn (gen_fix_truncdfsi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx,
- gen_rtx (LABEL_REF, VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
- emit_move_insn (reg2, gen_rtx (MINUS, DFmode, operands[1], reg1));
+ emit_move_insn (reg2, gen_rtx_MINUS (DFmode, operands[1], reg1));
emit_move_insn (reg3, GEN_INT (0x80000000));
emit_insn (gen_fix_truncdfsi2 (operands[0], reg2));
/* 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));
+ emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
DONE;
}
}")
emit_jump_insn (gen_bge (label1));
emit_insn (gen_fix_truncdfdi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx,
- gen_rtx (LABEL_REF, VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
- emit_move_insn (reg2, gen_rtx (MINUS, DFmode, operands[1], reg1));
+ emit_move_insn (reg2, gen_rtx_MINUS (DFmode, operands[1], reg1));
emit_move_insn (reg3, GEN_INT (0x80000000));
emit_insn (gen_ashldi3 (reg3, reg3, GEN_INT (32)));
/* 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));
+ emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
DONE;
}
}")
emit_jump_insn (gen_bge (label1));
emit_insn (gen_fix_truncsfsi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx,
- gen_rtx (LABEL_REF, VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
- emit_move_insn (reg2, gen_rtx (MINUS, SFmode, operands[1], reg1));
+ emit_move_insn (reg2, gen_rtx_MINUS (SFmode, operands[1], reg1));
emit_move_insn (reg3, GEN_INT (0x80000000));
emit_insn (gen_fix_truncsfsi2 (operands[0], reg2));
/* 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));
+ emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
DONE;
}
}")
emit_jump_insn (gen_bge (label1));
emit_insn (gen_fix_truncsfdi2 (operands[0], operands[1]));
- emit_jump_insn (gen_rtx (SET, VOIDmode, pc_rtx,
- gen_rtx (LABEL_REF, VOIDmode, label2)));
+ emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
+ gen_rtx_LABEL_REF (VOIDmode, label2)));
emit_barrier ();
emit_label (label1);
- emit_move_insn (reg2, gen_rtx (MINUS, SFmode, operands[1], reg1));
+ emit_move_insn (reg2, gen_rtx_MINUS (SFmode, operands[1], reg1));
emit_move_insn (reg3, GEN_INT (0x80000000));
emit_insn (gen_ashldi3 (reg3, reg3, GEN_INT (32)));
/* 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));
+ emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
DONE;
}
}")
rtx tem = ((reload_in_progress | reload_completed)
? operands[0] : gen_reg_rtx (mode));
- emit_insn (gen_rtx (SET, VOIDmode, tem,
- gen_rtx (HIGH, mode, operands[1])));
+ emit_insn (gen_rtx_SET (VOIDmode, tem,
+ gen_rtx_HIGH (mode, operands[1])));
- operands[1] = gen_rtx (LO_SUM, mode, tem, operands[1]);
+ operands[1] = gen_rtx_LO_SUM (mode, tem, operands[1]);
}
/* If we are generating embedded PIC code, and we are referring to a
rtx temp;
temp = embedded_pic_offset (operands[1]);
- temp = gen_rtx (PLUS, Pmode, embedded_pic_fnaddr_rtx,
- force_reg (DImode, temp));
+ temp = gen_rtx_PLUS (Pmode, embedded_pic_fnaddr_rtx,
+ force_reg (DImode, temp));
emit_move_insn (operands[0], force_reg (DImode, temp));
DONE;
}
if (! SMALL_INT (temp2))
temp2 = force_reg (DImode, temp2);
- emit_move_insn (operands[0], gen_rtx (PLUS, DImode, temp, temp2));
+ emit_move_insn (operands[0], gen_rtx_PLUS (DImode, temp, temp2));
DONE;
}
"TARGET_64BIT"
"
{
- rtx scratch = gen_rtx (REG, DImode,
- (REGNO (operands[0]) == REGNO (operands[2])
- ? REGNO (operands[2]) + 1
- : REGNO (operands[2])));
+ rtx scratch = gen_rtx_REG (DImode,
+ (REGNO (operands[0]) == REGNO (operands[2])
+ ? REGNO (operands[2]) + 1
+ : REGNO (operands[2])));
if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == HILO_REGNUM)
{
rtx addr = find_replacement (&XEXP (operands[1], 0));
rtx op1 = change_address (operands[1], VOIDmode, addr);
- scratch = gen_rtx (REG, SImode, REGNO (scratch));
+ scratch = gen_rtx_REG (SImode, REGNO (scratch));
memword = change_address (op1, SImode, NULL_RTX);
offword = change_address (adj_offsettable_operand (op1, 4),
SImode, NULL_RTX);
loword = memword;
}
emit_move_insn (scratch, hiword);
- emit_move_insn (gen_rtx (REG, SImode, 64), scratch);
+ emit_move_insn (gen_rtx_REG (SImode, 64), scratch);
emit_move_insn (scratch, loword);
emit_move_insn (gen_rtx (REG, SImode, 65), scratch);
emit_insn (gen_rtx_USE (VOIDmode, operands[0]));
else
{
emit_insn (gen_ashrdi3 (scratch, operands[1], GEN_INT (32)));
- emit_insn (gen_movdi (gen_rtx (REG, DImode, 64), scratch));
+ emit_insn (gen_movdi (gen_rtx_REG (DImode, 64), scratch));
emit_insn (gen_ashldi3 (scratch, operands[1], GEN_INT (32)));
emit_insn (gen_ashrdi3 (scratch, scratch, GEN_INT (32)));
emit_insn (gen_movdi (gen_rtx (REG, DImode, 65), scratch));
}
if (GET_CODE (operands[1]) == REG && REGNO (operands[1]) == HILO_REGNUM)
{
- emit_insn (gen_movdi (scratch, gen_rtx (REG, DImode, 65)));
+ emit_insn (gen_movdi (scratch, gen_rtx_REG (DImode, 65)));
emit_insn (gen_ashldi3 (scratch, scratch, GEN_INT (32)));
emit_insn (gen_lshrdi3 (scratch, scratch, GEN_INT (32)));
- emit_insn (gen_movdi (operands[0], gen_rtx (REG, DImode, 64)));
+ emit_insn (gen_movdi (operands[0], gen_rtx_REG (DImode, 64)));
emit_insn (gen_ashldi3 (operands[0], operands[0], GEN_INT (32)));
emit_insn (gen_iordi3 (operands[0], operands[0], scratch));
emit_insn (gen_rtx_USE (VOIDmode, operands[1]));
rtx addr = find_replacement (&XEXP (operands[0], 0));
rtx op0 = change_address (operands[0], VOIDmode, addr);
- scratch = gen_rtx (REG, SImode, REGNO (operands[2]));
+ scratch = gen_rtx_REG (SImode, REGNO (operands[2]));
memword = change_address (op0, SImode, NULL_RTX);
offword = change_address (adj_offsettable_operand (op0, 4),
SImode, NULL_RTX);
hiword = offword;
loword = memword;
}
- emit_move_insn (scratch, gen_rtx (REG, SImode, 64));
+ emit_move_insn (scratch, gen_rtx_REG (SImode, 64));
emit_move_insn (hiword, scratch);
- emit_move_insn (scratch, gen_rtx (REG, SImode, 65));
+ emit_move_insn (scratch, gen_rtx_REG (SImode, 65));
emit_move_insn (loword, scratch);
emit_insn (gen_rtx_USE (VOIDmode, operands[1]));
}
rtx tem = ((reload_in_progress | reload_completed)
? operands[0] : gen_reg_rtx (mode));
- emit_insn (gen_rtx (SET, VOIDmode, tem,
- gen_rtx (HIGH, mode, operands[1])));
+ emit_insn (gen_rtx_SET (VOIDmode, tem,
+ gen_rtx_HIGH (mode, operands[1])));
- operands[1] = gen_rtx (LO_SUM, mode, tem, operands[1]);
+ operands[1] = gen_rtx_LO_SUM (mode, tem, operands[1]);
}
/* If we are generating embedded PIC code, and we are referring to a
rtx temp;
temp = embedded_pic_offset (operands[1]);
- temp = gen_rtx (PLUS, Pmode, embedded_pic_fnaddr_rtx,
- force_reg (SImode, temp));
+ temp = gen_rtx_PLUS (Pmode, embedded_pic_fnaddr_rtx,
+ force_reg (SImode, temp));
emit_move_insn (operands[0], force_reg (SImode, temp));
DONE;
}
if (! SMALL_INT (temp2))
temp2 = force_reg (SImode, temp2);
- emit_move_insn (operands[0], gen_rtx (PLUS, SImode, temp, temp2));
+ emit_move_insn (operands[0], gen_rtx_PLUS (SImode, temp, temp2));
DONE;
}
if (TARGET_64BIT
&& GET_CODE (operands[0]) == REG && REGNO (operands[0]) == HILO_REGNUM)
{
- emit_insn (gen_movsi (gen_rtx (REG, SImode, 65), operands[1]));
+ emit_insn (gen_movsi (gen_rtx_REG (SImode, 65), operands[1]));
emit_insn (gen_ashrsi3 (operands[2], operands[1], GEN_INT (31)));
emit_insn (gen_movsi (gen_rtx (REG, SImode, 64), operands[2]));
emit_insn (gen_rtx_USE (VOIDmode, operands[0]));
if (GET_CODE (operands[1]) == MEM)
source = change_address (operands[1], SFmode, NULL_RTX);
else if (GET_CODE (operands[1]) == REG || GET_CODE (operands[1]) == SUBREG)
- source = gen_rtx (REG, SFmode, true_regnum (operands[1]));
+ source = gen_rtx_REG (SFmode, true_regnum (operands[1]));
else
source = operands[1];
- fp1 = gen_rtx (REG, SFmode, REGNO (operands[2]));
- fp2 = gen_rtx (REG, SFmode, REGNO (operands[2]) + 1);
+ fp1 = gen_rtx_REG (SFmode, REGNO (operands[2]));
+ fp2 = gen_rtx_REG (SFmode, REGNO (operands[2]) + 1);
emit_insn (gen_move_insn (fp1, source));
- emit_insn (gen_move_insn (fp2, gen_rtx (REG, SFmode, 0)));
- emit_insn (gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (LT, CCmode, fp2, fp1)));
+ emit_insn (gen_move_insn (fp2, gen_rtx_REG (SFmode, 0)));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx_LT (CCmode, fp2, fp1)));
DONE;
}")
(define_insn ""
[(set (mem:SF (plus:SI (match_operand:SI 1 "register_operand" "d")
(match_operand:SI 2 "register_operand" "d")))
- (match_operand:SF 0 "register_operand" "=f"))]
+ (match_operand:SF 0 "register_operand" "f"))]
"mips_isa >= 4 && TARGET_HARD_FLOAT"
"swxc1\\t%0,%1(%2)"
[(set_attr "type" "store")
(define_insn ""
[(set (mem:SF (plus:DI (match_operand:DI 1 "se_register_operand" "d")
(match_operand:DI 2 "se_register_operand" "d")))
- (match_operand:SF 0 "register_operand" "=f"))]
+ (match_operand:SF 0 "register_operand" "f"))]
"mips_isa >= 4 && TARGET_HARD_FLOAT"
"swxc1\\t%0,%1(%2)"
[(set_attr "type" "store")
(define_insn ""
[(set (mem:DF (plus:SI (match_operand:SI 1 "register_operand" "d")
(match_operand:SI 2 "register_operand" "d")))
- (match_operand:DF 0 "register_operand" "=f"))]
+ (match_operand:DF 0 "register_operand" "f"))]
"mips_isa >= 4 && TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
"sdxc1\\t%0,%1(%2)"
[(set_attr "type" "store")
(define_insn ""
[(set (mem:DF (plus:DI (match_operand:DI 1 "se_register_operand" "d")
(match_operand:DI 2 "se_register_operand" "d")))
- (match_operand:DF 0 "register_operand" "=f"))]
+ (match_operand:DF 0 "register_operand" "f"))]
"mips_isa >= 4 && TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT"
"sdxc1\\t%0,%1(%2)"
[(set_attr "type" "store")
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
+ operands[2] = GEN_INT (amount & 31);
operands[4] = const0_rtx;
- operands[5] = GEN_INT (((-amount) & 31));
+ operands[5] = GEN_INT ((-amount) & 31);
return \"sll\\t%M0,%M1,%2\;srl\\t%3,%L1,%5\;or\\t%M0,%M0,%3\;sll\\t%L0,%L1,%2\";
}"
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
return \"srl\\t%L0,%L1,%2\;sll\\t%3,%M1,%4\;or\\t%L0,%L0,%3\;sra\\t%M0,%M1,%2\";
}"
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
return \"srl\\t%L0,%L1,%2\;sll\\t%3,%M1,%4\;or\\t%L0,%L0,%3\;srl\\t%M0,%M1,%2\";
}"
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
"
{
int amount = INTVAL (operands[2]);
- operands[2] = GEN_INT ((amount & 31));
- operands[4] = GEN_INT (((-amount) & 31));
+ operands[2] = GEN_INT (amount & 31);
+ operands[4] = GEN_INT ((-amount) & 31);
}")
"!TARGET_MIPS16 && INTVAL (operands[2]) < 32767"
"*
{
- operands[2] = GEN_INT (INTVAL (operands[2])+1);
+ operands[2] = GEN_INT (INTVAL (operands[2]) + 1);
return \"sltu\\t%0,%1,%2\";
}"
[(set_attr "type" "arith")
"TARGET_64BIT && !TARGET_MIPS16 && INTVAL (operands[2]) < 32767"
"*
{
- operands[2] = GEN_INT (INTVAL (operands[2])+1);
+ operands[2] = GEN_INT (INTVAL (operands[2]) + 1);
return \"sltu\\t%0,%1,%2\";
}"
[(set_attr "type" "arith")
}
emit_call_insn (gen_call_internal0 (operands[0], operands[1],
- gen_rtx (REG, SImode, GP_REG_FIRST + 31)));
-
+ gen_rtx_REG (SImode,
+ GP_REG_FIRST + 31)));
DONE;
}
}")
(XEXP (XVECEXP (operands[0], 0, 0), 0),
operands[1], operands[2],
XEXP (XVECEXP (operands[0], 0, 1), 0),
- gen_rtx (REG, SImode, GP_REG_FIRST + 31)));
+ gen_rtx_REG (SImode, GP_REG_FIRST + 31)));
DONE;
}
operands[0] = XEXP (XVECEXP (operands[0], 0, 0), 0);
emit_call_insn (gen_call_value_internal0 (operands[0], operands[1], operands[2],
- gen_rtx (REG, SImode, GP_REG_FIRST + 31)));
+ gen_rtx_REG (SImode,
+ GP_REG_FIRST + 31)));
DONE;
}
;; "
;; {
;; operands[0] = gen_reg_rtx (SImode);
-;; operands[1] = gen_rtx (MEM, SImode, stack_pointer_rtx);
+;; operands[1] = gen_rtx_MEM (SImode, stack_pointer_rtx);
;; MEM_VOLATILE_P (operands[1]) = TRUE;
;;
;; /* fall through and generate default code */
/* Subroutines for insn-output.c for Matsushita MN10200 series
- Copyright (C) 1997 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Jeff Law (law@cygnus.com).
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "regs.h"
if (GET_CODE (x) != MEM)
abort ();
if (GET_CODE (XEXP (x, 0)) == REG)
- x = gen_rtx (PLUS, PSImode, XEXP (x, 0), GEN_INT (0));
+ x = gen_rtx_PLUS (PSImode, XEXP (x, 0), GEN_INT (0));
else
x = XEXP (x, 0);
fputc ('(', file);
if (!regs_ever_live[2])
{
regs_ever_live[2] = 1;
- zero_dreg = gen_rtx (REG, HImode, 2);
+ zero_dreg = gen_rtx_REG (HImode, 2);
}
if (!regs_ever_live[3])
{
regs_ever_live[3] = 1;
- zero_dreg = gen_rtx (REG, HImode, 3);
+ zero_dreg = gen_rtx_REG (HImode, 3);
}
}
if (!regs_ever_live[5])
{
regs_ever_live[5] = 1;
- zero_areg = gen_rtx (REG, HImode, 5);
+ zero_areg = gen_rtx_REG (HImode, 5);
}
if (!regs_ever_live[6])
{
regs_ever_live[6] = 1;
- zero_areg = gen_rtx (REG, HImode, 6);
+ zero_areg = gen_rtx_REG (HImode, 6);
}
}
{
emit_insn (gen_addpsi3 (stack_pointer_rtx, stack_pointer_rtx,
GEN_INT (-4)));
- emit_move_insn (gen_rtx (MEM, PSImode, stack_pointer_rtx),
- gen_rtx (REG, PSImode, STATIC_CHAIN_REGNUM));
+ emit_move_insn (gen_rtx_MEM (PSImode, stack_pointer_rtx),
+ gen_rtx_REG (PSImode, STATIC_CHAIN_REGNUM));
}
if (frame_pointer_needed)
{
/* Store a2 into a0 temporarily. */
- emit_move_insn (gen_rtx (REG, PSImode, 4), frame_pointer_rtx);
+ emit_move_insn (gen_rtx_REG (PSImode, 4), frame_pointer_rtx);
/* Set up the frame pointer. */
emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
register 4 (a0). */
regno = (i == FRAME_POINTER_REGNUM && frame_pointer_needed) ? 4 : i;
- emit_move_insn (gen_rtx (MEM, PSImode,
- gen_rtx (PLUS, Pmode,
- stack_pointer_rtx,
- GEN_INT (offset))),
- gen_rtx (REG, PSImode, regno));
+ emit_move_insn (gen_rtx_MEM (PSImode,
+ plus_constant (stack_pointer_rtx,
+ offset)),
+ gen_rtx_REG (PSImode, regno));
offset += 4;
}
}
expects to find it. */
if (current_function_needs_context)
{
- emit_move_insn (gen_rtx (REG, PSImode, STATIC_CHAIN_REGNUM),
+ emit_move_insn (gen_rtx_REG (PSImode, STATIC_CHAIN_REGNUM),
gen_rtx (MEM, PSImode,
- gen_rtx (PLUS, PSImode, stack_pointer_rtx,
- GEN_INT (size))));
+ gen_rtx_PLUS (PSImode, stack_pointer_rtx,
+ GEN_INT (size))));
}
}
regno = ((i == FRAME_POINTER_REGNUM && frame_pointer_needed)
? temp_regno : i);
- emit_move_insn (gen_rtx (REG, PSImode, regno),
- gen_rtx (MEM, PSImode,
- gen_rtx (PLUS, Pmode,
- basereg,
- GEN_INT (offset))));
+ emit_move_insn (gen_rtx_REG (PSImode, regno),
+ gen_rtx_MEM (PSImode,
+ plus_constant (basereg, offset)));
offset += 4;
}
}
/* Deallocate this frame's stack. */
emit_move_insn (stack_pointer_rtx, frame_pointer_rtx);
/* Restore the old frame pointer. */
- emit_move_insn (frame_pointer_rtx, gen_rtx (REG, PSImode, temp_regno));
+ emit_move_insn (frame_pointer_rtx, gen_rtx_REG (PSImode, temp_regno));
}
else if (size)
{
/* need a loop to get all the bits we want - we generate the
code at emit time, but need to allocate a scratch reg now */
- emit_insn (gen_rtx
- (PARALLEL, VOIDmode,
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
gen_rtvec (2,
- gen_rtx (SET, VOIDmode, operands[0],
- gen_rtx (code, mode,
- operands[0], operands[2])),
- gen_rtx (CLOBBER, VOIDmode,
- gen_rtx (SCRATCH, HImode, 0)))));
+ gen_rtx_SET (VOIDmode, operands[0],
+ gen_rtx (code, mode,
+ operands[0], operands[2])),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_SCRATCH (HImode)))));
return 1;
}
switch (cum->nbytes / UNITS_PER_WORD)
{
case 0:
- result = gen_rtx (REG, mode, 0);
+ result = gen_rtx_REG (mode, 0);
break;
case 1:
- result = gen_rtx (REG, mode, 1);
+ result = gen_rtx_REG (mode, 1);
break;
default:
result = 0;
/* Definitions of target machine for GNU compiler. Matsushita MN10200 series
- Copyright (C) 1997 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Jeff Law (law@cygnus.com).
This file is part of GNU CC.
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), TYPE_MODE (VALTYPE) == PSImode ? 4 : 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), TYPE_MODE (VALTYPE) == PSImode ? 4 : 0)
/* 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, (MODE) == PSImode ? 4 : 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, (MODE) == PSImode ? 4 : 0)
/* 1 if N is a possible register number for a function value. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, PSImode, plus_constant ((TRAMP), 20)), \
+ emit_move_insn (gen_rtx_MEM (PSImode, plus_constant ((TRAMP), 20)), \
(CXT)); \
- emit_move_insn (gen_rtx (MEM, PSImode, plus_constant ((TRAMP), 24)), \
+ emit_move_insn (gen_rtx_MEM (PSImode, plus_constant ((TRAMP), 24)), \
(FNADDR)); \
}
#define RETURN_ADDR_RTX(COUNT, FRAME) \
((COUNT == 0) \
- ? gen_rtx (MEM, Pmode, frame_pointer_rtx) \
+ ? gen_rtx_MEM (Pmode, frame_pointer_rtx) \
: (rtx) 0)
#define INIT_TARGET_OPTABS \
do { \
sdiv_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, DIVHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, DIVHI3_LIBCALL); \
smod_optab->handlers[(int) HImode].libfunc \
- = gen_rtx (SYMBOL_REF, Pmode, MODHI3_LIBCALL); \
+ = gen_rtx_SYMBOL_REF (Pmode, MODHI3_LIBCALL); \
} while (0)
/* The assembler op to get a word. */
;; GCC machine description for Matsushita MN10200
-;; Copyright (C) 1997, 1998 Free Software Foundation, Inc.
-
+;; Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by Jeff Law (law@cygnus.com).
;; This file is part of GNU CC.
rtx ret, insns;
start_sequence ();
- ret = emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__addsi3\"),
+ ret = emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__addsi3\"),
NULL_RTX, 1, SImode, 2, operands[1],
SImode, operands[2], SImode);
insns = get_insns ();
end_sequence ();
emit_libcall_block (insns, operands[0], ret,
- gen_rtx (PLUS, SImode, operands[1], operands[2]));
+ gen_rtx_PLUS (SImode, operands[1], operands[2]));
DONE;
}
else
rtx ret, insns;
start_sequence ();
- ret = emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__subsi3\"),
+ ret = emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__subsi3\"),
NULL_RTX, 1, SImode, 2, operands[1],
SImode, operands[2], SImode);
insns = get_insns ();
end_sequence ();
emit_libcall_block (insns, operands[0], ret,
- gen_rtx (MINUS, SImode, operands[1], operands[2]));
+ gen_rtx_MINUS (SImode, operands[1], operands[2]));
DONE;
}
else
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, HImode, operands[0],
- gen_rtx (ASHIFT, HImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (HImode, operands[0],
+ gen_rtx_ASHIFT (HImode,
+ operands[0], GEN_INT (1))));
count--;
}
DONE;
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, HImode, operands[0],
- gen_rtx (LSHIFTRT, HImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (HImode, operands[0],
+ gen_rtx_LSHIFTRT (HImode,
+ operands[0],
+ GEN_INT (1))));
count--;
}
DONE;
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, HImode, operands[0],
- gen_rtx (ASHIFTRT, HImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (HImode, operands[0],
+ gen_rtx_ASHIFTRT (HImode, operands[0],
+ GEN_INT (1))));
count--;
}
DONE;
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, PSImode, operands[0],
- gen_rtx (ASHIFT, PSImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (PSImode, operands[0],
+ gen_rtx_ASHIFT (PSImode,
+ operands[0], GEN_INT (1))));
count--;
}
DONE;
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, SImode, operands[0],
- gen_rtx (ASHIFT, SImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (SImode, operands[0],
+ gen_rtx_ASHIFT (SImode,
+ operands[0], GEN_INT (1))));
count--;
}
DONE;
rtx ret, insns;
start_sequence ();
- ret = emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__ashlsi3\"),
+ ret = emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__ashlsi3\"),
NULL_RTX, 1, SImode, 2, operands[1],
SImode, operands[2], HImode);
insns = get_insns ();
end_sequence ();
emit_libcall_block (insns, operands[0], ret,
- gen_rtx (ASHIFT, SImode, operands[1], operands[2]));
+ gen_rtx_ASHIFT (SImode, operands[1], operands[2]));
DONE;
}
else
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, SImode, operands[0],
- gen_rtx (LSHIFTRT, SImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (SImode, operands[0],
+ gen_rtx_LSHIFTRT (SImode, operands[0],
+ GEN_INT (1))));
count--;
}
DONE;
rtx ret, insns;
start_sequence ();
- ret = emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__lshrsi3\"),
+ ret = emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__lshrsi3\"),
NULL_RTX, 1, SImode, 2, operands[1],
SImode, operands[2], HImode);
insns = get_insns ();
end_sequence ();
emit_libcall_block (insns, operands[0], ret,
- gen_rtx (LSHIFTRT, SImode, operands[1], operands[2]));
+ gen_rtx_LSHIFTRT (SImode, operands[1], operands[2]));
DONE;
}
else
emit_move_insn (operands[0], operands[1]);
while (count > 0)
{
- emit_insn (gen_rtx (SET, SImode, operands[0],
- gen_rtx (ASHIFTRT, SImode,
- operands[0], GEN_INT (1))));
+ emit_insn (gen_rtx_SET (SImode, operands[0],
+ gen_rtx_ASHIFTRT (SImode, operands[0],
+ GEN_INT (1))));
count--;
}
DONE;
rtx ret, insns;
start_sequence ();
- ret = emit_library_call_value (gen_rtx (SYMBOL_REF, Pmode, \"__ashrsi3\"),
+ ret = emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__ashrsi3\"),
NULL_RTX, 1, SImode, 2, operands[1],
SImode, operands[2], HImode);
insns = get_insns ();
end_sequence ();
emit_libcall_block (insns, operands[0], ret,
- gen_rtx (ASHIFTRT, SImode, operands[1], operands[2]));
+ gen_rtx_ASHIFTRT (SImode, operands[1], operands[2]));
DONE;
}
else
/* Configuration for Matsushita MN10200.
- Copyright (C) 1997 Free Software Foundation, Inc.
+ Copyright (C) 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file is part of GNU CC.
tm.h is a symbolic link to the actual target specific file. */
#include "tm.h"
-
-#ifndef __STDC__
-extern char *malloc (), *realloc (), *calloc ();
-#else
-extern void *malloc (), *realloc (), *calloc ();
-#endif
-extern void free ();
/* Subroutines for insn-output.c for Matsushita MN10300 series
- Copyright (C) 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Jeff Law (law@cygnus.com).
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "regs.h"
case 'A':
fputc ('(', file);
if (GET_CODE (XEXP (x, 0)) == REG)
- output_address (gen_rtx (PLUS, SImode, XEXP (x, 0), GEN_INT (0)));
+ output_address (gen_rtx_PLUS (SImode, XEXP (x, 0), GEN_INT (0)));
else
output_address (XEXP (x, 0));
fputc (')', file);
{
case REG:
if (addr == stack_pointer_rtx)
- print_operand_address (file, gen_rtx (PLUS, SImode,
- stack_pointer_rtx,
- GEN_INT (0)));
+ print_operand_address (file, gen_rtx_PLUS (SImode,
+ stack_pointer_rtx,
+ GEN_INT (0)));
else
print_operand (file, addr, 0);
break;
need to be flushed back to the stack. */
if (current_function_varargs)
{
- emit_move_insn (gen_rtx (MEM, SImode,
- gen_rtx (PLUS, Pmode, stack_pointer_rtx,
- GEN_INT (4))),
- gen_rtx (REG, SImode, 0));
- emit_move_insn (gen_rtx (MEM, SImode,
- gen_rtx (PLUS, Pmode, stack_pointer_rtx,
- GEN_INT (8))),
- gen_rtx (REG, SImode, 1));
+ emit_move_insn (gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx, 4)),
+ gen_rtx_REG (SImode, 0));
+ emit_move_insn (gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx, 8)),
+ gen_rtx_REG (SImode, 1));
}
/* And now store all the registers onto the stack with a
switch (cum->nbytes / UNITS_PER_WORD)
{
case 0:
- result = gen_rtx (REG, mode, 0);
+ result = gen_rtx_REG (mode, 0);
break;
case 1:
- result = gen_rtx (REG, mode, 1);
+ result = gen_rtx_REG (mode, 1);
break;
default:
result = 0;
regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
regx1 = force_reg (Pmode,
gen_rtx (GET_CODE (y), Pmode, regx1, regy2));
- return force_reg (Pmode, gen_rtx (PLUS, Pmode, regx1, regy1));
+ return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
}
}
return x;
/* Definitions of target machine for GNU compiler. Matsushita MN10300 series
- Copyright (C) 1996, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by Jeff Law (law@cygnus.com).
This file is part of GNU CC.
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), POINTER_TYPE_P (VALTYPE) ? 4 : 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), POINTER_TYPE_P (VALTYPE) ? 4 : 0)
/* 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, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 0x14)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x14)), \
(CXT)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 0x18)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 0x18)), \
(FNADDR)); \
}
/* A C expression whose value is RTL representing the value of the return
#define RETURN_ADDR_RTX(COUNT, FRAME) \
((COUNT == 0) \
- ? gen_rtx (MEM, Pmode, arg_pointer_rtx) \
+ ? gen_rtx_MEM (Pmode, arg_pointer_rtx) \
: (rtx) 0)
/* Emit code for a call to builtin_saveregs. We must emit USE insns which
;; GCC machine description for Matsushita MN10300
-;; Copyright (C) 1996, 1997 Free Software Foundation, Inc.
-
-;; Contributed by Jeff Law (law@cygnus.com).
+;; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+;; Contributed by Jeff Law (law@cygnus.com).
;; This file is part of GNU CC.
&& (GET_MODE_SIZE (GET_MODE (XEXP (operands[1], 1)))
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (operands[1], 1))))))
emit_move_insn (operands[2],
- gen_rtx (ZERO_EXTEND, GET_MODE (XEXP (operands[1], 1)),
- SUBREG_REG (XEXP (operands[1], 1))));
+ gen_rtx_ZERO_EXTEND
+ (GET_MODE (XEXP (operands[1], 1)),
+ SUBREG_REG (XEXP (operands[1], 1))));
else
emit_move_insn (operands[2], XEXP (operands[1], 1));
emit_move_insn (operands[0], XEXP (operands[1], 0));
&& (GET_MODE_SIZE (GET_MODE (XEXP (operands[1], 0)))
> GET_MODE_SIZE (GET_MODE (SUBREG_REG (XEXP (operands[1], 0))))))
emit_move_insn (operands[2],
- gen_rtx (ZERO_EXTEND, GET_MODE (XEXP (operands[1], 0)),
- SUBREG_REG (XEXP (operands[1], 0))));
+ gen_rtx_ZERO_EXTEND
+ (GET_MODE (XEXP (operands[1], 0)),
+ SUBREG_REG (XEXP (operands[1], 0))));
else
emit_move_insn (operands[2], XEXP (operands[1], 0));
emit_move_insn (operands[0], XEXP (operands[1], 1));
if (GET_CODE (temp) != REG)
abort ();
- if (reg_overlap_mentioned_p (gen_rtx (REG, SImode, REGNO (temp)),
+ if (reg_overlap_mentioned_p (gen_rtx_REG (SImode, REGNO (temp)),
XEXP (operands[1], 0)))
return \"mov %H1,%H0\;mov %L1,%L0\";
else
if (GET_CODE (temp) != REG)
abort ();
- if (reg_overlap_mentioned_p (gen_rtx (REG, SImode, REGNO (temp)),
+ if (reg_overlap_mentioned_p (gen_rtx_REG (SImode, REGNO (temp)),
XEXP (operands[1], 0)))
return \"mov %H1,%H0\;mov %L1,%L0\";
else
&& GET_CODE (operands[2]) != CONST_INT)
{
rtx temp = gen_reg_rtx (SImode);
- emit_move_insn (temp, gen_rtx (PLUS, SImode, operands[1], operands[2]));
+ emit_move_insn (temp, gen_rtx_PLUS (SImode, operands[1], operands[2]));
emit_move_insn (operands[0], temp);
DONE;
}
/* Configuration for Matsushita MN10300.
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 1999 Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file is part of GNU CC.
tm.h is a symbolic link to the actual target specific file. */
#include "tm.h"
-
-#ifndef __STDC__
-extern char *malloc (), *realloc (), *calloc ();
-#else
-extern void *malloc (), *realloc (), *calloc ();
-#endif
-extern void free ();
/* Subroutines for assembler code output on the NS32000.
- Copyright (C) 1988, 1994, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1988, 94, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Some output-actions in ns32k.md need these. */
#include "config.h"
#include "system.h"
#include "rtl.h"
/* This generates an invalid addressing mode, if BASE is
fp or sp. This is handled by PRINT_OPERAND_ADDRESS. */
if (GET_CODE (base) != REG && GET_CODE (base) != CONST_INT)
- base = gen_rtx (MEM, SImode, base);
- addr = gen_rtx (MULT, SImode, index,
- GEN_INT (1 << INTVAL (scale)));
- addr = gen_rtx (PLUS, SImode, base, addr);
+ base = gen_rtx_MEM (SImode, base);
+ addr = gen_rtx_MULT (SImode, index,
+ GEN_INT (1 << INTVAL (scale)));
+ addr = gen_rtx_PLUS (SImode, base, addr);
return addr;
}
{
if (GET_CODE (operands[num]) == REG)
{
- lo_half[num] = gen_rtx (REG, SImode, REGNO (operands[num]));
- hi_half[num] = gen_rtx (REG, SImode, REGNO (operands[num]) + 1);
+ lo_half[num] = gen_rtx_REG (SImode, REGNO (operands[num]));
+ hi_half[num] = gen_rtx_REG (SImode, REGNO (operands[num]) + 1);
}
else if (CONSTANT_P (operands[num]))
{
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
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]) + 1);
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else if (optype1 == OFFSOP)
latehalf[1] = adj_offsettable_operand (operands[1], 4);
else if (optype1 == CNSTOP)
xops[0] = XEXP (operands[1], 0);
xops[1] = operands[0];
output_asm_insn ("addr %a0,%1", xops);
- operands[1] = gen_rtx (MEM, DImode, operands[0]);
+ operands[1] = gen_rtx_MEM (DImode, operands[0]);
latehalf[1] = adj_offsettable_operand (operands[1], 4);
/* The first half has the overlap, Do the late half first. */
output_asm_insn (singlemove_string (latehalf), latehalf);
case CONST_INT:
case LABEL_REF:
if (offset)
- offset = gen_rtx (PLUS, SImode, tmp, offset);
+ offset = gen_rtx_PLUS (SImode, tmp, offset);
else
offset = tmp;
break;
case SYMBOL_REF:
case LABEL_REF:
if (offset)
- offset = gen_rtx (PLUS, SImode, tmp, offset);
+ offset = gen_rtx_PLUS (SImode, tmp, offset);
else
offset = tmp;
break;
/* Definitions of target machine for GNU compiler. NS32000 version.
- Copyright (C) 1988, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1988, 93, 94-98, 1999 Free Software Foundation, Inc.
Contributed by Michael Tiemann (tiemann@cygnus.com)
This file is part of GNU CC.
or perhaps F0 is there is fp support. */
#define LIBCALL_VALUE(MODE) \
- gen_rtx (REG, MODE, \
- FLOAT_MODE_P(MODE) && TARGET_32081 ? F0_REGNUM: R0_REGNUM)
+ gen_rtx_REG (MODE, \
+ FLOAT_MODE_P(MODE) && TARGET_32081 ? F0_REGNUM: R0_REGNUM)
/* Define this if PCC uses the nonreentrant convention for returning
structure and union values. */
It exists only to test register calling conventions. */
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
-((TARGET_REGPARM && (CUM) < 8) ? gen_rtx (REG, (MODE), (CUM) / 4) : 0)
+((TARGET_REGPARM && (CUM) < 8) ? gen_rtx_REG ((MODE), (CUM) / 4) : 0)
/* For an arg passed partly in registers and partly in memory,
this is the number of registers used.
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 12)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 16)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 12)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 16)), FNADDR); \
}
/* This is the library routine that is used
;;- Machine description for GNU compiler, ns32000 Version
-;; Copyright (C) 1988, 1994, 1996, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1994, 1996, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by Michael Tiemann (tiemann@cygnus.com)
;; This file is part of GNU CC.
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"movd %1,tos\", xoperands);
output_asm_insn (\"movd %1,tos\", operands);
return \"movl tos,%0\";
if (REG_P (operands[0]))
{
output_asm_insn (\"movl %1,tos\;movd tos,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"movd tos,%0\";
}
else
convrt.i[1] = CONST_DOUBLE_HIGH (operands[1]);
convrt.f = convrt.d;
- /* Is there a better machine-independent way to do this? */
+ /* Is there a better machine-independent way to to this? */
operands[1] = GEN_INT (convrt.i[0]);
return \"movd %1,%0\";
}
if (REG_P (operands[1]))
{
rtx xoperands[2];
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
output_asm_insn (\"movd %1,tos\", xoperands);
output_asm_insn (\"movd %1,tos\", operands);
return \"movl tos,%0\";
if (REG_P (operands[0]))
{
output_asm_insn (\"movl %1,tos\;movd tos,%0\", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"movd tos,%0\";
}
else
&& REGNO (operands[0]) == FRAME_POINTER_REGNUM)
return \"lprd fp,%1\";
if (GET_CODE (operands[1]) == CONST_DOUBLE)
- operands[1]
- = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
+ operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
if (GET_CODE (operands[1]) == CONST_INT)
{
int i = INTVAL (operands[1]);
if (i <= 7 && i >= -8)
{
if (INTVAL (operands[1]) > 7)
- operands[1] =
- GEN_INT (i);
+ operands[1] = GEN_INT (i);
return \"movqw %1,%0\";
}
return \"movw %1,%0\";
if (char_val <= 7 && char_val >= -8)
{
if (INTVAL (operands[1]) > 7)
- operands[1] =
- GEN_INT (char_val);
+ operands[1] = GEN_INT (char_val);
return \"movqb %1,%0\";
}
return \"movb %1,%0\";
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, SImode, negate_rtx (SImode, operands[2]));
+ operands[2] = gen_rtx_NEG (SImode, negate_rtx (SImode, operands[2]));
}")
(define_insn ""
#include "config.h"
#include "system.h"
-
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
}
else
pic_ref = gen_rtx_MEM (Pmode,
- gen_rtx_PLUS (Pmode,
- pic_offset_table_rtx, orig));
+ gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
+ orig));
+
current_function_uses_pic_offset_table = 1;
RTX_UNCHANGING_P (pic_ref) = 1;
emit_move_insn (reg, pic_ref);
if (! VAL_14_BITS_P (newoffset)
&& GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
{
- rtx const_part
- = gen_rtx_CONST (VOIDmode, gen_rtx_PLUS (Pmode,
- XEXP (x, 0),
- GEN_INT (newoffset)));
+ rtx const_part = plus_constant (XEXP (x, 0), newoffset);
rtx tmp_reg
= force_reg (Pmode,
gen_rtx_HIGH (Pmode, const_part));
ptr_reg
= force_reg (Pmode,
- gen_rtx_LO_SUM (Pmode, tmp_reg, const_part));
+ gen_rtx_LO_SUM (Pmode,
+ tmp_reg, const_part));
}
else
{
reg2 = force_reg (Pmode, force_operand (reg2, 0));
return force_reg (Pmode, gen_rtx_PLUS (Pmode,
- gen_rtx_MULT (Pmode, reg2,
- GEN_INT (val)),
+ gen_rtx_MULT (Pmode,
+ reg2,
+ GEN_INT (val)),
reg1));
}
reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
/* We can now generate a simple scaled indexed address. */
- return force_reg (Pmode,
- gen_rtx_PLUS (Pmode,
- gen_rtx_MULT (Pmode, reg1,
- XEXP (XEXP (idx, 0), 1)),
- base));
+ return
+ force_reg
+ (Pmode, gen_rtx_PLUS (Pmode,
+ gen_rtx_MULT (Pmode, reg1,
+ XEXP (XEXP (idx, 0), 1)),
+ base));
}
/* If B + C is still a valid base register, then add them. */
reg2 = force_reg (Pmode, force_operand (reg2, 0));
return force_reg (Pmode, gen_rtx_PLUS (Pmode,
- gen_rtx_MULT (Pmode, reg2,
+ gen_rtx_MULT (Pmode,
+ reg2,
GEN_INT (val)),
reg1));
}
return force_reg (Pmode,
gen_rtx_PLUS (Pmode,
- gen_rtx_MULT (Pmode, reg2,
+ gen_rtx_MULT (Pmode,
+ reg2,
GEN_INT (val)),
- reg1));
+ reg1));
}
else if ((mode == DFmode || mode == SFmode)
&& GET_CODE (XEXP (y, 0)) == SYMBOL_REF
regx2 = force_reg (Pmode, force_operand (regx2, 0));
regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
regx2, regx1));
- return force_reg (Pmode,
- gen_rtx_PLUS (Pmode,
- gen_rtx_MULT (Pmode, regx2,
- XEXP (XEXP (x, 0),
- 1)),
- force_reg (Pmode, XEXP (y, 0))));
+ return
+ force_reg (Pmode,
+ gen_rtx_PLUS (Pmode,
+ gen_rtx_MULT (Pmode, regx2,
+ XEXP (XEXP (x, 0), 1)),
+ force_reg (Pmode, XEXP (y, 0))));
}
else if (GET_CODE (XEXP (y, 1)) == CONST_INT
&& INTVAL (XEXP (y, 1)) >= -4096
}
else
emit_move_insn (scratch_reg, XEXP (operand1, 0));
- emit_insn (gen_rtx_SET (VOIDmode, operand0, gen_rtx_MEM (mode,
- scratch_reg)));
+ emit_insn (gen_rtx_SET (VOIDmode, operand0,
+ gen_rtx_MEM (mode, scratch_reg)));
return 1;
}
else if (fp_reg_operand (operand1, mode)
emit_move_sequence (xoperands, Pmode, 0);
/* Now load the destination register. */
- emit_insn (gen_rtx_SET (mode, operand0, gen_rtx_MEM (mode, scratch_reg)));
+ emit_insn (gen_rtx_SET (mode, operand0,
+ gen_rtx_MEM (mode, scratch_reg)));
return 1;
}
/* Handle secondary reloads for SAR. These occur when trying to load
if (ishighonly)
set = gen_rtx_SET (mode, operand0, temp);
else
- set = gen_rtx_SET (VOIDmode, operand0,
+ set = gen_rtx_SET (VOIDmode,
+ operand0,
gen_rtx_LO_SUM (mode, temp, operand1));
emit_insn (gen_rtx_SET (VOIDmode,
Note in DISP > 8k case, we will leave the high part of the address
in %r1. There is code in expand_hppa_{prologue,epilogue} that knows this.*/
+
static void
store_reg (reg, disp, base)
int reg, disp, base;
{
if (VAL_14_BITS_P (disp))
- {
- emit_move_insn (gen_rtx_MEM (word_mode,
- gen_rtx_PLUS (Pmode,
- gen_rtx_REG (Pmode, base),
- GEN_INT (disp))),
- gen_rtx_REG (word_mode, reg));
- }
+ emit_move_insn (gen_rtx_MEM (word_mode,
+ plus_constant (gen_rtx_REG (Pmode, base),
+ disp)),
+ gen_rtx_REG (word_mode, reg));
else
{
emit_move_insn (gen_rtx_REG (Pmode, 1),
Note in DISP > 8k case, we will leave the high part of the address
in %r1. There is code in expand_hppa_{prologue,epilogue} that knows this.*/
+
static void
load_reg (reg, disp, base)
int reg, disp, base;
{
if (VAL_14_BITS_P (disp))
- {
- emit_move_insn (gen_rtx_REG (word_mode, reg),
- gen_rtx_MEM (word_mode,
- gen_rtx_PLUS (Pmode,
- gen_rtx_REG (Pmode, base),
- GEN_INT (disp))));
- }
+ emit_move_insn (gen_rtx_REG (word_mode, reg),
+ gen_rtx_MEM (word_mode,
+ plus_constant (gen_rtx_REG (Pmode, base),
+ disp)));
else
{
emit_move_insn (gen_rtx_REG (Pmode, 1),
Note in DISP > 8k case, we will leave the high part of the address
in %r1. There is code in expand_hppa_{prologue,epilogue} that knows this.*/
+
static void
-set_reg_plus_d(reg, base, disp)
+set_reg_plus_d (reg, base, disp)
int reg, base, disp;
{
if (VAL_14_BITS_P (disp))
- {
- emit_move_insn (gen_rtx_REG (Pmode, reg),
- gen_rtx_PLUS (Pmode,
- gen_rtx_REG (Pmode, base),
- GEN_INT (disp)));
- }
+ emit_move_insn (gen_rtx_REG (Pmode, reg),
+ plus_constant (gen_rtx_REG (Pmode, base), disp));
else
{
emit_move_insn (gen_rtx_REG (Pmode, 1),
place to get the expected results. sprintf here is just to
put something in the name. */
sprintf(hp_profile_label_name, "LP$%04d", -1);
- hp_profile_label_rtx = gen_rtx_SYMBOL_REF (Pmode, hp_profile_label_name);
+ hp_profile_label_rtx = gen_rtx_SYMBOL_REF (Pmode,
+ hp_profile_label_name);
if (current_function_returns_struct)
store_reg (STRUCT_VALUE_REGNUM, - 12 - offsetadj, basereg);
if (current_function_needs_context)
|| anchor_attr == PA_COMBINE_TYPE_FMPY))
{
/* Emit the new instruction and delete the old anchor. */
- emit_insn_before (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2,
- PATTERN (anchor),
- PATTERN (floater))),
- anchor);
+ emit_insn_before (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2, PATTERN (anchor),
+ PATTERN (floater))),
+ anchor);
+
PUT_CODE (anchor, NOTE);
NOTE_LINE_NUMBER (anchor) = NOTE_INSN_DELETED;
NOTE_SOURCE_FILE (anchor) = 0;
{
rtx temp;
/* Emit the new_jump instruction and delete the old anchor. */
- temp = emit_jump_insn_before (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2, PATTERN (anchor),
- PATTERN (floater))),
- anchor);
+ temp
+ = emit_jump_insn_before (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2, PATTERN (anchor),
+ PATTERN (floater))),
+ anchor);
+
JUMP_LABEL (temp) = JUMP_LABEL (anchor);
PUT_CODE (anchor, NOTE);
NOTE_LINE_NUMBER (anchor) = NOTE_INSN_DELETED;
#define LIBCALL_VALUE(MODE) \
gen_rtx_REG (MODE, \
(! TARGET_SOFT_FLOAT \
- && ((MODE) == SFmode || (MODE) == DFmode) ? 32 : 28))
+ && ((MODE) == SFmode || (MODE) == DFmode) ? 32 : 28))
/* 1 if N is a possible register number for a function value
as seen by the caller. */
|| !FLOAT_MODE_P (MODE) || TARGET_SOFT_FLOAT \
|| (CUM).nargs_prototype > 0) \
? gen_rtx_REG ((MODE), \
- (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
- ? (((!(CUM).indirect \
- || TARGET_PORTABLE_RUNTIME) \
- && (MODE) == DFmode \
- && ! TARGET_SOFT_FLOAT) \
- ? ((CUM).words ? 38 : 34) \
- : ((CUM).words ? 23 : 25)) \
- : (((!(CUM).indirect \
- || TARGET_PORTABLE_RUNTIME) \
- && (MODE) == SFmode \
- && ! TARGET_SOFT_FLOAT) \
- ? (32 + 2 * (CUM).words) \
- : (27 - (CUM).words - FUNCTION_ARG_SIZE ((MODE), \
- (TYPE))))))\
+ (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
+ ? (((!(CUM).indirect \
+ || TARGET_PORTABLE_RUNTIME) \
+ && (MODE) == DFmode \
+ && ! TARGET_SOFT_FLOAT) \
+ ? ((CUM).words ? 38 : 34) \
+ : ((CUM).words ? 23 : 25)) \
+ : (((!(CUM).indirect \
+ || TARGET_PORTABLE_RUNTIME) \
+ && (MODE) == SFmode \
+ && ! TARGET_SOFT_FLOAT) \
+ ? (32 + 2 * (CUM).words) \
+ : (27 - (CUM).words - FUNCTION_ARG_SIZE ((MODE),\
+ (TYPE))))))\
/* We are calling a non-prototyped function with floating point \
arguments using the portable conventions. */ \
- : gen_rtx_PARALLEL ((MODE), \
- gen_rtvec \
- (2, \
- gen_rtx_EXPR_LIST (VOIDmode, \
- gen_rtx_REG ((MODE), \
- (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
- ? ((CUM).words ? 38 : 34) \
- : (32 + 2 * (CUM).words))), \
- const0_rtx), \
- gen_rtx_EXPR_LIST (VOIDmode, \
- gen_rtx_REG ((MODE), \
- (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
- ? ((CUM).words ? 23 : 25) \
- : (27 - (CUM).words - \
- FUNCTION_ARG_SIZE ((MODE), \
- (TYPE))))), \
- const0_rtx))) \
- /* Pass this parameter in the stack. */ \
- : 0)
+ : (gen_rtx_PARALLEL \
+ ((MODE), \
+ gen_rtvec \
+ (2, \
+ gen_rtx_EXPR_LIST \
+ (VOIDmode, \
+ gen_rtx_REG ((MODE), \
+ (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
+ ? ((CUM).words ? 38 : 34) : (32 + 2 * (CUM).words))), \
+ const0_rtx), \
+ gen_rtx_EXPR_LIST \
+ (VOIDmode, \
+ gen_rtx_REG ((MODE), \
+ (FUNCTION_ARG_SIZE ((MODE), (TYPE)) > 1 \
+ ? ((CUM).words ? 23 : 25) \
+ : (27 - (CUM).words - \
+ FUNCTION_ARG_SIZE ((MODE), (TYPE))))), \
+ const0_rtx)))) \
+ /* Pass this parameter in the stack. */ \
+ : 0)
/* For an arg passed partly in registers and partly in memory,
this is the number of registers used.
operands[1] = force_reg (SImode, operands[1]);
operands[2] = force_reg (SImode, operands[2]);
emit_insn (gen_umulsidi3 (scratch, operands[1], operands[2]));
- emit_insn (gen_rtx_SET (VOIDmode,
- operands[0],
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0],
gen_rtx_SUBREG (SImode, scratch, 1)));
DONE;
}
/* Else call $$sh_func_adrs to extract the function's real add24. */
return output_millicode_call (insn,
- gen_rtx_SYMBOL_REF (SImode, \"$$sh_func_adrs\"));
+ gen_rtx_SYMBOL_REF (SImode,
+ \"$$sh_func_adrs\"));
}"
[(set_attr "type" "multi")
(set (attr "length")
/* Load the PIC register from the stack slot (in our caller's
frame). */
emit_move_insn (pic_offset_table_rtx,
- gen_rtx_MEM (SImode, plus_constant (stack_pointer_rtx, -32)));
- emit_insn (gen_rtx_USE (VOIDmode, pic_offset_table_rtx));
+ gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx, -32)));
+ emit_insn (gen_rtx (USE, VOIDmode, pic_offset_table_rtx));
emit_insn (gen_blockage ());
DONE;
}")
/* Subroutines for gcc2 for pdp11.
- Copyright (C) 1994, 1995, 1996, 1997, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1994, 95-98, 1999 Free Software Foundation, Inc.
Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at).
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
{
operands[0] = XEXP (XEXP (operands[0], 0), 0);
output_asm_insn ("sub $4,%0", operands);
- operands[0] = gen_rtx (MEM, SImode, operands[0]);
+ 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]);
+ operands[1] = gen_rtx_MEM (SImode, operands[1]);
optype1 = OFFSOP;
}
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, HImode, REGNO (operands[0]) + 1);
+ 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);
+ 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)
/* 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_INT (INTVAL(operands[1])>>16);
- operands[1] = GEN_INT (INTVAL(operands[1])&0xff);
+ latehalf[1] = GEN_INT (INTVAL(operands[1]) >> 16);
+ operands[1] = GEN_INT (INTVAL(operands[1]) & 0xff);
}
else if (GET_CODE (operands[1]) == CONST_DOUBLE)
{
{
operands[0] = XEXP (XEXP (operands[0], 0), 0);
output_asm_insn ("sub $8,%0", operands);
- operands[0] = gen_rtx (MEM, DImode, operands[0]);
+ 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]);
+ operands[1] = gen_rtx_MEM (SImode, operands[1]);
optype1 = OFFSOP;
}
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 2);
+ 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);
+ 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)
#ifndef HOST_WORDS_BIG_ENDIAN
latehalf[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
- operands[1] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
+ operands[1] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
#else /* HOST_WORDS_BIG_ENDIAN */
latehalf[1] = GEN_INT (CONST_DOUBLE_HIGH (operands[1]));
operands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[1]));
#endif /* HOST_WORDS_BIG_ENDIAN */
}
else if (GET_CODE(operands[1]) == CONST_INT)
- {
+ {
latehalf[1] = GEN_INT (0);
- }
+ }
else
- abort();
-
+ abort();
}
else
latehalf[1] = operands[1];
not without FPU!!!! ) */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), BASE_RETURN_VALUE_REG(TYPE_MODE(VALTYPE)))
+ 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)))
+ 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))
+#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.
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); \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 2)), CXT); \
+ emit_move_insn (gen_rtx_MEM (HImode, plus_constant (TRAMP, 6)), FNADDR); \
}
;;- Machine description for the pdp11 for GNU C compiler
-;; Copyright (C) 1994, 1995, 1997, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1994, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by Michael K. Gschwind (mike@vlsivie.tuwien.ac.at).
;; This file is part of GNU CC.
{
output_asm_insn(\"{stcdf|movfo} %1, -(sp)\", operands);
output_asm_insn(\"mov (sp)+, %0\", operands);
- operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
+ operands[0] = gen_rtx_REG (HImode, REGNO (operands[0])+1);
output_asm_insn(\"mov (sp)+, %0\", operands);
return \"\";
}
/* make register pair available */
latehalf[0] = operands[0];
- operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
-
+ operands[0] = gen_rtx_REG (HImode, REGNO (operands[0])+ 1);
+
output_asm_insn(\"movb %1, %0\", operands);
output_asm_insn(\"sxt %0\", latehalf);
/* make register pair available */
latehalf[0] = operands[0];
- operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
+ operands[0] = gen_rtx_REG (HImode, REGNO (operands[0]) + 1);
output_asm_insn(\"mov %1, %0\", operands);
output_asm_insn(\"sxt %0\", latehalf);
rtx lateoperands[2];
lateoperands[0] = operands[0];
- operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
+ operands[0] = gen_rtx_REG (HImode, REGNO (operands[0]) + 1);
output_asm_insn(\"tst %0\", operands);
sprintf(buf, \"bge extendhisi%d\", count);
rtx latehalf[2];
latehalf[0] = NULL;
- latehalf[1] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
+ latehalf[1] = gen_rtx_REG (HImode, REGNO (operands[0]) + 1);
output_asm_insn(\"mov %1, -(sp)\", latehalf);
output_asm_insn(\"mov %1, -(sp)\", operands);
output_asm_insn(\"{stcdl|movfi} %1, -(sp)\", operands);
output_asm_insn(\"seti\", operands);
output_asm_insn(\"mov (sp)+, %0\", operands);
- operands[0] = gen_rtx(REG, HImode, REGNO (operands[0])+1);
+ operands[0] = gen_rtx_REG (HImode, REGNO (operands[0]) + 1);
output_asm_insn(\"mov (sp)+, %0\", operands);
return \"\";
}
lateoperands[0] = operands[0];
if (REG_P (operands[0]))
- operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
+ 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);
+ operands[2] = gen_rtx_REG (HImode, REGNO (operands[2]) + 1);
else
operands[2] = adj_offsettable_operand(operands[2], 2);
return \"\";
}
- lateoperands[2] = GEN_INT ((INTVAL(operands[2]) >> 16) & 0xffff);
- operands[2] = GEN_INT (INTVAL(operands[2]) & 0xffff);
+ lateoperands[2] = GEN_INT (INTVAL (operands[2]) >> 16) & 0xffff);
+ operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
if (INTVAL(operands[2]))
{
lateoperands[0] = operands[0];
if (REG_P (operands[0]))
- operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
+ 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);
+ operands[2] = gen_rtx_REG (HImode, REGNO (operands[2]) + 1);
else
operands[2] = adj_offsettable_operand(operands[2], 2);
lateoperands[0] = operands[0];
if (REG_P (operands[0]))
- operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
+ 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);
+ operands[2] = gen_rtx_REG (HImode, REGNO (operands[2]) + 1);
else
operands[2] = adj_offsettable_operand(operands[2], 2);
return \"\";
}
- lateoperands[2] = GEN_INT ((INTVAL(operands[2]) >> 16) & 0xffff);
- operands[2] = GEN_INT (INTVAL(operands[2]) & 0xffff);
+ lateoperands[2] = GEN_INT ((INTVAL (operands[2]) >> 16) & 0xffff);
+ operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
/* these have different lengths, so we should have
different constraints! */
lateoperands[0] = operands[0];
if (REG_P (operands[0]))
- operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
+ 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];
+ {
+ 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);
+ 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 \"\";
- }
+ output_asm_insn (\"bis %2, %0\", operands);
+ output_asm_insn (\"bis %2, %0\", lateoperands);
+ return \"\";
+ }
- lateoperands[2] = GEN_INT ((INTVAL(operands[2]) >> 16) & 0xffff);
- operands[2] = GEN_INT (INTVAL(operands[2]) & 0xffff);
+ lateoperands[2] = GEN_INT ((INTVAL (operands[2]) >> 16) & 0xffff);
+ operands[2] = GEN_INT (INTVAL (operands[2]) & 0xffff);
/* these have different lengths, so we should have
different constraints! */
rtx lateoperands[3];
lateoperands[0] = operands[0];
- operands[0] = gen_rtx(REG, HImode, REGNO(operands[0]) + 1);
+ 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);
+ {
+ lateoperands[2] = operands[2];
+ operands[2] = gen_rtx_REG (HImode, REGNO (operands[2]) + 1);
- return \"\";
- }
+ output_asm_insn (\"xor %2, %0\", operands);
+ output_asm_insn (\"xor %2, %0\", lateoperands);
- lateoperands[2] = GEN_INT ((INTVAL(operands[2]) >> 16) & 0xffff);
+ return \"\";
+ }
+
+ lateoperands[2] = GEN_INT ((INTVAL (operands[2]) >> 16) & 0xffff);
operands[2] = GEN_INT (INTVAL(operands[2]) & 0xffff);
- if (INTVAL(operands[2]))
+ if (INTVAL (operands[2]))
output_asm_insn (\"xor %2, %0\", operands);
- if (INTVAL(lateoperands[2]))
+ if (INTVAL (lateoperands[2]))
output_asm_insn (\"xor %2, %0\", lateoperands);
return \"\";
;
; /* 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));
+; emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
; DONE;
;}")
/* Subroutines for insn-output.c for Pyramid 90x, 9000, and MIServer Series.
- Copyright (C) 1989, 1991, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* Some output-actions in pyr.md need these. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
val = val & ~((-1) << (GET_MODE_BITSIZE (from_mode)));
if (GET_MODE_BITSIZE (to_mode) == HOST_BITS_PER_INT)
return GEN_INT (val);
+
return GEN_INT (val & ~((-1) << (GET_MODE_BITSIZE (to_mode))));
}
if (op1 == 0)
{
op0 = ensure_extended (op0, extop, test_mode);
- emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx, op0));
+ emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx, op0));
}
else
{
op0 = force_reg (test_mode, op0);
}
- emit_insn (gen_rtx (SET, VOIDmode, cc0_rtx,
- gen_rtx (COMPARE, VOIDmode, op0, op1)));
+ emit_insn (gen_rtx_SET (VOIDmode, cc0_rtx,
+ gen_rtx_COMPARE (VOIDmode, op0, op1)));
}
}
}
operands[1] = GEN_INT (CONST_DOUBLE_HIGH (const_op));
output_asm_insn ("movw %1,%0", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
operands[1] = GEN_INT (CONST_DOUBLE_LOW (const_op));
return "movw %1,%0";
}
}
operands[1] = GEN_INT (CONST_DOUBLE_LOW (const_op));
output_asm_insn ("movw %1,%0", operands);
- operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
operands[1] = GEN_INT (CONST_DOUBLE_HIGH (const_op));
return "movw %1,%0";
}
/* Definitions of target machine parameters for GNU compiler,
for Pyramid 90x, 9000, and MIServer Series.
- Copyright (C) 1989, 1995, 1996, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 95-98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
--> its type. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), PYR_TREG(0))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), PYR_TREG(0))
/* --> but the callee has to leave it in PR0(/PR1) */
#define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), PYR_PREG(0))
+ gen_rtx_REG (TYPE_MODE (VALTYPE), PYR_PREG(0))
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* --> On Pyramid the return value is in TR0/TR1 regardless. */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, PYR_TREG(0))
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, PYR_TREG(0))
/* Define this if PCC uses the nonreentrant convention for returning
structure and union values. */
+ ((MODE) == BLKmode \
? (int_size_in_bytes (TYPE) + 3) / 4 \
: (GET_MODE_SIZE (MODE) + 3) / 4)) \
- ? gen_rtx (REG, (MODE), PYR_TREG(CUM)) \
+ ? gen_rtx_REG ((MODE), PYR_TREG(CUM)) \
: 0) \
: 0)
#ifdef __GNUC__
+ ((MODE) == BLKmode \
? (int_size_in_bytes (TYPE) + 3) / 4 \
: (GET_MODE_SIZE (MODE) + 3) / 4)) \
- ? gen_rtx (REG, (MODE), PYR_PREG(CUM)) \
+ ? gen_rtx_REG ((MODE), PYR_PREG(CUM)) \
: 0) \
: 0)
CXT is an RTX for the static chain value for the function. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
-{ emit_move_insn (gen_rtx (MEM, Pmode, plus_constant (TRAMP, 4)), CXT); \
+{ emit_move_insn (gen_rtx_MEM (Pmode, plus_constant (TRAMP, 4)), CXT); \
emit_move_insn (gen_rtx (MEM, Pmode, plus_constant (TRAMP, 12)), FNADDR); \
- emit_call_insn (gen_call (gen_rtx (MEM, QImode, \
- gen_rtx (SYMBOL_REF, Pmode, \
- "__enable_execute_stack")), \
- const0_rtx)); \
+ emit_call_insn (gen_call \
+ (gen_rtx_MEM \
+ (QImode, \
+ gen_rtx_SYMBOL_REF (Pmode, "__enable_execute_stack")), \
+ const0_rtx)); \
}
/* Output assembler code to FILE to increment profiler label # LABELNO
;; GNU C machine description for Pyramid 90x, 9000, MIServer Series
-;; Copyright (C) 1989, 1990, 1995, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1989, 90, 95, 97, 98, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
{
rtx xoperands[2];
CC_STATUS_INIT;
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (REG_P (operands[2]))
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
{
xoperands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
{
rtx xoperands[2];
CC_STATUS_INIT;
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (REG_P (operands[2]))
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
{
xoperands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
{
rtx xoperands[2];
CC_STATUS_INIT;
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (REG_P (operands[2]))
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
{
xoperands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
{
rtx xoperands[2];
CC_STATUS_INIT;
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (REG_P (operands[2]))
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
{
xoperands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
{
rtx xoperands[2];
CC_STATUS_INIT;
- xoperands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
if (REG_P (operands[2]))
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[2]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
{
xoperands[1] = GEN_INT (CONST_DOUBLE_LOW (operands[2]));
/* Subroutines used for code generation on ROMP.
- Copyright (C) 1990, 1991, 1992, 1993, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1990, 91, 92, 93, 97, 98, 1999 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@nyu.edu)
This file is part of GNU CC.
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
if (GET_CODE (x) == REG)
fprintf (file, "%s", reg_names[REGNO (x) + 1]);
else if (GET_CODE (x) == MEM)
- print_operand (file, gen_rtx (MEM, GET_MODE (x),
- plus_constant (XEXP (x, 0), 4)), 0);
+ print_operand (file, gen_rtx_MEM (GET_MODE (x),
+ plus_constant (XEXP (x, 0), 4)), 0);
else
abort ();
break;
/* Restore floating-point registers. */
if (write_code)
output_loadsave_fpregs (file, CLOBBER,
- gen_rtx (PLUS, Pmode, gen_rtx (REG, Pmode, 1),
- GEN_INT (fp_save)));
+ plus_constant (gen_rtx_REG (Pmode, 1), fp_save));
/* If we push the stack and do not have size > 32K, adjust the register
save location to the current position of sp. Otherwise, if long frame,
end_temporary_allocation ();
p = *last_p = (struct symref_hashent *)
permalloc (sizeof (struct symref_hashent));
- p->symref = gen_rtx (SYMBOL_REF, Pmode,
- obstack_copy0 (&permanent_obstack,
- name, strlen (name)));
+ p->symref = gen_rtx_SYMBOL_REF (Pmode,
+ obstack_copy0 (&permanent_obstack,
+ name, strlen (name)));
p->next = 0;
resume_temporary_allocation ();
}
if (mask)
fprintf (file, "\t%s\n",
- output_fpop (code, GEN_INT (mask),
- gen_rtx (MEM, Pmode, addr),
+ output_fpop (code, GEN_INT (mask), gen_rtx_MEM (Pmode, addr),
0, const0_rtx));
}
/* Definitions of target machine for GNU compiler, for ROMP chip.
- Copyright (C) 1989, 1991, 1993, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1989, 91, 93, 95, 96, 98, 1999 Free Software Foundation, Inc.
Contributed by Richard Kenner (kenner@nyu.edu)
This file is part of GNU CC.
/* Place to put static chain when calling a function that requires it. */
#define STATIC_CHAIN \
- gen_rtx (MEM, Pmode, gen_rtx (PLUS, Pmode, stack_pointer_rtx, \
- GEN_INT (-36)))
+ gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, -36))
/* Place where static chain is found upon entry to routine. */
#define STATIC_CHAIN_INCOMING \
- gen_rtx (MEM, Pmode, gen_rtx (PLUS, Pmode, arg_pointer_rtx, \
- GEN_INT (-20)))
+ gen_rtx_MEM (Pmode, plus_constant (arg_pointer_rtx, -20))
/* Place that structure value return address is placed.
On ROMP the value is found in r2, unless the machine specific option
fp-arg-in-fpregs is selected, in which case FP return values are in fr1 */
-#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), \
- (TARGET_FP_REGS && \
- GET_MODE_CLASS (TYPE_MODE (VALTYPE)) == MODE_FLOAT) ? 18 : 2)
+#define FUNCTION_VALUE(VALTYPE, FUNC) \
+ gen_rtx_REG (TYPE_MODE (VALTYPE), \
+ (TARGET_FP_REG \
+ && GET_MODE_CLASS (TYPE_MODE (VALTYPE)) == MODE_FLOAT) \
+ ? 18 : 2)
/* 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, 2)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 2)
/* The definition of this macro implies that there are cases where
a scalar value cannot be returned in registers.
#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \
(! (NAMED) ? 0 \
: ((TYPE) != 0 && TREE_CODE (TYPE_SIZE (TYPE)) != INTEGER_CST) ? 0 \
- : USE_FP_REG(MODE,CUM) ? gen_rtx(REG, (MODE),(CUM.fregs) + 17) \
- : (CUM).gregs < 4 ? gen_rtx(REG, (MODE), 2 + (CUM).gregs) : 0)
+ : USE_FP_REG(MODE,CUM) ? gen_rtx_REG ((MODE), (CUM.fregs) + 17) \
+ : (CUM).gregs < 4 ? gen_rtx_REG ((MODE), 2 + (CUM).gregs) : 0)
/* For an arg passed partly in registers and partly in memory,
this is the number of registers used.
if (! NO_RTL && first_reg_offset != 4) \
move_block_from_reg \
(2 + first_reg_offset, \
- gen_rtx (MEM, BLKmode, \
- plus_constant (virtual_incoming_args_rtx, \
- first_reg_offset * 4)), \
+ gen_rtx_MEM (BLKmode, \
+ plus_constant (virtual_incoming_args_rtx, \
+ first_reg_offset * 4)), \
4 - first_reg_offset, (4 - first_reg_offset) * UNITS_PER_WORD); \
PRETEND_SIZE = (4 - first_reg_offset) * UNITS_PER_WORD; \
} \
_temp = expand_binop (SImode, add_optab, ADDR, \
GEN_INT (4), \
0, 1, OPTAB_LIB_WIDEN); \
- emit_move_insn (gen_rtx (MEM, SImode, \
- memory_address (SImode, ADDR)), _temp); \
+ emit_move_insn (gen_rtx_MEM (SImode, \
+ memory_address (SImode, ADDR)), _temp); \
\
_val = force_reg (SImode, CXT); \
_addr = memory_address (HImode, plus_constant (ADDR, 10)); \
- emit_move_insn (gen_rtx (MEM, HImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (HImode, _addr), \
gen_lowpart (HImode, _val)); \
_temp = expand_shift (RSHIFT_EXPR, SImode, _val, \
build_int_2 (16, 0), 0, 1); \
_addr = memory_address (HImode, plus_constant (ADDR, 6)); \
- emit_move_insn (gen_rtx (MEM, HImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (HImode, _addr), \
gen_lowpart (HImode, _temp)); \
\
_val = force_reg (SImode, FNADDR); \
_addr = memory_address (HImode, plus_constant (ADDR, 24)); \
- emit_move_insn (gen_rtx (MEM, HImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (HImode, _addr), \
gen_lowpart (HImode, _val)); \
_temp = expand_shift (RSHIFT_EXPR, SImode, _val, \
build_int_2 (16, 0), 0, 1); \
_addr = memory_address (HImode, plus_constant (ADDR, 20)); \
- emit_move_insn (gen_rtx (MEM, HImode, _addr), \
+ emit_move_insn (gen_rtx_MEM (HImode, _addr), \
gen_lowpart (HImode, _temp)); \
\
}
low_int = INTVAL (XEXP (X, 1)) & 0xffff; \
if (low_int & 0x8000) \
high_int += 1, low_int |= 0xffff0000; \
- (X) = gen_rtx (PLUS, SImode, \
- force_operand \
- (gen_rtx (PLUS, SImode, XEXP (X, 0), \
- GEN_INT (high_int << 16)), 0),\
- GEN_INT (low_int)); \
+ (X) = gen_rtx_PLUS (SImode, \
+ force_operand (plus_constant (XEXP (X, 0), \
+ high_int << 16)), \
+ GEN_INT (low_int)); \
} \
}
&& GET_CODE (op2) == REG && FP_REGNO_P (REGNO (op2)) \
&& REGNO (op0) == REGNO (op2)) \
{ \
- tem = gen_rtx (REG, GET_MODE (op0), 17); \
+ tem = gen_rtx_REG (GET_MODE (op0), 17); \
emit_insn_after (gen_move_insn (op0, tem), INSN); \
SET_DEST (XVECEXP (PATTERN (INSN), 0, 0)) = tem; \
OPERANDS[0] = tem; \
else if (GET_CODE (addr) == SYMBOL_REF \
&& CONSTANT_POOL_ADDRESS_P (addr)) \
{ \
- offset = GEN_INT (get_pool_offset (addr) + 12); \
- base = gen_rtx (REG, SImode, 14); \
+ offset = GEN_INT (get_pool_offset (addr) + 12); \
+ base = gen_rtx_REG (SImode, 14); \
} \
else if (GET_CODE (addr) == CONST \
&& GET_CODE (XEXP (addr, 0)) == PLUS \
offset = plus_constant (XEXP (XEXP (addr, 0), 1), \
(get_pool_offset (XEXP (XEXP (addr, 0), 0)) \
+ 12)); \
- base = gen_rtx (REG, SImode, 14); \
+ base = gen_rtx_REG (SImode, 14); \
} \
output_addr_const (FILE, offset); \
if (base) \
;;- Machine description for ROMP chip for GNU C compiler
-;; Copyright (C) 1988, 91, 93, 94, 95, 1999 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 91, 93, 94, 95, 98, 1999 Free Software Foundation, Inc.
;; Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
;; This file is part of GNU CC.
|| (unsigned) ((- const_val) + 0x8000) < 0x10000)
{
/* Can do this by loading the negative constant and then negating. */
- emit_move_insn (operands[0],
- GEN_INT (- const_val));
+ emit_move_insn (operands[0], GEN_INT (- const_val));
emit_insn (gen_negsi2 (operands[0], operands[0]));
DONE;
}
if (low_part >= 0x10 && exact_log2 (low_part) >= 0)
i = high_part, high_part = low_part, low_part = i;
- emit_move_insn (operands[0],
- GEN_INT (low_part));
+ emit_move_insn (operands[0], GEN_INT (low_part));
emit_insn (gen_iorsi3 (operands[0], operands[0],
GEN_INT (high_part)));
DONE;
{ operands[2] = operand_subword (operands[0], 1, 0, DImode);
operands[3] = XEXP (operands[1], 0);
operands[4] = operand_subword (operands[0], 0, 0, DImode);
- operands[5] = gen_rtx (MEM, SImode, operands[2]);
+ operands[5] = gen_rtx_MEM (SImode, operands[2]);
operands[6] = operands[2];
- operands[7] = gen_rtx (MEM, SImode,
- gen_rtx (PLUS, SImode, operands[2],
- GEN_INT (4)));
+ operands[7] = gen_rtx_MEM (SImode, plus_constant (operands[2], 4));
if (operands[2] == 0 || operands[4] == 0)
FAIL;
(set (match_dup 6) (match_dup 7))]
"
{ operands[3] = XEXP (operands[0], 0);
- operands[4] = gen_rtx (MEM, SImode, operands[2]);
+ operands[4] = gen_rtx_MEM (SImode, operands[2]);
operands[5] = operand_subword (operands[1], 0, 0, DImode);
- operands[6] = gen_rtx (MEM, SImode,
- gen_rtx (PLUS, SImode, operands[2],
- GEN_INT (4)));
+ operands[6] = gen_rtx_MEM (SImode, plus_constant (operands[4], 4));
operands[7] = operand_subword (operands[1], 1, 0, DImode);
if (operands[5] == 0 || operands[7] == 0)
operands[7] = operands[8] = operands[6];
else
{
- operands[7] = gen_rtx (SCRATCH, SImode);
- operands[8] = gen_rtx (SCRATCH, SImode);
+ operands[7] = gen_rtx_SCRATCH (SImode);
+ operands[8] = gen_rtx_SCRATCH (SImode);
}
}")
if (op0 == op1)
{
- emit_insn (gen_rtx (SET, VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
DONE;
}
if (op0 == op1)
{
- emit_insn (gen_rtx (SET, VOIDmode, op0, op1));
+ emit_insn (gen_rtx_SET (VOIDmode, op0, op1));
DONE;
}
last = emit_move_insn (operand_subword (op0, 0, 1, SFmode),
operand_subword_force (op1, 0, SFmode));
- REG_NOTES (last) = gen_rtx (EXPR_LIST, REG_EQUAL, op1, REG_NOTES (last));
+ REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, op1, REG_NOTES (last));
DONE;
}
}")
"
{ operands[2] = XEXP (operands[1], 0);
operands[3] = operand_subword (operands[0], 0, 0, DFmode);
- operands[4] = gen_rtx (MEM, SImode, gen_rtx (REG, SImode, 15));
+ operands[4] = gen_rtx_MEM (SImode, gen_rtx (REG, SImode, 15));
operands[5] = operand_subword (operands[0], 1, 0, DFmode);
- operands[6] = gen_rtx (MEM, SImode,
- gen_rtx (PLUS, SImode, gen_rtx (REG, SImode, 15),
- GEN_INT (4)));
+ operands[6] = gen_rtx_MEM (SImode,
+ plus_constant (gen_rtx (REG, SImode, 15), 4));
if (operands[3] == 0 || operands[5] == 0)
FAIL;
(set (match_dup 5) (match_dup 6))]
"
{ operands[2] = XEXP (operands[0], 0);
- operands[3] = gen_rtx (MEM, SImode, gen_rtx (REG, SImode, 15));
+ operands[3] = gen_rtx_MEM (SImode, gen_rtx (REG, SImode, 15));
operands[4] = operand_subword (operands[1], 0, 0, DFmode);
- operands[5] = gen_rtx (MEM, SImode,
- gen_rtx (PLUS, SImode, gen_rtx (REG, SImode, 15),
- GEN_INT (4)));
+ operands[5] = gen_rtx_MEM (SImode,
+ plus_constant (gen_rtx_REG (SImode, 15), 4));
operands[6] = operand_subword (operands[1], 1, 0, DFmode);
if (operands[4] == 0 || operands[6] == 0)
FAIL;
if (reload_completed)
- operands[6] = operands[7] = gen_rtx (REG, SImode, 15);
+ operands[6] = operands[7] = gen_rtx_REG (SImode, 15);
else
{
- operands[6] = gen_rtx (SCRATCH, SImode);
- operands[7] = gen_rtx (SCRATCH, SImode);
+ operands[6] = gen_rtx_SCRATCH (SImode);
+ operands[7] = gen_rtx_SCRATCH (SImode);
}
}")
if (low & 0x8000)
high++, low |= 0xffff0000;
- emit_insn (gen_addsi3 (operands[0], operands[1],
- GEN_INT (high << 16)));
+ emit_insn (gen_addsi3 (operands[0], operands[1], GEN_INT (high << 16)));
operands[1] = operands[0];
operands[2] = GEN_INT (low);
}
rtx insn;
emit_insn (gen_divmodsi4_doit (operands[1], operands[2]));
- insn = emit_move_insn (operands[0], gen_rtx (REG, SImode, 2));
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
- gen_rtx (DIV, SImode, operands[1],
- operands[2]),
- REG_NOTES (insn));
- insn = emit_move_insn (operands[3], gen_rtx (REG, SImode, 3));
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
- gen_rtx (MOD, SImode, operands[1],
- operands[2]),
- REG_NOTES (insn));
+ insn = emit_move_insn (operands[0], gen_rtx_REG (SImode, 2));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL,
+ gen_rtx_DIV (SImode, operands[1],
+ operands[2]),
+ REG_NOTES (insn));
+ insn = emit_move_insn (operands[3], gen_rtx_REG (SImode, 3));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL,
+ gen_rtx_MOD (SImode, operands[1],
+ operands[2]),
+ REG_NOTES (insn));
DONE;
}")
rtx insn;
emit_insn (gen_udivmodsi4_doit (operands[1], operands[2]));
- insn = emit_move_insn (operands[0], gen_rtx (REG, SImode, 2));
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
- gen_rtx (UDIV, SImode, operands[1],
- operands[2]),
- REG_NOTES (insn));
- insn = emit_move_insn (operands[3], gen_rtx (REG, SImode, 3));
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
- gen_rtx (UMOD, SImode, operands[1],
- operands[2]),
- REG_NOTES (insn));
+ insn = emit_move_insn (operands[0], gen_rtx_REG (SImode, 2));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL,
+ gen_rtx_UDIV (SImode, operands[1],
+ operands[2]),
+ REG_NOTES (insn));
+ insn = emit_move_insn (operands[3], gen_rtx_REG (SImode, 3));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL,
+ gen_rtx_UMOD (SImode, operands[1],
+ operands[2]),
+ REG_NOTES (insn));
DONE;
}")
if (top != 0 && bottom != 0)
{
emit_insn (gen_iorsi3 (operands[0], operands[1],
- GEN_INT ((top << 16))));
+ GEN_INT (top << 16))));
operands[1] = operands[0];
operands[2] = GEN_INT (bottom);
}
else if (top != 0 && bottom != 0)
{
emit_insn (gen_xorsi3 (operands[0], operands[1],
- GEN_INT ((top << 16))));
+ GEN_INT (top << 16)));
operands[1] = operands[0];
operands[2] = GEN_INT (bottom);
}
""
"
{
- rtx reg0 = gen_rtx (REG, SImode, 0);
+ rtx reg0 = gen_rtx_REG (SImode, 0);
rtx call_insn;
if (GET_CODE (operands[0]) != MEM || GET_CODE (operands[1]) != CONST_INT)
if (GET_CODE (operands[0]) == SYMBOL_REF)
{
extern rtx get_symref ();
- char *real_fcnname =
- (char *) alloca (strlen (XSTR (operands[0], 0)) + 2);
+ char *real_fcnname
+ = (char *) alloca (strlen (XSTR (operands[0], 0)) + 2);
/* Copy the data area address to r0. */
emit_move_insn (reg0, force_reg (SImode, operands[0]));
rtx data_access;
emit_move_insn (reg0, force_reg (SImode, operands[0]));
- data_access = gen_rtx (MEM, SImode, operands[0]);
+ data_access = gen_rtx_MEM (SImode, operands[0]);
RTX_UNCHANGING_P (data_access) = 1;
operands[0] = copy_to_reg (data_access);
}
""
"
{
- rtx reg0 = gen_rtx (REG, SImode, 0);
+ rtx reg0 = gen_rtx_REG (SImode, 0);
rtx call_insn;
if (GET_CODE (operands[1]) != MEM || GET_CODE (operands[2]) != CONST_INT)
rtx data_access;
emit_move_insn (reg0,force_reg (SImode, operands[1]));
- data_access = gen_rtx (MEM, SImode, operands[1]);
+ data_access = gen_rtx_MEM (SImode, operands[1]);
RTX_UNCHANGING_P (data_access) = 1;
operands[1] = copy_to_reg (data_access);
}
result = expand_binop (SImode, xor_optab,
operand_subword_force (operands[1], 0, SFmode),
- GEN_INT (0x80000000),
- target, 0, OPTAB_WIDEN);
+ GEN_INT (0x80000000), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
start_sequence ();
result = expand_binop (SImode, xor_optab,
operand_subword_force (operands[1], 0, DFmode),
- GEN_INT (0x80000000),
- target, 0, OPTAB_WIDEN);
+ GEN_INT (0x80000000), target, 0, OPTAB_WIDEN);
if (result == 0)
abort ();
}
else
{
- src_addr = gen_rtx_PLUS (Pmode, src_reg, GEN_INT (offset));
- dest_addr = gen_rtx_PLUS (Pmode, dest_reg, GEN_INT (offset));
+ src_addr = plus_constant (src_reg, offset);
+ dest_addr = plus_constant (dest_reg, offset);
}
/* Generate the appropriate load and store, saving the stores for later */
if (TARGET_EABI)
#endif
{
- if (strcmp (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)), "main") == 0
+ if (0 == strcmp (IDENTIFIER_POINTER (DECL_NAME (current_function_decl)),
+ "main")
&& DECL_CONTEXT (current_function_decl) == NULL_TREE)
{
info_ptr->main_p = 1;
/* Macros to shorten the code expansions below. */
#define MEM_DEREF(addr) gen_rtx_MEM (pmode, memory_address (pmode, addr))
-#define MEM_PLUS(addr,offset) gen_rtx_MEM (pmode, memory_address (pmode, plus_constant (addr, offset)))
+#define MEM_PLUS(addr,offset) \
+ gen_rtx_MEM (pmode, memory_address (pmode, plus_constant (addr, offset)))
/* Under AIX, just build the 3 word function descriptor */
case ABI_AIX:
assuming the value has mode MODE. */
#define LIBCALL_VALUE(MODE) \
- gen_rtx_REG (MODE, \
- GET_MODE_CLASS (MODE) == MODE_FLOAT && TARGET_HARD_FLOAT ? 33 : 3)
+ gen_rtx_REG (MODE, (GET_MODE_CLASS (MODE) == MODE_FLOAT \
+ && TARGET_HARD_FLOAT ? 33 : 3))
/* The definition of this macro implies that there are cases where
a scalar value cannot be returned in registers.
((count == -1) \
? gen_rtx_REG (Pmode, 65) \
: gen_rtx_MEM (Pmode, \
- memory_address (Pmode, \
- plus_constant (copy_to_reg (gen_rtx_MEM (Pmode, \
- memory_address (Pmode, frame))), \
- RETURN_ADDRESS_OFFSET))))
+ memory_address \
+ (Pmode, \
+ plus_constant (copy_to_reg \
+ (gen_rtx_MEM (Pmode, \
+ memory_address (Pmode, \
+ frame))), \
+ RETURN_ADDRESS_OFFSET))))
\f
/* Definitions for register eliminations.
if (low_int & 0x8000) \
high_int += 0x10000, low_int |= ((HOST_WIDE_INT) -1) << 16; \
sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (X, 0), \
- GEN_INT (high_int)), 0); \
+ GEN_INT (high_int)), 0); \
(X) = gen_rtx_PLUS (Pmode, sum, GEN_INT (low_int)); \
goto WIN; \
} \
&& (MODE) != TImode) \
{ \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 0), \
- force_reg (Pmode, force_operand (XEXP (X, 1), 0))); \
+ force_reg (Pmode, force_operand (XEXP (X, 1), 0))); \
goto WIN; \
} \
else if (TARGET_ELF && TARGET_32BIT && TARGET_NO_TOC \
/* This is how to output an element of a case-vector that is relative. */
-#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL)\
+#define ASM_OUTPUT_ADDR_DIFF_ELT(FILE, BODY, VALUE, REL) \
do { char buf[100]; \
fputs (TARGET_32BIT ? "\t.long " : "\t.llong ", FILE); \
ASM_GENERATE_INTERNAL_LABEL (buf, "L", VALUE); \
else
indx = stack_pointer_rtx;
- operands[2] = gen_rtx_MEM (SImode,
- gen_rtx_PLUS (Pmode,
- indx,
- GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
- + ((WORDS_BIG_ENDIAN != 0) * 4))));
+ operands[2]
+ = gen_rtx_MEM (SImode,
+ plus_constant (indx,
+ (((rs6000_fpmem_offset & 0xffff) ^ 0x8000)
+ - 0x8000)
+ + ((WORDS_BIG_ENDIAN != 0) * 4)));
return \"{st|stw} %0,%2\";
}"
else
indx = stack_pointer_rtx;
- operands[2] = gen_rtx_MEM (SImode,
- gen_rtx_PLUS (Pmode,
- indx,
- GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
- + ((WORDS_BIG_ENDIAN == 0) * 4))));
+ operands[2]
+ = gen_rtx_MEM (SImode,
+ plus_constant (indx,
+ (((rs6000_fpmem_offset & 0xffff) ^ 0x8000)
+ - 0x8000)
+ + ((WORDS_BIG_ENDIAN == 0) * 4)));
return \"{st|stw} %0,%2\";
}"
else
indx = stack_pointer_rtx;
- operands[2] = gen_rtx_MEM (SImode,
- gen_rtx_PLUS (Pmode, indx, GEN_INT (offset)));
+ operands[2] = gen_rtx_MEM (SImode, plus_constant (indx, offset));
return \"lfd %0,%2\";
}"
indx = stack_pointer_rtx;
operands[2] = gen_rtx_MEM (DFmode,
- gen_rtx_PLUS (Pmode,
- indx,
- GEN_INT ((((rs6000_fpmem_offset & 0xffff)
- ^ 0x8000) - 0x8000))));
+ plus_constant (indx,
+ (((rs6000_fpmem_offset & 0xffff)
+ ^ 0x8000) - 0x8000)));
return \"stfd %0,%2\";
}"
else
indx = stack_pointer_rtx;
- operands[2] = gen_rtx_MEM (DFmode,
- gen_rtx_PLUS (Pmode,
- indx,
- GEN_INT ((((rs6000_fpmem_offset & 0xffff) ^ 0x8000) - 0x8000)
- + ((WORDS_BIG_ENDIAN) ? 4 : 0))));
+ operands[2]
+ = gen_rtx_MEM (DFmode,
+ plus_constant (indx,
+ (((rs6000_fpmem_offset & 0xffff) ^ 0x8000)
+ - 0x8000)
+ + ((WORDS_BIG_ENDIAN) ? 4 : 0)));
return \"{l|lwz} %0,%2\";
}"
rtx last = XVECEXP (insns, 0, XVECLEN (insns, 0) - 1);
REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
- REG_NOTES (first));
+ REG_NOTES (first));
REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
emit_insn (insns);
while (*name == '.')
name++;
new_ref = gen_rtx_SYMBOL_REF (Pmode, name);
- CONSTANT_POOL_ADDRESS_P (new_ref) = CONSTANT_POOL_ADDRESS_P (operands[1]);
+ CONSTANT_POOL_ADDRESS_P (new_ref)
+ = CONSTANT_POOL_ADDRESS_P (operands[1]);
SYMBOL_REF_FLAG (new_ref) = SYMBOL_REF_FLAG (operands[1]);
SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
operands[1] = new_ref;
for (i = 0; i < count; i++)
XVECEXP (operands[3], 0, i)
= gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, regno + i),
- change_address (operands[1], SImode,
- plus_constant (from, i * 4)));
+ change_address (operands[1], SImode,
+ plus_constant (from, i * 4)));
}")
(define_insn ""
XVECEXP (operands[3], 0, 0)
= gen_rtx_SET (VOIDmode, change_address (operands[0], SImode, to),
- operands[1]);
+ operands[1]);
XVECEXP (operands[3], 0, 1) = gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_SCRATCH (SImode));
+ gen_rtx_SCRATCH (SImode));
for (i = 1; i < count; i++)
XVECEXP (operands[3], 0, i + 1)
= gen_rtx_SET (VOIDmode,
- change_address (operands[0], SImode,
- plus_constant (to, i * 4)),
- gen_rtx_REG (SImode, regno + i));
+ change_address (operands[0], SImode,
+ plus_constant (to, i * 4)),
+ gen_rtx_REG (SImode, regno + i));
}")
(define_insn ""
&& (GET_CODE (operands[1]) != CONST_INT || INTVAL (operands[1]) > 4096))
{
rtx tmp = gen_reg_rtx (Pmode);
- emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode, \"__allocate_stack\"),
+ emit_library_call_value (gen_rtx_SYMBOL_REF (Pmode,
+ \"__allocate_stack\"),
tmp, 0, Pmode, 1, operands[1], Pmode);
emit_insn (gen_set_sp (tmp));
emit_move_insn (operands[0], tmp);
/* Copy the backchain to the first word, sp to the second. */
emit_move_insn (temp, gen_rtx_MEM (Pmode, operands[1]));
- emit_move_insn (operand_subword (operands[0], 0, 0, (TARGET_32BIT ? DImode : TImode)),
+ emit_move_insn (operand_subword (operands[0], 0, 0,
+ (TARGET_32BIT ? DImode : TImode)),
temp);
emit_move_insn (operand_subword (operands[0], 1, 0, (TARGET_32BIT ? DImode : TImode)),
operands[1]);
emit_move_insn (temp,
operand_subword (operands[1], 0, 0, (TARGET_32BIT ? DImode : TImode)));
emit_move_insn (operands[0],
- operand_subword (operands[1], 1, 0, (TARGET_32BIT ? DImode : TImode)));
+ operand_subword (operands[1], 1, 0,
+ (TARGET_32BIT ? DImode : TImode)));
emit_move_insn (gen_rtx_MEM (Pmode, operands[0]), temp);
DONE;
}")
if (DEFAULT_ABI == ABI_AIX)
{
- /* AIX function pointers are really pointers to a three word area */
+ /* AIX function pointers are really pointers to a three word
+ area. */
rtx static_chain = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
emit_call_insn (TARGET_32BIT
? gen_call_indirect_aix32 (force_reg (Pmode, operands[0]),
if (DEFAULT_ABI == ABI_AIX)
{
- /* AIX function pointers are really pointers to a three word area */
+ /* AIX function pointers are really pointers to a three word
+ area. */
rtx static_chain = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
emit_call_insn (TARGET_32BIT
? gen_call_value_indirect_aix32 (operands[0],
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
FAIL;
operands[1] = gen_rtx_COMPARE (CCFPmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCFPmode);
}")
FAIL;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
FAIL;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
"
{ enum machine_mode mode = rs6000_compare_fp_p ? CCFPmode : CCmode;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
FAIL;
operands[1] = gen_rtx_COMPARE (mode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (mode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
""
"
{ operands[1] = gen_rtx_COMPARE (CCUNSmode,
- rs6000_compare_op0, rs6000_compare_op1);
+ rs6000_compare_op0, rs6000_compare_op1);
operands[2] = gen_reg_rtx (CCUNSmode);
}")
\f
"TARGET_32BIT"
"
{ operands[0] = force_reg (SImode, operands[0]);
- operands[2] = force_reg (SImode, gen_rtx_LABEL_REF (VOIDmode, operands[1]));
+ operands[2] = force_reg (SImode, gen_rtx_LABEL_REF (SImode, operands[1]));
operands[3] = gen_reg_rtx (SImode);
}")
"TARGET_64BIT"
"
{ operands[0] = force_reg (DImode, operands[0]);
- operands[2] = force_reg (DImode, gen_rtx_LABEL_REF (VOIDmode, operands[1]));
+ operands[2] = force_reg (DImode, gen_rtx_LABEL_REF (SImode, operands[1]));
operands[3] = gen_reg_rtx (DImode);
}")
/* Configuration for GNU C-compiler for PowerPC running System V.4.
- Copyright (C) 1995, 1998 Free Software Foundation, Inc.
-
+ Copyright (C) 1995, 1998, 1999 Free Software Foundation, Inc.
Cloned from sparc/xm-sysv4.h by Michael Meissner (meissner@cygnus.com).
This file is part of GNU CC.
#undef ONLY_INT_FIELDS
#define ONLY_INT_FIELDS
#endif
-
-#ifdef __PPC__
-#ifndef __STDC__
-extern char *malloc (), *realloc (), *calloc ();
-#else
-extern void *malloc (), *realloc (), *calloc ();
-#endif
-extern void free ();
-#endif
/* Output routines for GCC for Hitachi Super-H.
- Copyright (C) 1993-1998 Free Software Foundation, Inc.
+ Copyright (C) 1993-1998, 1999 Free Software Foundation, Inc.
+ Contributed by Steve Chamberlain (sac@cygnus.com).
+ Improved by Jim Wilson (wilson@cygnus.com).
This file is part of GNU CC.
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* Contributed by Steve Chamberlain (sac@cygnus.com).
- Improved by Jim Wilson (wilson@cygnus.com). */
-
#include "config.h"
-
-#include <stdio.h>
-
+#include "system.h"
#include "rtl.h"
#include "tree.h"
#include "flags.h"
char entry[30];
tree entry_name;
rtx func_addr_rtx;
- rtx r4 = gen_rtx (REG, SImode, 4);
- rtx r5 = gen_rtx (REG, SImode, 5);
+ rtx r4 = gen_rtx_REG (SImode, 4);
+ rtx r5 = gen_rtx_REG (SImode, 5);
sprintf (entry, "__movstrSI%d", bytes);
entry_name = get_identifier (entry);
func_addr_rtx
= copy_to_mode_reg (Pmode,
- gen_rtx (SYMBOL_REF, Pmode,
- IDENTIFIER_POINTER (entry_name)));
+ gen_rtx_SYMBOL_REF
+ (Pmode, IDENTIFIER_POINTER (entry_name)));
force_into (XEXP (operands[0], 0), r4);
force_into (XEXP (operands[1], 0), r5);
emit_insn (gen_block_move_real (func_addr_rtx));
tree entry_name;
rtx func_addr_rtx;
int final_switch, while_loop;
- rtx r4 = gen_rtx (REG, SImode, 4);
- rtx r5 = gen_rtx (REG, SImode, 5);
- rtx r6 = gen_rtx (REG, SImode, 6);
+ rtx r4 = gen_rtx_REG (SImode, 4);
+ rtx r5 = gen_rtx_REG (SImode, 5);
+ rtx r6 = gen_rtx_REG (SImode, 6);
entry_name = get_identifier ("__movstr");
func_addr_rtx
= copy_to_mode_reg (Pmode,
- gen_rtx (SYMBOL_REF, Pmode,
- IDENTIFIER_POINTER (entry_name)));
+ gen_rtx_SYMBOL_REF
+ (Pmode, IDENTIFIER_POINTER (entry_name)));
force_into (XEXP (operands[0], 0), r4);
force_into (XEXP (operands[1], 0), r5);
prepare_scc_operands (code)
enum rtx_code code;
{
- rtx t_reg = gen_rtx (REG, SImode, T_REG);
+ rtx t_reg = gen_rtx_REG (SImode, T_REG);
enum rtx_code oldcode = code;
enum machine_mode mode;
insn = gen_ieee_ccmpeqsf_t (sh_compare_op0, sh_compare_op1);
}
else
- insn = gen_rtx (SET, VOIDmode,
- gen_rtx (REG, SImode, 18),
- gen_rtx (code, SImode, sh_compare_op0, sh_compare_op1));
+ insn = gen_rtx_SET (VOIDmode,
+ gen_rtx_REG (SImode, 18),
+ gen_rtx (code, SImode, sh_compare_op0,
+ sh_compare_op1));
if (TARGET_SH4 && GET_MODE_CLASS (mode) == MODE_FLOAT)
{
insn = gen_rtx (PARALLEL, VOIDmode,
if (dbr_sequence_length ())
print_slot (final_sequence);
- this.reg = gen_rtx (REG, SImode, 13);
+ this.reg = gen_rtx_REG (SImode, 13);
output_asm_insn ("mov.l r13,@-r15", 0);
output_asm_insn (jump, &this.lab);
output_asm_insn ("mov.l @r15+,r13", 0);
wrk = gen_reg_rtx (Pmode);
/* Load the value into an arg reg and call a helper. */
- emit_move_insn (gen_rtx (REG, SImode, 4), operands[1]);
+ emit_move_insn (gen_rtx_REG (SImode, 4), operands[1]);
sprintf (func, "__ashiftrt_r4_%d", value);
func_name = get_identifier (func);
- emit_move_insn (wrk, gen_rtx (SYMBOL_REF, Pmode,
- IDENTIFIER_POINTER (func_name)));
+ emit_move_insn (wrk, gen_rtx_SYMBOL_REF (Pmode,
+ IDENTIFIER_POINTER (func_name)));
emit_insn (gen_ashrsi3_n (GEN_INT (value), wrk));
- emit_move_insn (operands[0], gen_rtx (REG, SImode, 4));
+ emit_move_insn (operands[0], gen_rtx_REG (SImode, 4));
return 1;
}
if (dead)
{
- rtx reg = gen_rtx (REG, SImode, exact_log2 (dead & -dead));
+ rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead));
/* It would be nice if we could convert the jump into an indirect
jump / far branch right now, and thus exposing all constituent
{
rtx insn, mova;
int num_mova;
- rtx r0_rtx = gen_rtx (REG, Pmode, 0);
- rtx r0_inc_rtx = gen_rtx (POST_INC, Pmode, r0_rtx);
+ rtx r0_rtx = gen_rtx_REG (Pmode, 0);
+ rtx r0_inc_rtx = gen_rtx_POST_INC (Pmode, r0_rtx);
/* If relaxing, generate pseudo-ops to associate function calls with
the symbols they call. It does no harm to not generate these
or pseudo-op. */
label = gen_label_rtx ();
- REG_NOTES (link) = gen_rtx (EXPR_LIST, REG_LABEL, label,
- REG_NOTES (link));
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_LABEL, label,
- REG_NOTES (insn));
+ REG_NOTES (link) = gen_rtx_EXPR_LIST (REG_LABEL, label,
+ REG_NOTES (link));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_LABEL, label,
+ REG_NOTES (insn));
if (rescan)
{
scan = link;
&& reg_mentioned_p (reg, scan))
|| ((reg2 = sfunc_uses_reg (scan))
&& REGNO (reg2) == REGNO (reg))))
- REG_NOTES (scan) = gen_rtx (EXPR_LIST, REG_LABEL,
- label, REG_NOTES (scan));
+ REG_NOTES (scan)
+ = gen_rtx_EXPR_LIST (REG_LABEL, label, REG_NOTES (scan));
}
while (scan != dies);
}
offset += SUBREG_WORD (dst);
dst = SUBREG_REG (dst);
}
- dst = gen_rtx (REG, HImode, REGNO (dst) + offset);
+ dst = gen_rtx_REG (HImode, REGNO (dst) + offset);
}
if (GET_CODE (dst) == REG
else
{
lab = add_constant (src, mode, 0);
- newsrc = gen_rtx (MEM, mode,
- gen_rtx (LABEL_REF, VOIDmode, lab));
+ newsrc = gen_rtx_MEM (mode,
+ gen_rtx_LABEL_REF (VOIDmode, lab));
}
RTX_UNCHANGING_P (newsrc) = 1;
- *patp = gen_rtx (SET, VOIDmode, dst, newsrc);
+ *patp = gen_rtx_SET (VOIDmode, dst, newsrc);
INSN_CODE (scan) = -1;
}
}
to handle this case, so just abort when we see it. */
if (temp < 0)
abort ();
- const_reg = gen_rtx (REG, SImode, temp);
+ const_reg = gen_rtx_REG (SImode, temp);
/* If SIZE is negative, subtract the positive value.
This sometimes allows a constant pool entry to be shared
{
if ((rn - FIRST_FP_REG) & 1 && rn <= LAST_FP_REG)
return;
- x = gen_push_4 (gen_rtx (REG, DFmode, rn));
+ x = gen_push_4 (gen_rtx_REG (DFmode, rn));
}
else if (TARGET_SH3E && rn >= FIRST_FP_REG && rn <= LAST_FP_REG)
- x = gen_push_e (gen_rtx (REG, SFmode, rn));
+ x = gen_push_e (gen_rtx_REG (SFmode, rn));
else
- x = gen_push (gen_rtx (REG, SImode, rn));
+ x = gen_push (gen_rtx_REG (SImode, rn));
x = emit_insn (x);
- REG_NOTES (x) = gen_rtx (EXPR_LIST, REG_INC,
- gen_rtx(REG, SImode, STACK_POINTER_REGNUM), 0);
+ REG_NOTES (x)
+ = gen_rtx_EXPR_LIST (REG_INC,
+ gen_rtx_REG (SImode, STACK_POINTER_REGNUM), 0);
}
/* Output RTL to pop register RN from the stack. */
{
if ((rn - FIRST_FP_REG) & 1 && rn <= LAST_FP_REG)
return;
- x = gen_pop_4 (gen_rtx (REG, DFmode, rn));
+ x = gen_pop_4 (gen_rtx_REG (DFmode, rn));
}
else if (TARGET_SH3E && rn >= FIRST_FP_REG && rn <= LAST_FP_REG)
- x = gen_pop_e (gen_rtx (REG, SFmode, rn));
+ x = gen_pop_e (gen_rtx_REG (SFmode, rn));
else
- x = gen_pop (gen_rtx (REG, SImode, rn));
+ x = gen_pop (gen_rtx_REG (SImode, rn));
x = emit_insn (x);
- REG_NOTES (x) = gen_rtx (EXPR_LIST, REG_INC,
- gen_rtx(REG, SImode, STACK_POINTER_REGNUM), 0);
+ REG_NOTES (x)
+ = gen_rtx_EXPR_LIST (REG_INC,
+ gen_rtx_REG (SImode, STACK_POINTER_REGNUM), 0);
}
/* Generate code to push the regs specified in the mask. */
named args need not be saved. */
if (n_intregs > 0)
move_block_from_reg (BASE_ARG_REG (SImode) + first_intreg,
- gen_rtx (MEM, BLKmode,
- plus_constant (XEXP (regbuf, 0),
- n_floatregs * UNITS_PER_WORD)),
+ gen_rtx_MEM (BLKmode,
+ plus_constant (XEXP (regbuf, 0),
+ (n_floatregs
+ * UNITS_PER_WORD))),
n_intregs, n_intregs * UNITS_PER_WORD);
/* Save float args.
for (regno = NPARM_REGS (SFmode) - 1; regno >= first_floatreg; regno--)
{
emit_insn (gen_addsi3 (fpregs, fpregs, GEN_INT (- UNITS_PER_WORD)));
- emit_move_insn (gen_rtx (MEM, SFmode, fpregs),
- gen_rtx (REG, SFmode, BASE_ARG_REG (SFmode) + regno));
+ emit_move_insn (gen_rtx_MEM (SFmode, fpregs),
+ gen_rtx_REG (SFmode, BASE_ARG_REG (SFmode) + regno));
}
/* Return the address of the regbuf. */
if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
return 0;
- sp_switch = gen_rtx (SYMBOL_REF, VOIDmode,
- TREE_STRING_POINTER (TREE_VALUE (args)));
+ sp_switch = gen_rtx_SYMBOL_REF (VOIDmode,
+ TREE_STRING_POINTER (TREE_VALUE (args)));
return 1;
}
/* Definitions of target machine for GNU compiler for Hitachi Super-H.
- Copyright (C) 1993-1998 Free Software Foundation, Inc.
+ Copyright (C) 1993-1998, 1999 Free Software Foundation, Inc.
Contributed by Steve Chamberlain (sac@cygnus.com).
Improved by Jim Wilson (wilson@cygnus.com).
/* 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))
+ gen_rtx_REG ((MODE), BASE_RETURN_VALUE_REG (MODE));
/* 1 if N is a possible register number for a function value. */
#define FUNCTION_VALUE_REGNO_P(REGNO) \
((PASS_IN_REG_P ((CUM), (MODE), (TYPE)) \
&& ((NAMED) \
|| (! TARGET_HITACHI && (TARGET_SH3E || ! current_function_varargs)))) \
- ? gen_rtx (REG, (MODE), \
- ((BASE_ARG_REG (MODE) + ROUND_REG ((CUM), (MODE))) \
- ^ ((MODE) == SFmode && TARGET_SH4 \
- && TARGET_LITTLE_ENDIAN != 0))) \
+ ? gen_rtx_REG ((MODE), \
+ ((BASE_ARG_REG (MODE) + ROUND_REG ((CUM), (MODE))) \
+ ^ ((MODE) == SFmode && TARGET_SH4 \
+ && TARGET_LITTLE_ENDIAN != 0))) \
: 0)
#define PRETEND_OUTGOING_VARARGS_NAMED (! TARGET_HITACHI)
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, (TRAMP)), \
+ emit_move_insn (gen_rtx_MEM (SImode, (TRAMP)), \
GEN_INT (TARGET_LITTLE_ENDIAN ? 0xd301dd02 : 0xdd02d301));\
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 4)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 4)), \
GEN_INT (TARGET_LITTLE_ENDIAN ? 0x00094d2b : 0x4d2b0009));\
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 8)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 8)), \
(CXT)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 12)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 12)), \
(FNADDR)); \
if (TARGET_HARVARD) \
emit_insn (gen_ic_invalidate_line (TRAMP)); \
#define RETURN_ADDR_RTX(COUNT, FRAME) \
(((COUNT) == 0) \
- ? gen_rtx (MEM, Pmode, gen_rtx (REG, Pmode, RETURN_ADDRESS_POINTER_REGNUM)) \
+ ? gen_rtx_MEM (Pmode, gen_rtx_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM)) \
: (rtx) 0)
\f
/* Generate necessary RTL for __builtin_saveregs(). */
GEN_INT (offset_base), NULL_RTX, 0, \
OPTAB_LIB_WIDEN); \
\
- (X) = gen_rtx (PLUS, Pmode, sum, GEN_INT (offset - offset_base)); \
+ (X) = gen_rtx_PLUS (Pmode, sum, GEN_INT (offset - offset_base)); \
goto WIN; \
} \
} \
"
{
rtx high0, high2, low0 = gen_lowpart (SImode, operands[0]);
- high0 = gen_rtx (REG, SImode,
- true_regnum (operands[0]) + (TARGET_LITTLE_ENDIAN ? 1 : 0));
- high2 = gen_rtx (REG, SImode,
- true_regnum (operands[2]) + (TARGET_LITTLE_ENDIAN ? 1 : 0));
+ high0 = gen_rtx_REG (SImode,
+ true_regnum (operands[0])
+ + (TARGET_LITTLE_ENDIAN ? 1 : 0));
+ high2 = gen_rtx_REG (SImode,
+ true_regnum (operands[2])
+ + (TARGET_LITTLE_ENDIAN ? 1 : 0));
emit_insn (gen_clrt ());
emit_insn (gen_addc (low0, low0, gen_lowpart (SImode, operands[2])));
emit_insn (gen_addc1 (high0, high0, high2));
"
{
rtx high0, high2, low0 = gen_lowpart (SImode, operands[0]);
- high0 = gen_rtx (REG, SImode,
- true_regnum (operands[0]) + (TARGET_LITTLE_ENDIAN ? 1 : 0));
- high2 = gen_rtx (REG, SImode,
- true_regnum (operands[2]) + (TARGET_LITTLE_ENDIAN ? 1 : 0));
+ high0 = gen_rtx_REG (SImode,
+ true_regnum (operands[0])
+ + (TARGET_LITTLE_ENDIAN ? 1 : 0));
+ high2 = gen_rtx_REG (SImode,
+ true_regnum (operands[2])
+ + (TARGET_LITTLE_ENDIAN ? 1 : 0));
emit_insn (gen_clrt ());
emit_insn (gen_subc (low0, low0, gen_lowpart (SImode, operands[2])));
emit_insn (gen_subc1 (high0, high0, high2));
emit_insn (gen_mulsidi3_i (operands[1], operands[2]));
- emit_insn (gen_rtx (CLOBBER, VOIDmode, operands[0]));
- emit_move_insn (low_dst, gen_rtx (REG, SImode, 21));
- emit_move_insn (high_dst, gen_rtx (REG, SImode, 20));
+ emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
+ emit_move_insn (low_dst, gen_rtx_REG (SImode, 21));
+ emit_move_insn (high_dst, gen_rtx_REG (SImode, 20));
DONE;
}
}")
emit_insn (gen_umulsidi3_i (operands[1], operands[2]));
- emit_insn (gen_rtx (CLOBBER, VOIDmode, operands[0]));
- emit_move_insn (low_dst, gen_rtx (REG, SImode, 21));
- emit_move_insn (high_dst, gen_rtx (REG, SImode, 20));
+ emit_insn (gen_rtx_CLOBBER (VOIDmode, operands[0]));
+ emit_move_insn (low_dst, gen_rtx_REG (SImode, 21));
+ emit_move_insn (high_dst, gen_rtx_REG (SImode, 20));
DONE;
}
}")
emit_move_insn (operands[2], const_int);
emit_move_insn (operands[0],
change_address (operands[1], VOIDmode,
- gen_rtx (PLUS, SImode, reg, operands[2])));
+ gen_rtx_PLUS (SImode, reg, operands[2])));
DONE;
}")
FAIL;
emit_move_insn (operands[2], const_int);
emit_move_insn (change_address (operands[1], VOIDmode,
- gen_rtx (PLUS, SImode, reg, operands[2])),
+ gen_rtx_PLUS (SImode, reg, operands[2])),
operands[0]);
DONE;
}")
{
if (TARGET_IEEE)
{
- rtx t_reg = gen_rtx (REG, SImode, T_REG);
+ rtx t_reg = gen_rtx_REG (SImode, T_REG);
rtx lab = gen_label_rtx ();
prepare_scc_operands (EQ);
emit_jump_insn (gen_branch_true (lab));
addr_target = copy_addr_to_reg (plus_constant (orig_address, size - 1));
operands[0] = change_address (operands[0], QImode, addr_target);
- emit_insn (gen_movqi (operands[0], gen_rtx (SUBREG, QImode, shift_reg, 0)));
+ emit_insn (gen_movqi (operands[0], gen_rtx_SUBREG (QImode, shift_reg, 0)));
while (size -= 1)
{
emit_insn (gen_lshrsi3_k (shift_reg, shift_reg, GEN_INT (8)));
emit_insn (gen_addsi3 (addr_target, addr_target, GEN_INT (-1)));
emit_insn (gen_movqi (operands[0],
- gen_rtx (SUBREG, QImode, shift_reg, 0)));
+ gen_rtx_SUBREG (QImode, shift_reg, 0)));
}
DONE;
#define STRUCT_VALUE \
(TARGET_ARCH64 \
? 0 \
- : gen_rtx_MEM (Pmode, \
- gen_rtx_PLUS (Pmode, stack_pointer_rtx, \
- GEN_INT (STRUCT_VALUE_OFFSET))))
+ : gen_rtx_MEM (Pmode, plus_constant (stack_pointer_rtx, \
+ STRUCT_VALUE_OFFSET)))
+
#define STRUCT_VALUE_INCOMING \
- (TARGET_ARCH64 \
- ? 0 \
- : gen_rtx_MEM (Pmode, \
- gen_rtx_PLUS (Pmode, frame_pointer_rtx, \
- GEN_INT (STRUCT_VALUE_OFFSET))))
+ (TARGET_ARCH64 \
+ ? 0 \
+ : gen_rtx_MEM (Pmode, plus_constant (frame_pointer_rtx, \
+ STRUCT_VALUE_OFFSET)))
\f
/* Define the classes of registers for register constraints in the
machine description. Also define ranges of constants.
#define SECONDARY_MEMORY_NEEDED_RTX(MODE) \
(get_frame_size () == 0 \
? assign_stack_local (MODE, GET_MODE_SIZE (MODE), 0) \
- : gen_rtx_MEM (MODE, gen_rtx_PLUS (Pmode, frame_pointer_rtx, \
- GEN_INT (STARTING_FRAME_OFFSET))))
+ : gen_rtx_MEM (MODE, plus_constant (frame_pointer_rtx, \
+ STARTING_FRAME_OFFSET)))
/* Get_secondary_mem widens its argument to BITS_PER_WORD which loses on v9
because the movsi and movsf patterns don't handle r/f moves.
return an rtx for the address of the word in the frame
that holds the dynamic chain--the previous frame's address.
??? -mflat support? */
-#define DYNAMIC_CHAIN_ADDRESS(frame) \
- gen_rtx_PLUS (Pmode, frame, GEN_INT (14 * UNITS_PER_WORD))
+#define DYNAMIC_CHAIN_ADDRESS(frame) plus_constant (frame, 14 * UNITS_PER_WORD)
/* The return address isn't on the stack, it is in a register, so we can't
access it from the current frame pointer. We can access it from the
((count == -1) \
? gen_rtx_REG (Pmode, 31) \
: gen_rtx_MEM (Pmode, \
- memory_address (Pmode, plus_constant (frame, 15 * UNITS_PER_WORD))))
+ memory_address (Pmode, plus_constant (frame, \
+ 15 * UNITS_PER_WORD))))
/* Before the prologue, the return address is %o7 + 8. OK, sometimes it's
+12, but always using +8 is close enough for frame unwind purposes.
Actually, just using %o7 is close enough for unwinding, but %o7+8
is something you can return to. */
#define INCOMING_RETURN_ADDR_RTX \
- gen_rtx_PLUS (word_mode, gen_rtx_REG (word_mode, 15), GEN_INT (8))
+ plus_constant (gen_rtx_REG (word_mode, 15), 8)
/* The offset from the incoming value of %sp to the top of the stack frame
for the current function. On sparc64, we have to account for the stack
{ rtx sparc_x = (X); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), NULL_RTX)); \
+ force_operand (XEXP (X, 0), NULL_RTX)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), NULL_RTX)); \
+ force_operand (XEXP (X, 1), NULL_RTX)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == PLUS) \
(X) = gen_rtx_PLUS (Pmode, force_operand (XEXP (X, 0), NULL_RTX),\
- XEXP (X, 1)); \
+ XEXP (X, 1)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == PLUS) \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), NULL_RTX)); \
+ force_operand (XEXP (X, 1), NULL_RTX)); \
if (sparc_x != (X) && memory_address_p (MODE, X)) \
goto WIN; \
if (flag_pic) (X) = legitimize_pic_address (X, MODE, 0); \
else if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 0), \
- copy_to_mode_reg (Pmode, XEXP (X, 1))); \
+ copy_to_mode_reg (Pmode, XEXP (X, 1))); \
else if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
(X) = gen_rtx_PLUS (Pmode, XEXP (X, 1), \
- copy_to_mode_reg (Pmode, XEXP (X, 0))); \
+ copy_to_mode_reg (Pmode, XEXP (X, 0))); \
else if (GET_CODE (X) == SYMBOL_REF || GET_CODE (X) == CONST \
|| GET_CODE (X) == LABEL_REF) \
(X) = copy_to_suggested_reg (X, NULL_RTX, Pmode); \
(define_insn "*sethi_di_medlow_embmedany_pic"
[(set (match_operand:DI 0 "register_operand" "=r")
- (high:DI (match_operand:DI 1 "sp64_medium_pic_operand" "")))]
+ (high:DI (match_operand:DI 1 "sp64_medium_pic_operand" "")))
+ ;; The clobber is here because emit_move_sequence assumes the worst case.
+ (clobber (reg:DI 1))]
"(TARGET_CM_MEDLOW || TARGET_CM_EMBMEDANY) && check_pic (1)"
"sethi\\t%%hi(%a1), %0"
[(set_attr "type" "move")
(define_insn "*sethi_di_medlow"
[(set (match_operand:DI 0 "register_operand" "=r")
(high:DI (match_operand:DI 1 "symbolic_operand" "")))]
+ ;; The clobber is here because emit_move_sequence assumes the worst case.
+ (clobber (reg:DI 1))]
"TARGET_CM_MEDLOW && check_pic (1)"
"sethi\\t%%hi(%a1), %0"
[(set_attr "type" "move")
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_16));
emit_insn (gen_lshrsi3 (operand0, temp, shift_16));
DONE;
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1,
- op1_subword),
+ emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1, op1_subword),
shift_48));
emit_insn (gen_lshrdi3 (operand0, temp, shift_48));
DONE;
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_16));
emit_insn (gen_ashrsi3 (operand0, temp, shift_16));
DONE;
op0_subword = SUBREG_WORD (operand0);
operand0 = XEXP (operand0, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_24));
if (GET_MODE (operand0) != SImode)
operand0 = gen_rtx_SUBREG (SImode, operand0, op0_subword);
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1,
- op1_subword),
+ emit_insn (gen_ashlsi3 (temp, gen_rtx_SUBREG (SImode, operand1, op1_subword),
shift_24));
emit_insn (gen_ashrsi3 (operand0, temp, shift_24));
DONE;
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1,
- op1_subword),
+ emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1, op1_subword),
shift_56));
emit_insn (gen_ashrdi3 (operand0, temp, shift_56));
DONE;
operand1 = XEXP (operand1, 0);
}
- emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1,
- op1_subword),
+ emit_insn (gen_ashldi3 (temp, gen_rtx_SUBREG (DImode, operand1, op1_subword),
shift_48));
emit_insn (gen_ashrdi3 (operand0, temp, shift_48));
DONE;
{
if (! TARGET_ARCH64)
{
- emit_insn (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,
- gen_rtx_SET (VOIDmode, operand0,
- gen_rtx_NEG (DImode, operand1)),
- gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_REG (CCmode, SPARC_ICC_REG)))));
+ emit_insn (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2,
+ gen_rtx_SET (VOIDmode, operand0,
+ gen_rtx_NEG (DImode, operand1)),
+ gen_rtx_CLOBBER (VOIDmode,
+ gen_rtx_REG (CCmode,
+ SPARC_ICC_REG)))));
DONE;
}
}")
if (! TARGET_ARCH64 && INTVAL (operands[3]) != 0)
emit_jump_insn
- (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (3,
- gen_rtx_SET (VOIDmode, pc_rtx,
- XEXP (operands[0], 0)),
- GEN_INT (INTVAL (operands[3]) & 0xfff),
- gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_REG (Pmode, 15)))));
+ (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (3,
+ gen_rtx_SET (VOIDmode, pc_rtx, XEXP (operands[0], 0)),
+ GEN_INT (INTVAL (operands[3]) & 0xfff),
+ gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
else
emit_jump_insn
- (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2,
- gen_rtx_SET (VOIDmode, pc_rtx,
- XEXP (operands[0], 0)),
- gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_REG (Pmode, 15)))));
+ (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2,
+ gen_rtx_SET (VOIDmode, pc_rtx, XEXP (operands[0], 0)),
+ gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
goto finish_call;
}
if (! TARGET_ARCH64 && INTVAL (operands[3]) != 0)
emit_call_insn
- (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (3, gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx),
- GEN_INT (INTVAL (operands[3]) & 0xfff),
- gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_REG (Pmode, 15)))));
+ (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (3, gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx),
+ GEN_INT (INTVAL (operands[3]) & 0xfff),
+ gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
else
emit_call_insn
- (gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (2, gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx),
- gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_REG (Pmode, 15)))));
+ (gen_rtx_PARALLEL
+ (VOIDmode,
+ gen_rtvec (2, gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx),
+ gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)))));
finish_call:
#if 0
vec = gen_rtvec (2,
gen_rtx_SET (VOIDmode, operands[0],
- gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx)),
+ gen_rtx_CALL (VOIDmode, fn_rtx, nregs_rtx)),
gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 15)));
emit_call_insn (gen_rtx_PARALLEL (VOIDmode, vec));
; [(set_attr "type" "multi")
; (set_attr "length" "4")])
+
\f
;; Peepholes go at the end.
/* Subroutines for insn-output.c for SPUR. Adapted from routines for
the Motorola 68000 family.
- Copyright (C) 1988, 1991, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1988, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
operands in OPERANDS to be suitable for the low-numbered word. */
if (optype0 == REGOP)
- latehalf[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
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]) + 1);
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else if (optype1 == OFFSOP)
latehalf[1] = adj_offsettable_operand (operands[1], 4);
else if (optype1 == CNSTOP)
{
rtx xoperands[2];
int offset = - get_frame_size () - 8;
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
xoperands[0] = GEN_INT (offset + 4);
output_asm_insn ("st_32 %1,r25,%0", xoperands);
xoperands[1] = operands[1];
output_asm_insn ("st_dbl %1,r25,%0", xoperands);
xoperands[1] = operands[0];
output_asm_insn ("ld_32 %1,r25,%0\n\tnop", xoperands);
- xoperands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
xoperands[0] = GEN_INT (offset + 4);
output_asm_insn ("ld_32 %1,r25,%0\n\tnop", xoperands);
return "";
/* Definitions of target machine for GNU compiler, for SPUR chip.
- Copyright (C) 1988, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1988, 1995, 1996, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* On SPUR the value is found in the second "output" register. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 27)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 27)
/* But the called function leaves it in the second "input" register. */
#define FUNCTION_OUTGOING_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 11)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 11)
/* 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, 27)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 27)
/* 1 if N is a possible register number for a function value
as seen by the caller.
+ ((MODE) == BLKmode \
? (int_size_in_bytes (TYPE) + 3) / 4 \
: (GET_MODE_SIZE (MODE) + 3) / 4)) \
- ? gen_rtx (REG, (MODE), 27 + (CUM)) \
+ ? gen_rtx_REG ((MODE), 27 + (CUM)) \
: 0)
/* Define where a function finds its arguments.
+ ((MODE) == BLKmode \
? (int_size_in_bytes (TYPE) + 3) / 4 \
: (GET_MODE_SIZE (MODE) + 3) / 4)) \
- ? gen_rtx (REG, (MODE), 11 + (CUM)) \
+ ? gen_rtx_REG ((MODE), 11 + (CUM)) \
: 0)
/* For an arg passed partly in registers and partly in memory,
#define LEGITIMIZE_ADDRESS(X,OLDX,MODE,WIN) \
{ if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 1))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- copy_to_mode_reg (SImode, XEXP (X, 1))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ copy_to_mode_reg (SImode, XEXP (X, 1))); \
if (GET_CODE (X) == PLUS && CONSTANT_ADDRESS_P (XEXP (X, 0))) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- copy_to_mode_reg (SImode, XEXP (X, 0))); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ copy_to_mode_reg (SImode, XEXP (X, 0))); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 0)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 1), \
- force_operand (XEXP (X, 0), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 1), \
+ force_operand (XEXP (X, 0), 0)); \
if (GET_CODE (X) == PLUS && GET_CODE (XEXP (X, 1)) == MULT) \
- (X) = gen_rtx (PLUS, SImode, XEXP (X, 0), \
- force_operand (XEXP (X, 1), 0)); \
+ (X) = gen_rtx_PLUS (SImode, XEXP (X, 0), \
+ force_operand (XEXP (X, 1), 0)); \
if (memory_address_p (MODE, X)) \
goto WIN; }
;;- Machine description for SPUR chip for GNU C compiler
-;; Copyright (C) 1988 Free Software Foundation, Inc.
+;; Copyright (C) 1988, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
rtx addr = force_reg (SImode, XEXP (operands[1], 0));
rtx subreg;
- emit_move_insn (tem, gen_rtx (MEM, SImode, addr));
+ emit_move_insn (tem, gen_rtx_MEM (SImode, addr));
if (GET_CODE (operands[0]) == SUBREG)
- subreg = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[0]),
- SUBREG_WORD (operands[0]));
+ subreg = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[0]),
+ SUBREG_WORD (operands[0]));
else
- subreg = gen_rtx (SUBREG, SImode, operands[0], 0);
+ subreg = gen_rtx_SUBREG (SImode, operands[0], 0);
- emit_insn (gen_rtx (SET, VOIDmode, subreg,
- gen_rtx (ZERO_EXTRACT, SImode, tem,
- GEN_INT (8),
- addr)));
+ emit_insn (gen_rtx_SET (VOIDmode, subreg,
+ gen_rtx_ZERO_EXTRACT (SImode, tem,
+ GEN_INT (8),
+ addr)));
}
else if (GET_CODE (operands[0]) == MEM)
{
rtx addr = force_reg (SImode, XEXP (operands[0], 0));
rtx subreg;
- emit_move_insn (tem, gen_rtx (MEM, SImode, addr));
+ emit_move_insn (tem, gen_rtx_MEM (SImode, addr));
if (! CONSTANT_ADDRESS_P (operands[1]))
{
if (GET_CODE (operands[1]) == SUBREG)
- subreg = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ subreg = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- subreg = gen_rtx (SUBREG, SImode, operands[1], 0);
+ subreg = gen_rtx_SUBREG (SImode, operands[1], 0);
}
- emit_insn (gen_rtx (SET, VOIDmode,
- gen_rtx (ZERO_EXTRACT, SImode, tem,
- GEN_INT (8),
- addr),
- subreg));
- emit_move_insn (gen_rtx (MEM, SImode, addr), tem);
+ emit_insn (gen_rtx_SET (VOIDmode,
+ gen_rtx_ZERO_EXTRACT (SImode, tem,
+ GEN_INT (8),
+ addr),
+ subreg));
+ emit_move_insn (gen_rtx_MEM (SImode, addr), tem);
}
else
{
- emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
}
DONE;
}")
"
{
if (GET_CODE (operands[1]) == SUBREG)
- operands[5] = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ operands[5] = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- operands[5] = gen_rtx (SUBREG, SImode, operands[1], 0);
+ operands[5] = gen_rtx_SUBREG (SImode, operands[1], 0);
}")
;; Like storehi but operands[1] is a CONST_INT.
(match_dup 2))]
""
" operands[5] = GEN_INT (INTVAL (operands[1]) & 255);
- operands[6] = GEN_INT ((INTVAL (operands[1]) >> 8) & 255);
+ operands[6] = GEN_INT (INTVAL (operands[1]) >> 8) & 255);
")
\f
;; Main entry for generating insns to move halfwords.
gen_reg_rtx (SImode), gen_reg_rtx (SImode),
gen_reg_rtx (QImode)));
/* Tell cse what value the loadhi produces, so it detect duplicates. */
- REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, operands[1],
- REG_NOTES (insn));
+ REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, operands[1],
+ REG_NOTES (insn));
}
else if (GET_CODE (operands[0]) == MEM)
{
}
}
else
- emit_insn (gen_rtx (SET, VOIDmode, operands[0], operands[1]));
+ emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
DONE;
}")
\f
return output_fp_move_double (operands);
if (operands[1] == CONST0_RTX (DFmode) && GET_CODE (operands[0]) == REG)
{
- operands[1] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ operands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
return \"add_nt %0,r0,$0\;add_nt %1,r0,$0\";
}
if (operands[1] == CONST0_RTX (DFmode) && GET_CODE (operands[0]) == MEM)
"
{
if (GET_CODE (operands[1]) == SUBREG)
- operands[1] = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ operands[1] = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- operands[1] = gen_rtx (SUBREG, SImode, operands[1], 0);
+ operands[1] = gen_rtx_SUBREG (SImode, operands[1], 0);
operands[2] = force_reg (SImode, GEN_INT (65535));
}")
"
{
if (GET_CODE (operands[1]) == SUBREG)
- operands[1] = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ operands[1] = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- operands[1] = gen_rtx (SUBREG, SImode, operands[1], 0);
+ operands[1] = gen_rtx_SUBREG (SImode, operands[1], 0);
operands[2] = gen_reg_rtx (SImode);
operands[3] = gen_reg_rtx (SImode);
"
{
if (GET_CODE (operands[1]) == SUBREG)
- operands[1] = gen_rtx (SUBREG, HImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ operands[1] = gen_rtx_SUBREG (HImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- operands[1] = gen_rtx (SUBREG, HImode, operands[1], 0);
+ operands[1] = gen_rtx_SUBREG (HImode, operands[1], 0);
operands[2] = gen_reg_rtx (HImode);
operands[3] = gen_reg_rtx (HImode);
"
{
if (GET_CODE (operands[1]) == SUBREG)
- operands[1] = gen_rtx (SUBREG, SImode, SUBREG_REG (operands[1]),
- SUBREG_WORD (operands[1]));
+ operands[1] = gen_rtx_SUBREG (SImode, SUBREG_REG (operands[1]),
+ SUBREG_WORD (operands[1]));
else
- operands[1] = gen_rtx (SUBREG, SImode, operands[1], 0);
+ operands[1] = gen_rtx_SUBREG (SImode, operands[1], 0);
operands[2] = gen_reg_rtx (SImode);
operands[3] = gen_reg_rtx (SImode);
/* Subroutines for insn-output.c for Tahoe.
- Copyright (C) 1989, 1991, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1989, 1991, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Contributed by the University of Buffalo (Devon Bowen, Dale Wiles
+ and Kevin Zachmann.
+ Changes for HCX by Piet van Oostrum, University of Utrecht,
+ The Netherlands (piet@cs.ruu.nl)
+ Speed tweaks by Michael Tiemann (tiemann@lurch.stanford.edu).
This file is part of GNU CC.
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
#include "output.h"
#include "insn-attr.h"
-/*
- * File: output-tahoe.c
- *
- * Original port made at the University of Buffalo by Devon Bowen,
- * Dale Wiles and Kevin Zachmann.
- *
- * Changes for HCX by Piet van Oostrum,
- * University of Utrecht, The Netherlands (piet@cs.ruu.nl)
- *
- * Speed tweaks by Michael Tiemann (tiemann@lurch.stanford.edu).
- *
- * Mail bugs reports or fixes to: gcc@cs.buffalo.edu
- */
-
-
/* On tahoe, you have to go to memory to convert a register
from sub-word to word. */
|| (GET_CODE (op) == SUBREG
&& GET_CODE (SUBREG_REG (op)) == REG))
&& tahoe_reg_conversion_loc == 0)
- tahoe_reg_conversion_loc = assign_stack_local (SImode, GET_MODE_SIZE (SImode));
+ tahoe_reg_conversion_loc
+ = assign_stack_local (SImode, GET_MODE_SIZE (SImode));
+
return general_operand (op, mode);
}
-/* most of the print_operand_address function was taken from the vax */
-/* since the modes are basically the same. I had to add a special case, */
-/* though, for symbol references with offsets. */
+/* Most of the print_operand_address function was taken from the VAX since
+ the modes are basically the same. I had to add a special case, though, for
+ symbol references with offsets. */
print_operand_address (file, addr)
FILE *file;
break;
case PLUS:
- reg1 = 0; reg2 = 0;
- ireg = 0; breg = 0;
+ reg1 = 0, reg2 = 0;
+ ireg = 0, breg = 0;
offset = 0;
if (CONSTANT_ADDRESS_P (XEXP (addr, 0))
if (CONSTANT_ADDRESS_P (XEXP (addr, 0))
|| GET_CODE (XEXP (addr, 0)) == MEM)
- {
- offset = XEXP (addr, 0);
- addr = XEXP (addr, 1);
- }
+ 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);
- }
+ 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);
- }
+ reg1 = XEXP (addr, 0), addr = XEXP (addr, 1);
else if (GET_CODE (XEXP (addr, 1)) == MULT)
- {
- reg1 = XEXP (addr, 1);
- addr = XEXP (addr, 0);
- }
+ reg1 = XEXP (addr, 1), addr = XEXP (addr, 0);
else if (GET_CODE (XEXP (addr, 0)) == REG)
- {
- reg1 = XEXP (addr, 0);
- addr = XEXP (addr, 1);
- }
+ reg1 = XEXP (addr, 0), addr = XEXP (addr, 1);
else if (GET_CODE (XEXP (addr, 1)) == REG)
- {
- reg1 = XEXP (addr, 1);
- addr = XEXP (addr, 0);
- }
+ reg1 = XEXP (addr, 1), addr = XEXP (addr, 0);
+
if (GET_CODE (addr) == REG || GET_CODE (addr) == MULT)
{
if (reg1 == 0)
reg2 = addr;
addr = 0;
}
+
if (offset != 0)
{
- if (addr != 0) abort ();
+ if (addr != 0)
+ abort ();
+
addr = offset;
}
+
if (reg1 != 0 && GET_CODE (reg1) == MULT)
- {
- breg = reg2;
- ireg = reg1;
- }
+ breg = reg2, ireg = reg1;
else if (reg2 != 0 && GET_CODE (reg2) == MULT)
- {
- breg = reg1;
- ireg = reg2;
- }
+ breg = reg1, ireg = reg2;
else if (reg2 != 0 || GET_CODE (addr) == MEM)
- {
- breg = reg2;
- ireg = reg1;
- }
+ breg = reg2, ireg = reg1;
else
- {
- breg = reg1;
- ireg = reg2;
- }
+ breg = reg1, ireg = reg2;
+
if (addr != 0)
output_address (offset);
+
if (breg != 0)
{
if (GET_CODE (breg) != REG)
abort ();
fprintf (file, "(%s)", reg_name[REGNO (breg)]);
}
+
if (ireg != 0)
{
if (GET_CODE (ireg) == MULT)
}
}
-/* Do a quick check and find out what the best way to do the */
-/* mini-move is. Could be a push or a move..... */
+/* Do a quick check and find out what the best way to do the mini-move is.
+ Could be a push or a move..... */
static char *
singlemove_string (operands)
{
if (operands[1] == const0_rtx)
return "clrl %0";
+
if (push_operand (operands[0], SImode))
return "pushl %1";
+
return "movl %1,%0";
}
-/* given the rtx for an address, return true if the given */
-/* register number is used in the address somewhere. */
+/* Given the rtx for an address, return true if the given register number is
+ used in the address somewhere. */
-regisused(addr,regnum)
-rtx addr;
-int regnum;
+int
+regisused (addr, regnum)
+ rtx addr;
+ int regnum;
{
- if (GET_CODE(addr) == REG)
- if (REGNO(addr) == regnum)
- return (1);
- else
- return (0);
+ if (GET_CODE (addr) == REG)
+ return REGNO (addr) == regnum;
- if (GET_CODE(addr) == MEM)
- return regisused(XEXP(addr,0),regnum);
+ else if (GET_CODE (addr) == MEM)
+ return regisused (XEXP (addr, 0), regnum);
- if ((GET_CODE(addr) == MULT) || (GET_CODE(addr) == PLUS))
- return ((regisused(XEXP(addr,0),regnum)) ||
- (regisused(XEXP(addr,1),regnum)));
+ else if (GET_CODE (addr) == MULT || GET_CODE (addr) == PLUS)
+ return (regisused (XEXP (addr, 0), regnum)
+ || regisused (XEXP (addr, 1), regnum));
- return 0;
+ return 0;
}
-/* Given some rtx, traverse it and return the register used in a */
-/* index. If no index is found, return 0. */
+/* Given some rtx, traverse it and return the register used in a index. If no
+ index is found, return 0. */
rtx
-index_reg(addr)
-rtx addr;
+index_reg (addr)
+ rtx addr;
{
- rtx temp;
+ rtx temp;
- if (GET_CODE(addr) == MEM)
- return index_reg(XEXP(addr,0));
+ if (GET_CODE (addr) == MEM)
+ return index_reg (XEXP (addr, 0));
- if (GET_CODE(addr) == MULT)
- if (GET_CODE(XEXP(addr,0)) == REG)
- return XEXP(addr,0);
- else
- return XEXP(addr,1);
+ else if (GET_CODE (addr) == MULT)
+ {
+ if (GET_CODE (XEXP (addr, 0)) == REG)
+ return XEXP (addr, 0);
+ else
+ return XEXP (addr, 1);
+ }
- if (GET_CODE(addr) == PLUS)
- if (temp = index_reg(XEXP(addr,0)))
- return temp;
- else
- return index_reg(XEXP(addr,1));
+ else if (GET_CODE (addr) == PLUS)
+ {
+ if ((temp = index_reg (XEXP (addr, 0))) != 0)
+ return temp;
+ else
+ return index_reg (XEXP (addr, 1));
+ }
- return 0;
+ return 0;
}
-/* simulate the move double by generating two movl's. You have */
-/* to be careful about mixing modes here. */
+/* Simulate the move double by generating two movl's. We need to be careful
+ about mixing modes here. */
char *
output_move_double (operands)
if (REG_P (operands[0]))
optype0 = REGOP;
- else if ((GET_CODE(operands[0])==MEM) && (shftreg0=index_reg(operands[0])))
+ else if (GET_CODE (operands[0]) == MEM
+ && (shftreg0 = index_reg (operands[0])) != 0)
optype0 = INDOP;
else if (offsettable_memref_p (operands[0]))
optype0 = OFFSOP;
- else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC) {
- optype0 = PUSHOP;
- dohighfirst++;
- } else if (GET_CODE (operands[0]) == MEM)
+ else if (GET_CODE (XEXP (operands[0], 0)) == PRE_DEC)
+ {
+ optype0 = PUSHOP;
+ dohighfirst++;
+ }
+ else if (GET_CODE (operands[0]) == MEM)
optype0 = MEMOP;
else
optype0 = RNDOP;
if (REG_P (operands[1]))
optype1 = REGOP;
- else if ((GET_CODE(operands[1])==MEM) && (shftreg1=index_reg(operands[1])))
+ else if (GET_CODE (operands[1]) == MEM
+ && (shftreg1 = index_reg (operands[1])) !+ 0)
optype1 = INDOP;
else if (offsettable_memref_p (operands[1]))
optype1 = OFFSOP;
else
optype1 = RNDOP;
- /* set up for the high byte move for operand zero */
+ /* Set up for the high byte move for operand zero */
- switch (optype0) {
-
- /* if it's a register, just use the next highest in the */
- /* high address move. */
-
- case REGOP : latehalf[0] = gen_rtx (REG,SImode,REGNO(operands[0])+1);
- break;
-
- /* for an offsettable address, use the gcc function to */
- /* modify the operand to get an offset of 4 higher for */
- /* the second move. */
-
- case OFFSOP : latehalf[0] = adj_offsettable_operand (operands[0], 4);
- break;
-
- /* if the operand is MEMOP type, it must be a pointer */
- /* to a pointer. So just remember to increase the mem */
- /* location and use the same operand. */
-
- case MEMOP : latehalf[0] = operands[0];
- addreg0 = XEXP(operands[0],0);
- break;
+ switch (optype0)
+ {
+ /* If it's a register, just use the next highest in the high address
+ move. */
+ case REGOP:
+ latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
+ break;
- /* if we're dealing with a push instruction, just leave */
- /* the operand alone since it auto-increments. */
+ /* For an offsettable address, use the GCC function to modify the
+ operand to get an offset of 4 higher for the second move. */
+ case OFFSOP:
+ latehalf[0] = adj_offsettable_operand (operands[0], 4);
+ break;
- case PUSHOP : latehalf[0] = operands[0];
- break;
+ /* If the operand is MEMOP type, it must be a pointer to a pointer.
+ So just remember to increase the mem location and use the same
+ operand. */
+ case MEMOP:
+ latehalf[0] = operands[0];
+ addreg0 = XEXP(operands[0],0);
+ break;
- /* YUCK! Indexed addressing!! If the address is considered */
- /* offsettable, go use the offset in the high part. Otherwise */
- /* find what exactly is being added to the multiplication. If */
- /* it's a mem reference, increment that with the high part */
- /* being unchanged to cause the shift. If it's a reg, do the */
- /* same. If you can't identify it, abort. Remember that the */
- /* shift register was already set during identification. */
+ /* If we're dealing with a push instruction, just leave the operand
+ alone since it auto-increments. */
+ case PUSHOP:
+ latehalf[0] = operands[0];
+ break;
- case INDOP : if (offsettable_memref_p(operands[0])) {
- latehalf[0] = adj_offsettable_operand(operands[0],4);
- break;
- }
+ /* Indexed addressing. If the address is considered offsettable, use
+ the offset in the high part. Otherwise find what exactly is being
+ added to the multiplication. If it's a mem reference, increment that
+ with the high part being unchanged to cause the shift. If it's a
+ reg, do the same. If we can't identify it, abort. Remember that the
+ shift register was already set during identification. */
- latehalf[0] = operands[0];
+ case INDOP:
+ if (offsettable_memref_p (operands[0]))
+ {
+ latehalf[0] = adj_offsettable_operand (operands[0], 4);
+ break;
+ }
- temp0 = XEXP(XEXP(operands[0],0),0);
- if (GET_CODE(temp0) == MULT) {
- temp1 = temp0;
- temp0 = XEXP(XEXP(operands[0],0),1);
- } else {
- temp1 = XEXP(XEXP(operands[0],0),1);
- if (GET_CODE(temp1) != MULT)
- abort();
- }
+ latehalf[0] = operands[0];
- if (GET_CODE(temp0) == MEM)
- addreg0 = temp0;
- else if (GET_CODE(temp0) == REG)
- addreg0 = temp0;
- else
- abort();
+ temp0 = XEXP (XEXP (operands[0], 0), 0);
+ if (GET_CODE(temp0) == MULT)
+ {
+ temp1 = temp0;
+ temp0 = XEXP (XEXP (operands[0], 0), 1);
+ }
+ else
+ {
+ temp1 = XEXP (XEXP (operands[0], 0), 1);
+ if (GET_CODE (temp1) != MULT)
+ abort();
+ }
- break;
+ if (GET_CODE (temp0) == MEM)
+ addreg0 = temp0;
+ else if (GET_CODE (temp0) == REG)
+ addreg0 = temp0;
+ else
+ abort();
- /* if we don't know the operand type, print a friendly */
- /* little error message... 8-) */
+ break;
- case RNDOP :
- default : abort();
+ case RNDOP:
+ default:
+ abort();
}
- /* do the same setup for operand one */
+ /* Do the same setup for operand one. */
- switch (optype1) {
+ switch (optype1)
+ {
+ case REGOP:
+ latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
+ break;
- case REGOP : latehalf[1] = gen_rtx(REG,SImode,REGNO(operands[1])+1);
- break;
+ case OFFSOP:
+ latehalf[1] = adj_offsettable_operand (operands[1], 4);
+ break;
- case OFFSOP : latehalf[1] = adj_offsettable_operand (operands[1], 4);
- break;
+ case MEMOP:
+ latehalf[1] = operands[1];
+ addreg1 = XEXP (operands[1], 0);
+ break;
- case MEMOP : latehalf[1] = operands[1];
- addreg1 = XEXP(operands[1],0);
- break;
+ case POPOP:
+ latehalf[1] = operands[1];
+ break;
- case POPOP : latehalf[1] = operands[1];
- break;
+ case INDOP:
+ if (offsettable_memref_p (operands[1]))
+ {
+ latehalf[1] = adj_offsettable_operand (operands[1], 4);
+ break;
+ }
- case INDOP : if (offsettable_memref_p(operands[1])) {
- latehalf[1] = adj_offsettable_operand(operands[1],4);
- break;
- }
+ latehalf[1] = operands[1];
- latehalf[1] = operands[1];
+ temp0 = XEXP (XEXP (operands[1], 0), 0);
+ if (GET_CODE (temp0) == MULT)
+ {
+ temp1 = temp0;
+ temp0 = XEXP (XEXP (operands[1], 0), 1);
+ }
+ else
+ {
+ temp1 = XEXP (XEXP (operands[1], 0), 1);
+ if (GET_CODE (temp1) != MULT)
+ abort();
+ }
- temp0 = XEXP(XEXP(operands[1],0),0);
- if (GET_CODE(temp0) == MULT) {
- temp1 = temp0;
- temp0 = XEXP(XEXP(operands[1],0),1);
- } else {
- temp1 = XEXP(XEXP(operands[1],0),1);
- if (GET_CODE(temp1) != MULT)
- abort();
- }
+ if (GET_CODE (temp0) == MEM)
+ addreg1 = temp0;
+ else if (GET_CODE (temp0) == REG)
+ addreg1 = temp0;
+ else
+ abort();
+ break;
- if (GET_CODE(temp0) == MEM)
- addreg1 = temp0;
- else if (GET_CODE(temp0) == REG)
- addreg1 = temp0;
- else
- abort();
+ case CNSTOP:
+ if (GET_CODE (operands[1]) == CONST_DOUBLE)
+ split_double (operands[1], &operands[1], &latehalf[1]);
+ else if (CONSTANT_P (operands[1]))
+ latehalf[1] = const0_rtx;
+ else
+ abort ();
+ break;
- break;
+ case RNDOP:
+ default:
+ abort ();
+ }
- case CNSTOP :
- if (GET_CODE (operands[1]) == CONST_DOUBLE)
- split_double (operands[1], &operands[1], &latehalf[1]);
- else if (CONSTANT_P (operands[1]))
- latehalf[1] = const0_rtx;
- else abort ();
- break;
- case RNDOP :
- default : abort();
- }
+ /* Double the register used for shifting in both of the operands but make
+ sure the same register isn't doubled twice! */
+ if (shftreg0 != 0 && shftreg1 != 0 && rtx_equal_p (shftreg0, shftreg1))
+ output_asm_insn ("addl2 %0,%0", &shftreg0);
+ else
+ {
+ if (shftreg0 != 0)
+ output_asm_insn ("addl2 %0,%0", &shftreg0);
+ if (shftreg1!= 0)
+ output_asm_insn ("addl2 %0,%0", &shftreg1);
+ }
- /* double the register used for shifting in both of the operands */
- /* but make sure the same register isn't doubled twice! */
+ /* If the destination is a register and that register is needed in the
+ source addressing mode, swap the order of the moves since we don't want
+ this destroyed til last. If both regs are used, not much we can do, so
+ abort. If these becomes a problem, maybe we can do it on the stack? */
- if (shftreg0 && shftreg1 && (rtx_equal_p(shftreg0,shftreg1)))
- output_asm_insn("addl2 %0,%0", &shftreg0);
- else {
- if (shftreg0)
- output_asm_insn("addl2 %0,%0", &shftreg0);
- if (shftreg1)
- output_asm_insn("addl2 %0,%0", &shftreg1);
- }
+ if (GET_CODE (operands[0]) == REG
+ && regisused (operands[1], REGNO (operands[0])))
+ {
+ if (regisused (latehalf[1], REGNO(latehalf[0])))
+ ;
+ else
+ dohighfirst++;
+ }
+
+ /* If we're pushing, do the high address part first. */
- /* if the destination is a register and that register is needed in */
- /* the source addressing mode, swap the order of the moves since we */
- /* don't want this destroyed til last. If both regs are used, not */
- /* much we can do, so abort. If these becomes a problem, maybe we */
- /* can do it on the stack? */
-
- if (GET_CODE(operands[0])==REG && regisused(operands[1],REGNO(operands[0])))
- if (regisused(latehalf[1],REGNO(latehalf[0])))
- 8;
- else
- dohighfirst++;
-
- /* if we're pushing, do the high address part first. */
-
- if (dohighfirst) {
-
- if (addreg0 && addreg1 && (rtx_equal_p(addreg0,addreg1)))
- output_asm_insn("addl2 $4,%0", &addreg0);
- else {
- if (addreg0)
- output_asm_insn("addl2 $4,%0", &addreg0);
- if (addreg1)
- output_asm_insn("addl2 $4,%0", &addreg1);
+ if (dohighfirst)
+ {
+ if (addreg0 != 0 && addreg1 != 0 && rtx_equal_p (addreg0, addreg1))
+ output_asm_insn ("addl2 $4,%0", &addreg0);
+ else
+ {
+ if (addreg0 != 0)
+ output_asm_insn ("addl2 $4,%0", &addreg0);
+ if (addreg1 != 0)
+ output_asm_insn ("addl2 $4,%0", &addreg1);
}
- output_asm_insn(singlemove_string(latehalf), latehalf);
+ output_asm_insn (singlemove_string (latehalf), latehalf);
- if (addreg0 && addreg1 && (rtx_equal_p(addreg0,addreg1)))
- output_asm_insn("subl2 $4,%0", &addreg0);
- else {
- if (addreg0)
- output_asm_insn("subl2 $4,%0", &addreg0);
- if (addreg1)
- output_asm_insn("subl2 $4,%0", &addreg1);
+ if (addreg0 != 0 && addreg1 != 0 && rtx_equal_p (addreg0, addreg1))
+ output_asm_insn ("subl2 $4,%0", &addreg0);
+ else
+ {
+ if (addreg0 != 0)
+ output_asm_insn ("subl2 $4,%0", &addreg0);
+ if (addreg1 != 0)
+ output_asm_insn ("subl2 $4,%0", &addreg1);
}
- return singlemove_string(operands);
- }
+ return singlemove_string (operands);
+ }
- output_asm_insn(singlemove_string(operands), operands);
+ output_asm_insn (singlemove_string(operands), operands);
- if (addreg0 && addreg1 && (rtx_equal_p(addreg0,addreg1)))
- output_asm_insn("addl2 $4,%0", &addreg0);
- else {
- if (addreg0)
- output_asm_insn("addl2 $4,%0", &addreg0);
- if (addreg1)
- output_asm_insn("addl2 $4,%0", &addreg1);
- }
+ if (addreg0 != 0 && addreg1 != 0 && rtx_equal_p (addreg0, addreg1))
+ output_asm_insn ("addl2 $4,%0", &addreg0);
+ else
+ {
+ if (addreg0 != 0)
+ output_asm_insn ("addl2 $4,%0", &addreg0);
+ if (addreg1 != 0)
+ output_asm_insn ("addl2 $4,%0", &addreg1);
+ }
- output_asm_insn(singlemove_string(latehalf), latehalf);
+ output_asm_insn (singlemove_string (latehalf), latehalf);
- if (addreg0 && addreg1 && (rtx_equal_p(addreg0,addreg1)))
- output_asm_insn("subl2 $4,%0", &addreg0);
- else {
- if (addreg0)
- output_asm_insn("subl2 $4,%0", &addreg0);
- if (addreg1)
- output_asm_insn("subl2 $4,%0", &addreg1);
- }
+ if (addreg0 != 0 && addreg1 != 0 && rtx_equal_p(addreg0, addreg1))
+ output_asm_insn ("subl2 $4,%0", &addreg0);
+ else
+ {
+ if (addreg0 != 0)
+ output_asm_insn ("subl2 $4,%0", &addreg0);
+ if (addreg1 != 0)
+ output_asm_insn ("subl2 $4,%0", &addreg1);
+ }
- if (shftreg0 && shftreg1 && (rtx_equal_p(shftreg0,shftreg1)))
- output_asm_insn("shar $1,%0,%0", &shftreg0);
- else {
- if (shftreg0)
- output_asm_insn("shar $1,%0,%0", &shftreg0);
- if (shftreg1)
- output_asm_insn("shar $1,%0,%0", &shftreg1);
+ if (shftreg0 != 0 && shftreg1 != 0 && rtx_equal_p (shftreg0, shftreg1))
+ output_asm_insn ("shar $1,%0,%0", &shftreg0);
+ else
+ {
+ if (shftreg0 != 0)
+ output_asm_insn ("shar $1,%0,%0", &shftreg0);
+ if (shftreg1 != 0)
+ output_asm_insn ("shar $1,%0,%0", &shftreg1);
}
return "";
int
tahoe_cmp_check (insn, op, max)
-rtx insn, op; int max;
+ rtx insn, op;
+ int max;
{
+ register rtx next = NEXT_INSN (insn);
+
if (GET_CODE (op) == CONST_INT
- && ( INTVAL (op) < 0 || INTVAL (op) > max ))
- return 0;
+ && (INTVAL (op) < 0 || INTVAL (op) > max))
+ return 0;
+
+ if (GET_RTX_CLASS (GET_CODE (next)) == 'i')
{
- register rtx next = NEXT_INSN (insn);
-
- if ((GET_CODE (next) == JUMP_INSN
- || GET_CODE (next) == INSN
- || GET_CODE (next) == CALL_INSN))
- {
- next = PATTERN (next);
- if (GET_CODE (next) == SET
- && SET_DEST (next) == pc_rtx
- && GET_CODE (SET_SRC (next)) == IF_THEN_ELSE)
- switch (GET_CODE (XEXP (SET_SRC (next), 0)))
- {
- case EQ:
- case NE:
- case LTU:
- case GTU:
- case LEU:
- case GEU:
- return 1;
- }
- }
+ next = PATTERN (next);
+ if (GET_CODE (next) == SET
+ && SET_DEST (next) == pc_rtx
+ && GET_CODE (SET_SRC (next)) == IF_THEN_ELSE)
+ switch (GET_CODE (XEXP (SET_SRC (next), 0)))
+ {
+ case EQ:
+ case NE:
+ case LTU:
+ case GTU:
+ case LEU:
+ case GEU:
+ return 1;
+ }
}
- return 0;
+
+ return 0;
}
/* Definitions of target machine for GNU compiler. Tahoe version.
- Copyright (C) 1989, 1993, 1994, 1995, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1989, 93, 94, 95, 96, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* function values for all types are returned in register 0 */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* library routines also return things in reg 0 */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* Tahoe doesn't return structures in a reentrant way */
;; Machine description for GNU compiler, Tahoe version
-;; Copyright (C) 1989, 1994, 1996, 1997 Free Software Foundation, Inc.
+;; Copyright (C) 1989, 1994, 96-98, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
""
"*
{
- operands[1] = GEN_INT ((INTVAL (operands[1]) + 4));
+ operands[1] = GEN_INT (INTVAL (operands[1]) + 4);
if (GET_CODE(operands[0]) == MEM
&& CONSTANT_ADDRESS_P (XEXP(operands[0], 0))
&& INTVAL (operands[1]) < 64)
""
"*
{
- operands[2] = GEN_INT ((INTVAL (operands[2]) + 4));
+ operands[2] = GEN_INT (INTVAL (operands[2]) + 4));
if (GET_CODE(operands[1]) == MEM
&& CONSTANT_ADDRESS_P (XEXP(operands[1], 0))
&& INTVAL (operands[2]) < 64)
; && exact_log2 (INTVAL (operands[1])) >= 0"
; "*
;{
-; operands[1]
-; = GEN_INT (exact_log2 (INTVAL (operands[1])));
+; operands[1] = GEN_INT (exact_log2 (INTVAL (operands[1])));
; return \"bbs %1,%0,%l2\";
;}")
;
; && exact_log2 (INTVAL (operands[1])) >= 0"
; "*
;{
-; operands[1]
-; = GEN_INT (exact_log2 (INTVAL (operands[1])));
+; operands[1] = GEN_INT (exact_log2 (INTVAL (operands[1])));
; return \"bbc %1,%0,%l2\";
;}")
;
; && exact_log2 (INTVAL (operands[1])) >= 0"
; "*
;{
-; operands[1]
-; = GEN_INT (exact_log2 (INTVAL (operands[1])));
+; operands[1] = GEN_INT (exact_log2 (INTVAL (operands[1])));
; return \"bbc %1,%0,%l2\";
;}")
;
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
-#include <ctype.h>
+#include "system.h"
#include "tree.h"
#include "rtl.h"
#include "regs.h"
switch (cum->nbytes / UNITS_PER_WORD)
{
case 0:
- result = gen_rtx (REG, mode, 6);
+ result = gen_rtx_REG (mode, 6);
break;
case 1:
- result = gen_rtx (REG, mode, 7);
+ result = gen_rtx_REG (mode, 7);
break;
case 2:
- result = gen_rtx (REG, mode, 8);
+ result = gen_rtx_REG (mode, 8);
break;
case 3:
- result = gen_rtx (REG, mode, 9);
+ result = gen_rtx_REG (mode, 9);
break;
default:
result = 0;
{
case MEM:
if (GET_CODE (XEXP (x, 0)) == CONST_INT)
- output_address (gen_rtx (PLUS, SImode,
- gen_rtx (REG, SImode, 0),
- XEXP (x, 0)));
+ output_address (gen_rtx_PLUS (SImode, gen_rtx (REG, SImode, 0),
+ XEXP (x, 0)));
else
output_address (XEXP (x, 0));
break;
return "%S0st%W0 %.,%0";
}
- fatal_insn ("output_move_single:", gen_rtx (SET, VOIDmode, dst, src));
+ fatal_insn ("output_move_single:", gen_rtx_SET (VOIDmode, dst, src));
return "";
}
for (i = 0; i < 2; i++)
{
- xop[0] = gen_rtx (REG, SImode, REGNO (dst)+i);
+ xop[0] = gen_rtx_REG (SImode, REGNO (dst)+i);
xop[1] = GEN_INT (high_low[i]);
output_asm_insn (output_move_single (xop), xop);
}
rtx *p_r1;
rtx *p_ep;
{
- rtx reg = gen_rtx (REG, Pmode, regno);
+ rtx reg = gen_rtx_REG (Pmode, regno);
rtx insn;
if (!*p_r1)
{
regs_ever_live[1] = 1;
- *p_r1 = gen_rtx (REG, Pmode, 1);
- *p_ep = gen_rtx (REG, Pmode, 30);
+ *p_r1 = gen_rtx_REG (Pmode, 1);
+ *p_ep = gen_rtx_REG (Pmode, 30);
}
if (TARGET_DEBUG)
unsignedp))
&& ((INTVAL (XEXP (addr, 1))) >= 0))
*p_mem = change_address (*p_mem, VOIDmode,
- gen_rtx (PLUS, Pmode,
- *p_ep, XEXP (addr, 1)));
+ gen_rtx_PLUS (Pmode,
+ *p_ep,
+ XEXP (addr, 1)));
}
}
}
&& SET_SRC (PATTERN (insn)) == *p_r1)
delete_insn (insn);
else
- emit_insn_before (gen_rtx (SET, Pmode, *p_r1, *p_ep), first_insn);
+ emit_insn_before (gen_rtx_SET (Pmode, *p_r1, *p_ep), first_insn);
- emit_insn_before (gen_rtx (SET, Pmode, *p_ep, reg), first_insn);
- emit_insn_before (gen_rtx (SET, Pmode, *p_ep, *p_r1), last_insn);
+ emit_insn_before (gen_rtx_SET (Pmode, *p_ep, reg), first_insn);
+ emit_insn_before (gen_rtx_SET (Pmode, *p_ep, *p_r1), last_insn);
}
\f
offset = 0;
for (i = 6; i < 10; i++)
{
- emit_move_insn (gen_rtx (MEM, SImode,
- plus_constant (stack_pointer_rtx,
- offset)),
- gen_rtx (REG, SImode, i));
+ emit_move_insn (gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx,
+ offset)),
+ gen_rtx_REG (SImode, i));
offset += 4;
}
}
for (i = 1; i < 31; i++)
{
if (((1L << i) & reg_saved) != 0)
- save_regs[num_save++] = gen_rtx (REG, Pmode, i);
+ save_regs[num_save++] = gen_rtx_REG (Pmode, i);
}
/* If the return pointer is saved, the helper functions also allocate
16 bytes of stack for arguments to be saved in. */
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
{
- save_regs[num_save++] = gen_rtx (REG, Pmode, LINK_POINTER_REGNUM);
+ save_regs[num_save++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
default_stack = 16;
}
stack space is allocated. */
if (save_func_len < save_normal_len)
{
- save_all = gen_rtx (PARALLEL, VOIDmode,
- rtvec_alloc (num_save + (TARGET_V850 ? 2 : 1)));
- XVECEXP (save_all, 0, 0) = gen_rtx (SET, VOIDmode,
- stack_pointer_rtx,
- gen_rtx (PLUS, Pmode,
- stack_pointer_rtx,
- GEN_INT (-alloc_stack)));
+ save_all = gen_rtx_PARALLEL
+ (VOIDmode,
+ rtvec_alloc (num_save + (TARGET_V850 ? 2 : 1)));
+
+ XVECEXP (save_all, 0, 0)
+ = gen_rtx_SET (VOIDmode,
+ stack_pointer_rtx,
+ plus_constant (stack_pointer_rtx, -alloc_stack));
if (TARGET_V850)
{
- XVECEXP (save_all, 0, num_save + 1)
- = gen_rtx (CLOBBER, VOIDmode, gen_rtx (REG, Pmode, 10));
+ XVECEXP (save_all, 0, num_save+1)
+ = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 10));
}
offset = - default_stack;
for (i = 0; i < num_save; i++)
{
- XVECEXP (save_all, 0, i + 1)
- = gen_rtx (SET, VOIDmode,
- gen_rtx (MEM, Pmode,
- plus_constant (stack_pointer_rtx, offset)),
- save_regs[i]);
+ XVECEXP (save_all, 0, i+1)
+ = gen_rtx_SET (VOIDmode,
+ gen_rtx_MEM (Pmode,
+ plus_constant (stack_pointer_rtx,
+ offset)),
+ save_regs[i]);
offset -= 4;
}
/* Save the return pointer first. */
if (num_save > 0 && REGNO (save_regs[num_save-1]) == LINK_POINTER_REGNUM)
{
- emit_move_insn (gen_rtx (MEM, SImode,
- plus_constant (stack_pointer_rtx,
- offset)),
+ emit_move_insn (gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx,
+ offset)),
save_regs[--num_save]);
offset -= 4;
}
for (i = 0; i < num_save; i++)
{
- emit_move_insn (gen_rtx (MEM, SImode,
- plus_constant (stack_pointer_rtx,
- offset)),
+ emit_move_insn (gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx,
+ offset)),
save_regs[i]);
offset -= 4;
}
GEN_INT (-diff)));
else
{
- rtx reg = gen_rtx (REG, Pmode, 12);
+ rtx reg = gen_rtx_REG (Pmode, 12);
emit_move_insn (reg, GEN_INT (-diff));
emit_insn (gen_addsi3 (stack_pointer_rtx, stack_pointer_rtx, reg));
}
for (i = 1; i < 31; i++)
{
if (((1L << i) & reg_saved) != 0)
- restore_regs[num_restore++] = gen_rtx (REG, Pmode, i);
+ restore_regs[num_restore++] = gen_rtx_REG (Pmode, i);
}
/* If the return pointer is saved, the helper functions also allocate
16 bytes of stack for arguments to be saved in. */
if (((1L << LINK_POINTER_REGNUM) & reg_saved) != 0)
{
- restore_regs[num_restore++] = gen_rtx (REG, Pmode, LINK_POINTER_REGNUM);
+ restore_regs[num_restore++] = gen_rtx_REG (Pmode, LINK_POINTER_REGNUM);
default_stack = 16;
}
/* Don't bother checking if we don't actually save any space. */
if (restore_func_len < restore_normal_len)
{
- restore_all = gen_rtx (PARALLEL, VOIDmode,
- rtvec_alloc (num_restore + 2));
- XVECEXP (restore_all, 0, 0) = gen_rtx (RETURN, VOIDmode);
+ restore_all = gen_rtx_PARALLEL (VOIDmode,
+ rtvec_alloc (num_restore + 2));
+ XVECEXP (restore_all, 0, 0) = gen_rtx_RETURN (VOIDmode);
XVECEXP (restore_all, 0, 1)
- = gen_rtx (SET, VOIDmode, stack_pointer_rtx,
- gen_rtx (PLUS, Pmode,
- stack_pointer_rtx,
- GEN_INT (alloc_stack)));
+ = gen_rtx_SET (VOIDmode, stack_pointer_rtx,
+ gen_rtx_PLUS (Pmode,
+ stack_pointer_rtx,
+ GEN_INT (alloc_stack)));
offset = alloc_stack - 4;
for (i = 0; i < num_restore; i++)
{
XVECEXP (restore_all, 0, i+2)
- = gen_rtx (SET, VOIDmode,
- restore_regs[i],
- gen_rtx (MEM, Pmode,
- plus_constant
- (stack_pointer_rtx, offset)));
+ = gen_rtx_SET (VOIDmode,
+ restore_regs[i],
+ gen_rtx_MEM (Pmode,
+ plus_constant (stack_pointer_rtx,
+ offset)));
offset -= 4;
}
GEN_INT (actual_fsize)));
else
{
- rtx reg = gen_rtx (REG, Pmode, 12);
+ rtx reg = gen_rtx_REG (Pmode, 12);
emit_move_insn (reg, GEN_INT (actual_fsize));
emit_insn (gen_addsi3 (stack_pointer_rtx,
stack_pointer_rtx,
GEN_INT (diff)));
else
{
- rtx reg = gen_rtx (REG, Pmode, 12);
+ rtx reg = gen_rtx_REG (Pmode, 12);
emit_move_insn (reg, GEN_INT (diff));
emit_insn (gen_addsi3 (stack_pointer_rtx,
stack_pointer_rtx,
&& REGNO (restore_regs [num_restore - 1]) == LINK_POINTER_REGNUM)
{
emit_move_insn (restore_regs[--num_restore],
- gen_rtx (MEM, SImode,
- plus_constant (stack_pointer_rtx,
- offset)));
+ gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx,
+ offset)));
offset -= 4;
}
for (i = 0; i < num_restore; i++)
{
emit_move_insn (restore_regs[i],
- gen_rtx (MEM, SImode,
- plus_constant (stack_pointer_rtx,
- offset)));
+ gen_rtx_MEM (SImode,
+ plus_constant (stack_pointer_rtx,
+ offset)));
offset -= 4;
}
otherwise, FUNC is 0. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 10)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 10)
/* 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, 10)
+ gen_rtx_REG (MODE, 10)
/* 1 if N is a possible register number for a function value. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 16)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 16)), \
(CXT)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant ((TRAMP), 20)), \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant ((TRAMP), 20)), \
(FNADDR)); \
}
;; GCC machine description for NEC V850
-;; Copyright (C) 1996, 1997, 1999 Free Software Foundation, Inc.
-
-;; Contributed by Jeff Law (law@cygnus.com).
+;; Copyright (C) 1996, 1997, 1998, 1999 Free Software Foundation, Inc.
+;; Contributed by Jeff Law (law@cygnus.com).
;; This file is part of GNU CC.
else
temp = gen_reg_rtx (SImode);
- emit_insn (gen_rtx (SET, SImode, temp,
- gen_rtx (HIGH, SImode, operand1)));
- emit_insn (gen_rtx (SET, SImode, operand0,
- gen_rtx (LO_SUM, SImode, temp, operand1)));
+ emit_insn (gen_rtx_SET (SImode, temp,
+ gen_rtx_HIGH (SImode, operand1)));
+ emit_insn (gen_rtx_SET (SImode, operand0,
+ gen_rtx_LO_SUM (SImode, temp, operand1)));
DONE;
}
}")
int log2 = exact_log2 (~INTVAL (operands[1]) & 0xffff);
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0), log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"clr1 %1,%0\", xoperands);
return \"\";
int log2 = exact_log2 (~INTVAL (operands[1]) & 0xffffffff);
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0), log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"clr1 %1,%0\", xoperands);
return \"\";
else
{
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0),
+ log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"set1 %1,%0\", xoperands);
}
else
{
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0),
+ log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"set1 %1,%0\", xoperands);
}
else
{
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0),
+ log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"not1 %1,%0\", xoperands);
}
else
{
rtx xoperands[2];
- xoperands[0] = gen_rtx (MEM, QImode,
- plus_constant (XEXP (operands[0], 0), log2 / 8));
+ xoperands[0] = gen_rtx_MEM (QImode,
+ plus_constant (XEXP (operands[0], 0),
+ log2 / 8));
xoperands[1] = GEN_INT (log2 % 8);
output_asm_insn (\"not1 %1,%0\", xoperands);
}
emit_insn (gen_ashlsi3 (reg, reg, GEN_INT (TARGET_BIG_SWITCH ? 2 : 1)));
/* Load the table address into a pseudo. */
emit_insn (gen_movsi (tableaddress,
- gen_rtx (LABEL_REF, VOIDmode, operands[3])));
+ gen_rtx_LABEL_REF (VOIDmode, operands[3])));
/* Add the table address to the index. */
emit_insn (gen_addsi3 (reg, reg, tableaddress));
/* Load the table entry. */
- mem = gen_rtx (MEM, CASE_VECTOR_MODE, reg);
+ mem = gen_rtx_MEM (CASE_VECTOR_MODE, reg);
RTX_UNCHANGING_P (mem);
if (! TARGET_BIG_SWITCH)
{
/* Configuration for NEC V850.
- Copyright (C) 1996 Free Software Foundation, Inc.
+ Copyright (C) 1996, 1998, 1999 Free Software Foundation, Inc.
Contributed by Cygnus Support.
This file is part of GNU CC.
#define SUCCESS_EXIT_CODE 0
#define FATAL_EXIT_CODE 33
-#ifdef __v850
-#ifndef __STDC__
-extern char *malloc (), *realloc (), *calloc ();
-#else
-extern void *malloc (), *realloc (), *calloc ();
-#endif
-extern void free ();
-#endif
-
/* target machine dependencies.
tm.h is a symbolic link to the actual target specific file. */
/* Subroutines for insn-output.c for Vax.
- Copyright (C) 1987, 1994, 1995, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 94, 95, 97, 98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
Boston, MA 02111-1307, USA. */
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "regs.h"
#include "hard-reg-set.h"
&& (GET_CODE (XEXP (operands[i], 0)) == POST_INC))
{
rtx addr = XEXP (operands[i], 0);
- operands[i] = low[i] = gen_rtx (MEM, SImode, addr);
+ operands[i] = low[i] = gen_rtx_MEM (SImode, addr);
if (which_alternative == 0 && i == 0)
{
addr = XEXP (operands[i], 0);
- operands[i+1] = low[i+1] = gen_rtx (MEM, SImode, addr);
+ operands[i+1] = low[i+1] = gen_rtx_MEM (SImode, addr);
}
}
else
/* Definitions of target machine for GNU compiler. Vax version.
- Copyright (C) 1987, 88, 91, 93-96, 1997 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 91, 93-98, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
/* Given an rtx for the address of a frame,
return an rtx for the address of the word in the frame
that holds the dynamic chain--the previous frame's address. */
-#define DYNAMIC_CHAIN_ADDRESS(frame) \
-gen_rtx (PLUS, Pmode, frame, GEN_INT (12))
+#define DYNAMIC_CHAIN_ADDRESS(FRAME) plus_constant ((FRAME), 12)
/* If we generate an insn to push BYTES bytes,
this says how many the stack pointer really advances by.
/* On the Vax the return value is in R0 regardless. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* On the Vax the return value is in R0 regardless. */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* Define this if PCC uses the nonreentrant convention for returning
structure and union values. */
movl $STATIC,r0 (store the functions static chain)
jmp *$FUNCTION (jump to function code at address FUNCTION) */
-#define TRAMPOLINE_TEMPLATE(FILE) \
-{ \
- ASM_OUTPUT_SHORT (FILE, const0_rtx); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x8fd0)); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
- ASM_OUTPUT_BYTE (FILE, 0x50+STATIC_CHAIN_REGNUM); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x9f17)); \
- ASM_OUTPUT_INT (FILE, const0_rtx); \
+#define TRAMPOLINE_TEMPLATE(FILE) \
+{ \
+ ASM_OUTPUT_SHORT (FILE, const0_rtx); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x8fd0)); \
+ ASM_OUTPUT_INT (FILE, const0_rtx); \
+ ASM_OUTPUT_BYTE (FILE, 0x50 + STATIC_CHAIN_REGNUM); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x9f17)); \
+ ASM_OUTPUT_INT (FILE, const0_rtx); \
}
/* Length in units of the trampoline for entering a nested function. */
to the start of the trampoline. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_insn (gen_rtx (ASM_INPUT, VOIDmode, \
- "movpsl -(sp)\n\tpushal 1(pc)\n\trei")); \
- emit_move_insn (gen_rtx (MEM, HImode, TRAMP), \
- gen_rtx (MEM, HImode, FNADDR)); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 4)), CXT);\
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 11)), \
+ emit_insn (gen_rtx_ASM_INPUT (VOIDmode, \
+ "movpsl -(sp)\n\tpushal 1(pc)\n\trei")); \
+ emit_move_insn (gen_rtx_MEM (HImode, TRAMP), \
+ gen_rtx_MEM (HImode, FNADDR)); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 4)), CXT);\
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 11)), \
plus_constant (FNADDR, 2)); \
}
#define RETURN_ADDR_RTX(COUNT, FRAME) \
((COUNT == 0) \
- ? gen_rtx (MEM, Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET)) \
+ ? gen_rtx_MEM (Pmode, plus_constant (FRAME, RETURN_ADDRESS_OFFSET)) \
: (rtx) 0)
\f
-;;- Machine description for GNU compiler, Vax Version
-;; Copyright (C) 1987, 88, 91, 94-96, 1998 Free Software Foundation, Inc.
+;; Machine description for GNU compiler, Vax Version
+;; Copyright (C) 1987, 88, 91, 94-96, 1998, 1999 Free Software Foundation, Inc.
;; This file is part of GNU CC.
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn ""
""
"
{
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn "ashldi3"
"
{
if (GET_CODE (operands[2]) != CONST_INT)
- operands[2] = gen_rtx (NEG, QImode, negate_rtx (QImode, operands[2]));
+ operands[2] = gen_rtx_NEG (QImode, negate_rtx (QImode, operands[2]));
}")
(define_insn "rotlsi3"
""
"*
{
- operands[3] = GEN_INT (INTVAL (operands[3]) & ~((1 << INTVAL (operands[2])) - 1));
+ operands[3]
+ = GEN_INT (INTVAL (operands[3]) & ~((1 << INTVAL (operands[2])) - 1));
return \"rotl %2,%1,%0\;bicl2 %N3,%0\";
}")
/* Subroutines for insn-output.c for AT&T we32000 Family.
+ Copyright (C) 1991, 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
Contributed by John Wehle (john@feith1.uucp)
- Copyright (C) 1991, 1992, 1997 Free Software Foundation, Inc.
This file is part of GNU CC.
#include "config.h"
-#include <stdio.h>
+#include "system.h"
#include "rtl.h"
#include "function.h"
#include "real.h"
-
void
output_move_double (operands)
rtx *operands;
if (GET_CODE (operands[0]) == REG)
{
- lsw_operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
msw_dreg = operands[0];
}
else if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
if (GET_CODE (operands[1]) == REG)
{
- lsw_operands[1] = gen_rtx (REG, SImode, REGNO (operands[1]) + 1);
+ lsw_operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
lsw_sreg = lsw_operands[1];
}
else if (GET_CODE (operands[1]) == MEM && offsettable_memref_p (operands[1]))
rtx lsw_operands[1];
if (GET_CODE (operands[0]) == REG)
- lsw_operands[0] = gen_rtx (REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
lsw_operands[0] = adj_offsettable_operand (operands[0], 4);
else if (GET_CODE (operands[0]) == CONST_DOUBLE)
{
- lsw_operands[0] = GEN_INT (CONST_DOUBLE_HIGH (operands[0]));
+ lsw_operands[0] = GEN_INT CONST_DOUBLE_HIGH (operands[0]));
operands[0] = GEN_INT (CONST_DOUBLE_LOW (operands[0]));
}
else if (GET_CODE (operands[0]) == CONST_INT)
/* Definitions of target machine for GNU compiler. AT&T we32000 version.
- Copyright (C) 1991, 92, 93, 94, 95, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 94, 95, 96, 98, 1999
+ Free Software Foundation, Inc.
Contributed by John Wehle (john@feith1.uucp)
This file is part of GNU CC.
/* On the we32000 the return value is in r0 regardless. */
#define FUNCTION_VALUE(VALTYPE, FUNC) \
- gen_rtx (REG, TYPE_MODE (VALTYPE), 0)
+ gen_rtx_REG (TYPE_MODE (VALTYPE), 0)
/* Define how to find the value returned by a library function
assuming the value has mode MODE. */
/* On the we32000 the return value is in r0 regardless. */
-#define LIBCALL_VALUE(MODE) gen_rtx (REG, MODE, 0)
+#define LIBCALL_VALUE(MODE) gen_rtx_REG (MODE, 0)
/* 1 if N is a possible register number for a function value.
On the we32000, r0 is the only register thus used. */
mov #STATIC,%r8
jmp #FUNCTION */
-#define TRAMPOLINE_TEMPLATE(FILE) \
-{ \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x844f)); \
- ASM_OUTPUT_SHORT (FILE, const0_rtx); \
- ASM_OUTPUT_SHORT (FILE, const0_rtx); \
- ASM_OUTPUT_CHAR (FILE, GEN_INT (0x48)); \
- ASM_OUTPUT_SHORT (FILE, GEN_INT (0x247f)); \
- ASM_OUTPUT_SHORT (FILE, const0_rtx); \
- ASM_OUTPUT_SHORT (FILE, const0_rtx); \
+#define TRAMPOLINE_TEMPLATE(FILE) \
+{ \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x844f)); \
+ ASM_OUTPUT_SHORT (FILE, const0_rtx); \
+ ASM_OUTPUT_SHORT (FILE, const0_rtx); \
+ ASM_OUTPUT_CHAR (FILE, GEN_INT (0x48)); \
+ ASM_OUTPUT_SHORT (FILE, GEN_INT (0x247f)); \
+ ASM_OUTPUT_SHORT (FILE, const0_rtx); \
+ ASM_OUTPUT_SHORT (FILE, const0_rtx); \
}
/* Length in units of the trampoline for entering a nested function. */
#define INITIALIZE_TRAMPOLINE(TRAMP, FNADDR, CXT) \
{ \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 2)), CXT); \
- emit_move_insn (gen_rtx (MEM, SImode, plus_constant (TRAMP, 9)), FNADDR); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 2)), CXT); \
+ emit_move_insn (gen_rtx_MEM (SImode, plus_constant (TRAMP, 9)), FNADDR); \
}
\f
/* Generate calls to memcpy() and memset() rather
;; Machine description for GNU compiler, AT&T we32000 Version
-;; Copyright (C) 1991, 1992, 1994 Free Software Foundation, Inc.
+;; Copyright (C) 1991, 1992, 1994, 1998, 1999 Free Software Foundation, Inc.
;; Contributed by John Wehle (john@feith1.uucp)
;; This file is part of GNU CC.
rtx lsw_operands[3];
if (GET_CODE (operands[0]) == REG)
- lsw_operands[0] = gen_rtx(REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else
if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
lsw_operands[0] = adj_offsettable_operand(operands[0], 4);
abort();
if (GET_CODE (operands[2]) == REG)
- lsw_operands[2] = gen_rtx(REG, SImode, REGNO (operands[2]) + 1);
+ lsw_operands[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
if (GET_CODE (operands[2]) == MEM && offsettable_memref_p (operands[2]))
lsw_operands[2] = adj_offsettable_operand(operands[2], 4);
rtx lsw_operands[3];
if (GET_CODE (operands[0]) == REG)
- lsw_operands[0] = gen_rtx(REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else
if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
lsw_operands[0] = adj_offsettable_operand(operands[0], 4);
abort();
if (GET_CODE (operands[1]) == REG)
- lsw_operands[1] = gen_rtx(REG, SImode, REGNO (operands[1]) + 1);
+ lsw_operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else
if (GET_CODE (operands[1]) == MEM && offsettable_memref_p (operands[1]))
lsw_operands[1] = adj_offsettable_operand(operands[1], 4);
abort();
if (GET_CODE (operands[2]) == REG)
- lsw_operands[2] = gen_rtx(REG, SImode, REGNO (operands[2]) + 1);
+ lsw_operands[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
if (GET_CODE (operands[2]) == MEM && offsettable_memref_p (operands[2]))
lsw_operands[2] = adj_offsettable_operand(operands[2], 4);
rtx lsw_operands[3];
if (GET_CODE (operands[0]) == REG)
- lsw_operands[0] = gen_rtx(REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else
if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
lsw_operands[0] = adj_offsettable_operand(operands[0], 4);
abort();
if (GET_CODE (operands[2]) == REG)
- lsw_operands[2] = gen_rtx(REG, SImode, REGNO (operands[2]) + 1);
+ lsw_operands[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
if (GET_CODE (operands[2]) == MEM && offsettable_memref_p (operands[2]))
lsw_operands[2] = adj_offsettable_operand(operands[2], 4);
rtx lsw_operands[3];
if (GET_CODE (operands[0]) == REG)
- lsw_operands[0] = gen_rtx(REG, SImode, REGNO (operands[0]) + 1);
+ lsw_operands[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
else
if (GET_CODE (operands[0]) == MEM && offsettable_memref_p (operands[0]))
lsw_operands[0] = adj_offsettable_operand(operands[0], 4);
abort();
if (GET_CODE (operands[1]) == REG)
- lsw_operands[1] = gen_rtx(REG, SImode, REGNO (operands[1]) + 1);
+ lsw_operands[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
else
if (GET_CODE (operands[1]) == MEM && offsettable_memref_p (operands[1]))
lsw_operands[1] = adj_offsettable_operand(operands[1], 4);
abort();
if (GET_CODE (operands[2]) == REG)
- lsw_operands[2] = gen_rtx(REG, SImode, REGNO (operands[2]) + 1);
+ lsw_operands[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
else
if (GET_CODE (operands[2]) == MEM && offsettable_memref_p (operands[2]))
lsw_operands[2] = adj_offsettable_operand(operands[2], 4);
if (GET_CODE (operands[1]) == CONST_INT &&
((unsigned long)INTVAL (operands[1]) & 0x8000L))
- operands[1] = GEN_INT (INTVAL(operands[1]) | 0xffff0000L);
+ operands[1] = GEN_INT (INTVAL (operands[1]) | 0xffff0000L);
output_asm_insn(\"CMPH %1, %0\",operands);
"*
{
- operands[2] = GEN_INT (INTVAL(operands[2]) - 1);
+ operands[2] = GEN_INT (INTVAL (operands[2]) - 1);
output_asm_insn(\"EXTFH %2, %3, {uhalf}%1, {uword}%0\",operands);
return \"\";
"*
{
- operands[2] = GEN_INT (INTVAL(operands[2]) - 1);
+ operands[2] = GEN_INT (INTVAL (operands[2]) - 1);
output_asm_insn(\"EXTFB %2, %3, {ubyte}%1, {uword}%0\",operands);
return \"\";
"*
{
- operands[1] = GEN_INT (INTVAL(operands[1]) - 1);
+ operands[1] = GEN_INT (INTVAL (operands[1]) - 1);
output_asm_insn(\"INSFW %1, %2, %3, %0\",operands);
return \"\";
ac_help="$ac_help
--enable-c-cpplib link cpplib directly into C and C++ compilers
(EXPERIMENTAL) (implies --enable-cpplib)."
-ac_help="$ac_help
- --enable-c-mbchar enable multibyte characters for C and C++."
ac_help="$ac_help
--disable-fast-fixincludes
Disable the new fast fixincludes.
Run the old fixincludes script unconditionally"
+ac_help="$ac_help
+ --enable-c-mbchar Enable multibyte characters for C and C++."
ac_help="$ac_help
--enable-threads enable thread usage for target GCC.
--enable-threads=LIB use LIB thread package for target GCC."
fi
-# Enable Multibyte Characters for C/C++
-# Check whether --enable-c-mbchar or --disable-c-mbchar was given.
-if test "${enable_c_mbchar+set}" = set; then
- enableval="$enable_c_mbchar"
- if test x$enable_c_mbchar != xno; then
- extra_c_flags=-DMULTIBYTE_CHARS=1
-fi
-fi
-
-
# Disable fast fixincludes
# Check whether --enable-fast-fixincludes or --disable-fast-fixincludes was given.
if test "${enable_fast_fixincludes+set}" = set; then
fi
+# Enable Multibyte Characters for C/C++
+# Check whether --enable-c-mbchar or --disable-c-mbchar was given.
+if test "${enable_c_mbchar+set}" = set; then
+ enableval="$enable_c_mbchar"
+ if [ x$enable_c_mbchar != xno ]; then
+ extra_c_flags=-DMULTIBYTE_CHARS=1
+fi
+fi
+
+
# Enable threads
# Pass with no value to take the default
# Pass with a value to specify a thread package
fi
-for ac_hdr in limits.h stddef.h string.h strings.h stdlib.h time.h fcntl.h unistd.h stab.h sys/file.h sys/time.h sys/resource.h sys/param.h sys/times.h sys/stat.h direct.h
+for ac_hdr in limits.h stddef.h string.h strings.h stdlib.h time.h fcntl.h unistd.h stab.h sys/file.h sys/time.h sys/resource.h sys/param.h sys/times.h sys/stat.h direct.h malloc.h
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
fi
-for ac_func in malloc realloc calloc free bcopy bzero bcmp \
+for ac_func in bcopy bzero bcmp \
index rindex getenv atol sbrk abort atof strerror getcwd getwd \
strsignal putc_unlocked fputs_unlocked strstr
do
done
-for ac_func in getrlimit setrlimit
+for ac_func in malloc realloc calloc free
do
echo $ac_n "checking whether $ac_func must be declared""... $ac_c" 1>&6
echo "configure:2702: checking whether $ac_func must be declared" >&5
#line 2707 "configure"
#include "confdefs.h"
+#include <stdio.h>
+#ifdef STRING_WITH_STRINGS
+# include <string.h>
+# include <strings.h>
+#else
+# ifdef HAVE_STRING_H
+# include <string.h>
+# else
+# ifdef HAVE_STRINGS_H
+# include <strings.h>
+# endif
+# endif
+#endif
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
+#ifndef HAVE_RINDEX
+#define rindex strrchr
+#endif
+#ifndef HAVE_INDEX
+#define index strchr
+#endif
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+
+int main() {
+char *(*pfn) = (char *(*)) $ac_func
+; return 0; }
+EOF
+if { (eval echo configure:2743: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+ rm -rf conftest*
+ eval "gcc_cv_decl_needed_$ac_func=no"
+else
+ echo "configure: failed program was:" >&5
+ cat conftest.$ac_ext >&5
+ rm -rf conftest*
+ eval "gcc_cv_decl_needed_$ac_func=yes"
+fi
+rm -f conftest*
+fi
+
+if eval "test \"`echo '$gcc_cv_decl_needed_'$ac_func`\" = yes"; then
+ echo "$ac_t""yes" 1>&6
+ gcc_tr_decl=NEED_DECLARATION_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
+ cat >> confdefs.h <<EOF
+#define $gcc_tr_decl 1
+EOF
+
+else
+ echo "$ac_t""no" 1>&6
+fi
+
+done
+
+
+for ac_func in getrlimit setrlimit
+do
+echo $ac_n "checking whether $ac_func must be declared""... $ac_c" 1>&6
+echo "configure:2772: checking whether $ac_func must be declared" >&5
+if eval "test \"`echo '$''{'gcc_cv_decl_needed_$ac_func'+set}'`\" = set"; then
+ echo $ac_n "(cached) $ac_c" 1>&6
+else
+ cat > conftest.$ac_ext <<EOF
+#line 2777 "configure"
+#include "confdefs.h"
+
#include <stdio.h>
#ifdef STRING_WITH_STRINGS
# include <string.h>
char *(*pfn) = (char *(*)) $ac_func
; return 0; }
EOF
-if { (eval echo configure:2744: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2814: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
eval "gcc_cv_decl_needed_$ac_func=no"
else
echo $ac_n "checking for sys_siglist declaration in signal.h or unistd.h""... $ac_c" 1>&6
-echo "configure:2771: checking for sys_siglist declaration in signal.h or unistd.h" >&5
+echo "configure:2841: checking for sys_siglist declaration in signal.h or unistd.h" >&5
if eval "test \"`echo '$''{'ac_cv_decl_sys_siglist'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2776 "configure"
+#line 2846 "configure"
#include "confdefs.h"
#include <sys/types.h>
#include <signal.h>
char *msg = *(sys_siglist + 1);
; return 0; }
EOF
-if { (eval echo configure:2788: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2858: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_decl_sys_siglist=yes
else
# mkdir takes a single argument on some systems.
echo $ac_n "checking if mkdir takes one argument""... $ac_c" 1>&6
-echo "configure:2811: checking if mkdir takes one argument" >&5
+echo "configure:2881: checking if mkdir takes one argument" >&5
if eval "test \"`echo '$''{'gcc_cv_mkdir_takes_one_arg'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 2816 "configure"
+#line 2886 "configure"
#include "confdefs.h"
#include <sys/types.h>
mkdir ("foo", 0);
; return 0; }
EOF
-if { (eval echo configure:2833: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:2903: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
gcc_cv_mkdir_takes_one_arg=no
else
echo $ac_n "checking for strerror in -lcposix""... $ac_c" 1>&6
-echo "configure:6183: checking for strerror in -lcposix" >&5
+echo "configure:6253: checking for strerror in -lcposix" >&5
ac_lib_var=`echo cposix'_'strerror | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lcposix $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 6191 "configure"
+#line 6261 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
strerror()
; return 0; }
EOF
-if { (eval echo configure:6202: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6272: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
echo $ac_n "checking for working const""... $ac_c" 1>&6
-echo "configure:6225: checking for working const" >&5
+echo "configure:6295: checking for working const" >&5
if eval "test \"`echo '$''{'ac_cv_c_const'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6230 "configure"
+#line 6300 "configure"
#include "confdefs.h"
int main() {
; return 0; }
EOF
-if { (eval echo configure:6279: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:6349: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_c_const=yes
else
fi
echo $ac_n "checking for inline""... $ac_c" 1>&6
-echo "configure:6300: checking for inline" >&5
+echo "configure:6370: checking for inline" >&5
if eval "test \"`echo '$''{'ac_cv_c_inline'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_inline=no
for ac_kw in inline __inline__ __inline; do
cat > conftest.$ac_ext <<EOF
-#line 6307 "configure"
+#line 6377 "configure"
#include "confdefs.h"
int main() {
} $ac_kw foo() {
; return 0; }
EOF
-if { (eval echo configure:6314: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
+if { (eval echo configure:6384: \"$ac_compile\") 1>&5; (eval $ac_compile) 2>&5; }; then
rm -rf conftest*
ac_cv_c_inline=$ac_kw; break
else
esac
echo $ac_n "checking for off_t""... $ac_c" 1>&6
-echo "configure:6340: checking for off_t" >&5
+echo "configure:6410: checking for off_t" >&5
if eval "test \"`echo '$''{'ac_cv_type_off_t'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6345 "configure"
+#line 6415 "configure"
#include "confdefs.h"
#include <sys/types.h>
#if STDC_HEADERS
fi
echo $ac_n "checking for size_t""... $ac_c" 1>&6
-echo "configure:6373: checking for size_t" >&5
+echo "configure:6443: checking for size_t" >&5
if eval "test \"`echo '$''{'ac_cv_type_size_t'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6378 "configure"
+#line 6448 "configure"
#include "confdefs.h"
#include <sys/types.h>
#if STDC_HEADERS
# The Ultrix 4.2 mips builtin alloca declared by alloca.h only works
# for constant arguments. Useless!
echo $ac_n "checking for working alloca.h""... $ac_c" 1>&6
-echo "configure:6408: checking for working alloca.h" >&5
+echo "configure:6478: checking for working alloca.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_alloca_h'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6413 "configure"
+#line 6483 "configure"
#include "confdefs.h"
#include <alloca.h>
int main() {
char *p = alloca(2 * sizeof(int));
; return 0; }
EOF
-if { (eval echo configure:6420: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6490: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_header_alloca_h=yes
else
fi
echo $ac_n "checking for alloca""... $ac_c" 1>&6
-echo "configure:6441: checking for alloca" >&5
+echo "configure:6511: checking for alloca" >&5
if eval "test \"`echo '$''{'ac_cv_func_alloca_works'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6446 "configure"
+#line 6516 "configure"
#include "confdefs.h"
#ifdef __GNUC__
char *p = (char *) alloca(1);
; return 0; }
EOF
-if { (eval echo configure:6474: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6544: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
ac_cv_func_alloca_works=yes
else
echo $ac_n "checking whether alloca needs Cray hooks""... $ac_c" 1>&6
-echo "configure:6506: checking whether alloca needs Cray hooks" >&5
+echo "configure:6576: checking whether alloca needs Cray hooks" >&5
if eval "test \"`echo '$''{'ac_cv_os_cray'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6511 "configure"
+#line 6581 "configure"
#include "confdefs.h"
#if defined(CRAY) && ! defined(CRAY2)
webecray
if test $ac_cv_os_cray = yes; then
for ac_func in _getb67 GETB67 getb67; do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6536: checking for $ac_func" >&5
+echo "configure:6606: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6541 "configure"
+#line 6611 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:6564: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6634: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
fi
echo $ac_n "checking stack direction for C alloca""... $ac_c" 1>&6
-echo "configure:6591: checking stack direction for C alloca" >&5
+echo "configure:6661: checking stack direction for C alloca" >&5
if eval "test \"`echo '$''{'ac_cv_c_stack_direction'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_c_stack_direction=0
else
cat > conftest.$ac_ext <<EOF
-#line 6599 "configure"
+#line 6669 "configure"
#include "confdefs.h"
find_stack_direction ()
{
exit (find_stack_direction() < 0);
}
EOF
-if { (eval echo configure:6618: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6688: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
ac_cv_c_stack_direction=1
else
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:6643: checking for $ac_hdr" >&5
+echo "configure:6713: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6648 "configure"
+#line 6718 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6653: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6723: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
for ac_func in getpagesize
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6682: checking for $ac_func" >&5
+echo "configure:6752: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6687 "configure"
+#line 6757 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:6710: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:6780: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
done
echo $ac_n "checking for working mmap""... $ac_c" 1>&6
-echo "configure:6735: checking for working mmap" >&5
+echo "configure:6805: checking for working mmap" >&5
if eval "test \"`echo '$''{'ac_cv_func_mmap_fixed_mapped'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
ac_cv_func_mmap_fixed_mapped=no
else
cat > conftest.$ac_ext <<EOF
-#line 6743 "configure"
+#line 6813 "configure"
#include "confdefs.h"
/* Thanks to Mike Haertel and Jim Avera for this test.
}
EOF
-if { (eval echo configure:6883: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
+if { (eval echo configure:6953: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext} && (./conftest; exit) 2>/dev/null
then
ac_cv_func_mmap_fixed_mapped=yes
else
do
ac_safe=`echo "$ac_hdr" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for $ac_hdr""... $ac_c" 1>&6
-echo "configure:6911: checking for $ac_hdr" >&5
+echo "configure:6981: checking for $ac_hdr" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6916 "configure"
+#line 6986 "configure"
#include "confdefs.h"
#include <$ac_hdr>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:6921: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:6991: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
strdup __argz_count __argz_stringify __argz_next
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:6951: checking for $ac_func" >&5
+echo "configure:7021: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 6956 "configure"
+#line 7026 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:6979: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7049: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
for ac_func in stpcpy
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7008: checking for $ac_func" >&5
+echo "configure:7078: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7013 "configure"
+#line 7083 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:7036: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7106: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
if test $ac_cv_header_locale_h = yes; then
echo $ac_n "checking for LC_MESSAGES""... $ac_c" 1>&6
-echo "configure:7070: checking for LC_MESSAGES" >&5
+echo "configure:7140: checking for LC_MESSAGES" >&5
if eval "test \"`echo '$''{'am_cv_val_LC_MESSAGES'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7075 "configure"
+#line 7145 "configure"
#include "confdefs.h"
#include <locale.h>
int main() {
return LC_MESSAGES
; return 0; }
EOF
-if { (eval echo configure:7082: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7152: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
am_cv_val_LC_MESSAGES=yes
else
fi
fi
echo $ac_n "checking whether NLS is requested""... $ac_c" 1>&6
-echo "configure:7103: checking whether NLS is requested" >&5
+echo "configure:7173: checking whether NLS is requested" >&5
# Check whether --enable-nls or --disable-nls was given.
if test "${enable_nls+set}" = set; then
enableval="$enable_nls"
EOF
echo $ac_n "checking whether included gettext is requested""... $ac_c" 1>&6
-echo "configure:7123: checking whether included gettext is requested" >&5
+echo "configure:7193: checking whether included gettext is requested" >&5
# Check whether --with-included-gettext or --without-included-gettext was given.
if test "${with_included_gettext+set}" = set; then
withval="$with_included_gettext"
ac_safe=`echo "libintl.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for libintl.h""... $ac_c" 1>&6
-echo "configure:7142: checking for libintl.h" >&5
+echo "configure:7212: checking for libintl.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7147 "configure"
+#line 7217 "configure"
#include "confdefs.h"
#include <libintl.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7152: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:7222: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
if eval "test \"`echo '$ac_cv_header_'$ac_safe`\" = yes"; then
echo "$ac_t""yes" 1>&6
echo $ac_n "checking for gettext in libc""... $ac_c" 1>&6
-echo "configure:7169: checking for gettext in libc" >&5
+echo "configure:7239: checking for gettext in libc" >&5
if eval "test \"`echo '$''{'gt_cv_func_gettext_libc'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7174 "configure"
+#line 7244 "configure"
#include "confdefs.h"
#include <libintl.h>
int main() {
return (int) gettext ("")
; return 0; }
EOF
-if { (eval echo configure:7181: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7251: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
gt_cv_func_gettext_libc=yes
else
if test "$gt_cv_func_gettext_libc" != "yes"; then
echo $ac_n "checking for bindtextdomain in -lintl""... $ac_c" 1>&6
-echo "configure:7197: checking for bindtextdomain in -lintl" >&5
+echo "configure:7267: checking for bindtextdomain in -lintl" >&5
ac_lib_var=`echo intl'_'bindtextdomain | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lintl $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 7205 "configure"
+#line 7275 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
bindtextdomain()
; return 0; }
EOF
-if { (eval echo configure:7216: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7286: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
if eval "test \"`echo '$ac_cv_lib_'$ac_lib_var`\" = yes"; then
echo "$ac_t""yes" 1>&6
echo $ac_n "checking for gettext in libintl""... $ac_c" 1>&6
-echo "configure:7232: checking for gettext in libintl" >&5
+echo "configure:7302: checking for gettext in libintl" >&5
if eval "test \"`echo '$''{'gt_cv_func_gettext_libintl'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
echo $ac_n "checking for gettext in -lintl""... $ac_c" 1>&6
-echo "configure:7237: checking for gettext in -lintl" >&5
+echo "configure:7307: checking for gettext in -lintl" >&5
ac_lib_var=`echo intl'_'gettext | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-lintl $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 7245 "configure"
+#line 7315 "configure"
#include "confdefs.h"
/* Override any gcc2 internal prototype to avoid an error. */
/* We use char because int might match the return type of a gcc2
gettext()
; return 0; }
EOF
-if { (eval echo configure:7256: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7326: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7295: checking for $ac_word" >&5
+echo "configure:7365: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
for ac_func in dcgettext
do
echo $ac_n "checking for $ac_func""... $ac_c" 1>&6
-echo "configure:7329: checking for $ac_func" >&5
+echo "configure:7399: checking for $ac_func" >&5
if eval "test \"`echo '$''{'ac_cv_func_$ac_func'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7334 "configure"
+#line 7404 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char $ac_func(); below. */
; return 0; }
EOF
-if { (eval echo configure:7357: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7427: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_$ac_func=yes"
else
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7384: checking for $ac_word" >&5
+echo "configure:7454: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7420: checking for $ac_word" >&5
+echo "configure:7490: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
fi
cat > conftest.$ac_ext <<EOF
-#line 7452 "configure"
+#line 7522 "configure"
#include "confdefs.h"
int main() {
return _nl_msg_cat_cntr
; return 0; }
EOF
-if { (eval echo configure:7460: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7530: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
CATOBJEXT=.gmo
DATADIRNAME=share
if test "$CATOBJEXT" = "NONE"; then
echo $ac_n "checking whether catgets can be used""... $ac_c" 1>&6
-echo "configure:7483: checking whether catgets can be used" >&5
+echo "configure:7553: checking whether catgets can be used" >&5
# Check whether --with-catgets or --without-catgets was given.
if test "${with_catgets+set}" = set; then
withval="$with_catgets"
if test "$nls_cv_use_catgets" = "yes"; then
echo $ac_n "checking for main in -li""... $ac_c" 1>&6
-echo "configure:7496: checking for main in -li" >&5
+echo "configure:7566: checking for main in -li" >&5
ac_lib_var=`echo i'_'main | sed 'y%./+-%__p_%'`
if eval "test \"`echo '$''{'ac_cv_lib_$ac_lib_var'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
ac_save_LIBS="$LIBS"
LIBS="-li $LIBS"
cat > conftest.$ac_ext <<EOF
-#line 7504 "configure"
+#line 7574 "configure"
#include "confdefs.h"
int main() {
main()
; return 0; }
EOF
-if { (eval echo configure:7511: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7581: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_lib_$ac_lib_var=yes"
else
fi
echo $ac_n "checking for catgets""... $ac_c" 1>&6
-echo "configure:7539: checking for catgets" >&5
+echo "configure:7609: checking for catgets" >&5
if eval "test \"`echo '$''{'ac_cv_func_catgets'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7544 "configure"
+#line 7614 "configure"
#include "confdefs.h"
/* System header to define __stub macros and hopefully few prototypes,
which can conflict with char catgets(); below. */
; return 0; }
EOF
-if { (eval echo configure:7567: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
+if { (eval echo configure:7637: \"$ac_link\") 1>&5; (eval $ac_link) 2>&5; } && test -s conftest${ac_exeext}; then
rm -rf conftest*
eval "ac_cv_func_catgets=yes"
else
# Extract the first word of "gencat", so it can be a program name with args.
set dummy gencat; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7589: checking for $ac_word" >&5
+echo "configure:7659: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GENCAT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7625: checking for $ac_word" >&5
+echo "configure:7695: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7662: checking for $ac_word" >&5
+echo "configure:7732: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7697: checking for $ac_word" >&5
+echo "configure:7767: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "msgfmt", so it can be a program name with args.
set dummy msgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7755: checking for $ac_word" >&5
+echo "configure:7825: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_MSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "gmsgfmt", so it can be a program name with args.
set dummy gmsgfmt; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7789: checking for $ac_word" >&5
+echo "configure:7859: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_GMSGFMT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
# Extract the first word of "xgettext", so it can be a program name with args.
set dummy xgettext; ac_word=$2
echo $ac_n "checking for $ac_word""... $ac_c" 1>&6
-echo "configure:7825: checking for $ac_word" >&5
+echo "configure:7895: checking for $ac_word" >&5
if eval "test \"`echo '$''{'ac_cv_path_XGETTEXT'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
LINGUAS=
else
echo $ac_n "checking for catalogs to be installed""... $ac_c" 1>&6
-echo "configure:7918: checking for catalogs to be installed" >&5
+echo "configure:7988: checking for catalogs to be installed" >&5
NEW_LINGUAS=
for lang in ${LINGUAS=$ALL_LINGUAS}; do
case "$ALL_LINGUAS" in
if test "$CATOBJEXT" = ".cat"; then
ac_safe=`echo "linux/version.h" | sed 'y%./+-%__p_%'`
echo $ac_n "checking for linux/version.h""... $ac_c" 1>&6
-echo "configure:7946: checking for linux/version.h" >&5
+echo "configure:8016: checking for linux/version.h" >&5
if eval "test \"`echo '$''{'ac_cv_header_$ac_safe'+set}'`\" = set"; then
echo $ac_n "(cached) $ac_c" 1>&6
else
cat > conftest.$ac_ext <<EOF
-#line 7951 "configure"
+#line 8021 "configure"
#include "confdefs.h"
#include <linux/version.h>
EOF
ac_try="$ac_cpp conftest.$ac_ext >/dev/null 2>conftest.out"
-{ (eval echo configure:7956: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
+{ (eval echo configure:8026: \"$ac_try\") 1>&5; (eval $ac_try) 2>&5; }
ac_err=`grep -v '^ *+' conftest.out | grep -v "^conftest.${ac_ext}\$"`
if test -z "$ac_err"; then
rm -rf conftest*
echo $ac_n "checking whether windows registry support is requested""... $ac_c" 1>&6
-echo "configure:8031: checking whether windows registry support is requested" >&5
+echo "configure:8101: checking whether windows registry support is requested" >&5
if test x$enable_win32_registry != xno; then
cat >> confdefs.h <<\EOF
#define ENABLE_WIN32_REGISTRY 1
if test x$enable_win32_registry != xno; then
echo $ac_n "checking registry key on windows hosts""... $ac_c" 1>&6
-echo "configure:8060: checking registry key on windows hosts" >&5
+echo "configure:8130: checking registry key on windows hosts" >&5
cat >> confdefs.h <<EOF
#define WIN32_REGISTRY_KEY "$gcc_cv_win32_registry_key"
EOF
# Figure out what assembler alignment features are present.
echo $ac_n "checking assembler alignment features""... $ac_c" 1>&6
-echo "configure:8236: checking assembler alignment features" >&5
+echo "configure:8306: checking assembler alignment features" >&5
gcc_cv_as=
gcc_cv_as_alignment_features=
gcc_cv_as_gas_srcdir=`echo $srcdir | sed -e 's,/gcc$,,'`/gas
echo "$ac_t""$gcc_cv_as_alignment_features" 1>&6
echo $ac_n "checking assembler subsection support""... $ac_c" 1>&6
-echo "configure:8357: checking assembler subsection support" >&5
+echo "configure:8427: checking assembler subsection support" >&5
gcc_cv_as_subsections=
if test x$gcc_cv_as != x; then
# Check if we have .subsection
case "$target" in
sparc*-*-*)
echo $ac_n "checking assembler .register pseudo-op support""... $ac_c" 1>&6
-echo "configure:8399: checking assembler .register pseudo-op support" >&5
+echo "configure:8469: checking assembler .register pseudo-op support" >&5
gcc_cv_as_register_pseudo_op=
if test x$gcc_cv_as != x; then
# Check if we have .register
echo "$ac_t""$gcc_cv_as_register_pseudo_op" 1>&6
echo $ac_n "checking assembler offsetable %lo() support""... $ac_c" 1>&6
-echo "configure:8416: checking assembler offsetable %lo() support" >&5
+echo "configure:8486: checking assembler offsetable %lo() support" >&5
gcc_cv_as_offsetable_lo10=
if test x$gcc_cv_as != x; then
# Check if assembler has offsetable %lo()
i[34567]86-*-*)
echo $ac_n "checking assembler instructions""... $ac_c" 1>&6
-echo "configure:8453: checking assembler instructions" >&5
+echo "configure:8523: checking assembler instructions" >&5
gcc_cv_as_instructions=
if test x$gcc_cv_as != x; then
set "filds fists" "filds mem; fists mem"
cpp_main=cppmain
fi)
-# Enable Multibyte Characters for C/C++
-AC_ARG_ENABLE(c-mbchar,
-[ --enable-c-mbchar enable multibyte characters for C and C++.],
-if test x$enable_c_mbchar != xno; then
- extra_c_flags=-DMULTIBYTE_CHARS=1
-fi)
-
# Disable fast fixincludes
AC_ARG_ENABLE(fast-fixincludes,
[ --disable-fast-fixincludes
cp $srcdir/fixincludes ./fixinc.sh
fi)
+# Enable Multibyte Characters for C/C++
+AC_ARG_ENABLE(c-mbchar,
+[ --enable-c-mbchar Enable multibyte characters for C and C++.],
+if [[[ x$enable_c_mbchar != xno ]]]; then
+ extra_c_flags=-DMULTIBYTE_CHARS=1
+fi)
+
# Enable threads
# Pass with no value to take the default
# Pass with a value to specify a thread package
AC_HEADER_TIME
GCC_HEADER_STRING
AC_HEADER_SYS_WAIT
-AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h fcntl.h unistd.h stab.h sys/file.h sys/time.h sys/resource.h sys/param.h sys/times.h sys/stat.h direct.h)
+AC_CHECK_HEADERS(limits.h stddef.h string.h strings.h stdlib.h time.h fcntl.h unistd.h stab.h sys/file.h sys/time.h sys/resource.h sys/param.h sys/times.h sys/stat.h direct.h malloc.h)
# Check for thread headers.
AC_CHECK_HEADER(thread.h, [have_thread_h=yes], [have_thread_h=])
esac
AC_FUNC_VFORK
-GCC_NEED_DECLARATIONS(malloc realloc calloc free bcopy bzero bcmp \
+GCC_NEED_DECLARATIONS(bcopy bzero bcmp \
index rindex getenv atol sbrk abort atof strerror getcwd getwd \
strsignal putc_unlocked fputs_unlocked strstr)
+GCC_NEED_DECLARATIONS(malloc realloc calloc free, [
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+])
+
GCC_NEED_DECLARATIONS(getrlimit setrlimit, [
#include <sys/types.h>
#ifdef HAVE_SYS_RESOURCE_H
intended to be called by the language-specific convert () functions. */
#include "config.h"
+#include "system.h"
#include "tree.h"
#include "flags.h"
#include "convert.h"
tree
build_min_nt VPROTO((enum tree_code code, ...))
{
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
enum tree_code code;
#endif
register struct obstack *ambient_obstack = expression_obstack;
VA_START (p, code);
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
code = va_arg (p, enum tree_code);
#endif
tree
build_min VPROTO((enum tree_code code, tree tt, ...))
{
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
enum tree_code code;
tree tt;
#endif
VA_START (p, tt);
-#ifndef __STDC__
+#ifndef ANSI_PROTOTYPES
code = va_arg (p, enum tree_code);
tt = va_arg (p, tree);
#endif
Like @samp{-pedantic}, except that errors are produced rather than
warnings.
-@item -Wtrigraphs
-@findex -Wtrigraphs
-Warn if any trigraphs are encountered. Currently this only works if you
-have turned trigraphs on with @samp{-trigraphs} or @samp{-ansi}; in the
-future this restriction will be removed.
-
@item -Wcomment
@findex -Wcomment
@ignore
Warn whenever a comment-start sequence @samp{/*} appears in a @samp{/*}
comment, or whenever a Backslash-Newline appears in a @samp{//} comment.
+@item -Wtrigraphs
+@findex -Wtrigraphs
+Warn if any trigraphs are encountered (assuming they are enabled).
+
+@item -Wwhite-space
+@findex -Wwhite-space
+Warn about possible white space confusion, e.g. white space between a
+backslash and a newline.
+
@item -Wall
@findex -Wall
-Requests both @samp{-Wtrigraphs} and @samp{-Wcomment} (but not
-@samp{-Wtraditional} or @samp{-Wundef}).
+Requests @samp{-Wcomment}, @samp{-Wtrigraphs}, and @samp{-Wwhite-space}
+(but not @samp{-Wtraditional} or @samp{-Wundef}).
@item -Wtraditional
@findex -Wtraditional
/* Part of CPP library. (memory allocation - xmalloc etc)
- Copyright (C) 1986, 87, 89, 92, 93, 94, 1995, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1986, 87, 89, 92-95, 1998 Free Software Foundation, Inc.
Written by Per Bothner, 1994.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
/* Part of CPP library. (Macro handling.)
- Copyright (C) 1986, 87, 89, 92-95, 1996, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1986, 87, 89, 92-96, 98, 1999 Free Software Foundation, Inc.
Written by Per Bothner, 1994.
Based on CCCP program by Paul Rubin, June 1986
Adapted to ANSI C, Richard Stallman, Jan 1987
if (GET_CODE (op1) == AND)
{
if (rtx_equal_p (op0, XEXP (op1, 0)))
- return cse_gen_binary (AND, mode, op0, gen_rtx_NOT (mode, XEXP (op1, 1)));
+ return cse_gen_binary (AND, mode, op0,
+ gen_rtx_NOT (mode, XEXP (op1, 1)));
if (rtx_equal_p (op0, XEXP (op1, 1)))
- return cse_gen_binary (AND, mode, op0, gen_rtx_NOT (mode, XEXP (op1, 0)));
+ return cse_gen_binary (AND, mode, op0,
+ gen_rtx_NOT (mode, XEXP (op1, 0)));
}
break;
return gen_rtx_MULT (mode, op0,
CONST_DOUBLE_FROM_REAL_VALUE (d, mode));
#else
- return gen_rtx_MULT (mode, op0,
- CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode));
+ return
+ gen_rtx_MULT (mode, op0,
+ CONST_DOUBLE_FROM_REAL_VALUE (1./d, mode));
#endif
}
}
&& qty_first_reg[REG_QTY (REGNO (dest))] != REGNO (dest)
&& GET_CODE (src) == REG && REGNO (src) == REGNO (dest)
/* Don't do this if the original insn had a hard reg as
- SET_SRC. */
+ SET_SRC or SET_DEST. */
&& (GET_CODE (sets[i].src) != REG
- || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER))
+ || REGNO (sets[i].src) >= FIRST_PSEUDO_REGISTER)
+ && (GET_CODE (dest) != REG || REGNO (dest) >= FIRST_PSEUDO_REGISTER))
/* We can't call canon_reg here because it won't do anything if
SRC is a hard register. */
{
if (note)
XEXP (note, 0) = const_insn;
else
- REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_WAS_0,
- const_insn,
- REG_NOTES (insn));
+ REG_NOTES (insn)
+ = gen_rtx_INSN_LIST (REG_WAS_0, const_insn,
+ REG_NOTES (insn));
}
}
}
qty_first_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int));
qty_last_reg = (int *) alloca ((max_qty - max_reg) * sizeof (int));
- qty_mode= (enum machine_mode *) alloca ((max_qty - max_reg) * sizeof (enum machine_mode));
+ qty_mode = (enum machine_mode *) alloca ((max_qty - max_reg)
+ * sizeof (enum machine_mode));
qty_const = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx));
qty_const_insn = (rtx *) alloca ((max_qty - max_reg) * sizeof (rtx));
qty_comparison_code
#define ASM_OUTPUT_DWARF_DELTA2(FILE,LABEL1,LABEL2) \
assemble_integer (gen_rtx_MINUS (HImode, \
- gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
- gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
2, 1)
#define ASM_OUTPUT_DWARF_DELTA4(FILE,LABEL1,LABEL2) \
assemble_integer (gen_rtx_MINUS (SImode, \
- gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
- gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
4, 1)
#define ASM_OUTPUT_DWARF_ADDR_DELTA(FILE,LABEL1,LABEL2) \
assemble_integer (gen_rtx_MINUS (Pmode, \
- gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
- gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL1), \
+ gen_rtx_SYMBOL_REF (Pmode, LABEL2)), \
PTR_SIZE, 1)
#define ASM_OUTPUT_DWARF_DELTA(FILE,LABEL1,LABEL2) \
rtx new_addr = fix_lexical_addr (XEXP (loc, 0), bound);
if (XEXP (loc, 0) != new_addr)
- loc = gen_rtx (MEM, GET_MODE (loc), new_addr);
+ loc = gen_rtx_MEM (GET_MODE (loc), new_addr);
}
add_AT_flag (decl_die, DW_AT_artificial, 1);
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
+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.
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+
#include "config.h"
#include "system.h"
#include "dyn-string.h"
-/* Create a new dynamic string capable of holding at least SPACE
- characters, including the terminating NUL. If SPACE is 0, it
- will be silently increased to 1. */
+/* Create a new dynamic string capable of holding at least SPACE characters,
+ including the terminating NUL. If SPACE is 0, it will be silently
+ increased to 1. */
dyn_string_t
dyn_string_new (space)
{
dyn_string_t result = (dyn_string_t) xmalloc (sizeof (struct dyn_string));
+ /* We need at least one byte in which to store the terminating NUL. */
if (space == 0)
- /* We need at least one byte in which to store the terminating
- NUL. */
space = 1;
result->allocated = space;
- result->s = (char*) xmalloc (space);
+ result->s = (char *) xmalloc (space);
result->length = 0;
result->s[0] = '\0';
free (ds);
}
-/* Append the NUL-terminated string S to DS, resizing DS if
- necessary. */
+/* Append the NUL-terminated string S to DS, resizing DS if necessary. */
dyn_string_t
dyn_string_append (ds, s)
const char *s;
{
int len = strlen (s);
- dyn_string_resize (ds, ds->length + len + 1 /* '\0' */);
+
+ /* The new length is the old length plus the size of our string, plus
+ one for the null at the end. */
+ dyn_string_resize (ds, ds->length + len + 1);
strcpy (ds->s + ds->length, s);
ds->length += len;
return ds;
}
-/* Increase the capacity of DS so that it can hold at least SPACE
- characters, including the terminating NUL. This function will not
- (at present) reduce the capacity of DS. */
+/* Increase the capacity of DS so it can hold at least SPACE characters,
+ including the terminating NUL. This function will not (at present)
+ reduce the capacity of DS. */
dyn_string_t
dyn_string_resize (ds, space)
{
/* We actually need more space. */
ds->allocated = new_allocated;
- ds->s = (char*) xrealloc (ds->s, ds->allocated);
+ ds->s = (char *) xrealloc (ds->s, ds->allocated);
}
return ds;
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
+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.
+GNU CC is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GNU CC; see the file COPYING. If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+
typedef struct dyn_string
{
- int allocated; /* The amount of space allocated for the string. */
- int length; /* The actual length of the string. */
- char *s; /* The string itself, NUL-terminated. */
+ int allocated; /* The amount of space allocated for the string. */
+ int length; /* The actual length of the string. */
+ char *s; /* The string itself, NUL-terminated. */
}* dyn_string_t;
extern dyn_string_t dyn_string_new PROTO((int));
static rtx find_line_note PROTO((rtx));
static void mark_sequence_stack PROTO((struct sequence_stack *));
\f
+/* There are some RTL codes that require special attention; the generation
+ functions do the raw handling. If you add to this list, modify
+ special_rtx in gengenrtl.c as well. */
+
rtx
gen_rtx_CONST_INT (mode, arg)
enum machine_mode mode;
if (mode == Pmode && !reload_in_progress)
{
- if (regno == FRAME_POINTER_REGNUM)
+ if (frame_pointer_rtx != 0 && regno == FRAME_POINTER_REGNUM)
return frame_pointer_rtx;
#if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
- if (regno == HARD_FRAME_POINTER_REGNUM)
+ if (hard_frame_pointer_rtx != 0 && regno == HARD_FRAME_POINTER_REGNUM)
return hard_frame_pointer_rtx;
#endif
#if FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM && HARD_FRAME_POINTER_REGNUM != ARG_POINTER_REGNUM
- if (regno == ARG_POINTER_REGNUM)
+ if (arg_pointer_rtx != 0 && regno == ARG_POINTER_REGNUM)
return arg_pointer_rtx;
#endif
#ifdef RETURN_ADDRESS_POINTER_REGNUM
- if (regno == RETURN_ADDRESS_POINTER_REGNUM)
+ if (return_address_pointer_rtx != 0
+ && regno == RETURN_ADDRESS_POINTER_REGNUM)
return return_address_pointer_rtx;
#endif
- if (regno == STACK_POINTER_REGNUM)
+ if (stack_pointer_rtx != 0 && regno == STACK_POINTER_REGNUM)
return stack_pointer_rtx;
}
return rt;
}
-
+\f
/* rtx gen_rtx (code, mode, [element1, ..., elementn])
**
** This routine generates an RTX of the size specified by
i = INTVAL (x);
r = REAL_VALUE_FROM_TARGET_SINGLE (i);
+ /* Avoid changing the bit pattern of a NaN. */
+ if (REAL_VALUE_ISNAN (r))
+ return 0;
return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
}
#else
i[0] = low, i[1] = high;
r = REAL_VALUE_FROM_TARGET_DOUBLE (i);
+ if (REAL_VALUE_ISNAN (r))
+ return 0;
return CONST_DOUBLE_FROM_REAL_VALUE (r, mode);
}
#else
}
else
{
- rtx new = gen_rtx_COMPARE (VOIDmode, CONST0_RTX (GET_MODE (comp)), comp);
+ rtx new = gen_rtx_COMPARE (VOIDmode,
+ CONST0_RTX (GET_MODE (comp)), comp);
if (GET_CODE (body) == SET)
SET_SRC (body) = new;
else
if (GET_CODE (user) == INSN && GET_CODE (PATTERN (user)) == SEQUENCE)
user = XVECEXP (PATTERN (user), 0, 0);
- REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn, REG_NOTES (user));
+ REG_NOTES (user) = gen_rtx_INSN_LIST (REG_CC_SETTER, insn,
+ REG_NOTES (user));
REG_NOTES (insn) = gen_rtx_INSN_LIST (REG_CC_USER, user, REG_NOTES (insn));
}
/* Create the unique rtx's for certain rtx codes and operand values. */
+ /* Don't use gen_rtx here since gen_rtx in this case
+ tries to use these variables. */
for (i = - MAX_SAVED_CONST_INT; i <= MAX_SAVED_CONST_INT; i++)
{
PUT_CODE (&const_int_rtx[i + MAX_SAVED_CONST_INT], CONST_INT);
#ifdef STATIC_CHAIN_INCOMING_REGNUM
if (STATIC_CHAIN_INCOMING_REGNUM != STATIC_CHAIN_REGNUM)
- static_chain_incoming_rtx = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
+ static_chain_incoming_rtx
+ = gen_rtx_REG (Pmode, STATIC_CHAIN_INCOMING_REGNUM);
else
#endif
static_chain_incoming_rtx = static_chain_rtx;
if (GET_CODE (x) == LO_SUM)
return gen_rtx_LO_SUM (mode, XEXP (x, 0),
- plus_constant_for_output (XEXP (x, 1), c));
+ plus_constant_for_output (XEXP (x, 1), c));
else
return plus_constant (x, c);
#else
target = copy_to_mode_reg (Pmode, target);
#endif
+
+ if (mode == VOIDmode)
+ mode = Pmode;
+
size = convert_modes (mode, ptr_mode, size, 1);
if (insn_operand_predicate[(int) CODE_FOR_allocate_stack][1]
&& ! ((*insn_operand_predicate[(int) CODE_FOR_allocate_stack][1])
if (insn_operand_predicate[(int) CODE_FOR_check_stack][0]
&& ! ((*insn_operand_predicate[(int) CODE_FOR_check_stack][0])
- (last_address, Pmode)))
- last_address = copy_to_mode_reg (Pmode, last_address);
+ (last_addr, Pmode)))
+ last_addr = copy_to_mode_reg (Pmode, last_addr);
- emit_insn (gen_check_stack (last_address));
+ emit_insn (gen_check_stack (last_addr));
return;
}
#endif
#define MAX_BITS_PER_WORD BITS_PER_WORD
#endif
-/* Cost of various pieces of RTL. Note that some of these are indexed by shift count,
- and some by mode. */
+/* Cost of various pieces of RTL. Note that some of these are indexed by
+ shift count and some by mode. */
static int add_cost, negate_cost, zero_cost;
static int shift_cost[MAX_BITS_PER_WORD];
static int shiftadd_cost[MAX_BITS_PER_WORD];
makes. */
free_point = (char *) oballoc (0);
- reg = gen_rtx (REG, word_mode, 10000);
+ reg = gen_rtx_REG (word_mode, 10000);
zero_cost = rtx_cost (const0_rtx, 0);
add_cost = rtx_cost (gen_rtx_PLUS (word_mode, reg, reg), SET);
mul_highpart_cost[(int) mode]
= rtx_cost (gen_rtx_TRUNCATE
(mode,
- gen_rtx_LSHIFTRT
- (wider_mode,
- gen_rtx_MULT (wider_mode,
- gen_rtx_ZERO_EXTEND (wider_mode, reg),
- gen_rtx_ZERO_EXTEND (wider_mode, reg)),
- GEN_INT (GET_MODE_BITSIZE (mode)))),
+ gen_rtx_LSHIFTRT (wider_mode,
+ gen_rtx_MULT (wider_mode,
+ gen_rtx_ZERO_EXTEND
+ (wider_mode, reg),
+ gen_rtx_ZERO_EXTEND
+ (wider_mode, reg)),
+ GEN_INT (GET_MODE_BITSIZE (mode)))),
SET);
}
}
}
emit_insn (GEN_FCN (icode)
- (gen_rtx_SUBREG (fieldmode, op0, offset), value));
+ (gen_rtx_SUBREG (fieldmode, op0, offset), value));
}
return value;
}
tem = expand_shift (LSHIFT_EXPR, mode, op0,
build_int_2 (log, 0), NULL_RTX, 0);
accum = force_operand (gen_rtx_PLUS (mode, accum, tem),
- add_target ? add_target : accum_target);
+ add_target
+ ? add_target : accum_target);
val_so_far += (HOST_WIDE_INT) 1 << log;
break;
tem = expand_shift (LSHIFT_EXPR, mode, op0,
build_int_2 (log, 0), NULL_RTX, 0);
accum = force_operand (gen_rtx_MINUS (mode, accum, tem),
- add_target ? add_target : accum_target);
+ add_target
+ ? add_target : accum_target);
val_so_far -= (HOST_WIDE_INT) 1 << log;
break;
build_int_2 (log, 0), shift_subtarget,
0);
accum = force_operand (gen_rtx_PLUS (mode, accum, op0),
- add_target ? add_target : accum_target);
+ add_target
+ ? add_target : accum_target);
val_so_far = (val_so_far << log) + 1;
break;
build_int_2 (log, 0), shift_subtarget,
0);
accum = force_operand (gen_rtx_MINUS (mode, accum, op0),
- add_target ? add_target : accum_target);
+ add_target
+ ? add_target : accum_target);
val_so_far = (val_so_far << log) - 1;
break;
tem = expand_shift (LSHIFT_EXPR, mode, accum,
build_int_2 (log, 0), NULL_RTX, 0);
accum = force_operand (gen_rtx_PLUS (mode, accum, tem),
- add_target ? add_target : accum_target);
+ add_target
+ ? add_target : accum_target);
val_so_far += val_so_far << log;
break;
t3 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
build_int_2 (size - 1, 0), NULL_RTX, 0);
if (d < 0)
- quotient = force_operand (gen_rtx_MINUS (compute_mode, t3, t2),
- tquotient);
+ quotient
+ = force_operand (gen_rtx_MINUS (compute_mode,
+ t3, t2),
+ tquotient);
else
- quotient = force_operand (gen_rtx_MINUS (compute_mode, t2, t3),
- tquotient);
+ quotient
+ = force_operand (gen_rtx_MINUS (compute_mode,
+ t2, t3),
+ tquotient);
}
else
{
max_cost - extra_cost);
if (t1 == 0)
goto fail1;
- t2 = force_operand (gen_rtx_PLUS (compute_mode, t1, op0),
+ t2 = force_operand (gen_rtx_PLUS (compute_mode,
+ t1, op0),
NULL_RTX);
t3 = expand_shift (RSHIFT_EXPR, compute_mode, t2,
- build_int_2 (post_shift, 0), NULL_RTX, 0);
+ build_int_2 (post_shift, 0),
+ NULL_RTX, 0);
t4 = expand_shift (RSHIFT_EXPR, compute_mode, op0,
- build_int_2 (size - 1, 0), NULL_RTX, 0);
+ build_int_2 (size - 1, 0),
+ NULL_RTX, 0);
if (d < 0)
- quotient = force_operand (gen_rtx_MINUS (compute_mode, t4, t3),
- tquotient);
+ quotient
+ = force_operand (gen_rtx_MINUS (compute_mode,
+ t4, t3),
+ tquotient);
else
- quotient = force_operand (gen_rtx_MINUS (compute_mode, t3, t4),
- tquotient);
+ quotient
+ = force_operand (gen_rtx_MINUS (compute_mode,
+ t3, t4),
+ tquotient);
}
}
else /* Too wide mode to use tricky code */
we don't have to do anything. */
if (normalizep == 0 || normalizep == STORE_FLAG_VALUE)
;
- else if (normalizep == - STORE_FLAG_VALUE)
+ /* STORE_FLAG_VALUE might be the most negative number, so write
+ the comparison this way to avoid a compiler-time warning. */
+ else if (- normalizep == STORE_FLAG_VALUE)
op0 = expand_unop (compare_mode, neg_optab, op0, subtarget, 0);
/* We don't want to use STORE_FLAG_VALUE < 0 below since this
int autinc_to;
int explicit_inc_to;
int to_struct;
+ int to_readonly;
rtx from;
rtx from_addr;
int autinc_from;
int explicit_inc_from;
int from_struct;
+ int from_readonly;
int len;
int offset;
int reverse;
static void move_by_pieces_1 PROTO((rtx (*) (rtx, ...), enum machine_mode,
struct move_by_pieces *));
static void clear_by_pieces PROTO((rtx, int, int));
-static void clear_by_pieces_1 PROTO((rtx (*) (rtx, ...), enum machine_mode,
+static void clear_by_pieces_1 PROTO((rtx (*) (rtx, ...),
+ enum machine_mode,
struct clear_by_pieces *));
static int is_zeros_p PROTO((tree));
static int mostly_zeros_p PROTO((tree));
static void store_constructor_field PROTO((rtx, int, int, enum machine_mode,
- tree, tree, int));
-static void store_constructor PROTO((tree, rtx, int));
+ tree, tree, int, int));
+static void store_constructor PROTO((tree, rtx, int, int));
static rtx store_field PROTO((rtx, int, int, enum machine_mode, tree,
enum machine_mode, int, int,
int, int));
enqueue_insn (var, body)
rtx var, body;
{
- pending_chain = gen_rtx_QUEUED (GET_MODE (var),
- var, NULL_RTX, NULL_RTX, body,
- pending_chain);
+ pending_chain = gen_rtx_QUEUED (GET_MODE (var), var, NULL_RTX, NULL_RTX,
+ body, pending_chain);
return pending_chain;
}
data.to_struct = MEM_IN_STRUCT_P (to);
data.from_struct = MEM_IN_STRUCT_P (from);
+ data.to_readonly = RTX_UNCHANGING_P (to);
+ data.from_readonly = RTX_UNCHANGING_P (from);
/* If copying requires more than two move insns,
copy addresses to registers (to make displacements shorter)
plus_constant (data->to_addr,
data->offset))));
MEM_IN_STRUCT_P (to1) = data->to_struct;
+ RTX_UNCHANGING_P (to1) = data->to_readonly;
from1
= (data->autinc_from
plus_constant (data->from_addr,
data->offset))));
MEM_IN_STRUCT_P (from1) = data->from_struct;
+ RTX_UNCHANGING_P (from1) = data->from_readonly;
if (HAVE_PRE_DECREMENT && data->explicit_inc_to < 0)
emit_insn (gen_add2_insn (data->to_addr, GEN_INT (-size)));
negate_rtx (Pmode, plus_constant (size, extra)));
else
temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
- negate_rtx (Pmode, size));
+ negate_rtx (Pmode, size));
#endif
return memory_address (GET_CLASS_NARROWEST_MODE (MODE_INT), temp);
expand_assignment (to, from, want_value, suggest_reg)
tree to, from;
int want_value;
- int suggest_reg;
+ int suggest_reg ATTRIBUTE_UNUSED;
{
register rtx to_rtx = 0;
rtx result;
to_rtx = change_address (to_rtx, VOIDmode,
gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
- force_reg (ptr_mode, offset_rtx)));
+ force_reg (ptr_mode,
+ offset_rtx)));
}
+
if (volatilep)
{
if (GET_CODE (to_rtx) == MEM)
/* Helper function for store_constructor.
TARGET, BITSIZE, BITPOS, MODE, EXP are as for store_field.
TYPE is the type of the CONSTRUCTOR, not the element type.
- CLEARED is as for store_constructor.
+ ALIGN and CLEARED are as for store_constructor.
This provides a recursive shortcut back to store_constructor when it isn't
necessary to go through store_field. This is so that we can pass through
static void
store_constructor_field (target, bitsize, bitpos,
- mode, exp, type, cleared)
+ mode, exp, type, align, cleared)
rtx target;
int bitsize, bitpos;
enum machine_mode mode;
tree exp, type;
+ int align;
int cleared;
{
if (TREE_CODE (exp) == CONSTRUCTOR
target = change_address (target, VOIDmode,
plus_constant (XEXP (target, 0),
bitpos / BITS_PER_UNIT));
- store_constructor (exp, target, cleared);
+ store_constructor (exp, target, align, cleared);
}
else
- store_field (target, bitsize, bitpos, mode, exp,
- VOIDmode, 0, TYPE_ALIGN (type) / BITS_PER_UNIT,
- int_size_in_bytes (type), 0);
+ store_field (target, bitsize, bitpos, mode, exp, VOIDmode, 0,
+ (align + BITS_PER_UNIT - 1) / BITS_PER_UNIT,
+ int_size_in_bytes (type), cleared);
}
/* Store the value of constructor EXP into the rtx TARGET.
TARGET is either a REG or a MEM.
+ ALIGN is the maximum known alignment for TARGET, in bits.
CLEARED is true if TARGET is known to have been zero'd. */
static void
-store_constructor (exp, target, cleared)
+store_constructor (exp, target, align, cleared)
tree exp;
rtx target;
+ int align;
int cleared;
{
tree type = TREE_TYPE (exp);
{
if (! cleared)
clear_storage (target, expr_size (exp),
- TYPE_ALIGN (type) / BITS_PER_UNIT);
+ (align + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
cleared = 1;
}
for (elt = CONSTRUCTOR_ELTS (exp); elt; elt = TREE_CHAIN (elt))
{
register tree field = TREE_PURPOSE (elt);
+#ifdef WORD_REGISTER_OPERATIONS
tree value = TREE_VALUE (elt);
+#endif
register enum machine_mode mode;
int bitsize;
int bitpos = 0;
to_rtx
= change_address (to_rtx, VOIDmode,
gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
- force_reg (ptr_mode, offset_rtx)));
+ force_reg (ptr_mode,
+ offset_rtx)));
}
+
if (TREE_READONLY (field))
{
if (GET_CODE (to_rtx) == MEM)
mode = word_mode;
}
#endif
- store_constructor_field (to_rtx, bitsize, bitpos,
- mode, value, type, cleared);
+ store_constructor_field (to_rtx, bitsize, bitpos, mode,
+ TREE_VALUE (elt), type,
+ MIN (align,
+ DECL_ALIGN (TREE_PURPOSE (elt))),
+ cleared);
}
}
else if (TREE_CODE (type) == ARRAY_TYPE)
{
if (! cleared)
clear_storage (target, expr_size (exp),
- TYPE_ALIGN (type) / BITS_PER_UNIT);
+ (align + BITS_PER_UNIT - 1) / BITS_PER_UNIT);
cleared = 1;
}
else
int bitpos;
int unsignedp;
tree value = TREE_VALUE (elt);
+ int align = TYPE_ALIGN (TREE_TYPE (value));
tree index = TREE_PURPOSE (elt);
rtx xtarget = target;
for (; lo <= hi; lo++)
{
bitpos = lo * TREE_INT_CST_LOW (TYPE_SIZE (elttype));
- store_constructor_field (target, bitsize, bitpos,
- mode, value, type, cleared);
+ store_constructor_field (target, bitsize, bitpos, mode,
+ value, type, align, cleared);
}
}
else
addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
xtarget = change_address (target, mode, addr);
if (TREE_CODE (value) == CONSTRUCTOR)
- store_constructor (value, xtarget, cleared);
+ store_constructor (value, xtarget, align, cleared);
else
store_expr (value, xtarget, 0);
* TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
else
bitpos = (i * TREE_INT_CST_LOW (TYPE_SIZE (elttype)));
- store_constructor_field (target, bitsize, bitpos,
- mode, value, type, cleared);
+ store_constructor_field (target, bitsize, bitpos, mode, value,
+ type, align, cleared);
}
}
}
label_rtx (exp),
forced_labels);
}
+
temp = gen_rtx_MEM (FUNCTION_MODE,
gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
if (function != current_function_decl
RTX_UNCHANGING_P (target) = 1;
}
- store_constructor (exp, target, 0);
+ store_constructor (exp, target, TYPE_ALIGN (TREE_TYPE (exp)), 0);
return target;
}
op0 = change_address (op0, VOIDmode,
gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
- force_reg (ptr_mode, offset_rtx)));
+ force_reg (ptr_mode,
+ offset_rtx)));
}
/* Don't forget about volatility even if this is a bitfield. */
}
/* Check the access. */
- if (current_function && current_function_check_memory_usage
- && GET_CODE (op0) == MEM)
+ if (current_function_check_memory_usage && GET_CODE (op0) == MEM)
{
enum memory_use_mode memory_usage;
memory_usage = get_memory_usage_from_modifier (modifier);
/* Apply distributive law if OP0 is x+c. */
if (GET_CODE (op0) == PLUS
&& GET_CODE (XEXP (op0, 1)) == CONST_INT)
- return gen_rtx_PLUS (mode,
- gen_rtx_MULT (mode, XEXP (op0, 0),
- GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
- GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
- * INTVAL (XEXP (op0, 1))));
+ return
+ gen_rtx_PLUS
+ (mode,
+ gen_rtx_MULT
+ (mode, XEXP (op0, 0),
+ GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
+ GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
+ * INTVAL (XEXP (op0, 1))));
if (GET_CODE (op0) != REG)
op0 = force_operand (op0, NULL_RTX);
if (GET_CODE (op0) != REG)
op0 = copy_to_mode_reg (mode, op0);
- return gen_rtx_MULT (mode, op0,
- GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
+ return
+ gen_rtx_MULT (mode, op0,
+ GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
}
if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1), 1))
op0 = protect_from_queue (op0, 0);
- /* We would like the object in memory. If it is a constant,
- we can have it be statically allocated into memory. For
- a non-constant (REG, SUBREG or CONCAT), we need to allocate some
- memory and store the value into it. */
+ /* We would like the object in memory. If it is a constant, we can
+ have it be statically allocated into memory. For a non-constant,
+ we need to allocate some memory and store the value into it. */
if (CONSTANT_P (op0))
op0 = force_const_mem (TYPE_MODE (TREE_TYPE (TREE_OPERAND (exp, 0))),
extern rtx emit_move_insn PROTO((rtx, rtx));
/* Emit insns to set X from Y, with no frills. */
-extern rtx emit_move_insn_1 PROTO ((rtx, rtx));
+extern rtx emit_move_insn_1 PROTO((rtx, rtx));
/* Push a block of length SIZE (perhaps variable)
and return an rtx to address the beginning of the block. */
-@c Copyright (C) 1988,89,92,93,94,96,99 Free Software Foundation, Inc.
+@c Copyright (C) 1988,89,92,93,94,96,98, 99 Free Software Foundation, Inc.
@c This is part of the GCC manual.
@c For copying conditions, see the file gcc.texi.
function.
* Return Address:: Getting the return or frame address of a function.
* Deprecated Features:: Things might disappear from g++.
+* Other Builtins:: Other built-in functions.
@end menu
@end ifclear
@node Hex Floats
@section Hex Floats
@cindex hex floats
-GNU CC recognizes floating-point numbers written not only in the usual
+
+GNU CC recognizes floating-point numbers writen not only in the usual
decimal notation, such as @code{1.55e1}, but also numbers such as
@code{0x1.fp3} written in hexadecimal format. In that format the
@code{0x} hex introducer and the @code{p} or @code{P} exponent field are
@item no_check_memory_usage
@cindex @code{no_check_memory_usage} function attribute
-If @samp{-fcheck-memory-usage} is given, calls to support routines will
-be generated before most memory accesses, to permit support code to
-record usage and detect uses of uninitialized or unallocated storage.
-Since the compiler cannot handle them properly, @code{asm} statements
-are not allowed. Declaring a function with this attribute disables the
+The @code{no_check_memory_usage} attribute causes GNU CC to omit checks
+of memory references when it generates code for that function. Normally
+if you specify @samp{-fcheck-memory-usage} (see @pxref{Code Gen
+Options}), GNU CC generates calls to support routines before most memory
+accesses to permit support code to record usage and detect uses of
+uninitialized or unallocated storage. Since GNU CC cannot handle
+@code{asm} statements properly they are not allowed in such functions.
+If you declare a function with this attribute, GNU CC will not generate
memory checking code for that function, permitting the use of @code{asm}
-statements without requiring separate compilation with different
-options, and allowing you to write support routines of your own if you
-wish, without getting infinite recursion if they get compiled with this
-option.
+statements without having to compile that function with different
+options. This also allows you to write support routines of your own if
+you wish, without getting infinite recursion if they get compiled with
+@code{-fcheck-memory-usage}.
@item regparm (@var{number})
@cindex functions that are passed arguments in registers on the 386
: "r0", "r1", "r2", "r3", "r4", "r5");
@end example
-It is an error for a clobber description to overlap an input or output
-operand (for example, an operand describing a register class with one
-member, mentioned in the clobber list). Most notably, it is invalid to
-describe that an input operand is modified, but unused as output. It has
-to be specified as an input and output operand anyway. Note that if there
-are only unused output operands, you will then also need to specify
-@code{volatile} for the @code{asm} construct, as described below.
+You may not write a clobber description in a way that overlaps with an
+input or output operand. For example, you may not have an operand
+describing a register class with one member if you mention that register
+in the clobber list. There is no way for you to specify that an input
+operand is modified without also specifying it as an output
+operand. Note that if all the output operands you specify are for this
+purpose (and hence unused), you will then also need to specify
+@code{volatile} for the @code{asm} construct, as described below, to
+prevent GNU CC from deleting the @code{asm} statement as unused.
If you refer to a particular hardware register from the assembler code,
you will probably have to list the register after the third colon to
if (write_symbols != NO_DEBUG && profile_block_flag)
{
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 5);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, 1);
ASM_GENERATE_INTERNAL_LABEL (name, "LPBX", 6);
- assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name), pointer_bytes, 1);
+ assemble_integer (gen_rtx_SYMBOL_REF (Pmode, name),
+ pointer_bytes, 1);
}
else
{
#include "insn-flags.h"
#include "obstack.h"
+
#define obstack_chunk_alloc xmalloc
#define obstack_chunk_free free
putc ('\n', outf);
}
}
+
+ if (current_function_epilogue_delay_list != 0)
+ {
+ fprintf (outf, "\n;; Insns in epilogue delay list:\n\n");
+ for (tmp_rtx = current_function_epilogue_delay_list; tmp_rtx != 0;
+ tmp_rtx = XEXP (tmp_rtx, 1))
+ print_rtl_single (outf, XEXP (tmp_rtx, 0));
+ }
}
\f
TREE_TYPE (exp), TREE_OPERAND (exp, 0),
TREE_OPERAND (exp, 1));
- else if (current_function_decl != 0
+ else if (global_bindings_p () == 0
&& ! contains_placeholder_p (lhs))
{
tree common = save_expr (lhs);
&& (TREE_CODE (arg0) != COND_EXPR
|| count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
&& (! TREE_SIDE_EFFECTS (arg0)
- || (current_function_decl != 0
+ || (global_bindings_p () == 0
&& ! contains_placeholder_p (arg0))))
{
tree test, true_value, false_value;
in that case. */
if (TREE_CODE (arg0) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
- && current_function_decl != 0
+ && global_bindings_p () == 0
&& ((TREE_CODE (arg0) != VAR_DECL
&& TREE_CODE (arg0) != PARM_DECL)
|| TREE_SIDE_EFFECTS (arg0)))
&& (TREE_CODE (arg1) != COND_EXPR
|| count_cond (arg0, 25) + count_cond (arg1, 25) <= 25)
&& (! TREE_SIDE_EFFECTS (arg1)
- || (current_function_decl != 0
+ || (global_bindings_p () == 0
&& ! contains_placeholder_p (arg1))))
{
tree test, true_value, false_value;
}
if (TREE_CODE (arg1) != SAVE_EXPR && ! TREE_CONSTANT (arg0)
- && current_function_decl != 0
+ && global_bindings_p () == 0
&& ((TREE_CODE (arg1) != VAR_DECL
&& TREE_CODE (arg1) != PARM_DECL)
|| TREE_SIDE_EFFECTS (arg1)))
if (real_onep (arg1))
return non_lvalue (convert (type, arg0));
/* x*2 is x+x */
- if (! wins && real_twop (arg1) && current_function_decl != 0
+ if (! wins && real_twop (arg1) && global_bindings_p () == 0
&& ! contains_placeholder_p (arg0))
{
tree arg = save_expr (arg0);
} /* switch (code) */
}
-/* Determine if first argument is a multiple of second argument.
- Return 0 if it is not, or is not easily determined to so be.
+/* Determine if first argument is a multiple of second argument. Return 0 if
+ it is not, or we cannot easily determined it to be.
- An example of the sort of thing we care about (at this point --
- this routine could surely be made more general, and expanded
- to do what the *_DIV_EXPR's fold() cases do now) is discovering
- that
+ An example of the sort of thing we care about (at this point; this routine
+ could surely be made more general, and expanded to do what the *_DIV_EXPR's
+ fold cases do now) is discovering that
SAVE_EXPR (I) * SAVE_EXPR (J * 8)
SAVE_EXPR (J * 8)
- when we know that the two `SAVE_EXPR (J * 8)' nodes are the
- same node (which means they will have the same value at run
- time, even though we don't know when they'll be assigned).
+ when we know that the two SAVE_EXPR (J * 8) nodes are the same node.
This code also handles discovering that
SAVE_EXPR (I) * SAVE_EXPR (J * 8)
- is a multiple of
-
- 8
-
- (of course) so we don't have to worry about dealing with a
+ is a multiple of 8 so we don't have to worry about dealing with a
possible remainder.
- Note that we _look_ inside a SAVE_EXPR only to determine
- how it was calculated; it is not safe for fold() to do much
- of anything else with the internals of a SAVE_EXPR, since
- fold() cannot know when it will be evaluated at run time.
- For example, the latter example above _cannot_ be implemented
- as
-
- SAVE_EXPR (I) * J
-
- or any variant thereof, since the value of J at evaluation time
- of the original SAVE_EXPR is not necessarily the same at the time
- the new expression is evaluated. The only optimization of this
+ Note that we *look* inside a SAVE_EXPR only to determine how it was
+ calculated; it is not safe for fold to do much of anything else with the
+ internals of a SAVE_EXPR, since it cannot know when it will be evaluated
+ at run time. For example, the latter example above *cannot* be implemented
+ as SAVE_EXPR (I) * J or any variant thereof, since the value of J at
+ evaluation time of the original SAVE_EXPR is not necessarily the same at
+ the time the new expression is evaluated. The only optimization of this
sort that would be valid is changing
SAVE_EXPR (I) * SAVE_EXPR (SAVE_EXPR (J) * 8)
- divided by
- 8
- to
+ divided by 8 to
SAVE_EXPR (I) * SAVE_EXPR (J)
&& multiple_of_p (type, TREE_OPERAND (top, 1), bottom));
case NOP_EXPR:
- /* Punt if conversion from non-integral or wider integral type. */
+ /* Can't handle conversions from non-integral or wider integral type. */
if ((TREE_CODE (TREE_TYPE (TREE_OPERAND (top, 0))) != INTEGER_TYPE)
|| (TYPE_PRECISION (type)
< TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
return 0;
- /* Fall through. */
+
+ /* .. fall through ... */
+
case SAVE_EXPR:
return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
return 0;
}
}
-\f
struct fixup_replacement *p;
/* See if we have already replaced this. */
- for (p = *replacements; p && p->old != x; p = p->next)
+ for (p = *replacements; p != 0 && ! rtx_equal_p (p->old, x); p = p->next)
;
if (p == 0)
pos %= GET_MODE_BITSIZE (wanted_mode);
newmem = gen_rtx_MEM (wanted_mode,
- plus_constant (XEXP (tem, 0), offset));
+ plus_constant (XEXP (tem, 0),
+ offset));
RTX_UNCHANGING_P (newmem) = RTX_UNCHANGING_P (tem);
MEM_COPY_ATTRIBUTES (newmem, tem);
code = GET_CODE (x);
- if (code == ADDRESSOF && GET_CODE (XEXP (x, 0)) == MEM)
+ /* If we don't return in any of the cases below, we will recurse inside
+ the RTX, which will normally result in any ADDRESSOF being forced into
+ memory. */
+ if (code == SET)
+ {
+ purge_addressof_1 (&SET_DEST (x), insn, force, 1, ht);
+ purge_addressof_1 (&SET_SRC (x), insn, force, 0, ht);
+ return;
+ }
+
+ else if (code == ADDRESSOF && GET_CODE (XEXP (x, 0)) == MEM)
{
- rtx insns;
/* We must create a copy of the rtx because it was created by
overwriting a REG rtx which is always shared. */
rtx sub = copy_rtx (XEXP (XEXP (x, 0), 0));
+ rtx insns;
if (validate_change (insn, loc, sub, 0)
|| validate_replace_rtx (x, sub, insn))
emit_insn_before (insns, insn);
return;
}
+
else if (code == MEM && GET_CODE (XEXP (x, 0)) == ADDRESSOF && ! force)
{
rtx sub = XEXP (XEXP (x, 0), 0);
RTX_UNCHANGING_P (sub2) = RTX_UNCHANGING_P (sub);
sub = sub2;
}
-
- if (GET_CODE (sub) == REG
- && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
- {
- put_addressof_into_stack (XEXP (x, 0), ht);
- return;
- }
+ else if (GET_CODE (sub) == REG
+ && (MEM_VOLATILE_P (x) || GET_MODE (x) == BLKmode))
+ ;
else if (GET_CODE (sub) == REG && GET_MODE (x) != GET_MODE (sub))
{
int size_x, size_sub;
return;
}
}
+
else if (validate_change (insn, loc, sub, 0))
{
/* Remember the replacement so that the same one can be done
give_up:;
/* else give up and put it into the stack */
}
+
else if (code == ADDRESSOF)
{
put_addressof_into_stack (x, ht);
last_ptr = plus_constant (last_ptr, - GET_MODE_SIZE (Pmode));
#endif
last_ptr = copy_to_reg (gen_rtx_MEM (Pmode,
- memory_address (Pmode, last_ptr)));
+ memory_address (Pmode,
+ last_ptr)));
/* If we are not optimizing, ensure that we know that this
piece of context is live over the entire function. */
#define ATTRIBUTE_PRINTF_5 ATTRIBUTE_PRINTF(5, 6)
#endif /* ATTRIBUTE_PRINTF */
+#ifndef NULL
+#define NULL 0
+#endif
+
#define GENERIC_PTR PTR
#ifndef NULL_PTR
CC recognizes how to compile each input file by suffixes in the file names.
Once it knows which kind of compilation to perform, the procedure for
compilation is specified by a string called a "spec". */
-\f
+
+
#include "config.h"
#include "system.h"
#include <signal.h>
-
#include "obstack.h"
#include "intl.h"
#include "prefix.h"
/* gen-protos.c - massages a list of prototypes, for use by fixproto.
- Copyright (C) 1993, 94-96, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1993, 94-96, 1998, 1999 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
/* Generate from machine description:
-
- some macros CODE_FOR_... giving the insn_code_number value
for each of the defined standard insn names.
Copyright (C) 1987, 1991, 1995, 1998, 1999 Free Software Foundation, Inc.
static int register_constraint_flag;
static int have_cc0_flag;
static int have_cmove_flag;
+static int have_cond_arith_flag;
static int have_lo_sum_flag;
static int have_peephole_flag;
static int have_peephole2_flag;
two arms of the IF_THEN_ELSE are both MATCH_OPERAND. Otherwise,
we have some specific IF_THEN_ELSE construct (like the doz
instruction on the RS/6000) that can't be used in the general
- context we want it for. */
+ context we want it for. If the first operand is an arithmetic
+ operation and the second is a MATCH_OPERNAND, show we have
+ conditional arithmetic. */
if (recog_p && non_pc_set_src
&& GET_CODE (XEXP (part, 1)) == MATCH_OPERAND
&& GET_CODE (XEXP (part, 2)) == MATCH_OPERAND)
have_cmove_flag = 1;
+ else if (recog_p && non_pc_set_src
+ && (GET_RTX_CLASS (GET_CODE (XEXP (part, 1))) == '1'
+ || GET_RTX_CLASS (GET_CODE (XEXP (part, 1))) == '2'
+ || GET_RTX_CLASS (GET_CODE (XEXP (part, 1))) == 'c')
+ && GET_CODE (XEXP (XEXP (part, 1), 0)) == MATCH_OPERAND
+ && GET_CODE (XEXP (part, 2)) == MATCH_OPERAND)
+ have_cond_arith_flag = 1;
break;
case REG: case CONST_INT: case SYMBOL_REF:
if (have_cmove_flag)
printf ("#define HAVE_conditional_move\n");
+ if (have_cond_arith_flag)
+ printf ("#define HAVE_conditional_arithmetic\n");
+
if (have_lo_sum_flag)
printf ("#define HAVE_lo_sum\n");
}
else
{
- printf (" return gen_rtx_PARALLEL (VOIDmode, gen_rtvec (%d", XVECLEN (insn, 1));
+ printf (" return gen_rtx_PARALLEL (VOIDmode, gen_rtvec (%d",
+ XVECLEN (insn, 1));
+
for (i = 0; i < XVECLEN (insn, 1); i++)
{
printf (",\n\t\t");
/* Generate from machine description:
-
- some flags HAVE_... saying which simple standard instructions are
available for this machine.
Copyright (C) 1987, 1991, 1995, 1998, 1999 Free Software Foundation, Inc.
const char *formats[NUM_RTX_CODE];
-static const char *type_from_format PROTO((int));
-static const char *accessor_from_format PROTO((int));
-static int special_format PROTO((const char *));
-static int special_rtx PROTO((int));
-static void find_formats PROTO((void));
-static void gendecl PROTO((FILE *, const char *));
-static void genmacro PROTO((FILE *, int));
-static void gendef PROTO((FILE *, const char *));
-static void genlegend PROTO((FILE *));
-static void genheader PROTO((FILE *));
-static void gencode PROTO((FILE *));
-
+static const char *type_from_format PROTO((int));
+static const char *accessor_from_format PROTO((int));
+static int special_format PROTO((const char *));
+static int special_rtx PROTO((int));
+static void find_formats PROTO((void));
+static void gendecl PROTO((const char *));
+static void genmacro PROTO((int));
+static void gendef PROTO((const char *));
+static void genlegend PROTO((void));
+static void genheader PROTO((void));
+static void gencode PROTO((void));
+\f
/* Decode a format letter into a C type string. */
static const char *
switch (c)
{
case 'i':
- return "int";
+ return "int ";
+
case 'w':
- return "HOST_WIDE_INT";
+ return "HOST_WIDE_INT ";
+
case 's':
return "char *";
- case 'e':
- case 'u':
- return "rtx";
+
+ case 'e': case 'u':
+ return "rtx ";
+
case 'E':
- return "rtvec";
+ return "rtvec ";
case 'b':
return "struct bitmap_head_def *"; /* bitmap - typedef not available */
case 't':
{
case 'i':
return "XINT";
+
case 'w':
return "XWINT";
+
case 's':
return "XSTR";
- case 'e':
- case 'u':
+
+ case 'e': case 'u':
return "XEXP";
+
case 'E':
return "XVEC";
+
case 'b':
return "XBITMAP";
+
case 't':
return "XTREE";
+
default:
abort ();
}
}
-/* Return true if a format character doesn't need normal processing. */
+/* Return nonzero if we should ignore FMT, an RTL format, when making
+ the list of formats we write routines to create. */
static int
special_format (fmt)
|| strchr (fmt, 'n') != 0);
}
-/* Return true if an rtx requires special processing. */
+/* Return nonzero if the RTL code given by index IDX is one that we should not
+ generate a gen_RTX_FOO function foo (because that function is present
+ elsewhere in the compiler. */
static int
special_rtx (idx)
|| strcmp (defs[idx].enumname, "MEM") == 0);
}
-/* Fill `formats' with all unique format strings. */
+/* Place a list of all format specifiers we use into the array FORMAT. */
static void
find_formats ()
{
int i;
- for (i = 0; i < NUM_RTX_CODE; ++i)
+ for (i = 0; i < NUM_RTX_CODE; i++)
{
const char **f;
if (special_format (defs[i].format))
continue;
- for (f = formats; *f ; ++f)
+ for (f = formats; *f; f++)
if (! strcmp (*f, defs[i].format))
break;
- if (!*f)
+ if (*f == 0)
*f = defs[i].format;
}
}
-/* Emit a prototype for the rtx generator for a format. */
+/* Write the declarations for the routine to allocate RTL with FORMAT. */
static void
-gendecl (f, format)
- FILE *f;
+gendecl (format)
const char *format;
{
const char *p;
- int i;
+ int i, pos;
- fprintf (f, "extern rtx gen_rtx_fmt_%s PROTO((RTX_CODE, enum machine_mode mode",
- format);
- for (p = format, i = 0; *p ; ++p)
+ printf ("extern rtx gen_rtx_fmt_%s\tPROTO((RTX_CODE, ", format);
+ printf ("enum machine_mode mode");
+
+ /* Write each parameter that is needed and start a new line when the line
+ would overflow. */
+ for (p = format, i = 0, pos = 75; *p != 0; p++)
if (*p != '0')
- fprintf (f, ", %s arg%d", type_from_format (*p), i++);
- fprintf (f, "));\n");
+ {
+ int ourlen = strlen (type_from_format (*p)) + 6 + (i > 9);
+
+ printf (",");
+ if (pos + ourlen > 76)
+ printf ("\n\t\t\t\t "), pos = 39;
+
+ printf (" %sarg%d", type_from_format (*p), i++);
+ pos += ourlen;
+ }
+
+ printf ("));\n");
}
-/* Emit a define mapping an rtx code to the generator for its format. */
+/* Generate macros to generate RTL of code IDX using the functions we
+ write. */
static void
-genmacro (f, idx)
- FILE *f;
+genmacro (idx)
int idx;
{
const char *p;
int i;
- fprintf (f, "#define gen_rtx_%s%s(mode",
- (special_rtx (idx) ? "raw_" : ""), defs[idx].enumname);
+ /* We write a macro that defines gen_rtx_RTLCODE to be an equivalent to
+ gen_rtx_fmt_FORMAT where FORMAT is the RTX_FORMAT of RTLCODE. */
- for (p = defs[idx].format, i = 0; *p ; ++p)
+ printf ("#define gen_rtx_%s%s(MODE",
+ special_rtx (idx) ? "raw_" : "", defs[idx].enumname);
+
+ for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
- fprintf (f, ", arg%d", i++);
- fprintf (f, ") ");
+ printf (", ARG%d", i++);
+
+ printf (") \\\n gen_rtx_fmt_%s (%s, (MODE)",
+ defs[idx].format, defs[idx].enumname);
- fprintf (f, "gen_rtx_fmt_%s(%s,(mode)", defs[idx].format, defs[idx].enumname);
- for (p = defs[idx].format, i = 0; *p ; ++p)
+ for (p = defs[idx].format, i = 0; *p != 0; p++)
if (*p != '0')
- fprintf (f, ",(arg%d)", i++);
- fprintf (f, ")\n");
+ printf (", (ARG%d)", i++);
+
+ printf (")\n");
}
-/* Emit the implementation for the rtx generator for a format. */
+/* Generate the code for the function to generate RTL whose
+ format is FORMAT. */
static void
-gendef (f, format)
- FILE *f;
+gendef (format)
const char *format;
{
const char *p;
int i, j;
- fprintf (f, "rtx\ngen_rtx_fmt_%s (code, mode", format);
- for (p = format, i = 0; *p ; ++p)
- if (*p != '0')
- fprintf (f, ", arg%d", i++);
+ /* Start by writing the definition of the function name and the types
+ of the arguments. */
- fprintf (f, ")\n RTX_CODE code;\n enum machine_mode mode;\n");
- for (p = format, i = 0; *p ; ++p)
+ printf ("rtx\ngen_rtx_fmt_%s (code, mode", format);
+ for (p = format, i = 0; *p != 0; p++)
if (*p != '0')
- fprintf (f, " %s arg%d;\n", type_from_format (*p), i++);
+ printf (", arg%d", i++);
- /* See rtx_alloc in rtl.c for comments. */
- fprintf (f, "{\n");
- fprintf (f, " rtx rt;\n");
- fprintf (f, " if (ggc_p)\n");
- fprintf (f, " rt = ggc_alloc_rtx (%d);\n",
+ printf (")\n RTX_CODE code;\n enum machine_mode mode;\n");
+ for (p = format, i = 0; *p != 0; p++)
+ if (*p != '0')
+ printf (" %sarg%d;\n", type_from_format (*p), i++);
+
+ /* Now write out the body of the function itself, which allocates
+ the memory and initializes it. */
+ printf ("{\n");
+ printf (" rtx rt;\n");
+ printf (" if (ggc_p)\n");
+ printf (" rt = ggc_alloc_rtx (%d);\n",
(int) strlen (format));
- fprintf (f, " else\n");
- fprintf (f, " rt = obstack_alloc_rtx (sizeof (struct rtx_def) + %d * sizeof (rtunion));\n",
+ printf (" else\n");
+ printf (" rt = obstack_alloc_rtx (sizeof (struct rtx_def) + %d * sizeof (rtunion));\n",
(int) strlen (format) - 1);
- fprintf (f, " PUT_CODE (rt, code);\n");
- fprintf (f, " PUT_MODE (rt, mode);\n");
+ printf (" PUT_CODE (rt, code);\n");
+ printf (" PUT_MODE (rt, mode);\n");
for (p = format, i = j = 0; *p ; ++p, ++i)
if (*p != '0')
- {
- fprintf (f, " %s (rt, %d) = arg%d;\n",
- accessor_from_format (*p), i, j++);
- }
+ printf (" %s (rt, %d) = arg%d;\n", accessor_from_format (*p), i, j++);
- fprintf (f, "\n return rt;\n}\n\n");
+ printf ("\n return rt;\n}\n\n");
}
-/* Emit the `do not edit' banner. */
+/* Generate the documentation header for files we write. */
static void
-genlegend (f)
- FILE *f;
+genlegend ()
{
- fputs ("/* Generated automaticaly by the program `gengenrtl'\n", f);
- fputs (" from the RTL description file `rtl.def' */\n\n", f);
+ printf ("/* Generated automaticaly by the program `gengenrtl'\n");
+ printf (" from the RTL description file `rtl.def' */\n\n");
}
-/* Emit "genrtl.h". */
+/* Generate the text of the header file we make, genrtl.h. */
static void
-genheader (f)
- FILE *f;
+genheader ()
{
int i;
const char **fmt;
-
+
for (fmt = formats; *fmt; ++fmt)
- gendecl (f, *fmt);
+ gendecl (*fmt);
- fprintf (f, "\n");
+ printf ("\n");
for (i = 0; i < NUM_RTX_CODE; i++)
- {
- if (special_format (defs[i].format))
- continue;
- genmacro (f, i);
- }
+ if (! special_format (defs[i].format))
+ genmacro (i);
}
-/* Emit "genrtl.c". */
+/* Generate the text of the code file we write, genrtl.c. */
static void
-gencode (f)
- FILE *f;
+gencode ()
{
const char **fmt;
- fputs ("#include \"config.h\"\n", f);
- fputs ("#include \"system.h\"\n", f);
- fputs ("#include \"obstack.h\"\n", f);
- fputs ("#include \"rtl.h\"\n", f);
- fputs ("#include \"ggc.h\"\n\n", f);
- fputs ("extern struct obstack *rtl_obstack;\n\n", f);
- fputs ("static rtx obstack_alloc_rtx PROTO((int length));\n", f);
- fputs ("static rtx obstack_alloc_rtx (length)\n", f);
- fputs (" register int length;\n{\n", f);
- fputs (" rtx rt = (rtx) obstack_alloc (rtl_obstack, length);\n\n", f);
- fputs (" memset(rt, 0, sizeof(struct rtx_def) - sizeof(rtunion));\n\n", f);
- fputs (" return rt;\n}\n\n", f);
-
- for (fmt = formats; *fmt; ++fmt)
- gendef (f, *fmt);
+ puts ("#include \"config.h\"\n");
+ puts ("#include \"system.h\"\n");
+ puts ("#include \"obstack.h\"\n");
+ puts ("#include \"rtl.h\"\n");
+ puts ("#include \"ggc.h\"\n\n");
+ puts ("extern struct obstack *rtl_obstack;\n\n");
+ puts ("static rtx obstack_alloc_rtx PROTO((int length));\n");
+ puts ("static rtx obstack_alloc_rtx (length)\n");
+ puts (" register int length;\n{\n");
+ puts (" rtx rt = (rtx) obstack_alloc (rtl_obstack, length);\n\n");
+ puts (" memset(rt, 0, sizeof(struct rtx_def) - sizeof(rtunion));\n\n");
+ puts (" return rt;\n}\n\n");
+
+ for (fmt = formats; *fmt != 0; fmt++)
+ gendef (*fmt);
}
#if defined(USE_C_ALLOCA)
}
#endif /* USE_C_ALLOCA */
+/* This is the main program. We accept only one argument, "-h", which
+ says we are writing the genrtl.h file. Otherwise we are writing the
+ genrtl.c file. */
+
int
-main(argc, argv)
+main (argc, argv)
int argc;
char **argv;
{
- FILE *f;
-
- if (argc != 3)
- exit (1);
-
find_formats ();
+ genlegend ();
- f = fopen (argv[1], "w");
- if (f == NULL)
- {
- perror (argv[1]);
- exit (1);
- }
- genlegend (f);
- genheader (f);
- fclose (f);
-
- f = fopen (argv[2], "w");
- if (f == NULL)
- {
- perror (argv[2]);
- exit (1);
- }
- genlegend (f);
- gencode (f);
- fclose (f);
+ if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'h')
+ genheader ();
+ else
+ gencode ();
- exit (0);
+ fflush (stdout);
+ exit (ferror (stdout) != 0 ? FATAL_EXIT_CODE : SUCCESS_EXIT_CODE);
+ /* NOTREACHED */
+ return 0;
}
/* OSF/rose half-pic support functions.
- Copyright (C) 1992, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
return get_label_from_map (map, CODE_LABEL_NUMBER (orig));
case LABEL_REF:
- copy = gen_rtx_LABEL_REF (mode,
- LABEL_REF_NONLOCAL_P (orig) ? XEXP (orig, 0)
- : get_label_from_map (map,
- CODE_LABEL_NUMBER (XEXP (orig, 0))));
+ copy
+ = gen_rtx_LABEL_REF
+ (mode,
+ LABEL_REF_NONLOCAL_P (orig) ? XEXP (orig, 0)
+ : get_label_from_map (map, CODE_LABEL_NUMBER (XEXP (orig, 0))));
+
LABEL_OUTSIDE_LOOP_P (copy) = LABEL_OUTSIDE_LOOP_P (orig);
/* The fact that this label was previously nonlocal does not mean
#ifndef NO_FUNCTION_CSE
if (! (optimize && ! flag_no_function_cse))
#endif
- return gen_rtx_CALL (GET_MODE (orig),
- gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
- copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0), map)),
- copy_rtx_and_substitute (XEXP (orig, 1), map));
+ return
+ gen_rtx_CALL
+ (GET_MODE (orig),
+ gen_rtx_MEM (GET_MODE (XEXP (orig, 0)),
+ copy_rtx_and_substitute (XEXP (XEXP (orig, 0), 0),
+ map)),
+ copy_rtx_and_substitute (XEXP (orig, 1), map));
break;
#if 0
equiv_loc = VARRAY_CONST_EQUIV (map->const_equiv_varray, REGNO (equiv_reg)).rtx;
loc_offset
= GET_CODE (equiv_loc) == REG ? 0 : INTVAL (XEXP (equiv_loc, 1));
+
return gen_rtx_SET (VOIDmode, SET_DEST (orig),
force_operand
(plus_constant
(@pxref{Variable Attributes}).
@item -Wuninitialized
-An automatic variable is used without first being initialized.
+Warn if an automatic variable is used without first being initialized or
+if a variable may be clobbered by a @code{setjmp} call.
These warnings are possible only in optimizing compilation,
because they require data flow information that is computed only
@cindex @code{longjmp} warnings
This option also warns when a nonvolatile automatic variable might be
-changed by a call to @code{longjmp}.
+changed by a call to @code{longjmp}. These warnings as well are possible
+only in optimizing compilation.
The compiler sees only the calls to @code{setjmp}. It cannot know
where @code{longjmp} will be called; in fact, a signal handler could
you use that never return as @code{noreturn}. @xref{Function
Attributes}.
+@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:
+
@item -Wunknown-pragmas
@cindex warning for unknown pragmas
@cindex unknown pragmas, warning
code is to provide behaviour which is selectable at compile-time.
@item -Winline
-Warn if a function can not be inlined, and either it was declared as inline,
-or else the @samp{-finline-functions} option was given.
+Warn if a function can not be inlined and it was declared as inline.
@item -Wlong-long
Warn if @samp{long long} type is used. This is default. To inhibit
@table @code
@item -fexceptions
Enable exception handling. Generates extra code needed to propagate
-exceptions. For some targets, this implies generation of frame unwind
-information for all functions. This can produce significant data size
-overhead, although it does not affect execution.
-If you do not specify this option, it is enabled by
-default for languages like C++ which normally require exception handling,
-and disabled for languages like C that do not normally require it.
-However, when compiling C code that needs to interoperate properly with
-exception handlers written in C++, you may need to enable this option.
-You may also wish to disable this option is you are compiling older C++
-programs that don't use exception handling.
+exceptions. For some targets, this implies GNU CC will generate frame
+unwind information for all functions, which can produce significant data
+size overhead, although it does not affect execution. If you do not
+specify this option, GNU CC will enable it by default for languages like
+C++ which normally require exception handling, and disable itfor
+languages like C that do not normally require it. However, you may need
+to enable this option when compiling C code that needs to interoperate
+properly with exception handlers written in C++. You may also wish to
+disable this option if you are compiling older C++ programs that don't
+use exception handling.
@item -fpcc-struct-return
Return ``short'' @code{struct} and @code{union} values in memory like
exists in one copy per process.
@item -fno-common
-Allocate even uninitialized global variables in the bss section of the
+Allocate even uninitialized global variables in the data section of the
object file, rather than generating them as common blocks. This has the
effect that if the same variable is declared (without @code{extern}) in
two different compilations, you will get an error when you link them.
@samp{-fcheck-memory-usage} without @samp{-fprefix-function-name}.
If you specify this option, you can not use the @code{asm} or
-@code{__asm__} keywords in functions with memory checking enabled. The
-compiler cannot understand what the @code{asm} statement will do, and
-therefore cannot generate the appropriate code, so it is rejected.
-However, the function attribute @code{no_check_memory_usage} will
-disable memory checking within a function, and @code{asm} statements can
-be put inside such functions. Inline expansion of a non-checked
-function within a checked function is permitted; the inline function's
-memory accesses won't be checked, but the rest will.
-
-If you move your @code{asm} statements to non-checked inline functions,
-but they do access memory, you can add calls to the support code in your
+@code{__asm__} keywords in functions with memory checking enabled. GNU
+CC cannot understand what the @code{asm} statement may do, and therefore
+cannot generate the appropriate code, so it will reject it. However, if
+you specify the function attribute @code{no_check_memory_usage} (see
+@pxref{Function Attributes}, GNU CC will disable memory checking within a
+function; you may use @code{asm} statements inside such functions. You
+may have an inline expansion of a non-checked function within a checked
+function; in that case GNU CC will not generate checks for the inlined
+function's memory accesses.
+
+If you move your @code{asm} statements to non-checked inline functions
+and they do access memory, you can add calls to the support code in your
inline function, to indicate any reads, writes, or copies being done.
These calls would be similar to those done in the stubs described above.
-@c FIXME: The support-routine interface is defined by the compiler and
-@c should be documented!
-
@item -fprefix-function-name
Request GCC to add a prefix to the symbols generated for function names.
GCC adds a prefix to the names of functions defined as well as
#define YYPURE 1
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/local/gnu/share/bison.simple"
+#line 3 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
#endif
#endif
\f
-#line 196 "/usr/local/gnu/share/bison.simple"
+#line 196 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 498 "/usr/local/gnu/share/bison.simple"
+#line 498 "/usr/cygnus/TBD-TBD/share/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
last_insn = delete_unreferenced_labels (f);
- if (!optimize)
+ if (optimize == 0)
{
/* CAN_REACH_END is persistent for each function. Once set it should
not be cleared. This is especially true for the case where we
int this_is_simplejump, this_is_condjump, reversep = 0;
int this_is_condjump_in_parallel;
-#if 0
- /* If NOT the first iteration, if this is the last jump pass
- (just before final), do the special peephole optimizations.
- Avoiding the first iteration gives ordinary jump opts
- a chance to work before peephole opts. */
-
- if (reload_completed && !first && !flag_no_peephole)
- if (GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
- peephole (insn);
-#endif
-
- /* That could have deleted some insns after INSN, so check now
- what the following insn is. */
-
next = NEXT_INSN (insn);
/* See if this is a NOTE_INSN_LOOP_BEG followed by an unconditional
if (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
changed |= tension_vector_labels (PATTERN (insn), 1);
+ /* See if this jump goes to another jump and redirect if so. */
+ nlabel = follow_jumps (JUMP_LABEL (insn));
+ if (nlabel != JUMP_LABEL (insn))
+ changed |= redirect_jump (insn, nlabel);
+
/* If a dispatch table always goes to the same place,
get rid of it and replace the insn that uses it. */
}
}
- reallabelprev = prev_active_insn (JUMP_LABEL (insn));
-
/* If a jump references the end of the function, try to turn
it into a RETURN insn, possibly a conditional one. */
- if (JUMP_LABEL (insn)
+ if (JUMP_LABEL (insn) != 0
&& (next_active_insn (JUMP_LABEL (insn)) == 0
|| GET_CODE (PATTERN (next_active_insn (JUMP_LABEL (insn))))
== RETURN))
changed |= redirect_jump (insn, NULL_RTX);
+ reallabelprev = prev_active_insn (JUMP_LABEL (insn));
+
/* Detect jump to following insn. */
- if (reallabelprev == insn && condjump_p (insn))
+ if (reallabelprev == insn && this_is_condjump)
{
next = next_real_insn (JUMP_LABEL (insn));
delete_jump (insn);
continue;
}
+ /* Detect a conditional jump going to the same place
+ as an immediately following unconditional jump. */
+ else if (this_is_condjump
+ && (temp = next_active_insn (insn)) != 0
+ && simplejump_p (temp)
+ && (next_active_insn (JUMP_LABEL (insn))
+ == next_active_insn (JUMP_LABEL (temp))))
+ {
+ /* Don't mess up test coverage analysis. */
+ temp2 = temp;
+ if (flag_test_coverage && !reload_completed)
+ for (temp2 = insn; temp2 != temp; temp2 = NEXT_INSN (temp2))
+ if (GET_CODE (temp2) == NOTE && NOTE_LINE_NUMBER (temp2) > 0)
+ break;
+
+ if (temp2 == temp)
+ {
+ delete_jump (insn);
+ changed = 1;
+ continue;
+ }
+ }
+
+ /* Detect a conditional jump jumping over an unconditional jump. */
+
+ else if ((this_is_condjump || this_is_condjump_in_parallel)
+ && ! this_is_simplejump
+ && reallabelprev != 0
+ && GET_CODE (reallabelprev) == JUMP_INSN
+ && prev_active_insn (reallabelprev) == insn
+ && no_labels_between_p (insn, reallabelprev)
+ && simplejump_p (reallabelprev))
+ {
+ /* When we invert the unconditional jump, we will be
+ decrementing the usage count of its old label.
+ Make sure that we don't delete it now because that
+ might cause the following code to be deleted. */
+ rtx prev_uses = prev_nonnote_insn (reallabelprev);
+ rtx prev_label = JUMP_LABEL (insn);
+
+ if (prev_label)
+ ++LABEL_NUSES (prev_label);
+
+ if (invert_jump (insn, JUMP_LABEL (reallabelprev)))
+ {
+ /* It is very likely that if there are USE insns before
+ this jump, they hold REG_DEAD notes. These REG_DEAD
+ notes are no longer valid due to this optimization,
+ and will cause the life-analysis that following passes
+ (notably delayed-branch scheduling) to think that
+ these registers are dead when they are not.
+
+ To prevent this trouble, we just remove the USE insns
+ from the insn chain. */
+
+ while (prev_uses && GET_CODE (prev_uses) == INSN
+ && GET_CODE (PATTERN (prev_uses)) == USE)
+ {
+ rtx useless = prev_uses;
+ prev_uses = prev_nonnote_insn (prev_uses);
+ delete_insn (useless);
+ }
+
+ delete_insn (reallabelprev);
+ changed = 1;
+ }
+
+ /* We can now safely delete the label if it is unreferenced
+ since the delete_insn above has deleted the BARRIER. */
+ if (prev_label && --LABEL_NUSES (prev_label) == 0)
+ delete_insn (prev_label);
+
+ next = NEXT_INSN (insn);
+ }
+
/* If we have an unconditional jump preceded by a USE, try to put
the USE before the target and jump there. This simplifies many
of the optimizations below since we don't have to worry about
being branch to already has the identical USE or if code
never falls through to that label. */
- if (this_is_simplejump
- && (temp = prev_nonnote_insn (insn)) != 0
- && GET_CODE (temp) == INSN && GET_CODE (PATTERN (temp)) == USE
- && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
- && (GET_CODE (temp1) == BARRIER
- || (GET_CODE (temp1) == INSN
- && rtx_equal_p (PATTERN (temp), PATTERN (temp1))))
- /* Don't do this optimization if we have a loop containing only
- the USE instruction, and the loop start label has a usage
- count of 1. This is because we will redo this optimization
- everytime through the outer loop, and jump opt will never
- exit. */
- && ! ((temp2 = prev_nonnote_insn (temp)) != 0
- && temp2 == JUMP_LABEL (insn)
- && LABEL_NUSES (temp2) == 1))
+ else if (this_is_simplejump
+ && (temp = prev_nonnote_insn (insn)) != 0
+ && GET_CODE (temp) == INSN
+ && GET_CODE (PATTERN (temp)) == USE
+ && (temp1 = prev_nonnote_insn (JUMP_LABEL (insn))) != 0
+ && (GET_CODE (temp1) == BARRIER
+ || (GET_CODE (temp1) == INSN
+ && rtx_equal_p (PATTERN (temp), PATTERN (temp1))))
+ /* Don't do this optimization if we have a loop containing
+ only the USE instruction, and the loop start label has
+ a usage count of 1. This is because we will redo this
+ optimization everytime through the outer loop, and jump
+ opt will never exit. */
+ && ! ((temp2 = prev_nonnote_insn (temp)) != 0
+ && temp2 == JUMP_LABEL (insn)
+ && LABEL_NUSES (temp2) == 1))
{
if (GET_CODE (temp1) == BARRIER)
{
redirect_jump (insn, get_label_before (temp1));
reallabelprev = prev_real_insn (temp1);
changed = 1;
+ next = NEXT_INSN (insn);
}
/* Simplify if (...) x = a; else x = b; by converting it
redirect_jump (p, target);
changed = 1;
+ next = NEXT_INSN (insn);
continue;
}
}
continue;
}
-#ifndef HAVE_cc0
+#if !defined(HAVE_cc0) && !defined(HAVE_conditional_arithmetic)
+
/* If we have if (...) x = exp; and branches are expensive,
EXP is a single insn, does not have any side effects, cannot
trap, and is not too costly, convert this to
the potential for conflicts. We also can't do this when we have
notes on the insn for the same reason as above.
+ If we have conditional arithmetic, this will make this
+ harder to optimize later and isn't needed, so don't do it
+ in that case either.
+
We set:
TEMP to the "x = exp;" insn.
}
#endif /* HAVE_cc0 */
+#ifdef HAVE_conditional_arithmetic
+ /* See if this is a conditional jump around a small number of
+ instructions that we can conditionalize. Don't do this before
+ the initial CSE pass or after reload.
+
+ We reject any insns that have side effects or may trap.
+ Strictly speaking, this is not needed since the machine may
+ support conditionalizing these too, but we won't deal with that
+ now. Specifically, this means that we can't conditionalize a
+ CALL_INSN, which some machines, such as the ARC, can do, but
+ this is a very minor optimization. */
+ if (this_is_condjump && ! this_is_simplejump
+ && cse_not_expected && optimize > 0 && ! reload_completed
+ && BRANCH_COST > 2
+ && can_reverse_comparison_p (XEXP (SET_SRC (PATTERN (insn)), 0),
+ insn))
+ {
+ rtx ourcond = XEXP (SET_SRC (PATTERN (insn)), 0);
+ int num_insns = 0;
+ char *storage = (char *) oballoc (0);
+ int last_insn = 0, failed = 0;
+ rtx changed_jump = 0;
+
+ ourcond = gen_rtx (reverse_condition (GET_CODE (ourcond)),
+ VOIDmode, XEXP (ourcond, 0),
+ XEXP (ourcond, 1));
+
+ /* Scan forward BRANCH_COST real insns looking for the JUMP_LABEL
+ of this insn. We see if we think we can conditionalize the
+ insns we pass. For now, we only deal with insns that have
+ one SET. We stop after an insn that modifies anything in
+ OURCOND, if we have too many insns, or if we have an insn
+ with a side effect or that may trip. Note that we will
+ be modifying any unconditional jumps we encounter to be
+ conditional; this will have the effect of also doing this
+ optimization on the "else" the next time around. */
+ for (temp1 = NEXT_INSN (insn);
+ num_insns <= BRANCH_COST && ! failed && temp1 != 0
+ && GET_CODE (temp1) != CODE_LABEL;
+ temp1 = NEXT_INSN (temp1))
+ {
+ /* Ignore everything but an active insn. */
+ if (GET_RTX_CLASS (GET_CODE (temp1)) != 'i'
+ || GET_CODE (PATTERN (temp1)) == USE
+ || GET_CODE (PATTERN (temp1)) == CLOBBER)
+ continue;
+
+ /* If this was an unconditional jump, record it since we'll
+ need to remove the BARRIER if we succeed. We can only
+ have one such jump since there must be a label after
+ the BARRIER and it's either ours, in which case it's the
+ only one or some other, in which case we'd fail. */
+
+ if (simplejump_p (temp1))
+ changed_jump = temp1;
+
+ /* See if we are allowed another insn and if this insn
+ if one we think we may be able to handle. */
+ if (++num_insns > BRANCH_COST
+ || last_insn
+ || (temp2 = single_set (temp1)) == 0
+ || side_effects_p (SET_SRC (temp2))
+ || may_trap_p (SET_SRC (temp2)))
+ failed = 1;
+ else
+ validate_change (temp1, &SET_SRC (temp2),
+ gen_rtx_IF_THEN_ELSE
+ (GET_MODE (SET_DEST (temp2)),
+ copy_rtx (ourcond),
+ SET_SRC (temp2), SET_DEST (temp2)),
+ 1);
+
+ if (modified_in_p (ourcond, temp1))
+ last_insn = 1;
+ }
+
+ /* If we've reached our jump label, haven't failed, and all
+ the changes above are valid, we can delete this jump
+ insn. Also remove a BARRIER after any jump that used
+ to be unconditional and remove any REG_EQUAL or REG_EQUIV
+ that might have previously been present on insns we
+ made conditional. */
+ if (temp1 == JUMP_LABEL (insn) && ! failed
+ && apply_change_group ())
+ {
+ for (temp1 = NEXT_INSN (insn); temp1 != JUMP_LABEL (insn);
+ temp1 = NEXT_INSN (temp1))
+ if (GET_RTX_CLASS (GET_CODE (temp1)) == 'i')
+ for (temp2 = REG_NOTES (temp1); temp2 != 0;
+ temp2 = XEXP (temp2, 1))
+ if (REG_NOTE_KIND (temp2) == REG_EQUAL
+ || REG_NOTE_KIND (temp2) == REG_EQUIV)
+ remove_note (temp1, temp2);
+
+ if (changed_jump != 0)
+ {
+ if (GET_CODE (NEXT_INSN (changed_jump)) != BARRIER)
+ abort ();
+
+ delete_insn (NEXT_INSN (changed_jump));
+ }
+
+ delete_insn (insn);
+ changed = 1;
+ continue;
+ }
+ else
+ {
+ cancel_changes (0);
+ obfree (storage);
+ }
+ }
+#endif
+
/* Try to use a conditional move (if the target has them), or a
- store-flag insn. The general case is:
+ store-flag insn. If the target has conditional arithmetic as
+ well as conditional move, the above code will have done something.
+ Note that we prefer the above code since it is more general: the
+ code below can make changes that require work to undo.
+
+ The general case here is:
1) x = a; if (...) x = b; and
2) if (...) x = b;
if (/* We can't do this after reload has completed. */
! reload_completed
+#ifdef HAVE_conditional_arithmetic
+ /* Defer this until after CSE so the above code gets the
+ first crack at it. */
+ && cse_not_expected
+#endif
&& this_is_condjump && ! this_is_simplejump
/* Set TEMP to the "x = b;" insn. */
&& (temp = next_nonnote_insn (insn)) != 0
}
}
#endif
- /* Detect a conditional jump going to the same place
- as an immediately following unconditional jump. */
- else if (this_is_condjump
- && (temp = next_active_insn (insn)) != 0
- && simplejump_p (temp)
- && (next_active_insn (JUMP_LABEL (insn))
- == next_active_insn (JUMP_LABEL (temp))))
- {
- rtx tem = temp;
-
- /* ??? Optional. Disables some optimizations, but makes
- gcov output more accurate with -O. */
- if (flag_test_coverage && !reload_completed)
- for (tem = insn; tem != temp; tem = NEXT_INSN (tem))
- if (GET_CODE (tem) == NOTE && NOTE_LINE_NUMBER (tem) > 0)
- break;
-
- if (tem == temp)
- {
- delete_jump (insn);
- changed = 1;
- continue;
- }
- }
#ifdef HAVE_trap
/* Detect a conditional jump jumping over an unconditional trap. */
else if (HAVE_trap
}
}
#endif
-
- /* Detect a conditional jump jumping over an unconditional jump. */
-
- else if ((this_is_condjump || this_is_condjump_in_parallel)
- && ! this_is_simplejump
- && reallabelprev != 0
- && GET_CODE (reallabelprev) == JUMP_INSN
- && prev_active_insn (reallabelprev) == insn
- && no_labels_between_p (insn, reallabelprev)
- && simplejump_p (reallabelprev))
- {
- /* When we invert the unconditional jump, we will be
- decrementing the usage count of its old label.
- Make sure that we don't delete it now because that
- might cause the following code to be deleted. */
- rtx prev_uses = prev_nonnote_insn (reallabelprev);
- rtx prev_label = JUMP_LABEL (insn);
-
- if (prev_label)
- ++LABEL_NUSES (prev_label);
-
- if (invert_jump (insn, JUMP_LABEL (reallabelprev)))
- {
- /* It is very likely that if there are USE insns before
- this jump, they hold REG_DEAD notes. These REG_DEAD
- notes are no longer valid due to this optimization,
- and will cause the life-analysis that following passes
- (notably delayed-branch scheduling) to think that
- these registers are dead when they are not.
-
- To prevent this trouble, we just remove the USE insns
- from the insn chain. */
-
- while (prev_uses && GET_CODE (prev_uses) == INSN
- && GET_CODE (PATTERN (prev_uses)) == USE)
- {
- rtx useless = prev_uses;
- prev_uses = prev_nonnote_insn (prev_uses);
- delete_insn (useless);
- }
-
- delete_insn (reallabelprev);
- next = insn;
- changed = 1;
- }
-
- /* We can now safely delete the label if it is unreferenced
- since the delete_insn above has deleted the BARRIER. */
- if (prev_label && --LABEL_NUSES (prev_label) == 0)
- delete_insn (prev_label);
- continue;
- }
else
{
/* Detect a jump to a jump. */
- nlabel = follow_jumps (JUMP_LABEL (insn));
- if (nlabel != JUMP_LABEL (insn)
- && redirect_jump (insn, nlabel))
- {
- changed = 1;
- next = insn;
- }
-
/* Look for if (foo) bar; else break; */
/* The insns look like this:
insn = condjump label1;
rtx prev = prev_nonnote_insn (insn);
rtx set;
- /* If the comparison itself was a loop invariant, it could have been
- hoisted out of the loop. If we proceed to unroll such a loop, then
- we may not be able to find the comparison when copying the loop.
-
- Returning zero in that case is the safe thing to do. */
- if (prev == 0)
- return 0;
-
- set = single_set (prev);
- if (set == 0 || SET_DEST (set) != arg0)
- return 0;
-
- arg0 = SET_SRC (set);
+ /* First see if the condition code mode alone if enough to say we can
+ reverse the condition. If not, then search backwards for a set of
+ ARG0. We do not need to check for an insn clobbering it since valid
+ code will contain set a set with no intervening clobber. But
+ stop when we reach a label. */
+#ifdef REVERSIBLE_CC_MODE
+ if (GET_MODE_CLASS (GET_MODE (arg0)) == MODE_CC
+ && REVERSIBLE_CC_MODE (GET_MODE (arg0)))
+ return 1;
+#endif
+
+ for (prev = prev_nonnote_insn (insn);
+ prev != 0 && GET_CODE (prev) != CODE_LABEL;
+ prev = prev_nonnote_insn (prev))
+ if ((set = single_set (prev)) != 0
+ && rtx_equal_p (SET_DEST (set), arg0))
+ {
+ arg0 = SET_SRC (set);
- if (GET_CODE (arg0) == COMPARE)
- arg0 = XEXP (arg0, 0);
+ if (GET_CODE (arg0) == COMPARE)
+ arg0 = XEXP (arg0, 0);
+ break;
+ }
}
/* We can reverse this if ARG0 is a CONST_INT or if its mode is
rtx insn;
{
register rtx x = PATTERN (insn);
- if (GET_CODE (x) != SET)
- return 0;
- if (GET_CODE (SET_DEST (x)) != PC)
- return 0;
- if (GET_CODE (SET_SRC (x)) == LABEL_REF)
- return 1;
- if (GET_CODE (SET_SRC (x)) != IF_THEN_ELSE)
+
+ if (GET_CODE (x) != SET
+ || GET_CODE (SET_DEST (x)) != PC)
return 0;
- if (XEXP (SET_SRC (x), 2) == pc_rtx
- && (GET_CODE (XEXP (SET_SRC (x), 1)) == LABEL_REF
- || GET_CODE (XEXP (SET_SRC (x), 1)) == RETURN))
- return 1;
- if (XEXP (SET_SRC (x), 1) == pc_rtx
- && (GET_CODE (XEXP (SET_SRC (x), 2)) == LABEL_REF
- || GET_CODE (XEXP (SET_SRC (x), 2)) == RETURN))
+
+ x = SET_SRC (x);
+ if (GET_CODE (x) == LABEL_REF)
return 1;
+ else return (GET_CODE (x) == IF_THEN_ELSE
+ && ((GET_CODE (XEXP (x, 2)) == PC
+ && (GET_CODE (XEXP (x, 1)) == LABEL_REF
+ || GET_CODE (XEXP (x, 1)) == RETURN))
+ || (GET_CODE (XEXP (x, 1)) == PC
+ && (GET_CODE (XEXP (x, 2)) == LABEL_REF
+ || GET_CODE (XEXP (x, 2)) == RETURN))));
+
return 0;
}
-/* Return nonzero if INSN is a (possibly) conditional jump
- and nothing more. */
+/* Return nonzero if INSN is a (possibly) conditional jump inside a
+ PARALLEL. */
int
condjump_in_parallel_p (insn)
static void
__bb_init_prg ()
{
-
FILE *file;
char buf[BBINBUFSIZE];
const char *p;
const char *pos;
enum bb_func_mode m;
+ int i;
#ifdef ON_EXIT
/* Initialize destructor. */
bb_hashbuckets = (struct bb_edge **)
malloc (BB_BUCKETS * sizeof (struct bb_edge *));
if (bb_hashbuckets)
- memset (bb_hashbuckets, 0, BB_BUCKETS * sizeof (struct bb_edge *));
+ /* Use a loop here rather than calling bzero to avoid having to
+ conditionalize its existance. */
+ for (i = 0; i < BB_BUCKETS; i++)
+ bb_hashbuckets[i] = 0;
}
if (bb_mode & 12)
case '=': case '+': case '?':
case '#': case '&': case '!':
case '*': case '%':
- case '1': case '2': case '3': case '4':
+ case '1': case '2': case '3': case '4': case '5':
+ case '6': case '7': case '8': case '9':
case 'm': case '<': case '>': case 'V': case 'o':
case 'E': case 'F': case 'G': case 'H':
case 's': case 'i': case 'n':
struct loop_info *, rtx, int, int));
static void find_single_use_in_loop PROTO((rtx, rtx, varray_type));
static int valid_initial_value_p PROTO((rtx, rtx, int, rtx));
-static void find_mem_givs PROTO((rtx, rtx, int, rtx, rtx));
+static void find_mem_givs PROTO((rtx, rtx, int, int, rtx, rtx));
static void record_biv PROTO((struct induction *, rtx, rtx, rtx, rtx, rtx *, int, int));
static void check_final_value PROTO((struct induction *, rtx, rtx,
unsigned HOST_WIDE_INT));
-static void record_giv PROTO((struct induction *, rtx, rtx, rtx, rtx, rtx, int, enum g_types, int, rtx *, rtx, rtx));
+static void record_giv PROTO((struct induction *, rtx, rtx, rtx, rtx, rtx, int, enum g_types, int, int, rtx *, rtx, rtx));
static void update_giv_derive PROTO((rtx));
static int basic_induction_var PROTO((rtx, enum machine_mode, rtx, rtx, rtx *, rtx *, rtx **));
static rtx simplify_giv_expr PROTO((rtx, int *));
/* Try to change (SET (REG ...) (ZERO_EXTEND (..:B ...)))
to (SET (STRICT_LOW_PART (SUBREG:B (REG...))) ...). */
- new = gen_rtx_SET (VOIDmode,
- gen_rtx_STRICT_LOW_PART (VOIDmode,
- gen_rtx_SUBREG (GET_MODE (XEXP (SET_SRC (PATTERN (p)), 0)),
- SET_DEST (PATTERN (p)),
- 0)),
- XEXP (SET_SRC (PATTERN (p)), 0));
+ new
+ = gen_rtx_SET
+ (VOIDmode,
+ gen_rtx_STRICT_LOW_PART
+ (VOIDmode,
+ gen_rtx_SUBREG (GET_MODE (XEXP (SET_SRC (PATTERN (p)), 0)),
+ SET_DEST (PATTERN (p)), 0)),
+ XEXP (SET_SRC (PATTERN (p)), 0));
+
insn_code_number = recog (new, p);
if (insn_code_number)
register int i;
/* Clear destination register before the loop. */
- emit_insn_before (gen_rtx_SET (VOIDmode, SET_DEST (PATTERN (p)),
- const0_rtx),
+ emit_insn_before (gen_rtx_SET (VOIDmode,
+ SET_DEST (PATTERN (p)), const0_rtx),
loop_start);
/* Inside the loop, just load the low part. */
not_every_iteration = 0;
loop_depth = 0;
+ maybe_multiple = 0;
p = scan_start;
while (1)
{
p = last_consec_insn;
record_giv (v, p, src_reg, dest_reg, mult_val, add_val, benefit,
- DEST_REG, not_every_iteration, NULL_PTR, loop_start,
- loop_end);
+ DEST_REG, not_every_iteration, maybe_multiple,
+ NULL_PTR, loop_start, loop_end);
}
}
/* This resulted in worse code on a VAX 8600. I wonder if it
still does. */
if (GET_CODE (p) == INSN)
- find_mem_givs (PATTERN (p), p, not_every_iteration, loop_start,
- loop_end);
+ find_mem_givs (PATTERN (p), p, not_every_iteration, maybe_multiple,
+ loop_start, loop_end);
#endif
/* Update the status of whether giv can derive other givs. This can
|| GET_CODE (p) == CODE_LABEL)
update_giv_derive (p);
+ /* Past CODE_LABEL, we get to insns that may be executed multiple
+ times. The only way we can be sure that they can't is if every
+ every jump insn between here and the end of the loop either
+ returns, exits the loop, is a forward jump, or is a jump
+ to the loop start. */
+
+ if (GET_CODE (p) == CODE_LABEL)
+ {
+ rtx insn = p;
+
+ maybe_multiple = 0;
+
+ while (1)
+ {
+ insn = NEXT_INSN (insn);
+ if (insn == scan_start)
+ break;
+ if (insn == end)
+ {
+ if (loop_top != 0)
+ insn = loop_top;
+ else
+ break;
+ if (insn == scan_start)
+ break;
+ }
+
+ if (GET_CODE (insn) == JUMP_INSN
+ && GET_CODE (PATTERN (insn)) != RETURN
+ && (! condjump_p (insn)
+ || (JUMP_LABEL (insn) != 0
+ && JUMP_LABEL (insn) != scan_start
+ && (INSN_UID (JUMP_LABEL (insn)) >= max_uid_for_loop
+ || INSN_UID (insn) >= max_uid_for_loop
+ || (INSN_LUID (JUMP_LABEL (insn))
+ < INSN_LUID (insn))))))
+ {
+ maybe_multiple = 1;
+ break;
+ }
+ }
+ }
+
/* Past a jump, we get to insns for which we can't count
on whether they will be executed during each iteration. */
/* This code appears twice in strength_reduce. There is also similar
/* Scan X for memory refs and check each memory address
as a possible giv. INSN is the insn whose pattern X comes from.
NOT_EVERY_ITERATION is 1 if the insn might not be executed during
- every loop iteration. */
+ every loop iteration. MAYBE_MULTIPLE is 1 if the insn might be executed
+ more thanonce in each loop iteration. */
static void
-find_mem_givs (x, insn, not_every_iteration, loop_start, loop_end)
+find_mem_givs (x, insn, not_every_iteration, maybe_multiple, loop_start,
+ loop_end)
rtx x;
rtx insn;
- int not_every_iteration;
+ int not_every_iteration, maybe_multiple;
rtx loop_start, loop_end;
{
register int i, j;
record_giv (v, insn, src_reg, addr_placeholder, mult_val,
add_val, benefit, DEST_ADDR, not_every_iteration,
- &XEXP (x, 0), loop_start, loop_end);
+ maybe_multiple, &XEXP (x, 0), loop_start, loop_end);
v->mem_mode = GET_MODE (x);
}
fmt = GET_RTX_FORMAT (code);
for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
if (fmt[i] == 'e')
- find_mem_givs (XEXP (x, i), insn, not_every_iteration, loop_start,
- loop_end);
+ find_mem_givs (XEXP (x, i), insn, not_every_iteration, maybe_multiple,
+ loop_start, loop_end);
else if (fmt[i] == 'E')
for (j = 0; j < XVECLEN (x, i); j++)
find_mem_givs (XVECEXP (x, i, j), insn, not_every_iteration,
- loop_start, loop_end);
+ maybe_multiple, loop_start, loop_end);
}
\f
/* Fill in the data about one biv update.
static void
record_giv (v, insn, src_reg, dest_reg, mult_val, add_val, benefit,
- type, not_every_iteration, location, loop_start, loop_end)
+ type, not_every_iteration, maybe_multiple, location, loop_start,
+ loop_end)
struct induction *v;
rtx insn;
rtx src_reg;
rtx mult_val, add_val;
int benefit;
enum g_types type;
- int not_every_iteration;
+ int not_every_iteration, maybe_multiple;
rtx *location;
rtx loop_start, loop_end;
{
v->location = location;
v->cant_derive = 0;
v->combined_with = 0;
- v->maybe_multiple = 0;
+ v->maybe_multiple = maybe_multiple;
v->maybe_dead = 0;
v->derive_adjustment = 0;
v->same = 0;
&dummy);
if (tem && giv->derive_adjustment)
- tem = simplify_giv_expr (gen_rtx_PLUS (giv->mode, tem,
- giv->derive_adjustment),
- &dummy);
+ tem = simplify_giv_expr
+ (gen_rtx_PLUS (giv->mode, tem, giv->derive_adjustment),
+ &dummy);
+
if (tem)
giv->derive_adjustment = tem;
else
case PLUS:
/* (a + invar_1) + invar_2. Associate. */
- return simplify_giv_expr (
- gen_rtx_PLUS (mode, XEXP (arg0, 0),
- gen_rtx_PLUS (mode, XEXP (arg0, 1), arg1)),
- benefit);
+ return
+ simplify_giv_expr (gen_rtx_PLUS (mode,
+ XEXP (arg0, 0),
+ gen_rtx_PLUS (mode,
+ XEXP (arg0, 1),
+ arg1)),
+ benefit);
default:
abort ();
tem = arg0, arg0 = arg1, arg1 = tem;
if (GET_CODE (arg1) == PLUS)
- return simplify_giv_expr (gen_rtx_PLUS (mode,
- gen_rtx_PLUS (mode, arg0,
- XEXP (arg1, 0)),
- XEXP (arg1, 1)),
- benefit);
+ return
+ simplify_giv_expr (gen_rtx_PLUS (mode,
+ gen_rtx_PLUS (mode, arg0,
+ XEXP (arg1, 0)),
+ XEXP (arg1, 1)),
+ benefit);
/* Now must have MULT + MULT. Distribute if same biv, else not giv. */
if (GET_CODE (arg0) != MULT || GET_CODE (arg1) != MULT)
/* Handle "a - b" as "a + b * (-1)". */
return simplify_giv_expr (gen_rtx_PLUS (mode,
XEXP (x, 0),
- gen_rtx_MULT (mode, XEXP (x, 1),
+ gen_rtx_MULT (mode,
+ XEXP (x, 1),
constm1_rtx)),
benefit);
case MULT:
/* (a * invar_1) * invar_2. Associate. */
- return simplify_giv_expr (gen_rtx_MULT (mode, XEXP (arg0, 0),
+ return simplify_giv_expr (gen_rtx_MULT (mode,
+ XEXP (arg0, 0),
gen_rtx_MULT (mode,
XEXP (arg0, 1),
arg1)),
if (GET_CODE (XEXP (x, 1)) != CONST_INT)
return 0;
- return simplify_giv_expr (gen_rtx_MULT (mode,
- XEXP (x, 0),
- GEN_INT ((HOST_WIDE_INT) 1
- << INTVAL (XEXP (x, 1)))),
- benefit);
+ return
+ simplify_giv_expr (gen_rtx_MULT (mode,
+ XEXP (x, 0),
+ GEN_INT ((HOST_WIDE_INT) 1
+ << INTVAL (XEXP (x, 1)))),
+ benefit);
case NEG:
/* "-a" is "a * (-1)" */
if (v->cant_derive)
return 0;
- tem = gen_rtx_PLUS (mode, gen_rtx_MULT (mode, v->src_reg,
- v->mult_val),
- v->add_val);
+ tem = gen_rtx_PLUS (mode, gen_rtx_MULT (mode,
+ v->src_reg, v->mult_val),
+ v->add_val);
+
if (v->derive_adjustment)
tem = gen_rtx_MINUS (mode, tem, v->derive_adjustment);
return simplify_giv_expr (tem, benefit);
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
-/* These functions are used to manipulate multibyte characters. */
-
/* Note regarding cross compilation:
- In general translation of multibyte characters to wide characters can
+ In general, translation of multibyte characters to wide characters can
only work in a native compiler since the translation function (mbtowc)
needs to know about both the source and target character encoding. However,
this particular implementation for JIS, SJIS and EUCJP source characters
#include "mbchar.h"
#include <locale.h>
-typedef enum
-{
- ESCAPE, DOLLAR, BRACKET, AT, B, J, NUL, JIS_CHAR, OTHER, JIS_C_NUM
-} JIS_CHAR_TYPE;
+typedef enum {ESCAPE, DOLLAR, BRACKET, AT, B, J, NUL, JIS_CHAR, OTHER,
+ JIS_C_NUM} JIS_CHAR_TYPE;
-typedef enum
-{
- ASCII, A_ESC, A_ESC_DL, JIS, JIS_1, JIS_2, J_ESC, J_ESC_BR,
- J2_ESC, J2_ESC_BR, INV, JIS_S_NUM
-} JIS_STATE;
+typedef enum {ASCII, A_ESC, A_ESC_DL, JIS, JIS_1, JIS_2, J_ESC, J_ESC_BR,
+ J2_ESC, J2_ESC_BR, INV, JIS_S_NUM} JIS_STATE;
+
+typedef enum {COPYA, COPYJ, COPYJ2, MAKE_A, MAKE_J, NOOP,
+ EMPTY, ERROR} JIS_ACTION;
+
+/* State/action tables for processing JIS encoding:
+
+ Where possible, switches to JIS are grouped with proceding JIS characters
+ and switches to ASCII are grouped with preceding JIS characters.
+ Thus, maximum returned length is:
+ 2 (switch to JIS) + 2 (JIS characters) + 2 (switch back to ASCII) = 6. */
-typedef enum
-{
- COPYA, COPYJ, COPYJ2, MAKE_A, MAKE_J, NOOP, EMPTY, ERROR
-} JIS_ACTION;
-
-/*****************************************************************************
- * state/action tables for processing JIS encoding
- * Where possible, switches to JIS are grouped with proceding JIS characters
- * and switches to ASCII are grouped with preceding JIS characters.
- * Thus, maximum returned length is:
- * 2 (switch to JIS) + 2 (JIS characters) + 2 (switch back to ASCII) = 6.
- *****************************************************************************/
static JIS_STATE JIS_state_table[JIS_S_NUM][JIS_C_NUM] = {
-/* ESCAPE DOLLAR BRACKET AT B J NUL JIS_CHAR OTHER*/
+/* ESCAPE DOLLAR BRACKET AT B J NUL JIS_CHAR OTH*/
/*ASCII*/ { A_ESC, ASCII, ASCII, ASCII, ASCII, ASCII, ASCII,ASCII,ASCII},
/*A_ESC*/ { ASCII, A_ESC_DL,ASCII, ASCII, ASCII, ASCII, ASCII,ASCII,ASCII},
/*A_ESC_DL*/{ ASCII, ASCII, ASCII, JIS, JIS, ASCII, ASCII,ASCII,ASCII},
};
static JIS_ACTION JIS_action_table[JIS_S_NUM][JIS_C_NUM] = {
-/* ESCAPE DOLLAR BRACKET AT B J NUL JIS_CHAR OTHER */
+/* ESCAPE DOLLAR BRACKET AT B J NUL JIS_CHAR OTH */
/*ASCII */ {NOOP, COPYA, COPYA, COPYA, COPYA, COPYA, EMPTY, COPYA, COPYA},
/*A_ESC */ {COPYA, NOOP, COPYA, COPYA, COPYA, COPYA, COPYA, COPYA, COPYA},
/*A_ESC_DL */{COPYA, COPYA, COPYA, MAKE_J, MAKE_J, COPYA, COPYA, COPYA, COPYA},
-/*JIS */ {NOOP, NOOP, NOOP, NOOP, NOOP, NOOP, ERROR, NOOP, ERROR },
-/*JIS_1 */ {ERROR, NOOP, NOOP, NOOP, NOOP, NOOP, ERROR, NOOP, ERROR },
+/*JIS */ {NOOP, NOOP, NOOP, NOOP, NOOP, NOOP, ERROR, NOOP, ERROR},
+/*JIS_1 */ {ERROR, NOOP, NOOP, NOOP, NOOP, NOOP, ERROR, NOOP, ERROR},
/*JIS_2 */ {NOOP, COPYJ2,COPYJ2,COPYJ2, COPYJ2, COPYJ2,ERROR, COPYJ2,COPYJ2},
-/*J_ESC */ {ERROR, ERROR, NOOP, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR },
-/*J_ESC_BR */{ERROR, ERROR, ERROR, ERROR, NOOP, NOOP, ERROR, ERROR, ERROR },
-/*J2_ESC */ {ERROR, ERROR, NOOP, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR },
-/*J2_ESC_BR*/{ERROR, ERROR, ERROR, ERROR, COPYJ, COPYJ, ERROR, ERROR, ERROR },
+/*J_ESC */ {ERROR, ERROR, NOOP, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR},
+/*J_ESC_BR */{ERROR, ERROR, ERROR, ERROR, NOOP, NOOP, ERROR, ERROR, ERROR},
+/*J2_ESC */ {ERROR, ERROR, NOOP, ERROR, ERROR, ERROR, ERROR, ERROR, ERROR},
+/*J2_ESC_BR*/{ERROR, ERROR, ERROR, ERROR, COPYJ, COPYJ, ERROR, ERROR, ERROR},
};
char *literal_codeset = NULL;
+/* Store into *PWC (if PWC is not null) the wide character
+ corresponding to the multibyte character at the start of the
+ buffer S of size N. Return the number of bytes in the multibyte
+ character. Return -1 if the bytes do not form a valid character,
+ or 0 if S is null or points to a null byte.
+
+ This function behaves like the Standard C function mbtowc, except
+ it treats locale names of the form "C-..." specially. */
+
int
local_mbtowc (pwc, s, n)
- wchar_t *pwc;
- const char *s;
- size_t n;
+ wchar_t *pwc;
+ char *s;
+ size_t n;
{
static JIS_STATE save_state = ASCII;
JIS_STATE curr_state = save_state;
- unsigned char *t = (unsigned char *)s;
+ unsigned char *t = (unsigned char *) s;
if (s != NULL && n == 0)
return -1;
if (literal_codeset == NULL || strlen (literal_codeset) <= 1)
- {
- /* This must be the "C" locale or unknown locale -- fall thru */
- }
+ /* This must be the "C" locale or unknown locale -- fall thru */
+ ;
else if (! strcmp (literal_codeset, "C-SJIS"))
{
int char1;
if (s == NULL)
- return 0; /* not state-dependent */
+ /* Not state-dependent. */
+ return 0;
+
char1 = *t;
if (ISSJIS1 (char1))
{
int char2 = t[1];
+
if (n <= 1)
return -1;
+
if (ISSJIS2 (char2))
{
if (pwc != NULL)
- *pwc = (((wchar_t)*t) << 8) + (wchar_t)(*(t+1));
+ *pwc = (((wchar_t) *t) << 8) + (wchar_t) (*(t + 1));
return 2;
}
+
return -1;
}
+
if (pwc != NULL)
- *pwc = (wchar_t)*t;
+ *pwc = (wchar_t) *t;
+
if (*t == '\0')
return 0;
+
return 1;
}
else if (! strcmp (literal_codeset, "C-EUCJP"))
{
int char1;
+
if (s == NULL)
- return 0; /* not state-dependent */
+ /* Not state-dependent. */
+ return 0;
+
char1 = *t;
if (ISEUCJP (char1))
{
int char2 = t[1];
+
if (n <= 1)
return -1;
+
if (ISEUCJP (char2))
{
if (pwc != NULL)
- *pwc = (((wchar_t)*t) << 8) + (wchar_t)(*(t+1));
+ *pwc = (((wchar_t) *t) << 8) + (wchar_t) (*(t + 1));
return 2;
}
+
return -1;
}
+
if (pwc != NULL)
- *pwc = (wchar_t)*t;
+ *pwc = (wchar_t) *t;
+
if (*t == '\0')
return 0;
+
return 1;
}
else if (! strcmp (literal_codeset, "C-JIS"))
if (s == NULL)
{
save_state = ASCII;
- return 1; /* state-dependent */
+ /* State-dependent. */
+ return 1;
}
ptr = t;
- for (i = 0; i < n; ++i)
+ for (i = 0; i < n; i++)
{
curr_ch = t[i];
switch (curr_ch)
{
case NOOP:
break;
+
case EMPTY:
if (pwc != NULL)
- *pwc = (wchar_t)0;
+ *pwc = (wchar_t) 0;
+
save_state = curr_state;
return i;
+
case COPYA:
if (pwc != NULL)
- *pwc = (wchar_t)*ptr;
+ *pwc = (wchar_t) *ptr;
save_state = curr_state;
- return (i + 1);
+ return i + 1;
+
case COPYJ:
if (pwc != NULL)
- *pwc = (((wchar_t)*ptr) << 8) + (wchar_t)(*(ptr+1));
+ *pwc = (((wchar_t) *ptr) << 8) + (wchar_t) (*(ptr + 1));
+
save_state = curr_state;
- return (i + 1);
+ return i + 1;
+
case COPYJ2:
if (pwc != NULL)
- *pwc = (((wchar_t)*ptr) << 8) + (wchar_t)(*(ptr+1));
+ *pwc = (((wchar_t) *ptr) << 8) + (wchar_t) (*(ptr + 1));
+
save_state = curr_state;
- return (ptr - t) + 2;
+ return ptr - t + 2;
+
case MAKE_A:
case MAKE_J:
- ptr = (char *)(t + i + 1);
+ ptr = (char *) (t + i + 1);
break;
+
case ERROR:
default:
return -1;
}
}
- return -1; /* n < bytes needed */
+ /* More than n bytes needed. */
+ return -1;
}
#ifdef CROSS_COMPILE
if (s == NULL)
- return 0; /* not state-dependent */
+ /* Not state-dependent. */
+ return 0;
+
if (pwc != NULL)
*pwc = *s;
return 1;
#else
+
/* This must be the "C" locale or unknown locale. */
return mbtowc (pwc, s, n);
#endif
}
+/* Return the number of bytes in the multibyte character at the start
+ of the buffer S of size N. Return -1 if the bytes do not form a
+ valid character, or 0 if S is null or points to a null byte.
+
+ This function behaves like the Standard C function mblen, except
+ it treats locale names of the form "C-..." specially. */
+
int
local_mblen (s, n)
- const char *s;
- size_t n;
+ char *s;
+ size_t n;
{
return local_mbtowc (NULL, s, n);
}
+/* Return the maximum mumber of bytes in a multibyte character.
+
+ This function returns the same value as the Standard C macro MB_CUR_MAX,
+ except it treats locale names of the form "C-..." specially. */
+
int
local_mb_cur_max ()
{
-/* mbchar.h - Various declarations for functions found in mbchar.c
+/* Various declarations for functions found in mbchar.c
Copyright (C) 1998 Free Software Foundation, Inc.
This file is part of GNU CC.
#define __GCC_MBCHAR_H__
#ifdef MULTIBYTE_CHARS
-/* escape character used for JIS encoding */
+
+/* Escape character used for JIS encoding */
#define JIS_ESC_CHAR 0x1b
#define ISSJIS1(c) ((c) >= 0x81 && (c) <= 0x9f || (c) >= 0xe0 && (c) <= 0xef)
#define ISEUCJP(c) ((c) >= 0xa1 && (c) <= 0xfe)
#define ISJIS(c) ((c) >= 0x21 && (c) <= 0x7e)
-int local_mbtowc PROTO ((wchar_t *, const char *, size_t));
-int local_mblen PROTO ((const char *, size_t));
-int local_mb_cur_max PROTO ((void));
+extern int local_mbtowc PROTO ((wchar_t *, char *, size_t));
+extern int local_mblen PROTO ((char *, size_t));
+extern int local_mb_cur_max PROTO ((void));
/* The locale being used for multibyte characters in string/char literals. */
extern char *literal_codeset;
#endif /* MULTIBYTE_CHARS */
-
-#endif /* __GCC_MBCHAR_H__ */
identifies an operand that is both input and output; all other operands
are assumed to be input only.
+If you specify @samp{=} or @samp{+} in a constraint, you put it in the
+first character of the constraint string.
+
@cindex @samp{&} in constraint
@cindex earlyclobber operand
@item &
/* Read and manage MIPS symbol tables from object modules.
- Copyright (C) 1991, 1994, 1995, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1991, 1994, 1995, 1997, 1998, 1999
+ Free Software Foundation, Inc.
Contributed by hartzell@boulder.colorado.edu,
Rewritten by meissner@osf.org.
#include "config.h"
#include "system.h"
-
#ifdef index
#undef index
#undef rindex
/* A Bison parser, made from objc-parse.y
- by GNU Bison version 1.27
+ by GNU Bison version 1.25
*/
#define YYBISON 1 /* Identify Bison output. */
-#define IDENTIFIER 257
-#define TYPENAME 258
-#define SCSPEC 259
-#define TYPESPEC 260
-#define TYPE_QUAL 261
-#define CONSTANT 262
-#define STRING 263
-#define ELLIPSIS 264
-#define SIZEOF 265
-#define ENUM 266
-#define STRUCT 267
-#define UNION 268
-#define IF 269
-#define ELSE 270
-#define WHILE 271
-#define DO 272
-#define FOR 273
-#define SWITCH 274
-#define CASE 275
-#define DEFAULT 276
-#define BREAK 277
-#define CONTINUE 278
-#define RETURN 279
-#define GOTO 280
-#define ASM_KEYWORD 281
-#define TYPEOF 282
-#define ALIGNOF 283
-#define ATTRIBUTE 284
-#define EXTENSION 285
-#define LABEL 286
-#define REALPART 287
-#define IMAGPART 288
-#define VA_ARG 289
-#define END_OF_LINE 290
-#define ASSIGN 291
-#define OROR 292
-#define ANDAND 293
-#define EQCOMPARE 294
-#define ARITHCOMPARE 295
-#define LSHIFT 296
-#define RSHIFT 297
-#define UNARY 298
-#define PLUSPLUS 299
-#define MINUSMINUS 300
-#define HYPERUNARY 301
-#define POINTSAT 302
-#define INTERFACE 303
-#define IMPLEMENTATION 304
-#define END 305
-#define SELECTOR 306
-#define DEFS 307
-#define ENCODE 308
-#define CLASSNAME 309
-#define PUBLIC 310
-#define PRIVATE 311
-#define PROTECTED 312
-#define PROTOCOL 313
-#define OBJECTNAME 314
-#define CLASS 315
-#define ALIAS 316
-#define OBJC_STRING 317
+#define IDENTIFIER 258
+#define TYPENAME 259
+#define SCSPEC 260
+#define TYPESPEC 261
+#define TYPE_QUAL 262
+#define CONSTANT 263
+#define STRING 264
+#define ELLIPSIS 265
+#define SIZEOF 266
+#define ENUM 267
+#define STRUCT 268
+#define UNION 269
+#define IF 270
+#define ELSE 271
+#define WHILE 272
+#define DO 273
+#define FOR 274
+#define SWITCH 275
+#define CASE 276
+#define DEFAULT 277
+#define BREAK 278
+#define CONTINUE 279
+#define RETURN 280
+#define GOTO 281
+#define ASM_KEYWORD 282
+#define TYPEOF 283
+#define ALIGNOF 284
+#define ATTRIBUTE 285
+#define EXTENSION 286
+#define LABEL 287
+#define REALPART 288
+#define IMAGPART 289
+#define VA_ARG 290
+#define END_OF_LINE 291
+#define ASSIGN 292
+#define OROR 293
+#define ANDAND 294
+#define EQCOMPARE 295
+#define ARITHCOMPARE 296
+#define LSHIFT 297
+#define RSHIFT 298
+#define UNARY 299
+#define PLUSPLUS 300
+#define MINUSMINUS 301
+#define HYPERUNARY 302
+#define POINTSAT 303
+#define INTERFACE 304
+#define IMPLEMENTATION 305
+#define END 306
+#define SELECTOR 307
+#define DEFS 308
+#define ENCODE 309
+#define CLASSNAME 310
+#define PUBLIC 311
+#define PRIVATE 312
+#define PROTECTED 313
+#define PROTOCOL 314
+#define OBJECTNAME 315
+#define CLASS 316
+#define ALIAS 317
+#define OBJC_STRING 318
#line 33 "objc-parse.y"
#include "config.h"
#include "system.h"
#include <setjmp.h>
-
#include "tree.h"
#include "input.h"
#include "c-lex.h"
/* Cause the `yydebug' variable to be defined. */
#define YYDEBUG 1
-#line 65 "objc-parse.y"
+#line 64 "objc-parse.y"
typedef union {long itype; tree ttype; enum tree_code code;
char *filename; int lineno; int ends_in_label; } YYSTYPE;
-#line 196 "objc-parse.y"
+#line 195 "objc-parse.y"
/* Number of statements (loosely speaking) and compound statements
seen so far. */
#define YYFLAG -32768
#define YYNTBASE 86
-#define YYTRANSLATE(x) ((unsigned)(x) <= 317 ? yytranslate[x] : 314)
+#define YYTRANSLATE(x) ((unsigned)(x) <= 318 ? yytranslate[x] : 314)
static const char yytranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
- 2, 2, 2, 2, 2, 1, 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, 32, 33, 34, 35, 36,
- 37, 41, 42, 46, 47, 48, 49, 55, 56, 57,
- 58, 59, 63, 64, 65, 66, 67, 68, 69, 70,
- 71, 72, 73, 74, 75, 76, 77
+ 2, 2, 2, 2, 2, 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, 32, 33, 34, 35,
+ 36, 37, 41, 42, 46, 47, 48, 49, 55, 56,
+ 57, 58, 59, 63, 64, 65, 66, 67, 68, 69,
+ 70, 71, 72, 73, 74, 75, 76, 77
};
#if YYDEBUG != 0
#if YYDEBUG != 0
static const short yyrline[] = { 0,
- 236, 241, 255, 257, 257, 258, 260, 262, 263, 264,
- 272, 276, 287, 292, 297, 299, 301, 302, 303, 308,
- 315, 317, 322, 327, 333, 335, 340, 345, 351, 353,
- 358, 365, 367, 368, 369, 372, 374, 376, 378, 380,
- 382, 384, 388, 392, 395, 398, 401, 405, 407, 410,
- 413, 417, 445, 451, 454, 457, 460, 462, 464, 468,
- 472, 476, 478, 481, 485, 512, 514, 516, 518, 520,
- 522, 524, 526, 528, 530, 532, 534, 536, 538, 542,
- 544, 548, 550, 553, 557, 559, 566, 569, 577, 588,
- 748, 749, 751, 757, 759, 782, 791, 793, 795, 807,
- 821, 823, 825, 827, 829, 831, 833, 838, 840, 846,
- 848, 852, 854, 855, 865, 870, 872, 873, 874, 881,
- 887, 892, 895, 903, 908, 910, 911, 912, 919, 930,
- 934, 940, 945, 950, 955, 957, 959, 968, 971, 975,
- 977, 979, 984, 988, 991, 995, 998, 1000, 1012, 1015,
- 1017, 1019, 1023, 1027, 1029, 1032, 1045, 1048, 1052, 1054,
- 1062, 1063, 1064, 1068, 1070, 1075, 1077, 1079, 1085, 1086,
- 1087, 1090, 1092, 1095, 1097, 1100, 1103, 1109, 1116, 1118,
- 1125, 1132, 1135, 1142, 1145, 1149, 1152, 1156, 1161, 1164,
- 1168, 1171, 1173, 1175, 1177, 1184, 1186, 1187, 1188, 1193,
- 1195, 1200, 1208, 1213, 1217, 1220, 1222, 1227, 1229, 1230,
- 1233, 1233, 1236, 1239, 1241, 1243, 1246, 1248, 1251, 1259,
- 1273, 1281, 1285, 1299, 1307, 1314, 1316, 1321, 1324, 1329,
- 1331, 1333, 1340, 1342, 1343, 1351, 1357, 1359, 1361, 1368,
- 1370, 1376, 1382, 1384, 1386, 1388, 1395, 1397, 1400, 1403,
- 1407, 1410, 1414, 1417, 1421, 1426, 1428, 1432, 1434, 1436,
- 1438, 1442, 1444, 1447, 1450, 1453, 1456, 1460, 1462, 1465,
- 1467, 1472, 1475, 1480, 1482, 1484, 1488, 1512, 1519, 1524,
- 1530, 1535, 1537, 1542, 1544, 1548, 1552, 1556, 1566, 1568,
- 1573, 1578, 1581, 1585, 1588, 1592, 1595, 1598, 1601, 1605,
- 1608, 1612, 1616, 1618, 1620, 1622, 1624, 1626, 1628, 1630,
- 1634, 1642, 1650, 1652, 1654, 1658, 1660, 1663, 1666, 1679,
- 1681, 1686, 1688, 1691, 1705, 1708, 1711, 1713, 1715, 1723,
- 1731, 1741, 1759, 1764, 1769, 1772, 1786, 1795, 1799, 1803,
- 1807, 1813, 1817, 1822, 1825, 1830, 1833, 1834, 1851, 1856,
- 1859, 1871, 1873, 1883, 1893, 1894, 1902, 1905, 1917, 1921,
- 1938, 1948, 1957, 1962, 1967, 1972, 1976, 1980, 1991, 1998,
- 2005, 2012, 2023, 2029, 2032, 2037, 2060, 2094, 2125, 2156,
- 2171, 2185, 2189, 2193, 2196, 2201, 2203, 2206, 2208, 2212,
- 2217, 2220, 2226, 2231, 2236, 2238, 2247, 2248, 2254, 2256,
- 2266, 2268, 2272, 2275, 2281, 2291, 2300, 2309, 2319, 2333,
- 2338, 2343, 2345, 2354, 2357, 2362, 2365, 2369, 2377, 2379,
- 2380, 2381, 2382, 2383, 2397, 2400, 2404, 2410, 2416, 2423,
- 2428, 2434, 2441, 2447, 2453, 2458, 2464, 2471, 2477, 2483,
- 2489, 2497, 2503, 2509, 2517, 2524, 2530, 2539, 2546, 2554,
- 2559, 2562, 2572, 2574, 2577, 2579, 2580, 2583, 2588, 2589,
- 2606, 2613, 2619, 2623, 2626, 2627, 2630, 2638, 2644, 2653,
- 2663, 2670, 2674, 2679, 2688, 2695, 2699, 2709, 2711, 2712,
- 2714, 2716, 2717, 2718, 2719, 2721, 2723, 2726, 2734, 2741,
- 2741, 2748, 2754, 2756, 2762, 2767, 2772, 2781, 2783, 2789,
- 2791, 2794, 2796, 2797, 2798, 2801, 2807, 2809, 2813, 2816,
- 2823, 2829, 2834, 2841, 2846, 2851, 2856, 2863, 2867, 2870,
- 2876, 2878, 2879, 2880, 2883, 2885, 2886, 2887, 2888, 2889,
- 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898, 2899,
- 2900, 2901, 2902, 2903, 2903, 2906, 2912, 2917, 2922, 2928,
- 2930, 2933, 2935, 2942, 2954, 2959, 2965, 2967, 2973, 2977,
- 2978, 2984, 2986, 2989, 2991, 2997, 3002, 3008, 3015, 3024
+ 235, 240, 254, 256, 256, 257, 259, 261, 262, 263,
+ 271, 275, 286, 291, 296, 298, 300, 301, 302, 307,
+ 314, 316, 321, 326, 332, 334, 339, 344, 350, 352,
+ 357, 364, 366, 367, 368, 371, 373, 375, 377, 379,
+ 381, 383, 387, 391, 394, 397, 400, 404, 406, 409,
+ 412, 416, 444, 450, 453, 456, 459, 461, 463, 467,
+ 471, 475, 477, 480, 484, 511, 513, 515, 517, 519,
+ 521, 523, 525, 527, 529, 531, 533, 535, 537, 541,
+ 543, 547, 549, 552, 556, 558, 565, 568, 576, 587,
+ 747, 748, 750, 756, 758, 781, 790, 792, 794, 806,
+ 820, 822, 824, 826, 828, 830, 832, 837, 839, 845,
+ 847, 851, 853, 854, 864, 869, 871, 872, 873, 880,
+ 886, 891, 894, 902, 907, 909, 910, 911, 918, 929,
+ 933, 939, 944, 949, 954, 956, 958, 967, 970, 974,
+ 976, 978, 983, 987, 990, 994, 997, 999, 1011, 1014,
+ 1016, 1018, 1022, 1026, 1028, 1031, 1044, 1047, 1051, 1053,
+ 1061, 1062, 1063, 1067, 1069, 1074, 1076, 1078, 1084, 1085,
+ 1086, 1089, 1091, 1094, 1096, 1099, 1102, 1108, 1115, 1117,
+ 1124, 1131, 1134, 1141, 1144, 1148, 1151, 1155, 1160, 1163,
+ 1167, 1170, 1172, 1174, 1176, 1183, 1185, 1186, 1187, 1192,
+ 1194, 1199, 1207, 1212, 1216, 1219, 1221, 1226, 1228, 1229,
+ 1232, 1232, 1235, 1238, 1240, 1242, 1245, 1247, 1250, 1258,
+ 1272, 1280, 1284, 1298, 1306, 1313, 1315, 1320, 1323, 1328,
+ 1330, 1332, 1339, 1341, 1342, 1350, 1356, 1358, 1360, 1367,
+ 1369, 1375, 1381, 1383, 1385, 1387, 1394, 1396, 1399, 1402,
+ 1406, 1409, 1413, 1416, 1420, 1425, 1427, 1431, 1433, 1435,
+ 1437, 1441, 1443, 1446, 1449, 1452, 1455, 1459, 1461, 1464,
+ 1466, 1471, 1474, 1479, 1481, 1483, 1487, 1511, 1518, 1523,
+ 1529, 1534, 1536, 1541, 1543, 1547, 1551, 1555, 1565, 1567,
+ 1572, 1577, 1580, 1584, 1587, 1591, 1594, 1597, 1600, 1604,
+ 1607, 1611, 1615, 1617, 1619, 1621, 1623, 1625, 1627, 1629,
+ 1633, 1641, 1649, 1651, 1653, 1657, 1659, 1662, 1665, 1678,
+ 1680, 1685, 1687, 1690, 1704, 1707, 1710, 1712, 1714, 1722,
+ 1730, 1740, 1758, 1763, 1768, 1771, 1785, 1794, 1798, 1802,
+ 1806, 1812, 1816, 1821, 1824, 1829, 1832, 1833, 1850, 1855,
+ 1858, 1870, 1872, 1882, 1892, 1893, 1901, 1904, 1916, 1920,
+ 1937, 1947, 1956, 1961, 1966, 1971, 1975, 1979, 1990, 1997,
+ 2004, 2011, 2022, 2028, 2031, 2036, 2059, 2093, 2124, 2155,
+ 2170, 2184, 2188, 2192, 2195, 2200, 2202, 2205, 2207, 2211,
+ 2216, 2219, 2225, 2230, 2235, 2237, 2246, 2247, 2253, 2255,
+ 2265, 2267, 2271, 2274, 2280, 2290, 2299, 2308, 2318, 2332,
+ 2337, 2342, 2344, 2353, 2356, 2361, 2364, 2368, 2376, 2378,
+ 2379, 2380, 2381, 2382, 2396, 2399, 2403, 2409, 2415, 2422,
+ 2427, 2433, 2440, 2446, 2452, 2457, 2463, 2470, 2476, 2482,
+ 2488, 2496, 2502, 2508, 2516, 2523, 2529, 2538, 2545, 2553,
+ 2558, 2561, 2571, 2573, 2576, 2578, 2579, 2582, 2587, 2588,
+ 2605, 2612, 2618, 2622, 2625, 2626, 2629, 2637, 2643, 2652,
+ 2662, 2669, 2673, 2678, 2687, 2694, 2698, 2708, 2710, 2711,
+ 2713, 2715, 2716, 2717, 2718, 2720, 2722, 2725, 2733, 2740,
+ 2740, 2747, 2753, 2755, 2761, 2766, 2771, 2780, 2782, 2788,
+ 2790, 2793, 2795, 2796, 2797, 2800, 2806, 2808, 2812, 2815,
+ 2822, 2828, 2833, 2840, 2845, 2850, 2855, 2862, 2866, 2869,
+ 2875, 2877, 2878, 2879, 2882, 2884, 2885, 2886, 2887, 2888,
+ 2889, 2890, 2891, 2892, 2893, 2894, 2895, 2896, 2897, 2898,
+ 2899, 2900, 2901, 2902, 2902, 2905, 2911, 2916, 2921, 2927,
+ 2929, 2932, 2934, 2941, 2953, 2958, 2964, 2966, 2972, 2976,
+ 2977, 2983, 2985, 2988, 2990, 2996, 3001, 3007, 3014, 3023
};
#endif
46, 47, 48, 49, 50, 51, 52, 53, 54
};
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
-#line 3 "/usr/lib/bison.simple"
-/* This file comes from bison-1.27. */
+#line 3 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
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., 59 Temple Place - Suite 330,
- Boston, MA 02111-1307, USA. */
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
/* As a special exception, when this file is copied by Bison into a
Bison output file, you may use that output file without restriction.
This special exception was added by the Free Software Foundation
in version 1.24 of Bison. */
-/* This is the parser code that is written into each bison parser
- when the %semantic_parser declaration is not specified in the grammar.
- It was written by Richard Stallman by simplifying the hairy parser
- used when %semantic_parser is specified. */
-
-#ifndef YYSTACK_USE_ALLOCA
-#ifdef alloca
-#define YYSTACK_USE_ALLOCA
-#else /* alloca not defined */
+#ifndef alloca
#ifdef __GNUC__
-#define YYSTACK_USE_ALLOCA
#define alloca __builtin_alloca
#else /* not GNU C. */
-#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
-#define YYSTACK_USE_ALLOCA
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
-/* We think this test detects Watcom and Microsoft C. */
-/* This used to test MSDOS, but that is a bad idea
- since that symbol is in the user namespace. */
-#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
-#if 0 /* No need for malloc.h, which pollutes the namespace;
- instead, just don't use alloca. */
+#if defined (MSDOS) && !defined (__TURBOC__)
#include <malloc.h>
-#endif
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
-/* I don't know what this was needed for, but it pollutes the namespace.
- So I turned it off. rms, 2 May 1997. */
-/* #include <malloc.h> */
+#include <malloc.h>
#pragma alloca
-#define YYSTACK_USE_ALLOCA
-#else /* not MSDOS, or __TURBOC__, or _AIX */
-#if 0
-#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
- and on HPUX 10. Eventually we can turn this on. */
-#define YYSTACK_USE_ALLOCA
-#define alloca __builtin_alloca
+#else /* not MSDOS, __TURBOC__, or _AIX */
+#ifdef __hpux
+#ifdef __cplusplus
+extern "C" {
+void *alloca (unsigned int);
+};
+#else /* not __cplusplus */
+void *alloca ();
+#endif /* not __cplusplus */
#endif /* __hpux */
-#endif
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
-#endif /* not sparc */
-#endif /* not GNU C */
-#endif /* alloca not defined */
-#endif /* YYSTACK_USE_ALLOCA not defined */
+#endif /* not sparc. */
+#endif /* not GNU C. */
+#endif /* alloca not defined. */
-#ifdef YYSTACK_USE_ALLOCA
-#define YYSTACK_ALLOC alloca
-#else
-#define YYSTACK_ALLOC malloc
-#endif
+/* This is the parser code that is written into each bison parser
+ when the %semantic_parser declaration is not specified in the grammar.
+ It was written by Richard Stallman by simplifying the hairy parser
+ used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
#define yyclearin (yychar = YYEMPTY)
#define YYEMPTY -2
#define YYEOF 0
-#define YYACCEPT goto yyacceptlab
-#define YYABORT goto yyabortlab
+#define YYACCEPT return(0)
+#define YYABORT return(1)
#define YYERROR goto yyerrlab1
/* Like YYERROR except do call yyerror.
This remains here temporarily to ease the
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 10000
#endif
-\f
-/* Define __yy_memcpy. Note that the size argument
- should be passed with type unsigned int, because that is what the non-GCC
- definitions require. With GCC, __builtin_memcpy takes an arg
- of type size_t, but it can handle unsigned int. */
+/* Prevent warning if -Wstrict-prototypes. */
+#ifdef __GNUC__
+int yyparse (void);
+#endif
+\f
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
__yy_memcpy (to, from, count)
char *to;
char *from;
- unsigned int count;
+ int count;
{
register char *f = from;
register char *t = to;
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
-__yy_memcpy (char *to, char *from, unsigned int count)
+__yy_memcpy (char *to, char *from, int count)
{
- register char *t = to;
register char *f = from;
+ register char *t = to;
register int i = count;
while (i-- > 0)
#endif
#endif
\f
-#line 216 "/usr/lib/bison.simple"
+#line 196 "/usr/cygnus/TBD-TBD/share/bison.simple"
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
into yyparse. The argument should have type void *.
#define YYPARSE_PARAM_DECL
#endif /* not YYPARSE_PARAM */
-/* Prevent warning if -Wstrict-prototypes. */
-#ifdef __GNUC__
-#ifdef YYPARSE_PARAM
-int yyparse (void *);
-#else
-int yyparse (void);
-#endif
-#endif
-
int
yyparse(YYPARSE_PARAM_ARG)
YYPARSE_PARAM_DECL
#endif
int yystacksize = YYINITDEPTH;
- int yyfree_stacks = 0;
#ifdef YYPURE
int yychar;
if (yystacksize >= YYMAXDEPTH)
{
yyerror("parser stack overflow");
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
return 2;
}
yystacksize *= 2;
if (yystacksize > YYMAXDEPTH)
yystacksize = YYMAXDEPTH;
-#ifndef YYSTACK_USE_ALLOCA
- yyfree_stacks = 1;
-#endif
- yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
- __yy_memcpy ((char *)yyss, (char *)yyss1,
- size * (unsigned int) sizeof (*yyssp));
- yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
- __yy_memcpy ((char *)yyvs, (char *)yyvs1,
- size * (unsigned int) sizeof (*yyvsp));
+ yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
+ __yy_memcpy ((char *)yyss, (char *)yyss1, size * sizeof (*yyssp));
+ yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
+ __yy_memcpy ((char *)yyvs, (char *)yyvs1, size * sizeof (*yyvsp));
#ifdef YYLSP_NEEDED
- yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
- __yy_memcpy ((char *)yyls, (char *)yyls1,
- size * (unsigned int) sizeof (*yylsp));
+ yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
+ __yy_memcpy ((char *)yyls, (char *)yyls1, size * sizeof (*yylsp));
#endif
#endif /* no yyoverflow */
switch (yyn) {
case 1:
-#line 237 "objc-parse.y"
+#line 236 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids an empty source file");
finish_file ();
;
break;}
case 2:
-#line 242 "objc-parse.y"
+#line 241 "objc-parse.y"
{
/* In case there were missing closebraces,
get us back to the global binding level. */
;
break;}
case 3:
-#line 256 "objc-parse.y"
+#line 255 "objc-parse.y"
{yyval.ttype = NULL_TREE; ;
break;}
case 5:
-#line 257 "objc-parse.y"
+#line 256 "objc-parse.y"
{yyval.ttype = NULL_TREE; ;
break;}
case 10:
-#line 265 "objc-parse.y"
+#line 264 "objc-parse.y"
{ STRIP_NOPS (yyvsp[-2].ttype);
if ((TREE_CODE (yyvsp[-2].ttype) == ADDR_EXPR
&& TREE_CODE (TREE_OPERAND (yyvsp[-2].ttype, 0)) == STRING_CST)
error ("argument of `asm' is not a constant string"); ;
break;}
case 11:
-#line 273 "objc-parse.y"
+#line 272 "objc-parse.y"
{ pedantic = yyvsp[-1].itype; ;
break;}
case 12:
-#line 278 "objc-parse.y"
+#line 277 "objc-parse.y"
{ if (pedantic)
error ("ANSI C forbids data definition with no type or storage class");
else if (!flag_traditional)
resume_momentary (yyvsp[-2].itype); ;
break;}
case 13:
-#line 288 "objc-parse.y"
+#line 287 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 14:
-#line 293 "objc-parse.y"
+#line 292 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 15:
-#line 298 "objc-parse.y"
+#line 297 "objc-parse.y"
{ pedwarn ("empty declaration"); ;
break;}
case 16:
-#line 300 "objc-parse.y"
+#line 299 "objc-parse.y"
{ shadow_tag (yyvsp[-1].ttype); ;
break;}
case 19:
-#line 304 "objc-parse.y"
+#line 303 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C does not allow extra `;' outside of a function"); ;
break;}
case 20:
-#line 310 "objc-parse.y"
+#line 309 "objc-parse.y"
{ if (! start_function (current_declspecs, yyvsp[0].ttype,
prefix_attributes, NULL_TREE, 0))
YYERROR1;
reinit_parse_for_function (); ;
break;}
case 21:
-#line 315 "objc-parse.y"
+#line 314 "objc-parse.y"
{ store_parm_decls (); ;
break;}
case 22:
-#line 317 "objc-parse.y"
+#line 316 "objc-parse.y"
{ finish_function (0);
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-5].itype); ;
break;}
case 23:
-#line 323 "objc-parse.y"
+#line 322 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 24:
-#line 328 "objc-parse.y"
+#line 327 "objc-parse.y"
{ if (! start_function (current_declspecs, yyvsp[0].ttype,
prefix_attributes, NULL_TREE, 0))
YYERROR1;
reinit_parse_for_function (); ;
break;}
case 25:
-#line 333 "objc-parse.y"
+#line 332 "objc-parse.y"
{ store_parm_decls (); ;
break;}
case 26:
-#line 335 "objc-parse.y"
+#line 334 "objc-parse.y"
{ finish_function (0);
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-5].itype); ;
break;}
case 27:
-#line 341 "objc-parse.y"
+#line 340 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 28:
-#line 346 "objc-parse.y"
+#line 345 "objc-parse.y"
{ if (! start_function (NULL_TREE, yyvsp[0].ttype,
prefix_attributes, NULL_TREE, 0))
YYERROR1;
reinit_parse_for_function (); ;
break;}
case 29:
-#line 351 "objc-parse.y"
+#line 350 "objc-parse.y"
{ store_parm_decls (); ;
break;}
case 30:
-#line 353 "objc-parse.y"
+#line 352 "objc-parse.y"
{ finish_function (0);
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-5].itype); ;
break;}
case 31:
-#line 359 "objc-parse.y"
+#line 358 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 36:
-#line 373 "objc-parse.y"
+#line 372 "objc-parse.y"
{ yyval.code = ADDR_EXPR; ;
break;}
case 37:
-#line 375 "objc-parse.y"
+#line 374 "objc-parse.y"
{ yyval.code = NEGATE_EXPR; ;
break;}
case 38:
-#line 377 "objc-parse.y"
+#line 376 "objc-parse.y"
{ yyval.code = CONVERT_EXPR; ;
break;}
case 39:
-#line 379 "objc-parse.y"
+#line 378 "objc-parse.y"
{ yyval.code = PREINCREMENT_EXPR; ;
break;}
case 40:
-#line 381 "objc-parse.y"
+#line 380 "objc-parse.y"
{ yyval.code = PREDECREMENT_EXPR; ;
break;}
case 41:
-#line 383 "objc-parse.y"
+#line 382 "objc-parse.y"
{ yyval.code = BIT_NOT_EXPR; ;
break;}
case 42:
-#line 385 "objc-parse.y"
+#line 384 "objc-parse.y"
{ yyval.code = TRUTH_NOT_EXPR; ;
break;}
case 43:
-#line 389 "objc-parse.y"
+#line 388 "objc-parse.y"
{ yyval.ttype = build_compound_expr (yyvsp[0].ttype); ;
break;}
case 44:
-#line 394 "objc-parse.y"
+#line 393 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 46:
-#line 400 "objc-parse.y"
+#line 399 "objc-parse.y"
{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
break;}
case 47:
-#line 402 "objc-parse.y"
+#line 401 "objc-parse.y"
{ chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
break;}
case 49:
-#line 408 "objc-parse.y"
+#line 407 "objc-parse.y"
{ yyval.ttype = build_indirect_ref (yyvsp[0].ttype, "unary *"); ;
break;}
case 50:
-#line 411 "objc-parse.y"
+#line 410 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
pedantic = yyvsp[-1].itype; ;
break;}
case 51:
-#line 414 "objc-parse.y"
+#line 413 "objc-parse.y"
{ yyval.ttype = build_unary_op (yyvsp[-1].code, yyvsp[0].ttype, 0);
overflow_warning (yyval.ttype); ;
break;}
case 52:
-#line 418 "objc-parse.y"
+#line 417 "objc-parse.y"
{ tree label = lookup_label (yyvsp[0].ttype);
if (pedantic)
pedwarn ("ANSI C forbids `&&'");
;
break;}
case 53:
-#line 446 "objc-parse.y"
+#line 445 "objc-parse.y"
{ skip_evaluation--;
if (TREE_CODE (yyvsp[0].ttype) == COMPONENT_REF
&& DECL_C_BIT_FIELD (TREE_OPERAND (yyvsp[0].ttype, 1)))
yyval.ttype = c_sizeof (TREE_TYPE (yyvsp[0].ttype)); ;
break;}
case 54:
-#line 452 "objc-parse.y"
+#line 451 "objc-parse.y"
{ skip_evaluation--;
yyval.ttype = c_sizeof (groktypename (yyvsp[-1].ttype)); ;
break;}
case 55:
-#line 455 "objc-parse.y"
+#line 454 "objc-parse.y"
{ skip_evaluation--;
yyval.ttype = c_alignof_expr (yyvsp[0].ttype); ;
break;}
case 56:
-#line 458 "objc-parse.y"
+#line 457 "objc-parse.y"
{ skip_evaluation--;
yyval.ttype = c_alignof (groktypename (yyvsp[-1].ttype)); ;
break;}
case 57:
-#line 461 "objc-parse.y"
+#line 460 "objc-parse.y"
{ yyval.ttype = build_unary_op (REALPART_EXPR, yyvsp[0].ttype, 0); ;
break;}
case 58:
-#line 463 "objc-parse.y"
+#line 462 "objc-parse.y"
{ yyval.ttype = build_unary_op (IMAGPART_EXPR, yyvsp[0].ttype, 0); ;
break;}
case 59:
-#line 465 "objc-parse.y"
+#line 464 "objc-parse.y"
{ yyval.ttype = build_va_arg (yyvsp[-3].ttype, groktypename (yyvsp[-1].ttype)); ;
break;}
case 60:
-#line 469 "objc-parse.y"
+#line 468 "objc-parse.y"
{ skip_evaluation++; ;
break;}
case 61:
-#line 473 "objc-parse.y"
+#line 472 "objc-parse.y"
{ skip_evaluation++; ;
break;}
case 63:
-#line 479 "objc-parse.y"
+#line 478 "objc-parse.y"
{ tree type = groktypename (yyvsp[-2].ttype);
yyval.ttype = build_c_cast (type, yyvsp[0].ttype); ;
break;}
case 64:
-#line 482 "objc-parse.y"
+#line 481 "objc-parse.y"
{ start_init (NULL_TREE, NULL, 0);
yyvsp[-2].ttype = groktypename (yyvsp[-2].ttype);
really_start_incremental_init (yyvsp[-2].ttype); ;
break;}
case 65:
-#line 486 "objc-parse.y"
+#line 485 "objc-parse.y"
{ char *name;
tree result = pop_init_level (0);
tree type = yyvsp[-5].ttype;
;
break;}
case 67:
-#line 515 "objc-parse.y"
+#line 514 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 68:
-#line 517 "objc-parse.y"
+#line 516 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 69:
-#line 519 "objc-parse.y"
+#line 518 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 70:
-#line 521 "objc-parse.y"
+#line 520 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 71:
-#line 523 "objc-parse.y"
+#line 522 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 72:
-#line 525 "objc-parse.y"
+#line 524 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 73:
-#line 527 "objc-parse.y"
+#line 526 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 74:
-#line 529 "objc-parse.y"
+#line 528 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 75:
-#line 531 "objc-parse.y"
+#line 530 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 76:
-#line 533 "objc-parse.y"
+#line 532 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 77:
-#line 535 "objc-parse.y"
+#line 534 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 78:
-#line 537 "objc-parse.y"
+#line 536 "objc-parse.y"
{ yyval.ttype = parser_build_binary_op (yyvsp[-1].code, yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 79:
-#line 539 "objc-parse.y"
+#line 538 "objc-parse.y"
{ yyvsp[-1].ttype = truthvalue_conversion (default_conversion (yyvsp[-1].ttype));
skip_evaluation += yyvsp[-1].ttype == boolean_false_node; ;
break;}
case 80:
-#line 542 "objc-parse.y"
+#line 541 "objc-parse.y"
{ skip_evaluation -= yyvsp[-3].ttype == boolean_false_node;
yyval.ttype = parser_build_binary_op (TRUTH_ANDIF_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); ;
break;}
case 81:
-#line 545 "objc-parse.y"
+#line 544 "objc-parse.y"
{ yyvsp[-1].ttype = truthvalue_conversion (default_conversion (yyvsp[-1].ttype));
skip_evaluation += yyvsp[-1].ttype == boolean_true_node; ;
break;}
case 82:
-#line 548 "objc-parse.y"
+#line 547 "objc-parse.y"
{ skip_evaluation -= yyvsp[-3].ttype == boolean_true_node;
yyval.ttype = parser_build_binary_op (TRUTH_ORIF_EXPR, yyvsp[-3].ttype, yyvsp[0].ttype); ;
break;}
case 83:
-#line 551 "objc-parse.y"
+#line 550 "objc-parse.y"
{ yyvsp[-1].ttype = truthvalue_conversion (default_conversion (yyvsp[-1].ttype));
skip_evaluation += yyvsp[-1].ttype == boolean_false_node; ;
break;}
case 84:
-#line 554 "objc-parse.y"
+#line 553 "objc-parse.y"
{ skip_evaluation += ((yyvsp[-4].ttype == boolean_true_node)
- (yyvsp[-4].ttype == boolean_false_node)); ;
break;}
case 85:
-#line 557 "objc-parse.y"
+#line 556 "objc-parse.y"
{ skip_evaluation -= yyvsp[-6].ttype == boolean_true_node;
yyval.ttype = build_conditional_expr (yyvsp[-6].ttype, yyvsp[-3].ttype, yyvsp[0].ttype); ;
break;}
case 86:
-#line 560 "objc-parse.y"
+#line 559 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids omitting the middle term of a ?: expression");
/* Make sure first operand is calculated only once. */
skip_evaluation += yyvsp[-1].ttype == boolean_true_node; ;
break;}
case 87:
-#line 567 "objc-parse.y"
+#line 566 "objc-parse.y"
{ skip_evaluation -= yyvsp[-4].ttype == boolean_true_node;
yyval.ttype = build_conditional_expr (yyvsp[-4].ttype, yyvsp[-3].ttype, yyvsp[0].ttype); ;
break;}
case 88:
-#line 570 "objc-parse.y"
+#line 569 "objc-parse.y"
{ char class;
yyval.ttype = build_modify_expr (yyvsp[-2].ttype, NOP_EXPR, yyvsp[0].ttype);
class = TREE_CODE_CLASS (TREE_CODE (yyval.ttype));
;
break;}
case 89:
-#line 578 "objc-parse.y"
+#line 577 "objc-parse.y"
{ char class;
yyval.ttype = build_modify_expr (yyvsp[-2].ttype, yyvsp[-1].code, yyvsp[0].ttype);
/* This inhibits warnings in truthvalue_conversion. */
;
break;}
case 90:
-#line 590 "objc-parse.y"
+#line 589 "objc-parse.y"
{
yyval.ttype = lastiddecl;
if (!yyval.ttype || yyval.ttype == error_mark_node)
;
break;}
case 92:
-#line 750 "objc-parse.y"
+#line 749 "objc-parse.y"
{ yyval.ttype = combine_strings (yyvsp[0].ttype); ;
break;}
case 93:
-#line 752 "objc-parse.y"
+#line 751 "objc-parse.y"
{ char class = TREE_CODE_CLASS (TREE_CODE (yyvsp[-1].ttype));
if (class == 'e' || class == '1'
|| class == '2' || class == '<')
yyval.ttype = yyvsp[-1].ttype; ;
break;}
case 94:
-#line 758 "objc-parse.y"
+#line 757 "objc-parse.y"
{ yyval.ttype = error_mark_node; ;
break;}
case 95:
-#line 760 "objc-parse.y"
+#line 759 "objc-parse.y"
{ tree rtl_exp;
if (pedantic)
pedwarn ("ANSI C forbids braced-groups within expressions");
;
break;}
case 96:
-#line 783 "objc-parse.y"
+#line 782 "objc-parse.y"
{
/* Make sure we call expand_end_stmt_expr. Otherwise
we are likely to lose sequences and crash later. */
;
break;}
case 97:
-#line 792 "objc-parse.y"
+#line 791 "objc-parse.y"
{ yyval.ttype = build_function_call (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 98:
-#line 794 "objc-parse.y"
+#line 793 "objc-parse.y"
{ yyval.ttype = build_array_ref (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 99:
-#line 796 "objc-parse.y"
+#line 795 "objc-parse.y"
{
if (doing_objc_thang)
{
;
break;}
case 100:
-#line 808 "objc-parse.y"
+#line 807 "objc-parse.y"
{
tree expr = build_indirect_ref (yyvsp[-2].ttype, "->");
;
break;}
case 101:
-#line 822 "objc-parse.y"
+#line 821 "objc-parse.y"
{ yyval.ttype = build_unary_op (POSTINCREMENT_EXPR, yyvsp[-1].ttype, 0); ;
break;}
case 102:
-#line 824 "objc-parse.y"
+#line 823 "objc-parse.y"
{ yyval.ttype = build_unary_op (POSTDECREMENT_EXPR, yyvsp[-1].ttype, 0); ;
break;}
case 103:
-#line 826 "objc-parse.y"
+#line 825 "objc-parse.y"
{ yyval.ttype = build_message_expr (yyvsp[0].ttype); ;
break;}
case 104:
-#line 828 "objc-parse.y"
+#line 827 "objc-parse.y"
{ yyval.ttype = build_selector_expr (yyvsp[0].ttype); ;
break;}
case 105:
-#line 830 "objc-parse.y"
+#line 829 "objc-parse.y"
{ yyval.ttype = build_protocol_expr (yyvsp[0].ttype); ;
break;}
case 106:
-#line 832 "objc-parse.y"
+#line 831 "objc-parse.y"
{ yyval.ttype = build_encode_expr (yyvsp[0].ttype); ;
break;}
case 107:
-#line 834 "objc-parse.y"
+#line 833 "objc-parse.y"
{ yyval.ttype = build_objc_string_object (yyvsp[0].ttype); ;
break;}
case 109:
-#line 841 "objc-parse.y"
+#line 840 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 111:
-#line 849 "objc-parse.y"
+#line 848 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 114:
-#line 857 "objc-parse.y"
+#line 856 "objc-parse.y"
{ c_mark_varargs ();
if (pedantic)
pedwarn ("ANSI C does not permit use of `varargs.h'"); ;
break;}
case 115:
-#line 867 "objc-parse.y"
+#line 866 "objc-parse.y"
{ ;
break;}
case 120:
-#line 883 "objc-parse.y"
+#line 882 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 121:
-#line 888 "objc-parse.y"
+#line 887 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 122:
-#line 893 "objc-parse.y"
+#line 892 "objc-parse.y"
{ shadow_tag_warned (yyvsp[-1].ttype, 1);
pedwarn ("empty declaration"); ;
break;}
case 123:
-#line 896 "objc-parse.y"
+#line 895 "objc-parse.y"
{ pedwarn ("empty declaration"); ;
break;}
case 124:
-#line 905 "objc-parse.y"
+#line 904 "objc-parse.y"
{ ;
break;}
case 129:
-#line 920 "objc-parse.y"
+#line 919 "objc-parse.y"
{ yyval.itype = suspend_momentary ();
pending_xref_error ();
declspec_stack = tree_cons (prefix_attributes,
¤t_declspecs, &prefix_attributes); ;
break;}
case 130:
-#line 931 "objc-parse.y"
+#line 930 "objc-parse.y"
{ prefix_attributes = chainon (prefix_attributes, yyvsp[0].ttype); ;
break;}
case 131:
-#line 936 "objc-parse.y"
+#line 935 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 132:
-#line 941 "objc-parse.y"
+#line 940 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 133:
-#line 946 "objc-parse.y"
+#line 945 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 134:
-#line 951 "objc-parse.y"
+#line 950 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 135:
-#line 956 "objc-parse.y"
+#line 955 "objc-parse.y"
{ shadow_tag (yyvsp[-1].ttype); ;
break;}
case 136:
-#line 958 "objc-parse.y"
+#line 957 "objc-parse.y"
{ pedwarn ("empty declaration"); ;
break;}
case 137:
-#line 960 "objc-parse.y"
+#line 959 "objc-parse.y"
{ pedantic = yyvsp[-1].itype; ;
break;}
case 138:
-#line 970 "objc-parse.y"
+#line 969 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 139:
-#line 972 "objc-parse.y"
+#line 971 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
break;}
case 140:
-#line 976 "objc-parse.y"
+#line 975 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 141:
-#line 978 "objc-parse.y"
+#line 977 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 142:
-#line 980 "objc-parse.y"
+#line 979 "objc-parse.y"
{ if (extra_warnings)
warning ("`%s' is not at beginning of declaration",
IDENTIFIER_POINTER (yyvsp[0].ttype));
yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 143:
-#line 985 "objc-parse.y"
+#line 984 "objc-parse.y"
{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-1].ttype); ;
break;}
case 144:
-#line 990 "objc-parse.y"
+#line 989 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 145:
-#line 992 "objc-parse.y"
+#line 991 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
break;}
case 146:
-#line 997 "objc-parse.y"
+#line 996 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 147:
-#line 999 "objc-parse.y"
+#line 998 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 148:
-#line 1001 "objc-parse.y"
+#line 1000 "objc-parse.y"
{ if (extra_warnings)
warning ("`%s' is not at beginning of declaration",
IDENTIFIER_POINTER (yyvsp[0].ttype));
yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 149:
-#line 1014 "objc-parse.y"
+#line 1013 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 150:
-#line 1016 "objc-parse.y"
+#line 1015 "objc-parse.y"
{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, NULL_TREE); ;
break;}
case 151:
-#line 1018 "objc-parse.y"
+#line 1017 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 152:
-#line 1020 "objc-parse.y"
+#line 1019 "objc-parse.y"
{ yyval.ttype = tree_cons (yyvsp[0].ttype, NULL_TREE, yyvsp[-1].ttype); ;
break;}
case 153:
-#line 1025 "objc-parse.y"
+#line 1024 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE);
TREE_STATIC (yyval.ttype) = 1; ;
break;}
case 154:
-#line 1028 "objc-parse.y"
+#line 1027 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 155:
-#line 1030 "objc-parse.y"
+#line 1029 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype);
TREE_STATIC (yyval.ttype) = 1; ;
break;}
case 156:
-#line 1033 "objc-parse.y"
+#line 1032 "objc-parse.y"
{ if (extra_warnings && TREE_STATIC (yyvsp[-1].ttype))
warning ("`%s' is not at beginning of declaration",
IDENTIFIER_POINTER (yyvsp[0].ttype));
TREE_STATIC (yyval.ttype) = TREE_STATIC (yyvsp[-1].ttype); ;
break;}
case 157:
-#line 1047 "objc-parse.y"
+#line 1046 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 158:
-#line 1049 "objc-parse.y"
+#line 1048 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[0].ttype, tree_cons (NULL_TREE, yyvsp[-1].ttype, yyvsp[-2].ttype)); ;
break;}
case 159:
-#line 1053 "objc-parse.y"
+#line 1052 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 160:
-#line 1055 "objc-parse.y"
+#line 1054 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 163:
-#line 1065 "objc-parse.y"
+#line 1064 "objc-parse.y"
{ /* For a typedef name, record the meaning, not the name.
In case of `foo foo, bar;'. */
yyval.ttype = lookup_name (yyvsp[0].ttype); ;
break;}
case 164:
-#line 1069 "objc-parse.y"
+#line 1068 "objc-parse.y"
{ yyval.ttype = get_static_reference (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 165:
-#line 1071 "objc-parse.y"
+#line 1070 "objc-parse.y"
{ yyval.ttype = get_object_reference (yyvsp[0].ttype); ;
break;}
case 166:
-#line 1076 "objc-parse.y"
+#line 1075 "objc-parse.y"
{ yyval.ttype = get_object_reference (yyvsp[0].ttype); ;
break;}
case 167:
-#line 1078 "objc-parse.y"
+#line 1077 "objc-parse.y"
{ yyval.ttype = TREE_TYPE (yyvsp[-1].ttype); ;
break;}
case 168:
-#line 1080 "objc-parse.y"
+#line 1079 "objc-parse.y"
{ yyval.ttype = groktypename (yyvsp[-1].ttype); ;
break;}
case 176:
-#line 1102 "objc-parse.y"
+#line 1101 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 177:
-#line 1104 "objc-parse.y"
+#line 1103 "objc-parse.y"
{ if (TREE_CHAIN (yyvsp[-1].ttype)) yyvsp[-1].ttype = combine_strings (yyvsp[-1].ttype);
yyval.ttype = yyvsp[-1].ttype;
;
break;}
case 178:
-#line 1111 "objc-parse.y"
+#line 1110 "objc-parse.y"
{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1,
yyvsp[-1].ttype, prefix_attributes);
start_init (yyval.ttype, yyvsp[-2].ttype, global_bindings_p ()); ;
break;}
case 179:
-#line 1116 "objc-parse.y"
+#line 1115 "objc-parse.y"
{ finish_init ();
finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
break;}
case 180:
-#line 1119 "objc-parse.y"
+#line 1118 "objc-parse.y"
{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0,
yyvsp[0].ttype, prefix_attributes);
finish_decl (d, NULL_TREE, yyvsp[-1].ttype);
;
break;}
case 181:
-#line 1127 "objc-parse.y"
+#line 1126 "objc-parse.y"
{ yyval.ttype = start_decl (yyvsp[-3].ttype, current_declspecs, 1,
yyvsp[-1].ttype, prefix_attributes);
start_init (yyval.ttype, yyvsp[-2].ttype, global_bindings_p ()); ;
break;}
case 182:
-#line 1132 "objc-parse.y"
+#line 1131 "objc-parse.y"
{ finish_init ();
decl_attributes (yyvsp[-1].ttype, yyvsp[-3].ttype, prefix_attributes);
finish_decl (yyvsp[-1].ttype, yyvsp[0].ttype, yyvsp[-4].ttype); ;
break;}
case 183:
-#line 1136 "objc-parse.y"
+#line 1135 "objc-parse.y"
{ tree d = start_decl (yyvsp[-2].ttype, current_declspecs, 0,
yyvsp[0].ttype, prefix_attributes);
finish_decl (d, NULL_TREE, yyvsp[-1].ttype); ;
break;}
case 184:
-#line 1144 "objc-parse.y"
+#line 1143 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 185:
-#line 1146 "objc-parse.y"
+#line 1145 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 186:
-#line 1151 "objc-parse.y"
+#line 1150 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 187:
-#line 1153 "objc-parse.y"
+#line 1152 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 188:
-#line 1158 "objc-parse.y"
+#line 1157 "objc-parse.y"
{ yyval.ttype = yyvsp[-2].ttype; ;
break;}
case 189:
-#line 1163 "objc-parse.y"
+#line 1162 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 190:
-#line 1165 "objc-parse.y"
+#line 1164 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 191:
-#line 1170 "objc-parse.y"
+#line 1169 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 192:
-#line 1172 "objc-parse.y"
+#line 1171 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[0].ttype, NULL_TREE); ;
break;}
case 193:
-#line 1174 "objc-parse.y"
+#line 1173 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, build_tree_list (NULL_TREE, yyvsp[-1].ttype)); ;
break;}
case 194:
-#line 1176 "objc-parse.y"
+#line 1175 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-5].ttype, tree_cons (NULL_TREE, yyvsp[-3].ttype, yyvsp[-1].ttype)); ;
break;}
case 195:
-#line 1178 "objc-parse.y"
+#line 1177 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 201:
-#line 1196 "objc-parse.y"
+#line 1195 "objc-parse.y"
{ really_start_incremental_init (NULL_TREE);
/* Note that the call to clear_momentary
is in process_init_element. */
push_momentary (); ;
break;}
case 202:
-#line 1201 "objc-parse.y"
+#line 1200 "objc-parse.y"
{ yyval.ttype = pop_init_level (0);
if (yyval.ttype == error_mark_node
&& ! (yychar == STRING || yychar == CONSTANT))
pop_momentary_nofree (); ;
break;}
case 203:
-#line 1209 "objc-parse.y"
+#line 1208 "objc-parse.y"
{ yyval.ttype = error_mark_node; ;
break;}
case 204:
-#line 1215 "objc-parse.y"
+#line 1214 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids empty initializer braces"); ;
break;}
case 210:
-#line 1231 "objc-parse.y"
+#line 1230 "objc-parse.y"
{ set_init_label (yyvsp[-1].ttype); ;
break;}
case 213:
-#line 1238 "objc-parse.y"
+#line 1237 "objc-parse.y"
{ push_init_level (0); ;
break;}
case 214:
-#line 1240 "objc-parse.y"
+#line 1239 "objc-parse.y"
{ process_init_element (pop_init_level (0)); ;
break;}
case 215:
-#line 1242 "objc-parse.y"
+#line 1241 "objc-parse.y"
{ process_init_element (yyvsp[0].ttype); ;
break;}
case 219:
-#line 1253 "objc-parse.y"
+#line 1252 "objc-parse.y"
{ set_init_label (yyvsp[0].ttype); ;
break;}
case 220:
-#line 1261 "objc-parse.y"
+#line 1260 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids nested functions");
reinit_parse_for_function (); ;
break;}
case 221:
-#line 1273 "objc-parse.y"
+#line 1272 "objc-parse.y"
{ store_parm_decls (); ;
break;}
case 222:
-#line 1281 "objc-parse.y"
+#line 1280 "objc-parse.y"
{ finish_function (1);
pop_function_context (); ;
break;}
case 223:
-#line 1287 "objc-parse.y"
+#line 1286 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids nested functions");
reinit_parse_for_function (); ;
break;}
case 224:
-#line 1299 "objc-parse.y"
+#line 1298 "objc-parse.y"
{ store_parm_decls (); ;
break;}
case 225:
-#line 1307 "objc-parse.y"
+#line 1306 "objc-parse.y"
{ finish_function (1);
pop_function_context (); ;
break;}
case 228:
-#line 1323 "objc-parse.y"
+#line 1322 "objc-parse.y"
{ yyval.ttype = yyvsp[-1].ttype; ;
break;}
case 229:
-#line 1325 "objc-parse.y"
+#line 1324 "objc-parse.y"
{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 230:
-#line 1330 "objc-parse.y"
+#line 1329 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 231:
-#line 1332 "objc-parse.y"
+#line 1331 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
break;}
case 232:
-#line 1334 "objc-parse.y"
+#line 1333 "objc-parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 233:
-#line 1341 "objc-parse.y"
+#line 1340 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 236:
-#line 1353 "objc-parse.y"
+#line 1352 "objc-parse.y"
{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 237:
-#line 1358 "objc-parse.y"
+#line 1357 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 238:
-#line 1360 "objc-parse.y"
+#line 1359 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
break;}
case 239:
-#line 1362 "objc-parse.y"
+#line 1361 "objc-parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 240:
-#line 1369 "objc-parse.y"
+#line 1368 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 242:
-#line 1378 "objc-parse.y"
+#line 1377 "objc-parse.y"
{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 243:
-#line 1383 "objc-parse.y"
+#line 1382 "objc-parse.y"
{ yyval.ttype = yyvsp[-1].ttype; ;
break;}
case 244:
-#line 1385 "objc-parse.y"
+#line 1384 "objc-parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 245:
-#line 1387 "objc-parse.y"
+#line 1386 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 246:
-#line 1389 "objc-parse.y"
+#line 1388 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
break;}
case 247:
-#line 1396 "objc-parse.y"
+#line 1395 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 249:
-#line 1402 "objc-parse.y"
+#line 1401 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 250:
-#line 1404 "objc-parse.y"
+#line 1403 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 251:
-#line 1409 "objc-parse.y"
+#line 1408 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 252:
-#line 1411 "objc-parse.y"
+#line 1410 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 253:
-#line 1416 "objc-parse.y"
+#line 1415 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 254:
-#line 1418 "objc-parse.y"
+#line 1417 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 255:
-#line 1423 "objc-parse.y"
+#line 1422 "objc-parse.y"
{ yyval.ttype = start_struct (RECORD_TYPE, yyvsp[-1].ttype);
/* Start scope of tag before parsing components. */
;
break;}
case 256:
-#line 1427 "objc-parse.y"
+#line 1426 "objc-parse.y"
{ yyval.ttype = finish_struct (yyvsp[-3].ttype, yyvsp[-2].ttype, chainon (yyvsp[-6].ttype, yyvsp[0].ttype)); ;
break;}
case 257:
-#line 1429 "objc-parse.y"
+#line 1428 "objc-parse.y"
{ yyval.ttype = finish_struct (start_struct (RECORD_TYPE, NULL_TREE),
yyvsp[-2].ttype, chainon (yyvsp[-4].ttype, yyvsp[0].ttype));
;
break;}
case 258:
-#line 1433 "objc-parse.y"
+#line 1432 "objc-parse.y"
{ yyval.ttype = xref_tag (RECORD_TYPE, yyvsp[0].ttype); ;
break;}
case 259:
-#line 1435 "objc-parse.y"
+#line 1434 "objc-parse.y"
{ yyval.ttype = start_struct (UNION_TYPE, yyvsp[-1].ttype); ;
break;}
case 260:
-#line 1437 "objc-parse.y"
+#line 1436 "objc-parse.y"
{ yyval.ttype = finish_struct (yyvsp[-3].ttype, yyvsp[-2].ttype, chainon (yyvsp[-6].ttype, yyvsp[0].ttype)); ;
break;}
case 261:
-#line 1439 "objc-parse.y"
+#line 1438 "objc-parse.y"
{ yyval.ttype = finish_struct (start_struct (UNION_TYPE, NULL_TREE),
yyvsp[-2].ttype, chainon (yyvsp[-4].ttype, yyvsp[0].ttype));
;
break;}
case 262:
-#line 1443 "objc-parse.y"
+#line 1442 "objc-parse.y"
{ yyval.ttype = xref_tag (UNION_TYPE, yyvsp[0].ttype); ;
break;}
case 263:
-#line 1445 "objc-parse.y"
+#line 1444 "objc-parse.y"
{ yyvsp[0].itype = suspend_momentary ();
yyval.ttype = start_enum (yyvsp[-1].ttype); ;
break;}
case 264:
-#line 1448 "objc-parse.y"
+#line 1447 "objc-parse.y"
{ yyval.ttype= finish_enum (yyvsp[-4].ttype, nreverse (yyvsp[-3].ttype), chainon (yyvsp[-7].ttype, yyvsp[0].ttype));
resume_momentary (yyvsp[-5].itype); ;
break;}
case 265:
-#line 1451 "objc-parse.y"
+#line 1450 "objc-parse.y"
{ yyvsp[0].itype = suspend_momentary ();
yyval.ttype = start_enum (NULL_TREE); ;
break;}
case 266:
-#line 1454 "objc-parse.y"
+#line 1453 "objc-parse.y"
{ yyval.ttype= finish_enum (yyvsp[-4].ttype, nreverse (yyvsp[-3].ttype), chainon (yyvsp[-6].ttype, yyvsp[0].ttype));
resume_momentary (yyvsp[-5].itype); ;
break;}
case 267:
-#line 1457 "objc-parse.y"
+#line 1456 "objc-parse.y"
{ yyval.ttype = xref_tag (ENUMERAL_TYPE, yyvsp[0].ttype); ;
break;}
case 271:
-#line 1468 "objc-parse.y"
+#line 1467 "objc-parse.y"
{ if (pedantic && ! flag_isoc9x)
pedwarn ("comma at end of enumerator list"); ;
break;}
case 272:
-#line 1474 "objc-parse.y"
+#line 1473 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 273:
-#line 1476 "objc-parse.y"
+#line 1475 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
pedwarn ("no semicolon at end of struct or union"); ;
break;}
case 274:
-#line 1481 "objc-parse.y"
+#line 1480 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 275:
-#line 1483 "objc-parse.y"
+#line 1482 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[-1].ttype); ;
break;}
case 276:
-#line 1485 "objc-parse.y"
+#line 1484 "objc-parse.y"
{ if (pedantic)
pedwarn ("extra semicolon in struct or union specified"); ;
break;}
case 277:
-#line 1489 "objc-parse.y"
+#line 1488 "objc-parse.y"
{
tree interface = lookup_interface (yyvsp[-1].ttype);
;
break;}
case 278:
-#line 1514 "objc-parse.y"
+#line 1513 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 279:
-#line 1520 "objc-parse.y"
+#line 1519 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids member declarations with no members");
shadow_tag(yyvsp[0].ttype);
yyval.ttype = NULL_TREE; ;
break;}
case 280:
-#line 1525 "objc-parse.y"
+#line 1524 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 281:
-#line 1531 "objc-parse.y"
+#line 1530 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids member declarations with no members");
shadow_tag(yyvsp[0].ttype);
yyval.ttype = NULL_TREE; ;
break;}
case 282:
-#line 1536 "objc-parse.y"
+#line 1535 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 283:
-#line 1538 "objc-parse.y"
+#line 1537 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
pedantic = yyvsp[-1].itype; ;
break;}
case 285:
-#line 1545 "objc-parse.y"
+#line 1544 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 286:
-#line 1550 "objc-parse.y"
+#line 1549 "objc-parse.y"
{ yyval.ttype = grokfield (yyvsp[-3].filename, yyvsp[-2].lineno, yyvsp[-1].ttype, current_declspecs, NULL_TREE);
decl_attributes (yyval.ttype, yyvsp[0].ttype, prefix_attributes); ;
break;}
case 287:
-#line 1554 "objc-parse.y"
+#line 1553 "objc-parse.y"
{ yyval.ttype = grokfield (yyvsp[-5].filename, yyvsp[-4].lineno, yyvsp[-3].ttype, current_declspecs, yyvsp[-1].ttype);
decl_attributes (yyval.ttype, yyvsp[0].ttype, prefix_attributes); ;
break;}
case 288:
-#line 1557 "objc-parse.y"
+#line 1556 "objc-parse.y"
{ yyval.ttype = grokfield (yyvsp[-4].filename, yyvsp[-3].lineno, NULL_TREE, current_declspecs, yyvsp[-1].ttype);
decl_attributes (yyval.ttype, yyvsp[0].ttype, prefix_attributes); ;
break;}
case 290:
-#line 1569 "objc-parse.y"
+#line 1568 "objc-parse.y"
{ if (yyvsp[-2].ttype == error_mark_node)
yyval.ttype = yyvsp[-2].ttype;
else
yyval.ttype = chainon (yyvsp[0].ttype, yyvsp[-2].ttype); ;
break;}
case 291:
-#line 1574 "objc-parse.y"
+#line 1573 "objc-parse.y"
{ yyval.ttype = error_mark_node; ;
break;}
case 292:
-#line 1580 "objc-parse.y"
+#line 1579 "objc-parse.y"
{ yyval.ttype = build_enumerator (yyvsp[0].ttype, NULL_TREE); ;
break;}
case 293:
-#line 1582 "objc-parse.y"
+#line 1581 "objc-parse.y"
{ yyval.ttype = build_enumerator (yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 294:
-#line 1587 "objc-parse.y"
+#line 1586 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 295:
-#line 1589 "objc-parse.y"
+#line 1588 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 296:
-#line 1594 "objc-parse.y"
+#line 1593 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 298:
-#line 1600 "objc-parse.y"
+#line 1599 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 299:
-#line 1602 "objc-parse.y"
+#line 1601 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 300:
-#line 1607 "objc-parse.y"
+#line 1606 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 301:
-#line 1609 "objc-parse.y"
+#line 1608 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, yyvsp[0].ttype, yyvsp[-1].ttype); ;
break;}
case 302:
-#line 1614 "objc-parse.y"
+#line 1613 "objc-parse.y"
{ yyval.ttype = yyvsp[-1].ttype; ;
break;}
case 303:
-#line 1617 "objc-parse.y"
+#line 1616 "objc-parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[-1].ttype, yyvsp[0].ttype); ;
break;}
case 304:
-#line 1619 "objc-parse.y"
+#line 1618 "objc-parse.y"
{ yyval.ttype = make_pointer_declarator (yyvsp[0].ttype, NULL_TREE); ;
break;}
case 305:
-#line 1621 "objc-parse.y"
+#line 1620 "objc-parse.y"
{ yyval.ttype = build_nt (CALL_EXPR, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 306:
-#line 1623 "objc-parse.y"
+#line 1622 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 307:
-#line 1625 "objc-parse.y"
+#line 1624 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, yyvsp[-2].ttype, NULL_TREE); ;
break;}
case 308:
-#line 1627 "objc-parse.y"
+#line 1626 "objc-parse.y"
{ yyval.ttype = build_nt (CALL_EXPR, NULL_TREE, yyvsp[0].ttype, NULL_TREE); ;
break;}
case 309:
-#line 1629 "objc-parse.y"
+#line 1628 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, yyvsp[-1].ttype); ;
break;}
case 310:
-#line 1631 "objc-parse.y"
+#line 1630 "objc-parse.y"
{ yyval.ttype = build_nt (ARRAY_REF, NULL_TREE, NULL_TREE); ;
break;}
case 311:
-#line 1635 "objc-parse.y"
+#line 1634 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 312:
-#line 1644 "objc-parse.y"
+#line 1643 "objc-parse.y"
{
if (pedantic && yyvsp[0].ends_in_label)
pedwarn ("ANSI C forbids label at end of compound statement");
;
break;}
case 314:
-#line 1653 "objc-parse.y"
+#line 1652 "objc-parse.y"
{ yyval.ends_in_label = yyvsp[0].ends_in_label; ;
break;}
case 315:
-#line 1655 "objc-parse.y"
+#line 1654 "objc-parse.y"
{ yyval.ends_in_label = 0; ;
break;}
case 319:
-#line 1667 "objc-parse.y"
+#line 1666 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
pushlevel (0);
clear_last_expr ();
;
break;}
case 321:
-#line 1682 "objc-parse.y"
+#line 1681 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids label declarations"); ;
break;}
case 324:
-#line 1693 "objc-parse.y"
+#line 1692 "objc-parse.y"
{ tree link;
for (link = yyvsp[-1].ttype; link; link = TREE_CHAIN (link))
{
;
break;}
case 325:
-#line 1707 "objc-parse.y"
+#line 1706 "objc-parse.y"
{;
break;}
case 327:
-#line 1711 "objc-parse.y"
+#line 1710 "objc-parse.y"
{ compstmt_count++; ;
break;}
case 328:
-#line 1714 "objc-parse.y"
+#line 1713 "objc-parse.y"
{ yyval.ttype = convert (void_type_node, integer_zero_node); ;
break;}
case 329:
-#line 1716 "objc-parse.y"
+#line 1715 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
expand_end_bindings (getdecls (), 1, 0);
yyval.ttype = poplevel (1, 1, 0);
pop_momentary (); ;
break;}
case 330:
-#line 1724 "objc-parse.y"
+#line 1723 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
expand_end_bindings (getdecls (), kept_level_p (), 0);
yyval.ttype = poplevel (kept_level_p (), 0, 0);
pop_momentary (); ;
break;}
case 331:
-#line 1732 "objc-parse.y"
+#line 1731 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
expand_end_bindings (getdecls (), kept_level_p (), 0);
yyval.ttype = poplevel (kept_level_p (), 0, 0);
pop_momentary (); ;
break;}
case 332:
-#line 1743 "objc-parse.y"
+#line 1742 "objc-parse.y"
{ if (current_function_decl == 0)
{
error ("braced-group within expression allowed only inside a function");
;
break;}
case 333:
-#line 1760 "objc-parse.y"
+#line 1759 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 336:
-#line 1774 "objc-parse.y"
+#line 1773 "objc-parse.y"
{ emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
c_expand_start_cond (truthvalue_conversion (yyvsp[-1].ttype), 0,
compstmt_count);
position_after_white_space (); ;
break;}
case 337:
-#line 1788 "objc-parse.y"
+#line 1787 "objc-parse.y"
{ stmt_count++;
compstmt_count++;
emit_line_note (yyvsp[-2].filename, yyvsp[-1].lineno);
position_after_white_space (); ;
break;}
case 338:
-#line 1796 "objc-parse.y"
+#line 1795 "objc-parse.y"
{ expand_loop_continue_here (); ;
break;}
case 339:
-#line 1800 "objc-parse.y"
+#line 1799 "objc-parse.y"
{ yyval.filename = input_filename; ;
break;}
case 340:
-#line 1804 "objc-parse.y"
+#line 1803 "objc-parse.y"
{ yyval.lineno = lineno; ;
break;}
case 341:
-#line 1809 "objc-parse.y"
+#line 1808 "objc-parse.y"
{ ;
break;}
case 342:
-#line 1814 "objc-parse.y"
+#line 1813 "objc-parse.y"
{ ;
break;}
case 343:
-#line 1819 "objc-parse.y"
+#line 1818 "objc-parse.y"
{ yyval.ends_in_label = yyvsp[0].ends_in_label; ;
break;}
case 344:
-#line 1824 "objc-parse.y"
+#line 1823 "objc-parse.y"
{ yyval.ends_in_label = 0; ;
break;}
case 345:
-#line 1826 "objc-parse.y"
+#line 1825 "objc-parse.y"
{ yyval.ends_in_label = 1; ;
break;}
case 346:
-#line 1832 "objc-parse.y"
+#line 1831 "objc-parse.y"
{ stmt_count++; ;
break;}
case 348:
-#line 1835 "objc-parse.y"
+#line 1834 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
/* It appears that this should not be done--that a non-lvalue array
clear_momentary (); ;
break;}
case 349:
-#line 1852 "objc-parse.y"
+#line 1851 "objc-parse.y"
{ c_expand_start_else ();
yyvsp[-1].itype = stmt_count;
position_after_white_space (); ;
break;}
case 350:
-#line 1856 "objc-parse.y"
+#line 1855 "objc-parse.y"
{ c_expand_end_cond ();
if (extra_warnings && stmt_count == yyvsp[-3].itype)
warning ("empty body in an else-statement"); ;
break;}
case 351:
-#line 1860 "objc-parse.y"
+#line 1859 "objc-parse.y"
{ c_expand_end_cond ();
/* This warning is here instead of in simple_if, because we
do not want a warning if an empty if is followed by an
"empty body in an if-statement"); ;
break;}
case 352:
-#line 1872 "objc-parse.y"
+#line 1871 "objc-parse.y"
{ c_expand_end_cond (); ;
break;}
case 353:
-#line 1874 "objc-parse.y"
+#line 1873 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-2].filename, yyvsp[-1].lineno);
/* The emit_nop used to come before emit_line_note,
emit_nop (); ;
break;}
case 354:
-#line 1884 "objc-parse.y"
+#line 1883 "objc-parse.y"
{ /* Don't start the loop till we have succeeded
in parsing the end test. This is to make sure
that we end every loop we start. */
position_after_white_space (); ;
break;}
case 355:
-#line 1893 "objc-parse.y"
+#line 1892 "objc-parse.y"
{ expand_end_loop (); ;
break;}
case 356:
-#line 1896 "objc-parse.y"
+#line 1895 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
expand_exit_loop_if_false (NULL_PTR,
truthvalue_conversion (yyvsp[-2].ttype));
clear_momentary (); ;
break;}
case 357:
-#line 1903 "objc-parse.y"
+#line 1902 "objc-parse.y"
{ expand_end_loop ();
clear_momentary (); ;
break;}
case 358:
-#line 1907 "objc-parse.y"
+#line 1906 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
/* See comment in `while' alternative, above. */
;
break;}
case 359:
-#line 1919 "objc-parse.y"
+#line 1918 "objc-parse.y"
{ yyvsp[0].lineno = lineno;
yyval.filename = input_filename; ;
break;}
case 360:
-#line 1922 "objc-parse.y"
+#line 1921 "objc-parse.y"
{
/* Start the loop. Doing this after parsing
all the expressions ensures we will end the loop. */
position_after_white_space (); ;
break;}
case 361:
-#line 1938 "objc-parse.y"
+#line 1937 "objc-parse.y"
{ /* Emit the increment expression, with a line number. */
emit_line_note (yyvsp[-4].filename, yyvsp[-5].lineno);
expand_loop_continue_here ();
expand_end_loop (); ;
break;}
case 362:
-#line 1949 "objc-parse.y"
+#line 1948 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-5].filename, yyvsp[-4].lineno);
c_expand_start_case (yyvsp[-1].ttype);
position_after_white_space (); ;
break;}
case 363:
-#line 1957 "objc-parse.y"
+#line 1956 "objc-parse.y"
{ expand_end_case (yyvsp[-3].ttype);
if (yychar == CONSTANT || yychar == STRING)
pop_momentary_nofree ();
pop_momentary (); ;
break;}
case 364:
-#line 1963 "objc-parse.y"
+#line 1962 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
if ( ! expand_exit_something ())
error ("break statement not within loop or switch"); ;
break;}
case 365:
-#line 1968 "objc-parse.y"
+#line 1967 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
if (! expand_continue_loop (NULL_PTR))
error ("continue statement not within a loop"); ;
break;}
case 366:
-#line 1973 "objc-parse.y"
+#line 1972 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-3].filename, yyvsp[-2].lineno);
c_expand_return (NULL_TREE); ;
break;}
case 367:
-#line 1977 "objc-parse.y"
+#line 1976 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-4].filename, yyvsp[-3].lineno);
c_expand_return (yyvsp[-1].ttype); ;
break;}
case 368:
-#line 1981 "objc-parse.y"
+#line 1980 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-7].filename, yyvsp[-6].lineno);
STRIP_NOPS (yyvsp[-2].ttype);
error ("argument of `asm' is not a constant string"); ;
break;}
case 369:
-#line 1992 "objc-parse.y"
+#line 1991 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-9].filename, yyvsp[-8].lineno);
c_expand_asm_operands (yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE, NULL_TREE,
input_filename, lineno); ;
break;}
case 370:
-#line 1999 "objc-parse.y"
+#line 1998 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-11].filename, yyvsp[-10].lineno);
c_expand_asm_operands (yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype, NULL_TREE,
input_filename, lineno); ;
break;}
case 371:
-#line 2007 "objc-parse.y"
+#line 2006 "objc-parse.y"
{ stmt_count++;
emit_line_note (yyvsp[-13].filename, yyvsp[-12].lineno);
c_expand_asm_operands (yyvsp[-8].ttype, yyvsp[-6].ttype, yyvsp[-4].ttype, yyvsp[-2].ttype,
input_filename, lineno); ;
break;}
case 372:
-#line 2013 "objc-parse.y"
+#line 2012 "objc-parse.y"
{ tree decl;
stmt_count++;
emit_line_note (yyvsp[-4].filename, yyvsp[-3].lineno);
;
break;}
case 373:
-#line 2024 "objc-parse.y"
+#line 2023 "objc-parse.y"
{ if (pedantic)
pedwarn ("ANSI C forbids `goto *expr;'");
stmt_count++;
expand_computed_goto (convert (ptr_type_node, yyvsp[-1].ttype)); ;
break;}
case 376:
-#line 2039 "objc-parse.y"
+#line 2038 "objc-parse.y"
{
/* The value returned by this action is */
/* 1 if everything is OK */
;
break;}
case 377:
-#line 2060 "objc-parse.y"
+#line 2059 "objc-parse.y"
{
if (yyvsp[-1].itype)
iterator_for_loop_end (yyvsp[-3].ttype);
;
break;}
case 378:
-#line 2095 "objc-parse.y"
+#line 2094 "objc-parse.y"
{ register tree value = check_case_value (yyvsp[-1].ttype);
register tree label
= build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
position_after_white_space (); ;
break;}
case 379:
-#line 2126 "objc-parse.y"
+#line 2125 "objc-parse.y"
{ register tree value1 = check_case_value (yyvsp[-3].ttype);
register tree value2 = check_case_value (yyvsp[-1].ttype);
register tree label
position_after_white_space (); ;
break;}
case 380:
-#line 2157 "objc-parse.y"
+#line 2156 "objc-parse.y"
{
tree duplicate;
register tree label
position_after_white_space (); ;
break;}
case 381:
-#line 2172 "objc-parse.y"
+#line 2171 "objc-parse.y"
{ tree label = define_label (input_filename, lineno, yyvsp[-2].ttype);
stmt_count++;
emit_nop ();
position_after_white_space (); ;
break;}
case 382:
-#line 2187 "objc-parse.y"
+#line 2186 "objc-parse.y"
{ emit_line_note (input_filename, lineno);
yyval.ttype = NULL_TREE; ;
break;}
case 383:
-#line 2190 "objc-parse.y"
+#line 2189 "objc-parse.y"
{ emit_line_note (input_filename, lineno); ;
break;}
case 384:
-#line 2195 "objc-parse.y"
+#line 2194 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 386:
-#line 2202 "objc-parse.y"
+#line 2201 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 389:
-#line 2209 "objc-parse.y"
+#line 2208 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, yyvsp[0].ttype); ;
break;}
case 390:
-#line 2214 "objc-parse.y"
+#line 2213 "objc-parse.y"
{ yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype); ;
break;}
case 391:
-#line 2219 "objc-parse.y"
+#line 2218 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), NULL_TREE); ;
break;}
case 392:
-#line 2221 "objc-parse.y"
+#line 2220 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, combine_strings (yyvsp[0].ttype), yyvsp[-2].ttype); ;
break;}
case 393:
-#line 2227 "objc-parse.y"
+#line 2226 "objc-parse.y"
{ pushlevel (0);
clear_parm_order ();
declare_parm_level (0); ;
break;}
case 394:
-#line 2231 "objc-parse.y"
+#line 2230 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
parmlist_tags_warning ();
poplevel (0, 0, 0); ;
break;}
case 396:
-#line 2239 "objc-parse.y"
+#line 2238 "objc-parse.y"
{ tree parm;
if (pedantic)
pedwarn ("ANSI C forbids forward parameter declarations");
clear_parm_order (); ;
break;}
case 397:
-#line 2247 "objc-parse.y"
+#line 2246 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype; ;
break;}
case 398:
-#line 2249 "objc-parse.y"
+#line 2248 "objc-parse.y"
{ yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, NULL_TREE); ;
break;}
case 399:
-#line 2255 "objc-parse.y"
+#line 2254 "objc-parse.y"
{ yyval.ttype = get_parm_info (0); ;
break;}
case 400:
-#line 2257 "objc-parse.y"
+#line 2256 "objc-parse.y"
{ yyval.ttype = 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.
;
break;}
case 401:
-#line 2267 "objc-parse.y"
+#line 2266 "objc-parse.y"
{ yyval.ttype = get_parm_info (1); ;
break;}
case 402:
-#line 2269 "objc-parse.y"
+#line 2268 "objc-parse.y"
{ yyval.ttype = get_parm_info (0); ;
break;}
case 403:
-#line 2274 "objc-parse.y"
+#line 2273 "objc-parse.y"
{ push_parm_decl (yyvsp[0].ttype); ;
break;}
case 404:
-#line 2276 "objc-parse.y"
+#line 2275 "objc-parse.y"
{ push_parm_decl (yyvsp[0].ttype); ;
break;}
case 405:
-#line 2283 "objc-parse.y"
+#line 2282 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
resume_momentary (yyvsp[-2].itype); ;
break;}
case 406:
-#line 2292 "objc-parse.y"
+#line 2291 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
resume_momentary (yyvsp[-2].itype); ;
break;}
case 407:
-#line 2301 "objc-parse.y"
+#line 2300 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
resume_momentary (yyvsp[-2].itype); ;
break;}
case 408:
-#line 2310 "objc-parse.y"
+#line 2309 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
resume_momentary (yyvsp[-2].itype); ;
break;}
case 409:
-#line 2320 "objc-parse.y"
+#line 2319 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
resume_momentary (yyvsp[-2].itype); ;
break;}
case 410:
-#line 2334 "objc-parse.y"
+#line 2333 "objc-parse.y"
{ pushlevel (0);
clear_parm_order ();
declare_parm_level (1); ;
break;}
case 411:
-#line 2338 "objc-parse.y"
+#line 2337 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
parmlist_tags_warning ();
poplevel (0, 0, 0); ;
break;}
case 413:
-#line 2346 "objc-parse.y"
+#line 2345 "objc-parse.y"
{ tree t;
for (t = yyvsp[-1].ttype; t; t = TREE_CHAIN (t))
if (TREE_VALUE (t) == NULL_TREE)
yyval.ttype = tree_cons (NULL_TREE, NULL_TREE, yyvsp[-1].ttype); ;
break;}
case 414:
-#line 2356 "objc-parse.y"
+#line 2355 "objc-parse.y"
{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
break;}
case 415:
-#line 2358 "objc-parse.y"
+#line 2357 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
break;}
case 416:
-#line 2364 "objc-parse.y"
+#line 2363 "objc-parse.y"
{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
break;}
case 417:
-#line 2366 "objc-parse.y"
+#line 2365 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
break;}
case 418:
-#line 2371 "objc-parse.y"
+#line 2370 "objc-parse.y"
{ yyval.itype = pedantic;
pedantic = 0; ;
break;}
case 424:
-#line 2384 "objc-parse.y"
+#line 2383 "objc-parse.y"
{
if (objc_implementation_context)
{
;
break;}
case 425:
-#line 2399 "objc-parse.y"
+#line 2398 "objc-parse.y"
{ yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype); ;
break;}
case 426:
-#line 2401 "objc-parse.y"
+#line 2400 "objc-parse.y"
{ yyval.ttype = chainon (yyvsp[-2].ttype, build_tree_list (NULL_TREE, yyvsp[0].ttype)); ;
break;}
case 427:
-#line 2406 "objc-parse.y"
+#line 2405 "objc-parse.y"
{
objc_declare_class (yyvsp[-1].ttype);
;
break;}
case 428:
-#line 2412 "objc-parse.y"
+#line 2411 "objc-parse.y"
{
objc_declare_alias (yyvsp[-2].ttype, yyvsp[-1].ttype);
;
break;}
case 429:
-#line 2418 "objc-parse.y"
+#line 2417 "objc-parse.y"
{
objc_interface_context = objc_ivar_context
= start_class (CLASS_INTERFACE_TYPE, yyvsp[-2].ttype, NULL_TREE, yyvsp[-1].ttype);
;
break;}
case 430:
-#line 2424 "objc-parse.y"
+#line 2423 "objc-parse.y"
{
continue_class (objc_interface_context);
;
break;}
case 431:
-#line 2429 "objc-parse.y"
+#line 2428 "objc-parse.y"
{
finish_class (objc_interface_context);
objc_interface_context = NULL_TREE;
;
break;}
case 432:
-#line 2435 "objc-parse.y"
+#line 2434 "objc-parse.y"
{
objc_interface_context
= start_class (CLASS_INTERFACE_TYPE, yyvsp[-1].ttype, NULL_TREE, yyvsp[0].ttype);
;
break;}
case 433:
-#line 2442 "objc-parse.y"
+#line 2441 "objc-parse.y"
{
finish_class (objc_interface_context);
objc_interface_context = NULL_TREE;
;
break;}
case 434:
-#line 2448 "objc-parse.y"
+#line 2447 "objc-parse.y"
{
objc_interface_context = objc_ivar_context
= start_class (CLASS_INTERFACE_TYPE, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[-1].ttype);
;
break;}
case 435:
-#line 2454 "objc-parse.y"
+#line 2453 "objc-parse.y"
{
continue_class (objc_interface_context);
;
break;}
case 436:
-#line 2459 "objc-parse.y"
+#line 2458 "objc-parse.y"
{
finish_class (objc_interface_context);
objc_interface_context = NULL_TREE;
;
break;}
case 437:
-#line 2465 "objc-parse.y"
+#line 2464 "objc-parse.y"
{
objc_interface_context
= start_class (CLASS_INTERFACE_TYPE, yyvsp[-3].ttype, yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 438:
-#line 2472 "objc-parse.y"
+#line 2471 "objc-parse.y"
{
finish_class (objc_interface_context);
objc_interface_context = NULL_TREE;
;
break;}
case 439:
-#line 2478 "objc-parse.y"
+#line 2477 "objc-parse.y"
{
objc_implementation_context = objc_ivar_context
= start_class (CLASS_IMPLEMENTATION_TYPE, yyvsp[-1].ttype, NULL_TREE, NULL_TREE);
;
break;}
case 440:
-#line 2484 "objc-parse.y"
+#line 2483 "objc-parse.y"
{
objc_ivar_chain
= continue_class (objc_implementation_context);
;
break;}
case 441:
-#line 2490 "objc-parse.y"
+#line 2489 "objc-parse.y"
{
objc_implementation_context
= start_class (CLASS_IMPLEMENTATION_TYPE, yyvsp[0].ttype, NULL_TREE, NULL_TREE);
;
break;}
case 442:
-#line 2498 "objc-parse.y"
+#line 2497 "objc-parse.y"
{
objc_implementation_context = objc_ivar_context
= start_class (CLASS_IMPLEMENTATION_TYPE, yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE);
;
break;}
case 443:
-#line 2504 "objc-parse.y"
+#line 2503 "objc-parse.y"
{
objc_ivar_chain
= continue_class (objc_implementation_context);
;
break;}
case 444:
-#line 2510 "objc-parse.y"
+#line 2509 "objc-parse.y"
{
objc_implementation_context
= start_class (CLASS_IMPLEMENTATION_TYPE, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE);
;
break;}
case 445:
-#line 2518 "objc-parse.y"
+#line 2517 "objc-parse.y"
{
objc_interface_context
= start_class (CATEGORY_INTERFACE_TYPE, yyvsp[-4].ttype, yyvsp[-2].ttype, yyvsp[0].ttype);
;
break;}
case 446:
-#line 2525 "objc-parse.y"
+#line 2524 "objc-parse.y"
{
finish_class (objc_interface_context);
objc_interface_context = NULL_TREE;
;
break;}
case 447:
-#line 2531 "objc-parse.y"
+#line 2530 "objc-parse.y"
{
objc_implementation_context
= start_class (CATEGORY_IMPLEMENTATION_TYPE, yyvsp[-3].ttype, yyvsp[-1].ttype, NULL_TREE);
;
break;}
case 448:
-#line 2541 "objc-parse.y"
+#line 2540 "objc-parse.y"
{
remember_protocol_qualifiers ();
objc_interface_context
;
break;}
case 449:
-#line 2547 "objc-parse.y"
+#line 2546 "objc-parse.y"
{
forget_protocol_qualifiers();
finish_protocol(objc_interface_context);
;
break;}
case 450:
-#line 2556 "objc-parse.y"
+#line 2555 "objc-parse.y"
{
yyval.ttype = NULL_TREE;
;
break;}
case 452:
-#line 2564 "objc-parse.y"
+#line 2563 "objc-parse.y"
{
if (yyvsp[-2].code == LT_EXPR && yyvsp[0].code == GT_EXPR)
yyval.ttype = yyvsp[-1].ttype;
;
break;}
case 455:
-#line 2578 "objc-parse.y"
+#line 2577 "objc-parse.y"
{ objc_public_flag = 2; ;
break;}
case 456:
-#line 2579 "objc-parse.y"
+#line 2578 "objc-parse.y"
{ objc_public_flag = 0; ;
break;}
case 457:
-#line 2580 "objc-parse.y"
+#line 2579 "objc-parse.y"
{ objc_public_flag = 1; ;
break;}
case 458:
-#line 2585 "objc-parse.y"
+#line 2584 "objc-parse.y"
{
yyval.ttype = NULL_TREE;
;
break;}
case 460:
-#line 2590 "objc-parse.y"
+#line 2589 "objc-parse.y"
{
if (pedantic)
pedwarn ("extra semicolon in struct or union specified");
;
break;}
case 461:
-#line 2608 "objc-parse.y"
+#line 2607 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 462:
-#line 2614 "objc-parse.y"
+#line 2613 "objc-parse.y"
{ yyval.ttype = yyvsp[0].ttype;
current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
resume_momentary (yyvsp[-1].itype); ;
break;}
case 463:
-#line 2620 "objc-parse.y"
+#line 2619 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 464:
-#line 2625 "objc-parse.y"
+#line 2624 "objc-parse.y"
{ yyval.ttype = NULL_TREE; ;
break;}
case 467:
-#line 2632 "objc-parse.y"
+#line 2631 "objc-parse.y"
{
yyval.ttype = add_instance_variable (objc_ivar_context,
objc_public_flag,
;
break;}
case 468:
-#line 2639 "objc-parse.y"
+#line 2638 "objc-parse.y"
{
yyval.ttype = add_instance_variable (objc_ivar_context,
objc_public_flag,
;
break;}
case 469:
-#line 2645 "objc-parse.y"
+#line 2644 "objc-parse.y"
{
yyval.ttype = add_instance_variable (objc_ivar_context,
objc_public_flag,
;
break;}
case 470:
-#line 2655 "objc-parse.y"
+#line 2654 "objc-parse.y"
{
remember_protocol_qualifiers ();
if (objc_implementation_context)
;
break;}
case 471:
-#line 2663 "objc-parse.y"
+#line 2662 "objc-parse.y"
{
forget_protocol_qualifiers ();
add_class_method (objc_implementation_context, yyvsp[0].ttype);
;
break;}
case 472:
-#line 2670 "objc-parse.y"
+#line 2669 "objc-parse.y"
{
continue_method_def ();
;
break;}
case 473:
-#line 2674 "objc-parse.y"
+#line 2673 "objc-parse.y"
{
finish_method_def ();
objc_method_context = NULL_TREE;
;
break;}
case 474:
-#line 2680 "objc-parse.y"
+#line 2679 "objc-parse.y"
{
remember_protocol_qualifiers ();
if (objc_implementation_context)
;
break;}
case 475:
-#line 2688 "objc-parse.y"
+#line 2687 "objc-parse.y"
{
forget_protocol_qualifiers ();
add_instance_method (objc_implementation_context, yyvsp[0].ttype);
;
break;}
case 476:
-#line 2695 "objc-parse.y"
+#line 2694 "objc-parse.y"
{
continue_method_def ();
;
break;}
case 477:
-#line 2699 "objc-parse.y"
+#line 2698 "objc-parse.y"
{
finish_method_def ();
objc_method_context = NULL_TREE;
;
break;}
case 479:
-#line 2711 "objc-parse.y"
+#line 2710 "objc-parse.y"
{yyval.ttype = NULL_TREE; ;
break;}
case 484:
-#line 2718 "objc-parse.y"
+#line 2717 "objc-parse.y"
{yyval.ttype = NULL_TREE; ;
break;}
case 488:
-#line 2728 "objc-parse.y"
+#line 2727 "objc-parse.y"
{
/* Remember protocol qualifiers in prototypes. */
remember_protocol_qualifiers ();
;
break;}
case 489:
-#line 2734 "objc-parse.y"
+#line 2733 "objc-parse.y"
{
/* Forget protocol qualifiers here. */
forget_protocol_qualifiers ();
;
break;}
case 491:
-#line 2742 "objc-parse.y"
+#line 2741 "objc-parse.y"
{
/* Remember protocol qualifiers in prototypes. */
remember_protocol_qualifiers ();
;
break;}
case 492:
-#line 2748 "objc-parse.y"
+#line 2747 "objc-parse.y"
{
/* Forget protocol qualifiers here. */
forget_protocol_qualifiers ();
;
break;}
case 494:
-#line 2758 "objc-parse.y"
+#line 2757 "objc-parse.y"
{
yyval.ttype = build_method_decl (objc_inherit_code, yyvsp[-2].ttype, yyvsp[0].ttype, NULL_TREE);
;
break;}
case 495:
-#line 2763 "objc-parse.y"
+#line 2762 "objc-parse.y"
{
yyval.ttype = build_method_decl (objc_inherit_code, NULL_TREE, yyvsp[0].ttype, NULL_TREE);
;
break;}
case 496:
-#line 2768 "objc-parse.y"
+#line 2767 "objc-parse.y"
{
yyval.ttype = build_method_decl (objc_inherit_code, yyvsp[-3].ttype, yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 497:
-#line 2773 "objc-parse.y"
+#line 2772 "objc-parse.y"
{
yyval.ttype = build_method_decl (objc_inherit_code, NULL_TREE, yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 506:
-#line 2803 "objc-parse.y"
+#line 2802 "objc-parse.y"
{ current_declspecs = TREE_VALUE (declspec_stack);
prefix_attributes = TREE_PURPOSE (declspec_stack);
declspec_stack = TREE_CHAIN (declspec_stack);
resume_momentary (yyvsp[-2].itype); ;
break;}
case 507:
-#line 2808 "objc-parse.y"
+#line 2807 "objc-parse.y"
{ shadow_tag (yyvsp[-1].ttype); ;
break;}
case 508:
-#line 2810 "objc-parse.y"
+#line 2809 "objc-parse.y"
{ pedwarn ("empty declaration"); ;
break;}
case 509:
-#line 2815 "objc-parse.y"
+#line 2814 "objc-parse.y"
{ push_parm_decl (yyvsp[0].ttype); ;
break;}
case 510:
-#line 2817 "objc-parse.y"
+#line 2816 "objc-parse.y"
{ push_parm_decl (yyvsp[0].ttype); ;
break;}
case 511:
-#line 2825 "objc-parse.y"
+#line 2824 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
yyvsp[0].ttype)); ;
break;}
case 512:
-#line 2830 "objc-parse.y"
+#line 2829 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
yyvsp[0].ttype)); ;
break;}
case 513:
-#line 2835 "objc-parse.y"
+#line 2834 "objc-parse.y"
{ yyval.ttype = build_tree_list (build_tree_list (current_declspecs,
yyvsp[-1].ttype),
build_tree_list (prefix_attributes,
yyvsp[0].ttype)); ;
break;}
case 514:
-#line 2843 "objc-parse.y"
+#line 2842 "objc-parse.y"
{
yyval.ttype = NULL_TREE;
;
break;}
case 515:
-#line 2847 "objc-parse.y"
+#line 2846 "objc-parse.y"
{
/* oh what a kludge! */
yyval.ttype = (tree)1;
;
break;}
case 516:
-#line 2852 "objc-parse.y"
+#line 2851 "objc-parse.y"
{
pushlevel (0);
;
break;}
case 517:
-#line 2856 "objc-parse.y"
+#line 2855 "objc-parse.y"
{
/* returns a tree list node generated by get_parm_info */
yyval.ttype = yyvsp[0].ttype;
;
break;}
case 520:
-#line 2871 "objc-parse.y"
+#line 2870 "objc-parse.y"
{
yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 525:
-#line 2884 "objc-parse.y"
+#line 2883 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 526:
-#line 2885 "objc-parse.y"
+#line 2884 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 527:
-#line 2886 "objc-parse.y"
+#line 2885 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 528:
-#line 2887 "objc-parse.y"
+#line 2886 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 529:
-#line 2888 "objc-parse.y"
+#line 2887 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 530:
-#line 2889 "objc-parse.y"
+#line 2888 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 531:
-#line 2890 "objc-parse.y"
+#line 2889 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 532:
-#line 2891 "objc-parse.y"
+#line 2890 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 533:
-#line 2892 "objc-parse.y"
+#line 2891 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 534:
-#line 2893 "objc-parse.y"
+#line 2892 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 535:
-#line 2894 "objc-parse.y"
+#line 2893 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 536:
-#line 2895 "objc-parse.y"
+#line 2894 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 537:
-#line 2896 "objc-parse.y"
+#line 2895 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 538:
-#line 2897 "objc-parse.y"
+#line 2896 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 539:
-#line 2898 "objc-parse.y"
+#line 2897 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 540:
-#line 2899 "objc-parse.y"
+#line 2898 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 541:
-#line 2900 "objc-parse.y"
+#line 2899 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 542:
-#line 2901 "objc-parse.y"
+#line 2900 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 543:
-#line 2902 "objc-parse.y"
+#line 2901 "objc-parse.y"
{ yyval.ttype = get_identifier (token_buffer); ;
break;}
case 546:
-#line 2908 "objc-parse.y"
+#line 2907 "objc-parse.y"
{
yyval.ttype = build_keyword_decl (yyvsp[-5].ttype, yyvsp[-2].ttype, yyvsp[0].ttype);
;
break;}
case 547:
-#line 2913 "objc-parse.y"
+#line 2912 "objc-parse.y"
{
yyval.ttype = build_keyword_decl (yyvsp[-2].ttype, NULL_TREE, yyvsp[0].ttype);
;
break;}
case 548:
-#line 2918 "objc-parse.y"
+#line 2917 "objc-parse.y"
{
yyval.ttype = build_keyword_decl (NULL_TREE, yyvsp[-2].ttype, yyvsp[0].ttype);
;
break;}
case 549:
-#line 2923 "objc-parse.y"
+#line 2922 "objc-parse.y"
{
yyval.ttype = build_keyword_decl (NULL_TREE, NULL_TREE, yyvsp[0].ttype);
;
break;}
case 553:
-#line 2936 "objc-parse.y"
+#line 2935 "objc-parse.y"
{
yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 554:
-#line 2944 "objc-parse.y"
+#line 2943 "objc-parse.y"
{
if (TREE_CHAIN (yyvsp[0].ttype) == NULL_TREE)
/* just return the expr., remove a level of indirection */
;
break;}
case 555:
-#line 2956 "objc-parse.y"
+#line 2955 "objc-parse.y"
{
yyval.ttype = build_tree_list (yyvsp[-2].ttype, yyvsp[0].ttype);
;
break;}
case 556:
-#line 2960 "objc-parse.y"
+#line 2959 "objc-parse.y"
{
yyval.ttype = build_tree_list (NULL_TREE, yyvsp[0].ttype);
;
break;}
case 558:
-#line 2968 "objc-parse.y"
+#line 2967 "objc-parse.y"
{
yyval.ttype = get_class_reference (yyvsp[0].ttype);
;
break;}
case 559:
-#line 2975 "objc-parse.y"
+#line 2974 "objc-parse.y"
{ objc_receiver_context = 1; ;
break;}
case 560:
-#line 2977 "objc-parse.y"
+#line 2976 "objc-parse.y"
{ objc_receiver_context = 0; ;
break;}
case 561:
-#line 2979 "objc-parse.y"
+#line 2978 "objc-parse.y"
{
yyval.ttype = build_tree_list (yyvsp[-3].ttype, yyvsp[-1].ttype);
;
break;}
case 565:
-#line 2992 "objc-parse.y"
+#line 2991 "objc-parse.y"
{
yyval.ttype = chainon (yyvsp[-1].ttype, yyvsp[0].ttype);
;
break;}
case 566:
-#line 2999 "objc-parse.y"
+#line 2998 "objc-parse.y"
{
yyval.ttype = build_tree_list (yyvsp[-1].ttype, NULL_TREE);
;
break;}
case 567:
-#line 3003 "objc-parse.y"
+#line 3002 "objc-parse.y"
{
yyval.ttype = build_tree_list (NULL_TREE, NULL_TREE);
;
break;}
case 568:
-#line 3010 "objc-parse.y"
+#line 3009 "objc-parse.y"
{
yyval.ttype = yyvsp[-1].ttype;
;
break;}
case 569:
-#line 3017 "objc-parse.y"
+#line 3016 "objc-parse.y"
{
yyval.ttype = yyvsp[-1].ttype;
;
break;}
case 570:
-#line 3026 "objc-parse.y"
+#line 3025 "objc-parse.y"
{
yyval.ttype = groktypename (yyvsp[-1].ttype);
;
break;}
}
/* the action file gets copied in in place of this dollarsign */
-#line 542 "/usr/lib/bison.simple"
+#line 498 "/usr/cygnus/TBD-TBD/share/bison.simple"
\f
yyvsp -= yylen;
yyssp -= yylen;
yystate = yyn;
goto yynewstate;
-
- yyacceptlab:
- /* YYACCEPT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 0;
-
- yyabortlab:
- /* YYABORT comes here. */
- if (yyfree_stacks)
- {
- free (yyss);
- free (yyvs);
-#ifdef YYLSP_NEEDED
- free (yyls);
-#endif
- }
- return 1;
}
-#line 3031 "objc-parse.y"
+#line 3030 "objc-parse.y"
#include "config.h"
#include "system.h"
#include <setjmp.h>
-
#include "tree.h"
#include "input.h"
#include "c-lex.h"
#ifdef HAVE_conditional_trap
static void init_traps PROTO((void));
#endif
-static int cmp_available_p PROTO((enum machine_mode, enum rtx_code, int));
+static int cmp_available_p PROTO((enum machine_mode, int));
static void emit_cmp_and_jump_insn_1 PROTO((rtx, rtx, enum machine_mode,
enum rtx_code, int, rtx));
static void prepare_cmp_insn PROTO((rtx *, rtx *, enum rtx_code *, rtx,
copy_rtx (xop0),
copy_rtx (xop1)));
}
+
return target;
}
+
else
delete_insns_since (last);
}
copy_rtx (op0),
copy_rtx (op1)));
}
+
return product;
}
}
next = NEXT_INSN (insn);
- if (GET_CODE (PATTERN (insn)) == SET)
+ if (GET_CODE (PATTERN (insn)) == SET || GET_CODE (PATTERN (insn)) == USE
+ || GET_CODE (PATTERN (insn)) == CLOBBER)
set = PATTERN (insn);
else if (GET_CODE (PATTERN (insn)) == PARALLEL)
{
straightforwardly. */
static int
-cmp_available_p (mode, code, can_use_tst_p)
+cmp_available_p (mode, can_use_tst_p)
enum machine_mode mode;
- enum rtx_code code;
int can_use_tst_p;
{
do
int *punsignedp;
int align;
{
- enum rtx_code comparison = *pcomparison;
enum machine_mode mode = *pmode;
rtx x = *px, y = *py;
int unsignedp = *punsignedp;
*px = x;
*py = y;
- if (cmp_available_p (mode, comparison, y == CONST0_RTX (mode)))
+ if (cmp_available_p (mode, y == CONST0_RTX (mode)))
return;
/* Handle a lib call just for the mode we are using. */
code = swap_condition (code);
}
+ /* get_condition will prefer to generate LT and GT even if the old
+ comparison was against zero, so undo that canonicalization here since
+ comparisons against zero are cheaper. */
+ if (code == LT && GET_CODE (op1) == CONST_INT && INTVAL (op1) == 1)
+ code = LE, op1 = const0_rtx;
+ else if (code == GT && GET_CODE (op1) == CONST_INT && INTVAL (op1) == -1)
+ code = GE, op1 = const0_rtx;
+
if (cmode == VOIDmode)
cmode = GET_MODE (op0);
GET_MODE (to),
copy_rtx (from)));
}
+
return;
}
#endif
#ifndef INT_TYPE_SIZE
#define INT_TYPE_SIZE BITS_PER_WORD
#endif
- ffs_optab->handlers[(int) mode_for_size (INT_TYPE_SIZE, MODE_INT, 0)] .libfunc
+ ffs_optab->handlers[(int) mode_for_size (INT_TYPE_SIZE, MODE_INT, 0)].libfunc
= gen_rtx_SYMBOL_REF (Pmode, "ffs");
extendsfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsfdf2");
dwarf2.h
dwarf2out.c
dwarfout.c
+dyn-string.c
+dyn-string.h
emit-rtl.c
#enquire.c is used only by GCC maintainers and installers
except.c
#genemit.c is used only by GCC maintainers and installers
#genextract.c is used only by GCC maintainers and installers
#genflags.c is used only by GCC maintainers and installers
+#gengenrtl.c is used only by GCC maintainers and installers
#genopinit.c is used only by GCC maintainers and installers
#genoutput.c is used only by GCC maintainers and installers
#genpeep.c is used only by GCC maintainers and installers
loop.c
loop.h
machmode.h
+mbchar.c
+mbchar.h
#mips-tdump.c is not yet internationalized
#mips-tfile.c is not yet internationalized
objc/objc-act.c
stupid.c
sys-protos.h
sys-types.h
+system.h
toplev.c
tree.c
tree.h
/* Print RTL for GNU C Compiler.
- Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1992, 1997, 1998, 1999
+ Free Software Foundation, Inc.
This file is part of GNU CC.
rtx insert_after;
{
rtx profiler_target_addr
- = (arcno
- ? gen_rtx_CONST (Pmode,
- gen_rtx_PLUS (Pmode, profiler_label,
- GEN_INT (LONG_TYPE_SIZE / BITS_PER_UNIT * arcno)))
+ = (arcno ? plus_constant (profiler_label,
+ LONG_TYPE_SIZE / BITS_PER_UNIT * arcno)
: profiler_label);
enum machine_mode mode = mode_for_size (LONG_TYPE_SIZE, MODE_INT, 0);
rtx profiler_reg = gen_reg_rtx (mode);
else
{
if (decflg)
- nexp += 1; /* count digits after decimal point */
+ nexp += 1; /* count digits after decimal point */
- eshup1 (yy); /* multiply current number by 10 */
+ eshup1 (yy); /* multiply current number by 10 */
emovz (yy, xt);
eshup1 (xt);
eshup1 (xt);
exp *= 10;
exp += *s++ - '0';
if (exp > 999999)
- break;
+ break;
}
if (esign < 0)
exp = -exp;
/* Convert ASCII string S to floating point in mode M.
Decimal input uses ATOF. Hexadecimal uses HTOF. */
-#define REAL_VALUE_ATOF ereal_atof
-#define REAL_VALUE_HTOF ereal_atof
+#define REAL_VALUE_ATOF(s,m) ereal_atof(s,m)
+#define REAL_VALUE_HTOF(s,m) ereal_atof(s,m)
#define REAL_VALUE_NEGATE ereal_negate
size and where `float' is SFmode. */
/* Don't use REAL_VALUE_TRUNCATE directly--always call real_value_truncate. */
-extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode, REAL_VALUE_TYPE));
+extern REAL_VALUE_TYPE real_value_truncate PROTO((enum machine_mode,
+ REAL_VALUE_TYPE));
#ifndef REAL_VALUE_TRUNCATE
#define REAL_VALUE_TRUNCATE(mode, x) \
#define REAL_VALUE_NEGATIVE(x) (target_negative (x))
#endif
-extern int target_isnan PROTO ((REAL_VALUE_TYPE));
-extern int target_isinf PROTO ((REAL_VALUE_TYPE));
-extern int target_negative PROTO ((REAL_VALUE_TYPE));
+extern int target_isnan PROTO((REAL_VALUE_TYPE));
+extern int target_isinf PROTO((REAL_VALUE_TYPE));
+extern int target_negative PROTO((REAL_VALUE_TYPE));
/* Determine whether a floating-point value X is minus 0. */
#ifndef REAL_VALUE_MINUS_ZERO
#endif
/* Replace R by 1/R in the given machine mode, if the result is exact. */
-extern int exact_real_inverse PROTO((enum machine_mode, REAL_VALUE_TYPE *));
+extern int exact_real_inverse PROTO((enum machine_mode, REAL_VALUE_TYPE *));
+extern int target_isnan PROTO((REAL_VALUE_TYPE));
+extern int target_isinf PROTO((REAL_VALUE_TYPE));
+extern int target_negative PROTO((REAL_VALUE_TYPE));
+extern void debug_real PROTO((REAL_VALUE_TYPE));
-extern void debug_real PROTO ((REAL_VALUE_TYPE));
+/* In varasm.c */
+extern void assemble_real PROTO((REAL_VALUE_TYPE,
+ enum machine_mode));
+extern void debug_real PROTO((REAL_VALUE_TYPE));
/* In varasm.c */
-extern void assemble_real PROTO ((REAL_VALUE_TYPE,
- enum machine_mode));
+extern void assemble_real PROTO((REAL_VALUE_TYPE,
+ enum machine_mode));
#endif /* Not REAL_H_INCLUDED */
{
int j;
- newpat = gen_rtx_PARALLEL (VOIDmode,
- gen_rtvec (XVECLEN (pat, 0) - 1));
+ newpat
+ = gen_rtx_PARALLEL (VOIDmode,
+ gen_rtvec (XVECLEN (pat, 0) - 1));
for (j = 0; j < XVECLEN (newpat, 0); j++)
XVECEXP (newpat, 0, j) = XVECEXP (pat, 0, j);
}
if (CONSTANT_ADDRESS_P (y))
{
- new = gen_rtx_MEM (GET_MODE (op), plus_constant_for_output (y, offset));
+ new = gen_rtx_MEM (GET_MODE (op),
+ plus_constant_for_output (y, offset));
RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (op);
return new;
}
while (*p && (c = *p++) != ',')
switch (c)
{
- case '?':
- case '!':
- case '*':
- case '%':
- case '=':
- case '+':
+ case '?': case '!': case '*': case '%':
+ case '=': case '+':
break;
case '#':
earlyclobber[opno] = 1;
break;
- case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+
/* This operand must be the same as a previous one.
This kind of constraint is used for instructions such
as add when they take only two operands.
pop_insn = (*when) (pop_rtx, insn);
- REG_NOTES (pop_insn) = gen_rtx_EXPR_LIST (REG_DEAD,
- FP_MODE_REG (FIRST_STACK_REG, DFmode),
- REG_NOTES (pop_insn));
+ REG_NOTES (pop_insn)
+ = gen_rtx_EXPR_LIST (REG_DEAD, FP_MODE_REG (FIRST_STACK_REG, DFmode),
+ REG_NOTES (pop_insn));
regstack->reg[regstack->top - (hard_regno - FIRST_STACK_REG)]
= regstack->reg[regstack->top];
return ! rtx_unstable_p (x);
}
}
-
-/* Test if regmove seems profitable for this target. Regmove is useful only
- if some common patterns are two address, i.e. require matching constraints,
- so we check that condition here. */
-
-int
-regmove_profitable_p ()
-{
-#ifdef REGISTER_CONSTRAINTS
- struct match match;
- enum machine_mode mode;
- optab tstoptab = add_optab;
- do /* check add_optab and ashl_optab */
- for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT); mode != VOIDmode;
- mode = GET_MODE_WIDER_MODE (mode))
- {
- int icode = (int) tstoptab->handlers[(int) mode].insn_code;
- rtx reg0, reg1, reg2, pat;
- int i;
-
- if (GET_MODE_BITSIZE (mode) < 32 || icode == CODE_FOR_nothing)
- continue;
- for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
- if (TEST_HARD_REG_BIT (reg_class_contents[GENERAL_REGS], i))
- break;
- if (i + 2 >= FIRST_PSEUDO_REGISTER)
- break;
- reg0 = gen_rtx_REG (insn_operand_mode[icode][0], i);
- reg1 = gen_rtx_REG (insn_operand_mode[icode][1], i + 1);
- reg2 = gen_rtx_REG (insn_operand_mode[icode][2], i + 2);
- if (! (*insn_operand_predicate[icode][0]) (reg0, VOIDmode)
- || ! (*insn_operand_predicate[icode][1]) (reg1, VOIDmode)
- || ! (*insn_operand_predicate[icode][2]) (reg2, VOIDmode))
- break;
- pat = GEN_FCN (icode) (reg0, reg1, reg2);
- if (! pat)
- continue;
- if (GET_CODE (pat) == SEQUENCE)
- pat = XVECEXP (pat, 0, XVECLEN (pat, 0) - 1);
- else
- pat = make_insn_raw (pat);
- if (! single_set (pat)
- || GET_CODE (SET_SRC (single_set (pat))) != tstoptab->code)
- /* Unexpected complexity; don't need to handle this unless
- we find a machine where this occurs and regmove should
- be enabled. */
- break;
- if (find_matches (pat, &match))
- return 1;
- break;
- }
- while (tstoptab != ashl_optab && (tstoptab = ashl_optab, 1));
-#endif /* REGISTER_CONSTRAINTS */
- return 0;
-}
int goal_earlyclobber, this_earlyclobber;
enum machine_mode operand_mode[MAX_RECOG_OPERANDS];
int retval = 0;
- /* Cache the last regno for the last pseudo we did an output reload
- for in case the next insn uses it. */
- static int last_output_reload_regno = -1;
this_insn = insn;
n_reloads = 0;
while (*p && (c = *p++) != ',')
switch (c)
{
- case '=':
- case '+':
- case '*':
+ case '=': case '+': case '*':
break;
case '%':
while (*p && *p != ',') p++;
break;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
+ case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
+
c -= '0';
this_alternative_matches[i] = c;
/* We are supposed to match a previous operand.
&& this_alternative_matches[i] < 0)
bad = 1;
-#if 0
- /* If this is a pseudo-register that is set in the previous
- insns, there's a good chance that it will already be in a
- spill register and we can use that spill register. So
- make this case cheaper.
-
- Disabled for egcs. egcs has better inheritance code and
- this change causes problems with the improved reload
- inheritance code. */
- if (GET_CODE (operand) == REG
- && REGNO (operand) >= FIRST_PSEUDO_REGISTER
- && REGNO (operand) == last_output_reload_regno)
- reject--;
-#endif
-
/* If this is a constant that is reloaded into the desired
class by copying it to memory first, count that as another
reload. This is consistent with other code and is
reload_earlyclobbers[n_earlyclobbers++] = recog_operand[i];
/* Now record reloads for all the operands that need them. */
- last_output_reload_regno = -1;
for (i = 0; i < noperands; i++)
if (! goal_alternative_win[i])
{
(insn_code_number < 0 ? 0
: insn_operand_strict_low[insn_code_number][i]),
0, i, operand_type[i]);
- if (modified[i] != RELOAD_READ
- && GET_CODE (recog_operand[i]) == REG)
- last_output_reload_regno = REGNO (recog_operand[i]);
}
/* In a matching pair of operands, one must be input only
and the other must be output only.
operand_mode[goal_alternative_matched[i]],
0, 0, i, RELOAD_OTHER);
operand_reloadnum[goal_alternative_matched[i]] = output_reloadnum;
- if (GET_CODE (recog_operand[goal_alternative_matched[i]]) == REG)
- last_output_reload_regno
- = REGNO (recog_operand[goal_alternative_matched[i]]);
}
else if (modified[i] == RELOAD_WRITE
&& modified[goal_alternative_matched[i]] == RELOAD_READ)
operand_mode[i],
0, 0, i, RELOAD_OTHER);
operand_reloadnum[i] = output_reloadnum;
- if (GET_CODE (recog_operand[i]) == REG)
- last_output_reload_regno = REGNO (recog_operand[i]);
}
else if (insn_code_number >= 0)
abort ();
register rtx tem
= gen_rtx_MEM (Pmode,
gen_rtx_PLUS (Pmode,
- gen_rtx_REG (Pmode, LAST_VIRTUAL_REGISTER + 1),
+ gen_rtx_REG (Pmode,
+ LAST_VIRTUAL_REGISTER + 1),
GEN_INT (4)));
spill_indirect_levels = 0;
tem = gen_rtx_PLUS (Pmode,
gen_rtx_REG (Pmode, HARD_FRAME_POINTER_REGNUM),
gen_rtx_REG (Pmode, i));
+
/* This way, we make sure that reg+reg is an offsettable address. */
tem = plus_constant (tem, 4);
mem_mode, insn);
return x;
+ /* You might think handling MINUS in a manner similar to PLUS is a
+ good idea. It is not. It has been tried multiple times and every
+ time the change has had to have been reverted.
+
+ Other parts of reload know a PLUS is special (gen_reload for example)
+ and require special code to handle code a reloaded PLUS operand.
+
+ Also consider backends where the flags register is clobbered by a
+ MINUS, but we can emit a PLUS that does not clobber flags (ia32,
+ lea instruction comes to mind). If we try to reload a MINUS, we
+ may kill the flags register that was holding a useful value.
+
+ So, please before trying to handle MINUS, consider reload as a
+ whole instead of this little section as well as the backend issues. */
case PLUS:
/* If this is the sum of an eliminable register and a constant, rework
the sum. */
case CALL:
case COMPARE:
+ /* See comments before PLUS about handling MINUS. */
case MINUS:
case DIV: case UDIV:
case MOD: case UMOD:
case '#': case '&': case '!':
case '*': case '%':
case '0': case '1': case '2': case '3': case '4':
+ case '5': case '6': case '7': case '8': case '9':
case 'm': case '<': case '>': case 'V': case 'o':
case 'E': case 'F': case 'G': case 'H':
case 's': case 'i': case 'n':
we have one insn followed by a branch to the same label we branch to.
In both of these cases, inverting the jump and annulling the delay
slot give the same effect in fewer insns. */
- if ((next_trial == next_active_insn (JUMP_LABEL (insn)))
+ if ((next_trial == next_active_insn (JUMP_LABEL (insn))
+ && ! (next_trial == 0 && current_function_epilogue_delay_list != 0))
|| (next_trial != 0
&& GET_CODE (next_trial) == JUMP_INSN
&& JUMP_LABEL (insn) == JUMP_LABEL (next_trial)
|| (GET_CODE (insn) != JUMP_INSN && ! non_jumps_p))
continue;
- if (GET_CODE (insn) == JUMP_INSN)
- flags = get_jump_flags (insn, JUMP_LABEL (insn));
- else
- flags = get_jump_flags (insn, NULL_RTX);
+ /* It may have been that this insn used to need delay slots, but
+ now doesn't; ignore in that case. This can happen, for example,
+ on the HP PA RISC, where the number of delay slots depends on
+ what insns are nearby. */
slots_to_fill = num_delay_slots (insn);
/* Some machine description have defined instructions to have
slots_filled = 0;
delay_list = 0;
+ if (GET_CODE (insn) == JUMP_INSN)
+ flags = get_jump_flags (insn, JUMP_LABEL (insn));
+ else
+ flags = get_jump_flags (insn, NULL_RTX);
+
if ((trial = next_active_insn (insn))
&& GET_CODE (trial) == JUMP_INSN
&& simplejump_p (trial)
&& ! insn_sets_resource_p (trial, &needed, 1)
#ifdef HAVE_cc0
/* Can't separate set of cc0 from its use. */
- && ! (reg_mentioned_p (cc0_rtx, pat)
- && ! sets_cc0_p (pat))
+ && ! (reg_mentioned_p (cc0_rtx, pat) && ! sets_cc0_p (pat))
#endif
)
{
allows the port to favor filling the delay slot of the call with
the unconditional jump. */
if (slots_to_fill == 0)
- continue;
+ continue;
slots_filled = 0;
target_label = JUMP_LABEL (insn);
/* Allocate and read RTL for GNU C Compiler.
- Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 1988, 1991, 1994, 1997, 1998, 1999
+ Free Software Foundation, Inc.
This file is part of GNU CC.
return rt;
}
+/* Like the above, but allocate based only on the length. This is called
+ by the routines built into genrtl.c. */
+
+rtx
+obstack_alloc_rtx (length)
+ int length;
+{
+ rtx rt;
+ register struct obstack *ob = rtl_obstack;
+
+ /* This function is called more than any other in GCC,
+ so we manipulate the obstack directly.
+
+ Even though rtx objects are word aligned, we may be sharing an obstack
+ with tree nodes, which may have to be double-word aligned. So align
+ our length to the alignment mask in the obstack. */
+
+ length = (length + ob->alignment_mask) & ~ ob->alignment_mask;
+
+ if (ob->chunk_limit - ob->next_free < length)
+ _obstack_newchunk (ob, length);
+
+ rt = (rtx) ob->object_base;
+ ob->next_free += length;
+ ob->object_base = ob->next_free;
+
+ /* We want to clear everything up to the FLD array. Normally,
+ this is one int, but we don't want to assume that and it
+ isn't very portable anyway; this is. */
+
+ memset (rt, 0, sizeof (struct rtx_def) - sizeof (rtunion));
+
+ return rt;
+}
+
/* Free the rtx X and all RTL allocated since X. */
void
/* This file contains the definitions and documentation for the
Register Transfer Expressions (rtx's) that make up the
Register Transfer Language (rtl) used in the Back End of the GNU compiler.
- Copyright (C) 1987, 88, 92, 94, 95, 97, 98, 1999 Free Software Foundation, Inc.
+ Copyright (C) 1987, 88, 92, 94, 95, 97, 98, 1999
+ Free Software Foundation, Inc.
This file is part of GNU CC.
/* This is used to encapsulate an expression whose value is constant
(such as the sum of a SYMBOL_REF and a CONST_INT) so that it will be
recognized as a constant operand rather than by arithmetic instructions. */
-
DEF_RTL_EXPR(CONST, "const", "e", 'o')
+/* A unary `__builtin_constant_p' expression. This RTL code may only be used
+ as an operand of a CONST. This pattern is only emitted during RTL
+ generation and then only if optimize > 0. It is converted by the first
+ CSE pass into the appropriate CONST_INT. */
+DEF_RTL_EXPR(CONSTANT_P_RTX, "constant_p_rtx", "e", 'x')
+
/* program counter. Ordinary jumps are represented
by a SET whose first operand is (PC). */
DEF_RTL_EXPR(PC, "pc", "", 'o')
0 is the live bitmap. Operand 1 is the original block number. */
DEF_RTL_EXPR(RANGE_LIVE, "range_live", "bi", 'x')
-/* A unary `__builtin_constant_p' expression. These are only emitted
- during RTL generation, and then only if optimize > 0. They are
- eliminated by the first CSE pass. */
-DEF_RTL_EXPR(CONSTANT_P_RTX, "constant_p_rtx", "e", 'x')
-
/* A placeholder for a CALL_INSN which may be turned into a normal call,
a sibling (tail) call or tail recursion.
extern char *oballoc PROTO((int));
extern char *permalloc PROTO((int));
extern rtx rtx_alloc PROTO((RTX_CODE));
+extern rtx obstack_alloc_rtx PROTO((int));
extern rtvec rtvec_alloc PROTO((int));
extern rtx copy_rtx PROTO((rtx));
extern rtx copy_rtx_if_shared PROTO((rtx));
and without prototypes. */
#define GEN_INT(N) gen_rtx_CONST_INT (VOIDmode, (HOST_WIDE_INT) (N))
-
/* If HARD_FRAME_POINTER_REGNUM is defined, then a special dummy reg
is used to represent the frame pointer. This is because the
hard frame pointer and the automatic variables are separated by an amount
{
if (current_function_check_memory_usage)
{
- error ("`asm' cannot be used with `-fcheck-memory-usage'");
+ error ("`asm' cannot be used in function where memory usage is checked");
return;
}
MD_ASM_CLOBBERS (clobbers);
#endif
+ if (current_function_check_memory_usage)
+ {
+ error ("`asm' cannot be used in function where memory usage is checked");
+ return;
+ }
+
/* Count the number of meaningful clobbered registers, ignoring what
we would ignore later. */
nclobbers = 0;
XVECEXP (body, 0, i)
= gen_rtx_SET (VOIDmode,
output_rtx[i],
- gen_rtx_ASM_OPERANDS (VOIDmode,
- TREE_STRING_POINTER (string),
- TREE_STRING_POINTER (TREE_PURPOSE (tail)),
- i, argvec, constraints,
- filename, line));
+ gen_rtx_ASM_OPERANDS
+ (VOIDmode,
+ TREE_STRING_POINTER (string),
+ TREE_STRING_POINTER (TREE_PURPOSE (tail)),
+ i, argvec, constraints,
+ filename, line));
+
MEM_VOLATILE_P (SET_SRC (XVECEXP (body, 0, i))) = vol;
}
{
XVECEXP (body, 0, i++)
= gen_rtx_CLOBBER (VOIDmode,
- gen_rtx_MEM (BLKmode,
- gen_rtx_SCRATCH (VOIDmode)));
+ gen_rtx_MEM
+ (BLKmode,
+ gen_rtx_SCRATCH (VOIDmode)));
continue;
}
bytes_needed = (size + HOST_BITS_PER_CHAR) / HOST_BITS_PER_CHAR;
if (size > 0 && size < 600000
- /* We deliberately use calloc here - not xcalloc. */
+ /* We deliberately use calloc here, not cmalloc, so that we can suppress
+ this optimization if we don't have enough memory rather than
+ aborting, as xmalloc would do. */
&& (cases_seen = (unsigned char *) calloc (bytes_needed, 1)) != NULL)
{
long i;
/* Dummy data flow analysis for GNU compiler in nonoptimizing mode.
- Copyright (C) 1987, 91, 94-96, 1998 Free Software Foundation, Inc.
+ Copyright (C) 1987, 91, 94-96, 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
-/* system.h - Get common system includes and various definitions and
- declarations based on autoconf macros.
+/* Get common system includes and various definitions and declarations based
+ on autoconf macros.
Copyright (C) 1998, 1999 Free Software Foundation, Inc.
This file is part of GNU CC.
the Free Software Foundation, 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
+
#ifndef __GCC_SYSTEM_H__
#define __GCC_SYSTEM_H__
#define ISDIGIT(c) ((unsigned) (c) - '0' <= 9)
+#ifdef HAVE_SYS_TYPES_H
#include <sys/types.h>
+#endif
+
#include <errno.h>
#ifndef errno
extern char *strstr ();
#endif
+#ifdef HAVE_MALLOC_H
+#include <malloc.h>
+#endif
+
+#ifdef NEED_DECLARATION_MALLOC
+extern char *malloc ();
+#endif
+
+#ifdef NEED_DECLARATION_CALLOC
+extern char *calloc ();
+#endif
+
+#ifdef NEED_DECLARATION_REMALLOC
+extern char *realloc ();
+#endif
+
#ifdef HAVE_STRERROR
# ifdef NEED_DECLARATION_STRERROR
# ifndef strerror
% texinfo.tex -- TeX macros to handle Texinfo files.
-% $Id: texinfo.tex,v 1.5 1998/06/29 21:40:12 law Exp $
+%
+% Load plain if necessary, i.e., if running under initex.
+\expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi
+%
+\def\texinfoversion{1998-11-13}%
%
% Copyright (C) 1985, 86, 88, 90, 91, 92, 93, 94, 95, 96, 97, 98
% Free Software Foundation, Inc.
% Sometimes one run after texindex suffices, and sometimes you need more
% than two; texi2dvi does it as many times as necessary.
-
-% Make it possible to create a .fmt file just by loading this file:
-% if the underlying format is not loaded, start by loading it now.
-% Added by gildea November 1993.
-\expandafter\ifx\csname fmtname\endcsname\relax\input plain\fi
-
-% This automatically updates the version number based on RCS.
-\def\deftexinfoversion$#1: #2 ${\def\texinfoversion{#2}}
-\deftexinfoversion$Revision: 1.5 $
-\message{Loading texinfo package [Version \texinfoversion]:}
+\message{Loading texinfo [version \texinfoversion]:}
% If in a .fmt file, print the version number
% and turn on active characters that we couldn't do earlier because
% they might have appeared in the input file name.
-\everyjob{\message{[Texinfo version \texinfoversion]}\message{}
+\everyjob{\message{[Texinfo version \texinfoversion]}%
\catcode`+=\active \catcode`\_=\active}
% Save some parts of plain tex whose names we will redefine.
\shipout\vbox{%
\ifcropmarks \vbox to \outervsize\bgroup
\hsize = \outerhsize
- \line{\ewtop\hfil\ewtop}%
- \nointerlineskip
- \line{%
- \vbox{\moveleft\cornerthick\nstop}%
- \hfill
- \vbox{\moveright\cornerthick\nstop}%
- }%
+ \vskip-\topandbottommargin
+ \vtop to0pt{%
+ \line{\ewtop\hfil\ewtop}%
+ \nointerlineskip
+ \line{%
+ \vbox{\moveleft\cornerthick\nstop}%
+ \hfill
+ \vbox{\moveright\cornerthick\nstop}%
+ }%
+ \vss}%
\vskip\topandbottommargin
\line\bgroup
\hfil % center the page within the outer (page) hsize.
\hfil\egroup % end of (centering) \line\bgroup
\vskip\topandbottommargin plus1fill minus1fill
\boxmaxdepth = \cornerthick
- \line{%
- \vbox{\moveleft\cornerthick\nsbot}%
- \hfill
- \vbox{\moveright\cornerthick\nsbot}%
+ \vbox to0pt{\vss
+ \line{%
+ \vbox{\moveleft\cornerthick\nsbot}%
+ \hfill
+ \vbox{\moveright\cornerthick\nsbot}%
+ }%
+ \nointerlineskip
+ \line{\ewbot\hfil\ewbot}%
}%
- \nointerlineskip
- \line{\ewbot\hfil\ewbot}%
\egroup % \vbox from first cropmarks clause
\fi
}% end of \shipout\vbox
\immediate\write16{If you are running another version of TeX, relax.}
\immediate\write16{If you are running Unix TeX 3.0, kill this TeX process.}
\immediate\write16{ Then upgrade your TeX installation if you can.}
- \immediate\write16{ (See ftp://ftp.gnu.ai.mit.edu/pub/gnu/TeX.README.)}
+ \immediate\write16{ (See ftp://ftp.gnu.org/pub/gnu/TeX.README.)}
\immediate\write16{If you are stuck with version 3.0, run the}
\immediate\write16{ script ``tex3patch'' from the Texinfo distribution}
\immediate\write16{ to use a workaround.}
%
\def\expandablevalue#1{%
\expandafter\ifx\csname SET#1\endcsname\relax
- {[No value for ``#1'']v}%
+ {[No value for ``#1'']}%
\else
\csname SET#1\endcsname
\fi
\def\copyright{\realbackslash copyright}%
\def\tclose##1{\realbackslash tclose {##1}}%
\def\code##1{\realbackslash code {##1}}%
+\def\uref##1{\realbackslash uref {##1}}%
+\def\url##1{\realbackslash url {##1}}%
+\def\env##1{\realbackslash env {##1}}%
+\def\command##1{\realbackslash command {##1}}%
+\def\option##1{\realbackslash option {##1}}%
\def\dotless##1{\realbackslash dotless {##1}}%
\def\samp##1{\realbackslash samp {##1}}%
\def\,##1{\realbackslash ,{##1}}%
\def\kbd##1{\realbackslash kbd {##1}}%
\def\dfn##1{\realbackslash dfn {##1}}%
\def\emph##1{\realbackslash emph {##1}}%
+\def\acronym##1{\realbackslash acronym {##1}}%
%
% Handle some cases of @value -- where the variable name does not
% contain - or _, and the value does not contain any
%\let\tt=\indexdummyfont
\let\tclose=\indexdummyfont
\let\code=\indexdummyfont
+\let\url=\indexdummyfont
+\let\uref=\indexdummyfont
+\let\env=\indexdummyfont
+\let\command=\indexdummyfont
+\let\option=\indexdummyfont
\let\file=\indexdummyfont
\let\samp=\indexdummyfont
\let\kbd=\indexdummyfont
\vsize = #1\relax
\advance\vsize by \topskip
\outervsize = \vsize
- \advance\outervsize by 0.6in
+ \advance\outervsize by 2\topandbottommargin
\pageheight = \vsize
%
\hsize = #2\relax
@rm
@c Local variables:
+@c eval: (add-hook 'write-file-hooks 'time-stamp)
@c page-delimiter: "^\\\\message"
+@c time-stamp-start: "def\\\\texinfoversion{"
+@c time-stamp-format: "%:y-%02m-%02d"
+@c time-stamp-end: "}"
@c End:
@findex MOVE_RATIO
@item MOVE_RATIO
The threshold of number of scalar memory-to-memory move insns, @emph{below}
-which a sequence of insns should be generated instead of a
+which a sequence of insns should be generated instead of a
string move insn or a library call. Increasing the value will always
make code faster, but eventually incurs high cost in increased code size.
-Note that on machines with no memory-to-memory move insns, this macro denotes
-the corresponding number of memory-to-memory @emph{sequences}.
+Note that on machines where the corresponding move insn is a
+@code{define_expand} that emits a sequence of insns, this macro counts
+the number of such sequences.
If you don't define this, a reasonable default is used.
va_end (ap);
}
-/* Report a fatal error at the current line number. */
+/* Report a fatal error at the current line number. Allow a front end to
+ intercept the message. */
+
+static void (*fatal_function) PROTO((const char *, va_list));
+
+/* Set the function to call when a fatal error occurs. */
+
+void
+set_fatal_function (f)
+ void (*f) PROTO((char *, va_list));
+{
+ fatal_function = f;
+}
static void
vfatal (msgid, ap)
const char *msgid;
va_list ap;
{
+ if (fatal_function != 0)
+ (*fatal_function) (_(msgid), ap);
+
verror (msgid, ap);
exit (FATAL_EXIT_CODE);
}
TIMEVAR (cse_time, reg_scan (insns, max_reg_num (), 1));
if (flag_thread_jumps)
- /* Hacks by tiemann & kenner. */
TIMEVAR (jump_time, thread_jumps (insns, max_reg_num (), 1));
TIMEVAR (cse_time, tem = cse_main (insns, max_reg_num (),
0, rtl_dump_file));
TIMEVAR (cse_time, delete_trivially_dead_insns (insns, max_reg_num ()));
+ /* If we are not running the second CSE pass, then we are no longer
+ expecting CSE to be run. */
+ cse_not_expected = !flag_rerun_cse_after_loop;
+
if (tem || optimize > 1)
TIMEVAR (jump_time, jump_optimize (insns, !JUMP_CROSS_JUMP,
!JUMP_NOOP_MOVES,
be instrumented with calls to support routines. */
#define DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT(NODE) ((NODE)->decl.no_instrument_function_entry_exit)
-/* Used in FUNCTION_DECLs to indicate that in this function,
- check-memory-usage should be disabled. */
+/* Used in FUNCTION_DECLs to indicate that check-memory-usage should be
+ disabled in this function. */
#define DECL_NO_CHECK_MEMORY_USAGE(NODE) ((NODE)->decl.no_check_memory_usage)
/* Additional flags for language-specific uses. */
#include "config.h"
#include "system.h"
#include <setjmp.h>
-/* #include <stab.h> */
#include "rtl.h"
#include "tree.h"
#include "flags.h"
DECL_RTL (decl) = gen_rtx_MEM (DECL_MODE (decl),
gen_rtx_SYMBOL_REF (Pmode, name));
MEM_ALIAS_SET (DECL_RTL (decl)) = get_alias_set (decl);
-
+
/* If this variable is to be treated as volatile, show its
tree node has side effects. If it has side effects, either
because of this test or from TREE_THIS_VOLATILE also
#Makefile for GNU Objective C runtime library.
-#Copyright (C) 1993, 95-97, 1998 Free Software Foundation, Inc.
+#Copyright (C) 1993, 95-98, 1999 Free Software Foundation, Inc.
#This file is part of GNU CC.
copy-headers:
-rm -rf $(incinstalldir)/objc
-mkdir $(incinstalldir)/objc
+ -chmod a+rx $(incinstalldir)/objc
for file in $(OBJC_H); do \
realfile=$(srcdir)/objc/$${file}; \
cp $${realfile} $(incinstalldir)/objc; \
projects / thirdparty / gcc.git / commitdiff
