SPACE 2/SPACE - Library 2 - Volume 1.iso/program/316/install/change.log

Text File | 1988-10-20 | 119.8 KB | 3,012 lines

Sun Jun 26 10:47:47 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * Version 1.23 released.

    * tm-3b1.h: Define IDENT_DIRECTIVE.

    * tm-encore.h: Define SDB_DEBUGGING_INFO.
    Define SCCS_DIRECTIVE and IDENT_DIRECTIVE.

    * output-ns32k.c: Decl of paren_base_reg_printed must be outside fcns.

    * tm-encore.h (ASM_OUTPUT_DOUBLE): Do 0f, not 0l.
    (CPP_PREDEFINES): No -Dns32032.

    * sdbout.c: Include syms.h, not storclass.h.
    (unnamed_struct_member): Decl was missing.
    (PUT_SDB_INT_VAL, PUT_SDB_VAL): Fix typos.
    (sdbout_types, sdbout_one_type, sdbout_parms): Fix typos.

    * Makefile: Add file sdbout.o.
    Changed comments pertaining to sysV.
    Make a separate target `doc' to make the info files.

    * m68k.md (bit-field insns): Use nonimmediate_operand for the thing
    to extract from.
    * vax.md (QImode bit-field insns): Likewise.

    * recog.c (nonimmediate_operand): Accept any nonconst general operand.

Sat Jun 25 07:54:42 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * cse.c (lookup_as_function): arg to exp_equiv_p was missing.

Fri Jun 24 09:14:47 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * recog.c (memory_operand): Allow (subreg (mem...)).

Thu Jun 23 07:34:07 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * decl.c (finish_enum): Compute minimum value like maximum.
    If minimum is negative, install it in the type and make it signed.

    * stor-layout.c (layout_record): STRUCTURE_SIZE_BOUNDARY is minimum.
    (layout_type): A RECORD_TYPE or UNION_TYPE must be BLKmode if
    any member is BLKmode.  This is to prevent putting it in a register.
    (layout_decl): If decl's type is BLKmode, the decl *must* be BLKmode.

    * local-alloc.c (find_free_reg): Never allocate the frame pointer reg.

    * tm-sequent.h (PRINT_OPERAND): Bug in SFmode CONST_DOUBLE.
    * tm-encore.h: Likewise.

    * flow.c (flow_analysis): Bug in n_basic_blocks error check.

    * stmt.c (expand_asm_operands): Emit no insn if an arg is erroneous.

Tue Jun 21 08:34:24 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * reload.c (find_reloads_address): Write back *loc even if
    subst_reg_equivs makes no change, in case subst_index_address did.

    * flow.c: Define macros for -1 and -2 as values of reg_basic_block.
    (mark_used_regs): Add an `else'; no change in behavior.
    (mark_label_ref): Abort if LABEL_REF doesn't contain a CODE_LABEL.
    (find_basic_blocks): Extra error check.

    * output-ns32k.c (print_operand_address): Changes in handling of
    register-indirect, and of indexing by sb register.

Mon Jun 20 04:55:38 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * cccp.c (collect_definition): Compute needed space more accurately.
    Abort if use more space than was allocated.
    (rescan) [USE_C_ALLOCA]: Do alloca (0) after handle_directive.

    * genflags.c (gen_insn): Put parens around defns of HAVE_... macros.

Sun Jun 19 02:52:53 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * expr.c (emit_push_insn): Consider PARM_BOUNDARY when compensating
    for size of a pushed arg to bcopy.

Sat Jun 18 07:20:54 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * New files sparc.md, tm-sparc.h, config-sparc.h, output-sparc.c.

    * final.c (final): After an ADDR_{,DIFF_}VEC, do ASM_OUTPUT_CASE_END.
    * tm-3b1.h: Define ASM_OUTPUT_CASE_END.
    (PRINT_OPERAND_ADDRESS): Ref the case tables via an intermediate symbol
    `LDnnn' whose def. is output by ASM_OUTPUT_CASE_END.
    (ASM_OUTPUT_CASE_LABEL): Add missing newline.

    * reload.c (find_equiv_reg): Reject a MEM containing an autoincrement.

Fri Jun 17 06:58:37 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * genpeep.c (main): Write `extern' in the decl for `peep_operand'.

    * flow.c (propagate_block): When a dead insn has a REG_RETVAL note,
    call mark_set_regs anyway, so that `significant' is updated.

    * jump.c (follow_jumps): New arg IGNORE_LOOPS.  If 0, don't follow
    the insn at the beginning of a loop that enters the loop; this avoids
    interference with loop optimizer.
    (jump_optimize, tension_vector_labels): Pass that arg.

    * loop.c (loop_optimize): Mention invalid multiple-entry loops in log.

    * m68k.md (extv, extzv): Fix # of alternatives mismatch in constraints.

Thu Jun 16 03:06:48 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * genrecog.c (change_state): Was mishandling printing XVECEXP indices
    greater than 9.

    * combine.c (subst, simplify_and_const_int): Avoid making SUBREG
    of a non-REG.

    * expr.c (expand_expr): For FIX_TRUNC_EXPR to unsigned short/char,
    go via signed int.

    * optabs.c (expand_fix): Copy hard_libcall_value reg only once.

    * reload1.c (order_regs_for_reload): Init all elements
    of  potential_reload_regs to -1.

    * Prevent generation of (set (reg) (plus ... (label_ref ...))).
    * explow.c (memory_address_noforce): Like `memory_address' but
    never force it into a register.
    * expr.c (do_tablejump): Use that.
    * m68k.md (casesi): Use that.

    * rtl.h (struct rtx_def, GET_CODE, PUT_CODE): If SHORT_ENUM_BUG,
    define the `code' field as a short.

Wed Jun 15 01:25:57 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * gcc.c (CPP_SPEC): New spec set by config.h gives flags to cpp.
    * tm-*.h for m68k: Define CPP_SPEC to define __HAVE_FPU__ on
    appropriate conditions.

    * combine.c (subst): Simplify (not (minus x 1)) and (neg (minus x y)).

Mon Jun 13 02:22:43 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * typecheck.c (build_array_ref): Avoid duplicate errmsg if index
    is an error-mark.

Sun Jun 12 23:04:39 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * cccp.c (handle_directive): If -traditional, quotes aren't special.
    (rescan): Assume newline ends a string constant.

    * cccp.c, cexp.y: Make all fcns non-static; add some forward decls.

    * various: add static forward-decls for various functions.

Fri Jun 10 00:25:18 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * reload1.c (choose_reload_targets): When writing back an incremented
    value (handling reload_inc), write back to the real place, not to
    OLDEQUIV (a register that holds the same value).

    * tm-m68k.h (LEGITIMIZE_ADDRESS): Don't give force_operand a target.
    This can cause the use of multiple insns with same output reg,
    which can confuse cse.

    * loop.c (consec_sets_invariant_p):
    If invariant_p ever returns 2, we return 2.
    New arg is # of consecutive sets to look for,
    since this info is no longer in n_times_set at move_movables.
    (scan_loop): If consec_sets_invariant_p returns 2, set m->cond.
    (move_movables): check consecutive insns if m->consec && m->cond.

    * tm*.h: ASM_DECLARE_FUNCTION_NAME now takes 3rd arg,
    the FUNCTION_DECL node.
    * varasm.c (assemble_function): Pass this arg.

    * expr.c (expand_call, expand_builtin [alloca]):
    If STACK_POINTER_OFFSET is defined, add it to stack pointer contents
    before using it as address of actual data on the stack.
    * stmt.c (expand_decl): Likewise.

    * stmt.c (assign_parms): If 1st parm named `__builtin_va_alist'
    came in regs, pretend it came on stack.
    Handle pretending a BLKmode var came on the stack.
    If REG_PARM_STACK_SLOT, count stack space for each parm
    even if the parm came in a register; and use that stack space
    if the parm needs to be addressable or is BLKmode.
    Rearrange to simplify conditionals.

Thu Jun  9 01:21:29 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * local-alloc.c:
    `qty_...' vectors' elements for hard-reg-numbers now aren't used.
    `reg_qty' elements for hard-reg numbers now aren't used,
    and the element for a pseudo is never a hard-reg number.
    (local_alloc): No need to reset those elements.
    No need to reset elements out of range of prev block's NEXT_QTY.
    (reg_is_born, reg_is_set, wipe_dead_reg):
    Divide labor in same way for hard regs and pseudos;
    simplify using fact that locality-to-basic-block has been precomputed
    and recorded in reg_qty; avoid refs to reg_qty[HARDREG].
    (reg_is_born, wipe_dead_regs): Block-number arg no longer needed.

    * local-alloc.c (combine_regs): Remove old code for tying hard regs
    to pseudos; great simplification results.
    Use find_regno_note, not regno_dead_p.

Wed Jun  8 00:18:04 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * reload.c (subst_reg_equivs): Set a flag if anything is changed.
    (find_reloads_address): Check that flag to avoid extra work.
    Also check early for safe reg+const address and avoid work.

    * reload.c (find_reloads): Use loops instead of bcopy.
    Check early for insn with no real constraints, and return.
    Also check for move from hard reg to hard reg and return.

    * cse.c (canon_reg): Rewrite for speed; use a switch.
    (cse_insn): Don't call find_reg_note if REG_NOTES is 0.

    * cse.c (cse_insn): Store modified SET_SRC even if there's a REG_EQUIV.
    Inhibition was needed when the SET_SRC was the only place to find the
    equivalent value; now it is in the REG_EQUIV note.

    * stmt.c (expand_asm_operands): If NINPUTS is 0, make vec of no elts.
    * regclass.c (reg_scan_mark_refs): Don't lose if XVEC (x,i) is 0.

Tue Jun  7 03:51:28 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * stmt.c (assign_stack_local): If big-endian and MODE is narrow,
    the bytes actually used are the least significant.

    * parse.y (skip_white_space): Accept char as arg; let caller read it.
    (yylex): Change call.
    (check_newline): Return 1st nonwhite char after skipping lines.
    (skip_white_space): Change call.
    * toplev.c (compile_file): Change call.

    * gcc.c: Pass -traditional to cc1.

    * cse.c (cse_insn): Return very early for (set (reg) (call...)).
    Mainly to save time.
    (cse-insn) Old code to add REG_WAS_0 note wasted time but did nothing.

    * expr.c (clear_pending_stack_adjust): Really do clear it,
    if current fcn doesn't want to be inline.

    * cse.c (cse_insn): Speedup: instead of safe_hash, use canon_hash
    or HASHREG.

Mon Jun  6 21:47:23 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * jump.c (rtx_renumbered_equal_p): Reject ADDR_VEC fast.

    * cse.c (cse_insn): Ignore a REG_EQUIV or REG_EQUAL note if the
    equivalent value is the same as the SET_SRC of the insn.

    * flow.c (life_analysis): Don't call volatile_refs_p for a CALL_INSN;
    just assume value is 1.
    (propagate_block): Don't call mark_{used,set}_regs for a stack-pop
    since if it isn't dead it has no effect on any useful life data.
    (mark_set_1): Return quickly if setting stack-ptr, and almost as
    quickly if setting any hard reg.
    (mark_used_regs): Likewise for refs.
    Also don't scan the vector of an ADDR_VEC or ADDR_DIFF_VEC.
    (volatile_refs_p): Likewise.

    * varasm.c (output_constant): Discard NOP_EXPR and CONVERT_EXPR
    in integer case (they were for casting a pointer).

    * parse.y (compstmt_or_error): Parse a compstmt after ignoring error.
    Use this for fctn body so that an error after store_parm_decls
    won't recover to xdecls and call store_parm_decls again.
    Typical cause was missing semi at end of last parmdecl.

    * parse.y: Add missing semicolons in actions.
    (yylex): Don't use yylloc.

Sun Jun  5 16:14:40 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * typecheck.c (build_array_ref): Check arg types here, to make
    error message more accurate (not about "addition").

Thu Jun  2 02:41:40 1988  Richard Stallman  (rms at rice-krispies.ai.mit.edu)

    * cccp.c (collect_expansion): `#' isn't special if -traditional.

    * dbxout.c (dbxout_parms): Don't output a regparm symbol
    unless the parm got a hard reg assigned.

    * tm-encore.h (ASM_OUTPUT_DOUBLE): Use 0f... not 0d...

    * tm-vax.h (CHECK_FLOAT_VALUE): Define this.

Wed Jun  1 17:13:00 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * expr.c (expand_call): Have sequence points between args.

Tue May 31 00:27:06 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * expmed.c (store_fixed_bit_field): Avoid shifting by 32.
    * cse.c (fold_rtx):
    * symout.c (subrange_p):  likewise.

    * local-alloc.c (block_alloc): If operands 1 and 2 commute,
    try tying output to operand 2 if operand 1 won't do.

    * toplev.c (compile_file): Pass main_input_file to symout_init.

    * tree.c (build_real, build_real_from_int_cst):
    Call CHECK_FLOAT_VALUE if it's defined, to report out-of-range values.

    * tree.c (build_real, build_real_from_int_cst): New 1st arg TYPE.
    * parse.y (yylex): Pass this arg; requires parsing suffixes first.
    * fold-const.c (fold, combine, fold_convert): Pass this arg.
    Handling of float binops in `combine' simplified.

    * tm-encore.h (CPP_PREDEFINES): Remove -Dencore since CC lacks it.

    * final.c (output_source_line): Let ASM_OUTPUT_SOURCE_LINE
    be used for SDB also.

Mon May 30 00:21:15 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * cse.c (insert): Was inserting in wrong place in list.
    (exp_equiv_p): Was failing to check validity when x == y.

    * tree.c (build_pointer_type): Handle saveable_obstack
    like current_obstack.

    * decl.c (finish_decl): Error in test for zero-size array warning.

    * reload.c (find_equiv_reg): New arg MODE specifies mode in which
    an equivalent value is needed.  Equivalence must be good in that mode.
    In addition, notice overlap with multiword register modes.
    Simplify, knowing that registers have already been renumbered.
    It was invalidating memory-goals too easily; setting a reg
    only invalidates memory-goal if its address varies.
    * reload.c, reload1.c, jump.c: Calls pass the new argument.

    * cccp.c: For correct ANSI, must reject `$' in identifiers.
    (dollars_in_ident): Variable says whether to allow them.
    (rescan): Handle `$' as randomchar if that's 0.
    (main): dollars_in_ident is set to 0 by -$, to 1 by -traditional.
    (rescan, do_define): Delete former pedantic warnings for `$'.
    (initialize_char_syntax, initialize_builtins): Inits split to two
    functions; former is called after options are scanned
    so `$' is in is_idchar conditionally.
    * gcc.c: For -ansi, pass -$ to cccp.
    * toplev.c, flags.h: Define dollars_in_ident.
    * parse.y (yylex): Treat $ as punctuation unless dollars_in_ident.
    Delete old pedantic warning about $.
    * tm-vms.h: Define DOLLARS_IN_IDENTIFIERS as 1.

    * cccp.c (rescan): Preprocessing numbers can have signs, after `e'.

    * integrate.c (expand_inline_function): Abort, don't return failure,
    if max_regno is too low.  I believe this can't happen.

    * typecheck.c (build_binary_op_nodefault):
    For ordered comparisons, no pedantic warning about void *.
    For MAX, MIN, ditto, and also don't allow pointer vs 0.

    * typecheck.c (build_unary_op): Don't allow pointer for +.

    * typecheck.c (convert_for_assignment):
    Add missing warning for    case of unrelated pointer types.
    Change criteria for new ANSI C draft.

    * optabs.c (expand_binop): Don't set unused target_is_not_an_operand.

    * fold-const.c (fold_convert): Don't set unused inprec, outprec.

    * emit-rtl.c, parse.y: Delete unused var.

    * stor-layout.c (add_vc_sizes): Unused function deleted.
    * loop.c (constant_high_bytes): #if 0 this unused function.

    * gcc.c (fatal): Add missing arg to delete_temp_files.

    * cccp.c (dump_defn_1): Add missing arg to skip_quoted_string.

    * reload.c (find_reloads): If constraints don't fit in an `asm',
    print error instead of aborting.

    * regclass.c (reg_class_record): Ignore `&' in constraint.

Sun May 29 00:20:23 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * Makefile: Run ranlib only if /usr/bin/ranlib exists.
    Add comment saying what to do on system V.

    * tree.c (suspend_momentary): Switch to the saveable_obstack
    for the sake of inline functions.

    * flags.h (enum debugger): New enum for write_symbols.
    * toplev.c, varasm.c, final.c: Use the enum constants where appro.
    Add calls to sdbout paralleling the calls to dbxout;
    put each in the appropriate conditional {SDB,DBX}_DEBUGGING_INFO.

    * toplev.c (main): Delete -noreg option; it's now the default.
    Make -O an alias for -opt.  Rename -g to -gg.  -g is alias for -G.
    Accept and ignore -Wtrigraphs.
    * gcc.c: Simplify the specs.

    * toplev.c (compile_file), tm-*.h:
    ASM_FILE_START is now a statement, not just a string to be output.
    Output it *after* determining the real source file name.

    * fold-const.c (fold): Simplify x >= CST to x > CST-1 (CST positive).
    To simplify this, canonicalize relationals to put constat last.

    * decl.c (duplicate_decls): Make a 2nd errmsg to show previous decl.

    * cccp.c (file_size_and_mode): Delete temporary VMS bootstrap patch.

    * tm-att386.h: New file.

    * decl.c (pushdecl): Warn if a local `extern' decl precedes
    a file-scope `static' decl.

    * expr.c (expand_call): No warning for failure to inline.

    * expmed.c (extract_bit_field): copy operand 1 of extv or extzv
    into register if memory isn't allowed.

Sat May 28 02:10:56 1988  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

    * gnulib.c, Makefile: Delete va_end.

    * final.c, symout.c: Check DBX_DEBUGGING_INFO, not NO_DBX_FORMAT.

    * genemit.c (gen_expand): Notice a CALL inside a PARALLEL.

    * regclass.c (init_reg_sets_1): Part of init_reg_set is put in this
    new fn which is called after options are scanned.
    Now CONDITIONAL_REGISTER_USAGE can depend on the options.
    (fix_register): Just alter the data that init_reg_sets_1 will look at.

    * reload1.c (reload): Don't complain if two different but tieable
    modes require groups of the same regclass (assuming same size group).

    * cccp.c: Add 3rd arg to all `open' calls.

    * parse.y (check_newline): Typo prevented ignoring whitespace.

    * cccp.c (perror_with_name): fprintf had harmful extra arg.

    * cccp.c (main, trigraph_pcp): -Wtrigraphs means warn if any trigraphs.

    * emit-rtl.c (gen_sequence): If LEN is 1, avoid looking at PATTERN
    of something that doesn't have one.

    * reload1.c (alter_frame_pointer_addresses): frame pointer can
    occur by itself, not just inside a PLUS.
    (reload): Call eliminate_frame_pointer before reload_as_needed.
    Otherwise the latter can make reload insns that copy the frame ptr
    to a data reg, but 68k can't copy sp+const to a data reg.

    * decl.c (implicitly_declare): Always save the implicit decl
    permanently.  Reuse an old one if it exists.
    * tree.c (resume_temporary_allocation): Used after `end_temporary...'
    to go back to temporary allocation.

    * stor-layout (layout_{type,decl}): Call variable_size.
    (variable_size): Turn a size into a SAVE_EXPR and either compute
    it right away or put it on a list to be computed later.
    (get_pending_sizes): Return that list and clear it out.
    * stmt.c (expand_start_function): Tell `variable_size' to compute
    sizes right away, and compute those saved on the list.
    (expand_end_function): Tell it to put them on a list.

Fri May 27 00:02:34 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * dbxout.c (dbxout_symbol): For local static var, use 'V', not 'v'.

    * gcc.c (main): Don't handle SIGHUP or SIGTERM if shell ignored it.

    * Makefile, gcc.c: Propagate Make var `libdir' to gcc search path.

    * expr.c (expand_expr): a PARM_DECL with no rtl can occur in size of
    `a' in `foo (a,i) int i; struct {int x[i];} a;', so report an error.

    * flow.c (insn_dead_p): insn that makes stack bigger is never dead.
    * combine.c (try_combine): Don't splice out stores into stack ptr.

    * reload.c (find_equiv_reg): Test given regno for OVERLAPPING_REGNO_P.

    * varasm.c (assemble_variable): Use saveable_obstack for allocation.

Thu May 26 01:17:00 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * integrate.c (save_for_inline): Clear unused slots in parmdecl_map.
    (There may be some non-parm regs below max_parm_regno.)
    * integrate.c (copy_for_inline): Don't crash if parmdecl_map elt is 0.

    * Don't fail to output a static inline function that was referenced
    via a local extern decl before its definition.
    * expr.c (expand_call): If need to mark a fcn decl addressable,
    mark the identifier addressable also.
    * typecheck.c (mark_addressable): If marking fcn addressable,
    mark the identifier as well.
    * decl.c (start_function): If identifier was marked addressable,
    propagate it to the function.

    * parse.y (yylex): Check for ERANGE after atof is called.
    (Sun doesn't report ERANGE.)

    * loop.c (may_trap_p): Any floating arithmetic may trap.

Wed May 25 00:03:34 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * parse.y: Delete `noalias'.
    (asm_operand): Don't allow this to be empty.
    (asm_operands): Do allow this to be empty.

    * reload.c (operands_match_p): Don't let REG and SUBREG match
    if the reg isn't a hard reg.
    No longer nec. to check reg_renumber, now that reload
    substitutes the hard regno.

    * reload1.c (reload): Counting existing spilled groups,
    check HARD_REGNO_MODE_OK so we don't get fooled by an odd-even pair.
    Spill entire need for new groups before spilling any solitary regs.
    Reg already counted against max_nongroups can't become part of a group.
    (new_spill_reg): Do bookkeeping associated with a new spill-reg.
    (n_spills): This var is now static, no longer passed as arg
    within the file.

    (reload_reg_class_lower): Handle all group-reloads before solitaries.
    (choose_reload_targets): therefore #if 0 the special code for
    finding solitary registers that aren't suitable for groups.
    But fix two bugs in it: braino deciding whether a reload
    is looking for 1 register (not a group).  Use CLASS_MAX_NREGS.
    Also braino deciding whether a spill reg can be in a group.
    Did not fix bug that it fails to test HARD_REGNO_MODE_OK,
    so it might split up an even-odd pair.

    * vax.md: Special patterns for 8 and 16-bit fields, to make
    move-insns (like the ones for the 68k).

    * tree.c (convert_to_integer): Pass truncation down thru COND_EXPR
    as through a binary operator.

    * typecheck.c (build_cond_expr): If unpromoted operand types match,
    don't promote them--let containing expression promote (just once).

Tue May 24 14:46:26 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * combine.c (subst): Simplify (subreg (sign_extend X) 0).

    * tm-hp9k320.h: Delete NO_DBX_FORMAT.
    * Most tm...h files: Define DBX_DEBUGGING_INFO.
    * dbxout.c: Change conditional to DBX_DEBUGGING_INFO.

    * integrate.c (expand_inline_function): If inline fcn was declared to
    return QI, but actually computes an SI, use SImode for INLINE_TARGET
    but actually return a QI.

    * varasm.c (force_const_mem): Failed to determine alignment bdry
    from machine mode.

    * jump.c (jump_optimize): Don't delete (move X Y) if X or Y is a
    PRESERVE_DEATH_INFO_REGNO_P register.

    * final.c (output_addr_const): In PLUS, output constant term last.

    * final.c (final): Before outputting an insn, do FINAL_PRESCAN_INSN.

    * final.c (next_block_index): No longer static.
    (final): Add SDB_DEBUGGING_INFO cases for outputing NOTEs
    for beginning and end of a block.
    (output_source_line): Add SDB_DEBUGGING_INFO case for line number.
    * varasm.c (assemble_function): Add code for SDB symbol output.

    * gnulib.c: Allow config to override INTIFY.
    New macro SFVALUE for data type to return a single-float in.

    * combine.c (remove_death): No longer `static'.

    * reload1. (choose_reload_targets): PRESERVE_DEATH_INFO_REGNO_P
    selects hard regs for which death info should be updated for final.

    * reload1.c (reload_as_needed): Let INSN_CLOBBERS_REGNO_P
    prevent inheritance of certain reloads.

    * reload.c (find_equiv_reg): Let OVERLAPPING_REGNO_P reject
    an equiv reg.  Needed for funny float regs on 80387.

    * cccp.c (do_ident): Define #ident as a no-op if IDENT_DIRECTIVE.
    Warn if pedantic.
    (do_sccs): Warn if pedantic.

    * emit-rtl.c (restore_reg_data): Set cur_insn_uid--prevent duplicates.

Sun May 22 12:25:06 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * Version 1.22 released.

    * reload1.c (reload): Spilling isn't finished till max_nongroups is 0.

    * tm-encore.h (PRINT_OPERAND): No `$' before a CONST.

Sat May 21 13:08:54 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * fold-const.c (combine): Typo in MIN_EXPR, MAX_EXPR.

    * reload1.c (reload): Was counting insn_groups as total size of groups,
    not number of groups.
    A new spilled group counts against group-needs of superclasses.

    * parse.y (parmlist{,_or_identifiers}_1): In error case,
    return a tree list just as in the other cases.

Fri May 20 02:14:51 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * config-vax.h, config-m68k.h: If __GNUC__, use builtin-alloca.

    * genpeep.c (match_rtx): Generated code was testing the wrong rtx
    when testing an int or string at a nonzero index in the rtx.

    * reload.c (find_reloads): Typo checking `modified' for conflict
    with an earlyclobber.

    * reload.c (find_equiv_reg): Reject stack ptr as return value.

    * expr.c (expand_builtin): Alloca must do pending stack adjust.

Thu May 19 13:01:01 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * flow.c (propagate_block): Skipping back across libcall didn't happen
    due to failing to set PREV.

    * expr.c (emit_library_call): Code to increment and decrement
    current_args_size broke since emit_call_1 was changed to restore it.

    * combine.c (try_combine): When i1 or i2 auto-incs a reg, don't combine
    if i3 uses that reg.

    * config-hp9k3.h: #define bcopy, bcmp, bzero here.
    * conf-hp9k320.h: Delete file.

    * integrate.c: Don't include strings.h--no need.

    * stmt.c (expand_asm_operands): Don't make zero-length vectors.

    * loop.c (scan_loop): After a fcn call, maybe-trap insns can't move.
    The fcn call might exit and that would prevent the trap.

    * reload1.c (reload): Set reload_first_uid to next uid to be used.
    * reload.c (find_equiv_reg): Use reload_first_uid to ignore insns
    that are due to reloading--only if reload_reg_p is not 0 or 1.

Wed May 18 22:11:20 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * typecheck.c (build_unary_op): Don't complain about array
    as argument to `!'.

    * decl.c (pushdecl): If locally declaring an extern function,
    check the identifier's global value in case it's an inline function.

Mon May 16 03:06:08 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * output-ns32k.c (output_shift_insn): New fn, maybe turn shift to adds.
    (reg_or_mem_operand): Predicate for a non-immediate general_operand.
    * tm-ns32k.h (CONST_OK_FOR_LETTER_P): Define letter K.
    * ns32k.md: Use output_shift_insn for various addr insns that shift.
    Don't allow nonexplicit constants in lprd, multiply or truncate insns.
    Use reg_or_mem_operand for constraint in op1 of divide insns;
    a constant there causes regclass to screw up.
    Split alternative constraints on the bit-field insns to avoid
    out-of-range operands in exts, inss.  Some cases of extraction
    can be done faster via memory.

    * flow.c (mark_set_1): When adding a REG_DEAD note, inc reg_n_deaths.

    * dbxout.c (dbxout_type_def): Do nothing for {integer,char}_type_node.

Sun May 15 00:56:44 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * tm-sequent.h, tm-ns32k.h, tm-encore.h (PRINT_OPERAND):
    Was treating SF's as SI's.

    * expr.c (emit_move_insn): Check all CONST_DOUBLEs for
    LEGITIMATE_CONSTANT_P and put them in memory if not.

    * local-alloc.c (combine_regs): Allow a reg to be tied to a qty
    if the reg's class is contained in the qty's class
    (as well as if the reg's class contains the qty's class as before).
    Rename qty_reg_class to qty_min_class and make it the smallest
    class of any reg tied to the qty.
    (reg_class_subset_p, reg_meets_class_p, update_qty_class):
    New subroutines to implement this.
    (local_alloc): Init reg_qty to -1 for pseudos not in cur. basic block.
    (reg_is_born): Abort if pseudo not in basic block has -2 in reg_qty.

    * jump.c (rtx_renumbered_equal_p): Insist that modes of REGs match.

Sat May 14 01:05:35 1988  Richard Stallman  (rms at lucky-charms.ai.mit.edu)

    * stmt.c (expand_return): Empty frame frame_offset isn't nec. 0.

    * expr.c (emit_call_1): Use stack_size_rtx everywhere appropriate.

    * decl.c (init_decl_processing): Set sizetype to `unsigned long'
    if `int' is less than a word.

    * stddef.h (size_t, ptrdiff_t): Both are now long.

Fri May 13 01:06:00 1988  Richard Stallman  (rms at lucky-charms.ai.mit.edu)

    * emit-rtl.c (gen_lowpart): Handle non-lowpart subreg as arg.

    * recog.c (register_operand): VOIDmode means allow any mode.
    (immediate_operand, nonmemory_operand): Likewise.

    * emit-rtl.c (classify_insn): Update for changed CALL_INSN format.
    (emit): New function to emit an rtl pattern as the right kind of insn.
    * jump.c (simplejump_p): No longer static.

    * genemit.c (gen_expand): For match_operand at top level, call `emit'.
    Use `emit_call_insn' when appropriate.
    (gen_exp): Handle rtx's that contain strings.

    * final.c, symout.c: If not NO_DBX_FORMAT, include stab.h to get the
    N_... symbols.  Use their default definitions only if they're undef.

    * expr.c (expand_call) [no PUSH_ROUNDING]: Always set argblock
    if there are any stack-passed arguments.

    * typecheck.c (build_unary_op): Mark all increment-exprs volatile.

    * recog.c (reg_renumbered_fits_class_p): Delete private copy of
    reg_class_contents.

    * reload1.c (forget_old_reloads): Handle PARALLEL case by recursion.
    Explicit store into a spilled reg invalidates old reloaded contents;
    this can occur when we drop through into a basic block whose need was 0
    (and so whose local pseudos were not spilled).

    * gcc.c (main): If -v, print gcc's own version; also no error msg
    if no input files.

    * loop.c (may_trap_p): Mem ref to nonconstant address may trap.
    (scan_loop): Check may_trap_p only when insn is in other respects ok.

    * cexp.y: #include config.h (for decl of alloca on some machines).

Thu May 12 17:24:19 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * regclass.c (regclass): When inserting an insn at start of block,
    update basic_block_head.

Wed May 11 00:47:09 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * stmt.c (assign_parms): DECL_OFFSET should be offset as passed
    (not including big-endian width-change correction).

    * typecheck.c (shorten_compare): Set unsignedp[01] right in case
    where get_narrower makes no change.
    (build_binary_op_nodefault): Likewise for shortening shifts.

    * stmt.c (expand_end_case): Use type_for_size to get the type
    to convert the index to, since `int' is wrong if -mshort.

    * decl.c (grokdeclarator): Don't check PARM type for completeness.
    (grokparms): If fn definition, check all parm types for completeness.
    (store_parm_decls): Likewise.

Tue May 10 22:42:13 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * typecheck.c (store_init): For invalid init, store error_mark_node.
    * varasm.c (assemble_variable): Ignore error_mark as an init.
    * stmt.c (expand_decl): If init is error_mark, init to 0 if possible.
    This avoids a spurious "uninitialized variable" warning.

Sun May  8 17:08:07 1988  Richard Stallman  (rms at lucky-charms.ai.mit.edu)

    * tm-hp9k320.h: Define STRUCTURE_SIZE_BOUNDARY.

    * decl.c (get_parm_info): Replaces get_parm_types.  Returns a tree_list
    containing parmdecls and tag list as well as type list.
    (grokparms): Accept that tree_list as argument.
    (grokdeclarator): Calling grokparms, say "not a definition" for the
    function declarators for arg or value types within a definition.

    * parse.y: Call get_parm_info.
    (parmlist_or_identifiers): If identifiers, make a tree_list
    like the one get_parm_info returns.

Fri May  6 16:44:19 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * m68k.md (casesi): Delete template aside from match_operand's.

    * tm-encore.h: New file from Robert Brown.

    * ns32k.md: Use %c in some addr insns.
    (tst*): Use {d,f,}const0_rtx to make the constant 0; OS-independent.
    (call, call_value): Use %? before address in a bsr.

    * output-ns32k.c (print_operand_address): To output a local label,
    use `output_asm_label'.
    Make SEQUENT_ADDRESS_BUG conditionals happen at compile time.

    * tm-ns32k.h: Delete SEQUENT_HAS_FIXED_THEIR_BUG.
    (PRINT_OPERAND): Output nothing for `%?'.
    * tm-sequent.h: (PRINT_OPERAND): Output nothing for `%?'.

    * final.c (output_asm_label): No longer `static'.

Thu May  5 09:03:37 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * explow.c (memory_address): Ignore flag_force_reg unless optimize.
    Also ignore it for addresses of stack slots (avoid invalid REG_EQUIVs).

    * typecheck.c (digest_init): If traditional, allow `char x[100]=0;'.

    * tree.c (get_unwidened): Don't alter a COMPONENT_REF if
    innerprec equals the precision of the existing type.
    It was changing pointers to integers.

    * m68k.md (movdi): Put all fpregs in separate constraint alternatives
    and handicap them so spill reg won't be an fp reg.

    * parse.y (yyerror): Use the arg as part of the error message.

    * decl.c (start_function): Give the RESULT_DECL type int rather
    than char or short.
    * typecheck.c (c_expand_return): Convert value from fn's return type
    to the RESULT_DECL's type.

    * Avoid generating dbx xrefs to enums, since dbx loses on them.
    Do this by outputting all types in order of definition.
    This is done only for top-level types; problem remains for local ones.

    * decl.c (finish_decl): Do rest_of_decl_compilation for TYPE_DECLs.
    * toplev.c (rest_of_decl_compilation): Do dbxout_symbol for them.

    * dbxout.c (dbxout_symbol): Check DECL_RTL only for fns and variables.
    For a TYPE_DECL, ignore it if the type was already output
    and its preferred name is the TYPE_DECL.  Else output type in full.

    * decl.c (pushdecl): Don't prefer typedef names to type tag names.

    * stor-layout.c (chain_type): Build chain in forward order.


    * tm-3b1.h (ASM_OUTPUT_CASE_LABEL): Error getting length of table.

    * tm-3b1.h: #define SGS_3B1 was missing.

    * typecheck.c (build_compound_expr): Ignore non-volatile subexprs.

    * fold-const.c (fold): Simplify (unsigned) foo >= 0, etc.

    * stor-layout.c (layout_type): Set TYPE_PRECISION of ptr types.

Wed May  4 08:06:25 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * parse.y: Don't use the Bison @ construct, since it makes parser slow.

    * decl.c (finish_function): Delete FILENAME and LINE args.

    * typecheck.c (digest_init): No pedantic warning for array="string".

Tue May  3 09:09:30 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * toplev.c (main): Ignore `-Wcomment'.
    * gcc.c: Pass -Wall to cpp (which treats it like -Wcomment).

    * tm-isi68.h: Greatly simplified; now works only with GAS.

    * tm-m68k.h (EMPTY_FIELD_BOUNDARY): now 16 (right on Sun, ISI and HP).
    * tm-sun3.h: No need to redefine it.

    * decl.c (finish_struct): Don't ever make DECL_ALIGN smaller.

    * decl.c: Rename min, max to MIN, MAX.

    * typecheck.c (convert_for_assignment): Avoid warning if assigning
    a `void *' from a `const void *'.

    * combine.c (FAKE_EXTEND_SAFE_P): Turn off for mem refs; avoid faults.

Mon May  2 07:28:27 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * tm-vax.h: Support -mg switch to use g-float instead of d-float.
    New macros TARGET_G_SWITCH, ASM_DOUBLE_CHAR.
    Changes in TARGET_SWITCHES, ASM_OUTPUT_DOUBLE.
    Define code `#' for PRINT_OPERAND.
    * vax.md: use `#' in opcodes for doubleword float.

    * tm-vax.h: Define UDIVSI3_LIBCALL and UMODSI3_LIBCALL.

    * cccp.c (main, do_include): Implement -I- switch.

    * jump.c (jump_optimize): When hunting NOTE_INSN_FUNCTION_END,
    skip final RETURN (found on the vax).

    * toplev.c (main): -Wall is equiv to all -W switches combined.

    * stmt.c (expand_decl, expand_end_bindings,
    expand_{start,end}_function).  The -noreg treatment of `register' vars
    is extended to vars used as addresses of vars in memory (varying-size
    structures).
    (use_variable): Emit USE for regs used in specified rtx.

    * cse.c (fold_cc0): Stack-frame addresses are always nonzero.
    (fold_rtx): 0200 bit in prev_insn_cc0 means only zeroness is known.

    * parse.y (parmlist): poplevel needs 3 args.

Sun May  1 07:20:34 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * decl.c (start_function): typo checking for incomplete return type.

    * emit-rtl.c (restore_reg_data): If a pseudo appears nowhere,
    don't leave its slot empty; create a pseudo for that slot.

    * Version 1.21 released.

    * expr.c (expand_call): Merge duplicate code for structure_value_addr.

    * emit-rtl.c (restore_reg_data): Delete error check; it's legit for
    a pseudo reg to appear nowhere in the rtl.

Sat Apr 30 07:35:31 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * integrate.c (copy_rtx_and_substitute): Fix typo for arg_pointer_rtx.

    * decl.c (poplevel): Undo previous change with #if 0.

    * stmt.c: `struct nesting' now records the depth on the stack.
    Each expand_start... must update and record the depth;
    each expand_end... uses macro POPSTACK to pop.
    This way, if a level isn't explicitly popped, it won't cause
    circular structure.

    * dbxout.c (dbxout_type): Replace with main variant only if incomplete.

    * typecheck.c (build_unary_op): Test of `pedantic' was backwards.

    * expr.c (STACK_BYTES): Typo in definition.

    * typecheck.c (build_binary_op_nodefault): Rename code1 to code0,
    a

    * expr.c (expand_call): Wrong arg order for warning_with_decl.

Fri Apr 29 08:41:06 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * integrate.c (copy_decl_tree): New arg is depth in recursion.
    Always discard the outermost LET_STMT being copied; never discard any
    others.  This way the copied LET_STMTs correspond to the copied NOTEs.

    * varasm.c (decode_rtx_const): For SYMBOL_REF, use string address
    not address of the rtx.  Library fns have only one copy of the name
    but many copies of the SYMBOL_REF.

    * expr.c (emit_call_1): New arg OLD_ARGS_SIZE is used to reset
    current_args_size.
    (emit_library_call, expand_call): Pass new arg; don't restore it here.

    * flow.c (life_analysis): Don't mark sp live at end if fn is empty.

    * parse.y (parse_or_identifiers_1): Handle `error' in here, not in
    callers notype_declarator etc.  Also read the closeparen here.

Thu Apr 28 12:43:52 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * expmed.c (expand_shift): In extzv strategy, handle the operand
    predicates for operands 0, 1 and 3.  (Not needed for 2.)
    * vax.md: extzv pattern for SImode op1 must recognize general_operand
    since the pattern named "extzv" allows them.

Wed Apr 27 00:52:44 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * expr.c (emit_call_1): New arg NEXT_ARG_REG describes # regs
    used for passing args.
    (emit_library_call, expand_call): Provide that argument.

    * explow.c (round_push): New fn: round arg up to STACK_BOUNDARY.
    * expr.c (expand_builtin): Use round_push on size for __builtin_alloca.
    * stmt.c (expand_decl): Likewise for variable-size objects.
    * expr.c (expand_call): Likewise for args_size.var.
    Also use STACK_BOUNDARY to round a constant arg-block size.
    Pass emit_call_1 that rounded value.
    (emit_library_call): Round arg_size with STACK_BOUNDARY.
    * tm-spur.h: Define STACK_BOUNDARY instead of ROUND_CALL_BLOCK_SIZE.
    * tm-m68k.h: Define STACK_BOUNDARY as 16.

    * expr.c (emit_call_1): Don't change current_args_size.
    (emit_library_call, expand_call): Always restore current_args_size
    to ambient value, after calling emit_call_1.

    * tm-hp9k320.h: Don't define USG here.
    * config-hp9k3.h: New file.  USG defined here.

    * tm-3b1.h: #undef ASM_OUTPUT_ASCII (a defn came from tm-hp9k320.h).

    * decl.c (grokdeclarator primarily): Cast all RID_... to (int) before
    using them in arithmetic.  Placates CC on Sequent.

    * emit-rtl.c (emit_jump_insn): Return proper value, for a SEQUENCE.
    * emit-rtl.c (emit_call_insn): Handle SEQUENCE like emit_jump_insn.

Tue Apr 26 02:41:26 1988  Richard Stallman  (rms at lucky-charms.ai.mit.edu)

    * cccp.c (macroexpand): If traditional, don't disable called macro.
    (macarg1): Was failing to count backslash-newline inside a string
    in a macro arg as part of file's linenumber.

Mon Apr 25 18:46:53 1988  Richard Stallman  (rms at lucky-charms.ai.mit.edu)

    * jump.c (jump_optimize): Don't do April 20 optimization on first
    iteration; let other simpler opts be done before this is considered.

Sun Apr 24 02:45:28 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * tree.c (staticp): a CONSTRUCTOR can be static.

    * varasm.c (output_constant_def): Always return memref, not address.

    * decl.c (complete_array_type): New fn, make an array type complete
    based on an initializer.
    (finish_decl): Use complete_array_type.
    * parse.y (expr_no_commas): When parsing a constructor,
    Use complete_array_type    on constructors for incomplete array types.

    * typecheck.c (digest_init, store_init_value,process_init_constructor):
    It's now TREE_STATIC, not TREE_ADDRESSABLE, that records that all elts
    in a CONSTRUCTOR are simple constants.
    (digest_init): A CONSTRUCTOR with non-null type is treated as ordinary
    expression, not as a braced initializer.
    Allow init of an array from an array-valued expr; warn if pedantic.
    * expr.c (expand_expr, CONSTRUCTOR case): Put in memory only if static.
    Was making an extraneous level of MEM; output_constant_def does it all.

    * typecheck.c (build_unary_op): Allow ADDR_EXPR of static CONSTRUCTOR.
    (default_conversion): Likewise.
    (initializer_constant_valid_p): Constructor is ok if static.

    * gcc.c: Change -fnostd... to -nostd...
    * cccp.c (main): Likewise.

    * Everywhere: Use REG_NOTE_KIND to get the kind of a reg note.

    * rtl.c (find_regno_note): New function.
    * flow.c (flow_deadp): Deleted; caller uses find_regno_note.
    * global-alloc.c (reg_dead_p): Deleted.
    (global_conflicts): Use find_regno_note instead of reg_dead_p.

    * final.c (final) Use find_reg_note to look for a REG_INC.
    * combine.c (insn_has_inc_p): deleted; callers use find_reg_note.
    (try_combine): Use find_reg_note whenever looking for a REG_INC.
    (regno_dead_p, remove_death): Check the REG_NOTE_KIND before assuming
    that the datum in it is a REG.
    * reload1.c (reload): Use find_reg_note to find a REG_EQUIV.

    * gcc.c: Don't delete .o files if not all compilations succeed.
    (record_temp_file): New arg SUCCESS_ONLY--delete file only if succeed.
    (delete_temp_files): New arg SUCCESS says compilation succeeded.
    (store_arg): Now 3 possibilities for arg TEMPNAMEP; 2 = del on success.
    (do_spec_1): For %d, set delete_this_arg to 2.

    * decl.c (poplevel): Warn about any still-incomplete type-tags.

Sat Apr 23 02:54:16 1988  Richard Stallman  (rms at rice-krispies.ai.mit.edu)

    * expr.c (expand_builtin): For alloca, round arg up to multiple
    of PARM_BOUNDARY.  Also to convert it to Pmode unless it already is.

    * stor-layout.c (layout_union): Bug in 14 April change:
    use caller-specified alignment as minimum, not as maximum.

    * parse.y (skip_white_space): Avoid infinite loop on unterm. comment.

Fri Apr 22 00:22:59 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * cccp.c: Text following #else or #endif is just a warning.
    (rescan): Digit-case was dropping into the $-case; reorder.

    * cccp.c (rescan): Comment start when -traditional was output as
    `/*'; should be nothing.

    * jump.c (jump_optimize): Fix prev change:
    do nothing if range1end == range2end;
    don't lose any NOTEs when splicing.

    * flow.c (propagate-block): For CALL_INSN, clobber the call-used regs
    only after mark_set_regs is done; avoids confusion about lifespan
    of function value reg.

    * gcc.c: Pass -Wcomment to cpp.

    * cccp.c (main, rescan): If -Wcomment, warn if `/*' inside comment.

    * decl.c (duplicate_decls): Ignore `inline' decl following definition.

    * m68k.md (casesi): Split it up into subroutines, so insns emitted
    by the call to memory_address (on 68000) come in the right place.

    * combine.c (record_dead_and_set_regs): Notice storing in a SUBREG.

    * integrate.c (expand_inline_function): Insn to copy a subroutine's
    return-value was being output twice, once incorrectly.

    * reload.c (find_equiv_reg): A stack-push insn does not invalidate
    an equiv for a goal in memory.
    Any other write to memory does invalidate any goal in memory
    (PARALLEL case failed to check for this).

    * expmed.c (expand_shift): In the extzv clause, force shifted value
    out of memory if -fforce-mem.

    * print-tree.c (prtypeinfo): Some attributes were missing.
    (dump): In ..._TYPE nodes, ignore the TREE_CHAIN field.

    * cse.c (note_mem_written): Pushing on stack does not invalidate mem.

    * vax.md (extv/andl peephole opt): Made incorrect code if output was
    pushed on stack.  Added special case code.
    (extv, extzv for SImode operand): Require register_operand.

Thu Apr 21 00:24:52 1988  Richard Stallman  (rms at corn-chex.ai.mit.edu)

    * stmt.c (assign_parms): Round current_function_pretend_args_size up.

    * integrate.c: `pushlevel' arg was missing.

    * dbxout.c (dbxout_type): Undo rest of March 29 change:
    When a named type is first seen inside another type, output an xref
    and let the real definition come out later.
    It is strange that Sun dbx has sometimes appeared to demand
    one strategy and sometimes appeared to demand the other.

    * typecheck.c (convert_for_assignment): Allow conversion to or from
    `const void *', etc., unless pedantic.

    * decl.c (get_parm_types): For `foo (void){}', set last_function_parms
    to nil so store_parm_decls won't lose.

    * combine.c (subst): (plus (plus X N) -N) => X.

    * explow.c ({anti_,}adjust_stack): Don't make a copy of
    `stack_pointer_rtx'.

    * integrate.c (expand_inline_function): Typo testing for the
    USE that indicates a CALL_INSN's value is being returned.

    * expr.c (expand_builtin, alloca case): Copy arg to reg before
    adjusting stack, to avoid invalid insns on some machines.

Wed Apr 20 00:15:14 1988  Richard Stallman  (rms at rice-krispies.ai.mit.edu)

    * typecheck.c (build_binary_op_nodefault): When shortening,
    get_narrower may make no change because ARGn is already narrow.
    In this case, set UNSIGNEPn from ARGn's type.

    * typecheck.c: Rename ARG1,ARG2 to ARG0,ARG1, etc. in several fns.

    * tm-vax.h: Turn off continuation on DBX output.

    * typecheck.c (build_function_call): Don't change __builtin_ffs to an
    FFS_EXPR.  Note that __builtin_alloca has always made a CALL_EXPR.
    * expr.c (expand_builtin): New function expands all CALL_EXPRs that
    are really built-in functions.
    (preexpand_calls): Do nothing to a CALL_EXPR for a built-in function.

    * loop.c (count_loop_regs_set): Don't move a reg that is in a CLOBBER.

    * stupid.c (stupid_mark_refs): Was getting hard reg's mode from
    the wrong place.

    * rtl.c (note_stores): Typo in checking vector elt for SET vs CLOBBER.

    * stmt.c (expand_end_bindings): If restoring stack level,
    first do pending stack adjust (so it won't be done erroneously after).
    (expand_goto): likewise.

    * rtl.h: LABEL_NUSES was an rtx.  It should be an int.
    * stmt.c (expand_label, expand_goto): Delete frobbing with LABEL_NUSES;
    the value stored there was the same as the CODE_LABEL rtx.

    * jump.c (jump_optimize): Detect  if (foo) ...; else { ... break;}
    and change to  if (! foo) { ... break;} else ...; so can drop out.
    (next_label): New fn returns the next label after given insn.

Tue Apr 19 21:30:05 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * flow.c (insn_dead_p): Delete special handling for stack ptr.
    (mark_set_regs, mark_used_regs): Likewise.
    (life_analysis): Mark stack ptr live at end of fn if necessary.
    (propagate_block): Mark stack ptr live leading up to a CALL_INSN.

    * jump.c (jump_optimize): #if 0 around stack-adjust-deletion code.

    * cse.c (fold_rtx): Change const_arg from an array to 3 separate
    scalars for the first three operands.
    Handle SIGN_EXTEND and ZERO_EXTEND.

    * integrate.c (copy_rtx_and_substitute): If arg is 0, return 0.
    (expand_inline_function): Separate vars for old pattern and new insn.

    * expr.c (expand_call): Set TREE_ADDRESSABLE if call is not inlined.

Tue Apr 19 02:25:22 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * Version 1.20 released.

    * tm-ns32k.h: Define new reg class GEN_OR_FLOAT_REGS
    so that GENERAL_REGS and FLOAT_REGS have a union.

    * tm-ns32k.h (GO_IF_LEGITIMATE_ADDRESS): Recognize a stack-push.
    * ns32k.md: Many constraints must now allow or reject pushes.
    Delete the special patterns for pushing.

Mon Apr 18 06:02:39 1988  Richard Stallman  (rms at rice-krispies.ai.mit.edu)

    * reload1.c (forget_old_reloads): For a multiword hard reg,
    forget old reloads for each word.

    * reload.c (find_reloads): Typo in calling push_replacement.

    * tm-ns32k.h (HARD_REGNO_MODE_OK): Failed to allow fp regs for SFmode.

Sun Apr 17 01:21:35 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * tm-sequent.h (PRINT_OPERAND): Handle absolute integer memaddress.

    * ns32k.md: Add DImode push insns.  Add QImode and HImode push insns.
    Supply missing statement in movsf.

    * dbxout.c (dbxout_type): Don't contin before 1st field of struct.

    * dbxout.c (dbx_continue): Use DBX_CONTIN_CHAR instead of backslash.

    * loop.c (scan_loop): Ov vax, the "loop-entry jump" can be a return,
    in which case perhaps there is no label following it.
    Detect phoniness of loop before looking for that label.

    * decl.c (init_decl_processing): Builtin fn names start with `__'.

    * typecheck.c (shorten_compare): Warn about constant result only in
    cases like (char)x < 0x80, where old C compilers made it -0x80.

    * vax.md: All jbs/jbc/jlbs/jlbc patters with op0 in SImode
    must reject mode-dependent memory addresses.

    * recog.c (mode_independent_operand): Test for general operand
    that doesn't have a mode-dependent memory address.

    * varasm.c (assemble_function): ASM_DECLARE_FUNCTION_NAME, if def,
    is now responsible for outputting the function name as a label.

Sat Apr 16 05:02:55 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * cccp.c (do_xifdef): Warn about punctuation or other junk in argument.
    Warn about no argument.  If pedantic, warn if arg starts with digit.
    If traditional, ignore all after first non-idchar and never warn.

Thu Apr 14 01:12:59 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * integrate.c (expand_inline_function): Typo for addressable parms.

    * cse.c (insert_regs): Copying half a DImode into half of another
    does not make the two DImode regs equivalent.

    * recog.c (general_operand): Was failing to accept symbol_ref:SI
    when MODE arg was VOIDmode.

    * expr.c (preexpand_calls): For RTL_EXPR, do nothing.

    * decl.c (start_enum, build_enumerator): Remember default for next one
    as a tree node (so the high-half isn't lost in a negative one).

    * stor-layout.c (layout_{record,union}): Pay attn to initial value
    of TYPE_ALIGN in computing final alignment.
    (layout_union): Round size up to multiple of the alignment.

    * decl.c (finish_struct): Don't alter size after type is laid out.
    Instead, set TYPE_ALIGN before layout_type.

    * reload1.c (choose_reload_targets): Introduce reg_has_output_reload.
    If there are two separate reloads (one in and one out)
    for the same (hard or pseudo) reg, always set reg_last_reload_reg
    based on the output reload.

Wed Apr 13 21:26:16 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * reload.c (find_reloads_address_1): Always barf if a "constant"
    register is autoincremented.

    * parse.y (structsp): suspend_momentary before start_enum;
    else some nodes made by start_enum might be momentary.

    * stmt.c (expand_start_case): New arg is nominal type for comparison
    (which is the promoted type of the index expression).
    (pushcase): Always convert VALUE to that nominal type
    before validating it.
    * parse.y (case stmt): Promote each case-value before pushcase.
    * typecheck.c (c_expand_start_case): Promote the index-expr
    to determine the nominal type, before get_narrower.

Wed Apr 13 12:43:08 1988  Chris Hanson  (cph at kleph)

    * tm-hp9k320.h: Define ASM_FORMAT_PRIVATE_NAME.  HPUX asm forbids
    `.' in identifiers, so use `___' (there is some danger in this choice).

Tue Apr 12 23:26:48 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * local-alloc.c (block_alloc): Make 1 extra slot in regs_live_at.

    * stmt.c (optimize_bit_field): Function moved from reload1.c.
    When need to generate a SIGN_EXTEND or ZERO_EXTEND, make it a separate
    insn and use gen_extend_insn to make it.
    * optabs.c (gen_extend_insn): New fn, construct body of an insn
    to extend Y and store in X.

Mon Apr 11 19:20:57 1988  Richard Stallman  (rms at rice-krispies.ai.mit.edu)

    * decl.c (finish_decl): Error if static var has variable size.

    * parse.y (yylex): Warn if int const is out of range.

    * parse.y: New keyword __alignof.
    * typecheck.c (c_alignof): Given a type, return its alignment in bytes.

    * typecheck.c (c_sizeof{,_nowarn)): Don't return integer_one_node;
    use build_int to make sure we get something with type `sizetype'.

    * Support variable-sized structures (containing var-sized arrays).

    * stmt.c (assign_parms): Handle parms whose size varies.
    Use `memory_address' when constructing memrefs to args;
    no need to set `invalid_stack_slot'.
    Don't make a REG_EQUIV note for a scalar arg at variable offset.
    * stor-layout.c (genop, build_int): No longer `static'.

    * stor-layout.c (convert_units): Optimize ceil (ceil(x,2)*2, 4) etc.

    * stmt.c (expand_decl): Don't abort if var-sized object has init.
    Convert variable size from units of DECL_SIZE_UNIT to units of bytes.

    * expr.c (emit_push_insn): Arg ARGS_SO_FAR is now an rtx.
    Pay attention to ARGS_ADDR even if machine has push insns.
    (expand_call): Handle variable-sized arguments.
    If have any such, push entire arg-block in advance.
    Record each arg's offset during first loop and don't change args_size
    during the actual pushing loop; this way the actual pushing loop
    works regardless of arg-order if arg-block was pushed in advance.
    (push_block): Copy SIZE to reg unless it's a reg or constant.

    * expmed.c (expand_divmod): If converting CEIL_DIV to FLOOR_DIV,
    make new pseudo for incremented value, to help cse understand.

Sun Apr 10 00:07:45 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * expr.c (emit_library_call): Two dumb bugs calling emit_call_1.

    * dbxout.c (dbxout_symbol): Handle case of (MEM (REG frameptr)).

    * cccp.c (skip_if_group): Ignore quote-chars if -traditional.
    (rescan): If -traditional, don't output a space for a comment.
    (handle_directive): If not -traditional, output a space for a comment.

Sat Apr  9 21:26:51 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * decl.c (get_parm_types): `void' type is error, except as entire list.
    * parse.y (parmlist_1): `void,...' is error.

    * typecheck.c (pointer_int_sum, pointer_diff):
    Use an integer type with at least POINTER_SIZE bits.
    * expr.c (expand_expr, ARRAY_REF): Likewise.
    * tree.c (type_precision): Prec of a pointer is POINTER_SIZE.
    (convert_to_pointer): Directly convert any int w/ width==POINTER_SIZE.
    Other int types convert via an int of that width.
    (convert_to_integer): Pointers convert via an int of that width.

    * decl.c (init_decl_processing): Use INT_TYPE_SIZE, if def,
    to set width of `int' and `unsigned int'.
    (make_index_type): Give new type the width of a long int.

    * tm-m68k.h: Add new -mshort which controls TARGET_SHORT.
    * tm-m68k.h: Define INT_TYPE_SIZE depending on TARGET_SHORT.

Fri Apr  8 05:02:59 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * typecheck.c (require_complete_type): Fix typo in detection of `void'.
    (build_function_call): Fix backward test to allow `void' values.

    * dbxout.c (dbxout_tags): Output each tag once even if type is defined.

    * m68k.md (movstrictqi): Reject addr-reg always, for both operands.

    * tm-vax.h (STRUCTURE_SIZE_BOUNDARY): Make this always 8, for BSD.
    * tm-ultrix.h: New file, overriding STRUCTURE_SIZE_BOUNDARY.
    [This change has been taken out; tm-ultrix.h is now equivalent to
    tm-vax.h.  I must have been confused when testing PCC.]

    * integrate.c (expand_inline_function): Don't let inline_target
    be nonzero in BLKmode.

    * decl.c (grokdeclarator): Const array parm becomes ptr-to-const.

Thu Apr  7 05:02:41 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * genoutput.c (bcopy, bzero): Renamed to mybcopy, mybzero
    so variation in C library and config.h won't affect the results.
    * genrecog.c (bzero): likewise.
    * genextract.c (bcopy): Fn deleted; used only in a string constant.

    * varasm.c (force_const_mem): Fix typo in arg decl.

    * toplev.c (compile_file): init_file with main_input_filename
    so dbx output doesn't lack N_SOL symbols.

    * cccp.c (rescan) [CPLUSPLUS]: Put out // comments as // comments.

Wed Apr  6 14:06:38 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * expr.c: Delete SLOW_ZERO_EXTEND conditionals added March 3.
    Now that enums types can be unsigned, this isn't needed.

    * emit-rtl.c (emit_jump_insn): Handle SEQUENCEs.

    * genemit.c (gen_expand): Use emit_jump_insn, emit_label, emit_barrier
    when the insn rtl requires it.

    * m68k.md (subsi3): Prefer to avoid reverse-subtraction alternative.

    * stmt.c (expand_end_case): Let CASE_DROPS_THROUGH control what to
    emit after the table.
    * tm-vax.h: Define CASE_DROPS_THROUGH.

Tue Apr  5 15:47:10 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * genemit.c (gen_exp): Handle vectors within exprs.

    * stmt.c (expand_end_case): Pass 5th arg (default_label) to gen_casesi.
    * m68k.md: Define casesi insn rather than tablejump insn.

    * cccp.c (skip_if_group): For validate_else, pass BP (end of cmd name).
    Don't call validate_else if do_else or do_endif will detect error.

    * Bug: inline fcns can refer to the return reg with a strict_low_part
    which confuses expand_inline_function.  Fix is to change return reg
    into inline_target *everywhere* except in or right after a call.
    * integrate.c (copy_rtx_and_substitute): Delete special case for SET.
    Replace return-value hard regs with INLINE_TARGET in all contexts.
    (expand_inline_function): special handling for insn after a CALL_INSN
    if it copies the function value out.
    Allow notes and stack adjust insns to intervene
    between the CALL_INSN and the value-copy.

    * expr.c (emit_call_1): New name for gen_call_1.

    * Bug: ({...}) insns were in wrong place for a subexpression
    after a sequence point, as in x ? y : ({...}).
    * tree.def: New tree-code RTL_EXPR holds a sequence.
    * expr.c (expand_expr): Handle RTL_EXPR by emitting the sequence.
    * stmt.c (expand_{start,end}_stmt_expr): Use emit_to_sequence
    to make a sequence from everything within the ({...}).
    (expand_{start,end,emit}_delayed_expr): Delete these functions.
    * parse.y (`for'-statements): Don't call them; nothing special needed.

    * parse.y (yylex): Handle syntax L"..." and L'...'
    (combine_strings): Handle wide strings being combined.
    * typecheck.c (digest_init): Reject wide string as init for char array.
    Allow it for an int array, but don't allow a narrow string.
    * decl.c (init_decl_processing): New var int_array_type_node.

    * parse.y: Define keyword `noalias'.
    * parse.h: Define RID_NOALIAS.

    * typecheck.c (compparms): Not all parmlists match an empty one;
    call `compparms1' to filter them.

    * decl.c (groktypename): Remove special case for `void' as parameter.
    (get_parm_types): Special case for list of one decl with type void.

    * decl.c (build_enumerator): Give enum constants the type `int'.
    Variable `current_enum_type' eliminated.
    (finish_enum): No need to repeat `fixup_unsigned_type'
    since the precision has not changed.
    * stor-layout.c (layout_type): Allow enum types to be unsigned.

    * emit-rtl.c (unshare_all_rtl): Unshare contents of all reg-notes.

    * parse.y (check_newline): filename is optional in #-lines.

Mon Apr  4 14:36:54 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * typecheck.c (shorten_compare): When data type determines the value,
    eval the nonconstant arg anyway if it has side effects.
    (build_conditional_expr): When merging `foo *' with `void *',
    also allow `const void *'.  Result type has merged set of qualifiers.
    (qualify_type): Merge qualifiers of two types.

    * decl.c (get_parm_types): Store any tags defined in parmlist
    into `last_function_parm_types'.
    (store_parm_decls): Add those tags into the current binding level.

    * parse.y (parmlist, parmlist_or_identifier): Pass 0 to pushlevel;
    no binding levels in C should be transparent to tags.

    * 3b1 support:
    * tm-3b1.h: New file.

    * m68k.md: Add HPUX_ASM conditionals for shift-by-24-and-compare.
    In one of the dbra patterns, a HPUX_ASM conditional was backwards.
    (movhi) [SGS_3B1]: Define the LI... label as in MIT syntax.
    (addsi3) [SGS]: Syntax for base-displacement differs from MOTOROLA.
    (subsi3) [SGS]: likewise.
    (tablejump) [ASM_OUTPUT_CASE_LABEL]: Use 6, not 2, as displacement.
    This assumes ASM_OUTPUT_CASE_LABEL on 68k is used for a `swbeg'.

    * final.c (final): Use ASM_OUTPUT_CASE_LABEL (if defined) to output
    any CODE_LABEL followed by an ADDR_VEC or ADDR_DIFF_VEC.
    It has 4 args; 4th is the insn which is the ADDR_VEC or ADDR_DIFF_VEC.

    * tm-*.h for 68000 (PRINT_OPERAND_ADDRESS): For unscaled indexing in
    fetch from a branch table, use L and LI symbols as in the scaled case.

    * cccp.c: If SCCS_DIRECTIVE, define #sccs as no-op.

    * integrate.c (output_inline_function): Real start of function
    is FIRST_PARM_INSN, not FIRST_FUNCTION_INSN.

    * tree.c (build_string): String contents must be saveable (for
    inline fcn).

    * cse.c (cse_insn): Don't forget to set dest_hash_code when dest
    is a stack slot (and so its address is not being optimized).

    * emit-rtl.c (restore_reg_data_1): reg_rtx_no must be 1+ largest REGNO.

    * m68k.md (non-SImode bit-field insns): Change constraint to "o,d"
    so a nonoffsetable memref is handled by reloading its address
    but a register can still be handled.

    * toplev.c (main): Execute OVERRIDE_OPTIONS, if it's defined.

Sat Apr  2 00:55:21 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (convert_move): Handle a SUBREG in direct truncation case.

    * cse.c (lookup_for_remove): Don't test machine mode of registers:
    Storing in (REG:SI 0) invalidates (REG:DF 0).

    * decl.c (pushlevel): New arg, nonzero means this level is for
    variables only, not for tags.  All calls changed.
    (lookup_tag): Even if THIS_LEVEL_ONLY, skip variables-only levels.
    (pushtag): Define it in the first non-variables-only level.

    * dbxout.c (dbxout_type): Undo Mar 29 change, in the DBX_NO_XREFS case.
    So now each struct or union will contain only nameless cross-refs
    to any others it uses.  The prior change is still in effect when
    DBX_NO_XREFS is not defined.

    * Implement variable array bounds for parameters.
    * decl.c (poplevel): Don't crash if DECL_NAME gives 0.
    * typecheck.c (comptypes): A variable array bound matches anything.
    * parse.y (parmlist): Call pushlevel, then pushdecl each parm as it
    is parsed; then poplevel after using get_parm_types to extract the
    results of the parmlist.
    * decl.c (get_parm_types): New function; reverse the current decls,
    put them in last_function_parms, and return a list of their types.
    (grokparms): Arg is now an idlist or a typelist.  Do nothing if latter.
    (push_parm_decl): New function, like {start,finish}_decl combined
    for a parm in a parmlist.

    * dbxout.c (dbxout_symbol): Ignore sym if its DECL_RTL is 0.

    * symout.c (symout_block_symbols): Ignore sym if type is error_mark.

Fri Apr  1 11:41:21 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (prepare_call_address): New function; given two rtx's
    for function and context, copy the context to the right hard reg,
    put the function address in the right place and return an rtx for it.
    (gen_call_1): No longer do those things.  Delete args CONTEXT, PROTECT.
    (emit_library_call, expand_call): Call `prepare_call_address'.
    In between that and `gen_call_1', USE the parm registers.

    * tm-hp9k320.h (ASM_OUTPUT_*): Flush uses of output_arith_constant.

    * varasm.c (assemble_variable): Use ASM_FORMAT_PRIVATE_NAME
    to make the name for a local static variable.
    * tm-m68k.h, tm-vax.h, tm-ns32k.h, tm-spur.h:
    Define ASM_FORMAT_PRIVATE_NAME.  Use `.', not `$', to separate.

    * tm-m68k.h, tm-ns32k.h (FIX_FRAME_POINTER_ADDRESS):
    To refer to stack ptr, use stack_pointer_rtx, not a copy.

    * tree.c (build_real_from_string): Function deleted.
    * parse.y (yylex): Use build_real and atof.

    * parse.y: Allow string concatenation in arg of asm.

    * parse.y (yylex): Always allow `$' in ident, but warn if pedantic.
    * tm-vms.h: Delete DOLLARS_IN_IDENTIFIERS (no longer tested).

    * cccp.c (rescan, do_define, initialize_random_junk):
    Always allow `$', but warn if pedantic.
    (main): If -t, set `traditional'.
    (collect_expansion): If `traditional', no special handling for quotes
    and no whitespace added at end of macro definition.

    * expr.c (compare, compare1): Last arg to compare_constants
    must be a size in bits.

Thu Mar 31 00:31:52 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expmed.c (expand_mult, expand_divmod, extract_fixed_bit_field):
    Reject function return register as target if may need to read it.
    (Reading the return register in an inline function doesn't work.)

    * decl.c (start_function): Delete extra arg to `error'.

    * emit-rtl.c (last_parm_insn): Delete this unused var.

    * make-cc1.com: New version from Kashtan.

    * integrate.c (expand_inline_function): Always set up an INLINE_TARGET
    for a function that returns a nonvoid nonBLK value.
    Since `pushlevel' and `poplevel' are called, must also call
    `expand_{start,end}_bindings' to make a pair of NOTEs.
    Let them handle USEs at end of scope of formal parameter copies.

    * integrate.c (expand_inline_function): In a new-style CALL_INSN,
    don't change the result reg into INLINE_TARGET.  Also,
    generate a move insn after the call only if INLINE_TARGET is non-0.

    * integrate.c (copy_decl_tree): Don't crash if DECL_RTL is 0.

    * integrate.c (copy_for_inline): Don't treat `return' rtx's specially.

    * stmt.c (expand_{start,end,emit}_delayed_expr):
    New fns to handle ({...})'s in expressions output not where parsed
    (such as third expression in a `for' statement).
    * parse.y: Call them to handle third expression in a `for'.

    * decl.c (duplicate_decls): Result is `inline' if either OLD or NEW is.

    * emit-rtl.c (emit_note): Return the note, or 0 if none.
    * stmt.c (expand_start_bindings): Use emit_note's value.

Wed Mar 30 12:48:22 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * obstack.c (_obstack_begin): If ALIGNMENT is 0, use default.
    Compute default for the alignment of a `double'.
    * obstack.h (obstack_{begin,init}): Pass 0 for the alignment.

    * flow.c (mark_used_regs): Discard multiple SUBREGs, STRICT_LOW_PARTs.

    ** Call insns that return values are now represented as
    (set (reg ...) (call ...)), not just (call ...).

    * *.md: Define a "call_value" insn pattern.

    * tm-m68k.h, tm-vax.h, tm-ns32k.h: (NOTICE_UPDATE_CC):
    These insns invalidate the CC.

    * local-alloc.c (combine_regs): #if 0 special treatment of
    function value hard reg.
    (wipe_dead_reg): If hard reg, call reg_is_born so that the death
    will not be ignored.
    (reg_is_set): For reg that dies in this insn, mark it dead from now on
    and post_mark it live after this insn only.

    * combine.c (try_combine): Don't allow a call insn as I1 or I2.

    * loop.c (count_loop_regs_set): Move CALL_INSN into a separate
    clause.  When finding regs that are function addresses, handle
    both old and new format call insns.

    * flow.c (insn_dead_p): A SET that contains a CALL can't be dead.
    (volatile_refs_p): Any CALL constitutes a volatile ref.
    (mark_used_regs): If setting a reg from a volatile ref,
    treat it like setting a reg whose value will be used.

    * expr.c (gen_call_1): New arg VALREG if nonzero means generate
    a call_value insn which stores in VALREG.
    (expand_call): Use `hard_function_value' to make the VALREG arg
    unless expression has type `void'.

    * expr.c (emit_library_call): New 2nd arg OUTMODE is mode of result.
    (So can give gen_call_1 the proper value-register.)
    All callers (here and optabs.c) pass this arg.

    * cse.c (canon_hash): Consider all CALL rtx's volatile.

    ** end of change in representation of call insns.

    * stmt.c (expand_asm_operands): Replace complex lvalues with
    SAVE_EXPRs here
    * typecheck.c (c_expand_asm_operands):  rather than here.

    * typecheck.c (pointer_diff): Fix typo preventing use of FLOOR_DIV_EXPR
    when dividing by power of 2.
    (build_c_cast): Flush unused locals.
    (store_init_value): likewise.
    (process_init_constructor): Delete unused 4th arg `for_static'.

    * toplev.c (fatal_io_error): Arg to fprintf was missing.

    * tm-m68k.h (LEGITIMIZE_ADDRESS): Flush extra arg to `emit_move_insn'.

    * decl.c: Delete some unused local vars.

    * stor-layout.c (layout_decl): `packed_size' now unsigned.

Tue Mar 29 14:47:07 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * Version 1.19 released.

    * loop.c (may_trap_p): Nonzero if X is a division that might trap.
    (scan_loop): If insn might trap, move only if loop always executes it.

    * dbxout.c (dbxout_type): Never output a cross-ref for
    a type whose definition is known.  Sun dbx won't accept them.

Mon Mar 28 12:34:46 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * tm-vms.h (TARGET_DEFAULT): Default is PCC alignment.
    The VMS compile driver controls the real default.

    * typecheck.c (c_expand_return): Don't ignore return value
    when its type is void.

    * final.c (final): Forget the condition codes after an `asm'.

    * typecheck.c (build_binary_op_nodefault): Warn about ptr < 0
    even if not pedantic, but not if traditional.

    * typecheck.c (convert_for_assignment): Don't warn about
    pointers volatile * vs nonvolatile * if -fvolatile specified.

    * decl.c (store_parm_decls): Among the old-style parm decls
    there can legitiately be other decls!  For example, if a parm
    is declared `enum {foo, bar} x;', there are decls for `foo' and `bar'.
    Don't let anything but a PARM_DECL match a parm name;
    pass all the other decls through into the lexical context.

    * jump.c (jump_optimize): When deleting stack adjusts before a
    jump-to-return, don't be fooled by intervening NOTEs.

    * tm-sequent.h (PRINT_OPERAND): Output (MEM (MEM (REG))) properly.
    * output-ns32k.c (print_operand_address): Output (MEM (REG))
    properly; output stack-pointer as `tos'.

    * flow.c (find_use_as_address): Reject uses within operand 0
    of a ZERO_EXTRACT or SIGN_EXTRACT reference.  It's hard to reload
    an autoincrement inside these because they can refer to multiple bytes.

    * reload.c (find_reloads): `o' in constraint means any memref
    (except auto-increment) is acceptable with reloading.
    Braino: Clear BADOP, not BAD.

    * reload.c (push_reloads): Use rtx_equal_p (via macro MATCHES)
    when considering reuse of an old reload.  Otherwise equal values
    may get reloaded into different registers, and two MEMs that
    originally matched may fail to match once reloaded.

    * m68k.md (sign_extract and zero_extract insns):
    If operand 0 is QI or HImode, don't allow register--only `o'
    (except in some bftst patterns where bitpos is < 8).
    And change `m' to `o' in all these patterns.

Sun Mar 27 15:32:54 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_expr, case CONSTRUCTOR):
    Not all aggregates are BLKmode; use the type's mode.

    * gcc.c: Pass -y* to ld.

    * cse.c (struct hash): New member `equivalence_only'.
    (insert): Initialize it.
    (cse_insn): Set it to 1 when src_eqv is inserted.
    When finding cheapest equivalent of something,
    skip elts that are marked with `equivalence_only'.

    * decl.c (duplicate_decls): Don't call `layout_type'
    if the type is `error_mark_node'.

    * decl.c (implicitly_declare): If decl will be file-scope,
    make sure it's a permanent node, and its associated data too.

Sat Mar 26 15:48:50 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * flow.c (insn_dead_p, mark_used_regs): Storing a reg via a
    ZERO_EXTRACT or SIGN_EXTRACT is dead if the reg isn't needed afterward.

    * stmt.c (expand_start_function): Set current_function_name
    to the name of this function.
    * tm-vms.h (MAYBE_VMS_FUNCTION_PROLOGUE): Use current_function_name.

    * expr.c (expand_increment): A SUBREG in op0 can also a be a copy.

    * ns32k.md: Correct range of args for `adjspb' insn.
    Use `adjspw' when appropriate.
    New pattern for `lprd' insn.
    Change some `const_int' predicates to GET_CODE tests.

    * expr.c (expand_call): Eval function before copying args to hard regs.

    * tree.c (make_node, copy_node): Don't get length of a REAL_CST
    from tree_code_length.

    * expmed.c (extract_fixed_bit_field): In memory-word case, abort
    if tm.h parms say word could fail to be well-aligned.
    * tm-ns32k.h: Define STRUCTURE_SIZE_BOUNDARY so they will be aligned.
    * tm-vax.h: Define STRUCTURE_SIZE_BOUNDARY since Unix CC seems to.

    * tm-vms.h (CPP_PREDEFINES): Predefine __GNU__ and __GNUC__.

Fri Mar 25 13:23:27 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * gcc.c (main): Handle SIGHUP, SIGTERM.

    * expmed.c (expand_bit_and): Don't clobber OP1 when trying andcb.

Thu Mar 24 21:59:09 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * stmt.c (assign_parms): Get size of BLKmode local from the type,
    not the mode.
    (expand_function_start): Init frame_offset before calling assign_parms.

Wed Mar 23 23:50:37 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (emit_push_insn): When making a move insn,
    go via emit_move_insn; else fails to put constants into memory.

Tue Mar 22 15:45:10 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_increment): Flush special case for register_operand;
    actually call the predicate whatever it is.

    * genemit.c (gen_expand): Make `operands' a local variable,
    not a global static one, in the `gen_...' function.
    Avoids lossage when one `gen_...' fcn calls another indirectly.

    * genoutput.c (output_epilogue): Don't give printf a null string.

Mon Mar 21 15:41:42 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expmed.c (store_bit_field) [HAVE_insv]:
    Force VALUE1, not VALUE, into a register.

    * expmed.c (store_fixed_bit_field): Width of mask for clearing
    the bit-field depends on mode of OP0.

    * ns32k.md (branch and store-flag insns):
    Test cc_prev_status, not cc_status.

    * expmed.c (extract_bit_field): Delete unused var `omode'.

    * dbxout.c (dbxout_type, dbxout_tag): Use the main variant
    of the specified type.

    * reload.c (find_reloads): When an alternative succeeds without reload,
    initialize goal_alternative_matches from this_alternative_matches.

Sun Mar 20 17:58:00 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * tm-sun*.h: Don't predefine `m68k'; Sun's compiler does not.

Fri Mar 18 13:48:29 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * reload.c (find_reloads): Set up goal_alternative_matches
    *after* the label `finish'.

    * stmt.c (assign_parms): GET_MODE_SIZE needs a mode, not an rtx.

    * recog.c (constrain_operands): Set global var `which_alternative'
    to indicate which of the alternatives this insn matches.

    * typecheck.c (commontype): long int vs unsigned int
    gives long unsigned, if long and int are the same width.

Thu Mar 17 15:39:45 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * emit-rtl.c, tree.c: include local version of varargs.h.

    * decl.c (start_function): Clear TREE_EXTERNAL and set TREE_STATIC
    here rather than in finish_function.  Affects the case of
       `extern foo ();  static foo (a) {...}'

    * gcc.c: Handle -fnostdinc and -fnostdlib switches in specs.

    * cccp.c (main): Handle -fnostdinc: don't put default dirs
    on the chain to be searched.

    * cccp.c (error, warning, error_with_line): No longer print
    charpos within file; lineno is enough.

Wed Mar 16 16:56:36 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expmed.c (expand_inc, expand_dec): Handy new subroutines
    to generate x+=y or x-=y, given x and y as rtl.
    * expmed.c (expand_divmod): Use them instead of gen_{add2,sub2}_insn.

    * expr.c (emit_move_insn): Return the move insn emitted.
    Eliminate the code here to move a DImode or DFmode by pieces.

    * emit-rtl.c (emit_insn): Return-value was wrong if emit_to_sequence;
    cannot use `last_insn' in that case.

    * regclass.c, stupid.c, local-alloc.c, global-alloc.c:
    Some vars of type HARD_REG_SET should be `register' only
    if HARD_REG_SET is a macro (ie a scalar).

    * expr.c (move_block_from_reg): New function, converse of
    move_block_from_reg.
    * stmt.c (assign_parms): If a BLKmode arrives in regs,
    copy to a stack slot using move_block_from_reg.

Tue Mar 15 17:33:22 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * regclass.c (regclass): Don't convert to two-operand insns
    unless optimizing.

    * varasm.c (decode_rtx_const, const_hash_rtx): Fix typos.

    * stmt.c (fixup_var_1): Don't alter insn moving VAR to or from
    a subreg of a register.

    * cse.c (fold_rtx): Don't fold if result is not LEGITIMATE_CONSTANT_P.
    Construct all results in new local variable NEW; then test that
    and decide whether to return it or the original rtx.

    * cse.c (cse_insn): When SRC_EQV is non-0 but set[0] has been
    cleared, don't insert SRC_EQV in hash table.

    * All insns emitted by a define_expand become part of the SEQUENCE:
    * SEQUENCE now contains a vector of insns, not of bodies.
    * insn-emit.c (add_insn): If `emit_to_sequence' nonzero, add the
    insn to a separate chain, `sequence_first_insn'.
    (gen_sequence): Take everything on that chain and make a SEQUENCE.
    (emit_insn): Handle SEQUENCE differently since elts are now insns.
    (emit_insn_{before,after}): Handle SEQUENCE.
    (classify_insn): #if 0.
    * genemit.c (gen_expand): emit all the insns, then call gen_sequence
    to make the return value.
    Define two macros DONE and FAIL for use in a DEFINE_EXPAND:
    Use DONE to inhibit emission of the pattern of the DEFINE_EXPAND.
    Use FAIL to make the gen_... function return 0.

Mon Mar 14 12:47:28 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_expr): Extend the don't-sign-extend-enums hack
    to COMPONENT_REF.  (See 3 March.)

    * tm-*.h (FUNCTION_ARG, etc.) New argument NAMED
    is nonzero for a named arg, zero for an anonymous extra arg.
    * expr.c (expand_call): Pass 1 for NAMED if appropriate.
    * expr.c (emit_library_call): Pass 1 for NAMED.
    * stmt.c (assign_parms): Pass 1 for NAMED.

    * cccp.c: Test __GNUC__, not __GNU__.

    * integrate.c (copy_and_substitute_rtx):
    Replacing a MEM parm with the parm value, convert mode if mismatch.
    Always use VOIDmode when generating SETs.
    Take heed of FIRST_PARM_OFFSET and distinguish arg-pointer
    from frame-pointer when they are different.
    (expand_inline_function): Handle (RETURN) insns, by creating a
    return_label which is output after the integrated code.

    * parse.y (yylex): Condition for ignoring `inline' was backwards.

    * flow.c (mark_used_regs): Ignore STRICT_LOW_PART, so that
    an insn that sets STRICT_LOW_PART (and its source values) may be dead.
    (propagate_block): Always pass 1 for strict_low_ok to insn_dead_p.

    * optabs.c (emit_unop_insn): Don't make a REG_RETVAL note.
    Change above deletes dead STRICT_LOW_PART stores without one.

    * optabs.c (expand_binop, expand_unop): If the library address
    is to be put in a pseudoreg, do it here, and make the REG_RETVAL
    note point after that.

    * expr.c (emit_library_call): Never defer stack-pops.
    Deletion of the library call by flow.c loses if they are deferred.

    * cse.c (cse_insn): Handling of 68k's zero-extend was broken:
    it made the actual source and the REG_EQUAL source equivalent.
    * If dest is a STRICT_LOW_PART, ignore the actual source and use
    the REG_EQUAL source in its place.  src_eqv's mode may be different
    from src's, so use proper mode in lookups or inserts for src_eqv.
    * Don't forget to set src_eqv_elt if src_eqv already has an elt.
    * On use_related_value for src_eqv, use src_eqv_elt.

    * toplev.c (main_input_filename): Name of file mentioned in first
    #-line in the input.
    (compile_file): Pass it to dbxout_init as 2nd arg.
    * dbxout.c (dbxout_init): Use 2nd arg to make the N_
    * parse.y (check_newline): Store main_input_filename.

    * expr.c (move_block_to_reg): New function, copies a MEM:BLK
    to consecutive registers.
    (use_regs): New function to emit a USE for each reg in a series.
    (expand_call): Use the two new functions when a precomputed BLKmode
    arg is passed entirely in regs.
    (emit_push_insn): Use move_block_to_reg when PARTIAL > 0.
    Also, don't subtract USED from SIZE twice.
    Use plus_constant to add ARGS_SO_FAR so can use indexing on stack ptr.

    * varasm.c (assemble_integer_zero): Use rtx 0, not tree 0,
    to go with prev change in ASM_OUTPUT_INT.

Sun Mar 13 01:16:17 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * varasm.c (const_hash, compare_constant_1, record_constant_1):
    Handle NOP_EXPR and CONVERT_EXPR in constant expressions.

    * optabs.c (expand_binop, expand_unop): When widening operands,
    those with VOIDmode (like CONST_INT) may be left alone.

Sat Mar 12 01:09:24 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * varasm.c (assemble_variable): When making a .comm or .lcomm,
    round size up to multiple of BIGGEST_ALIGNMENT.

    * obstack.c (_obstack_newchunk): Eliminate fencepost causing copying
    to access the word past the end of the existing object.

    * tm-vax.h, tm-ns32k.h: Define {INIT_,}CUMULATIVE_ARGS
    and upgrade FUNCTION_ARGS for new calling convention.

    * gcc.c: If -O, define __OPTIMIZE__.
    (do_spec_1): %c now scans SIGNED_CHAR_SPEC: define __CHAR_UNSIGNED__
    when appropriate whether or not it is the default.

Fri Mar 11 16:49:25 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * parse.y: Define YYDEBUG.

    * rtl.c (rtx_unstable_p): New function, same as old rtx_varies_p.
    * explow.c (stabilize): Use rtx_unstable_p.
    * rtl.c (rtx_varies_p): Ignore `unchanging' (undoing previous change
    in this function) because `unchanging' doesn't enable cse to compare
    the value with any particular constant value.
    * rtl.c (insn_store_addr_varies_p): Delete, since not used.

    * hard-reg-set.h (COPY_HARD_REG_SET, etc.) non-scalar case:
    Rename and rearrange temp variables to avoid name conflicts with args.

    * regclass.c (reg_class_record): Don't smash class to GENERAL_REGS
    and don't exit prematurely, when `r' or `g' is seen.  Must merge
    GENERAL_REGS with previously determined desired class.

    * expr.c (expand_call) [no PUSH_ROUNDING]: When pushing the arg
    block, try to reuse some of the pending_stack_adjust.

    * cse.c: qty_const can now hold values (PLUS frame_pointer integer).
    Effect is that storing into a structure doesn't invalidate
    mem refs to scalar stack variables via addresses in registers.
    (insert): Load such values into qty_const, like true constants.
    (fold_rtx): Ignore qty_const if it isn't really a constant.

    * expr.c (expand_expr) VAR_DECL: Copy DECL_RTL before calling
    change_address, so it isn't permanently clobbered.

    * stmt.c (fixup_var_refs_1): Make sure the stack slot address
    is valid by calling fixup_stack_1 each time it is substituted.

    * stmt.c (fixup_stack_1): Return the altered rtx.
    If it's a MEM in the stack, return a copy of it.

    * stmt.c (fixup_stack_slots): #if 0.
    * stmt.c (expand_finish_function): Don't call fixup_stack_slots
    because fixup_stack_1 is called elsewhere when necessary.

    * reload.c (find_reloads_address): New arg is location of the MEM
    whose address is being reloaded.  So we copy the MEM if it
    is one that can be shared.  New arg 0 means no need to copy the MEM.
    All callers pass the new arg.

    * stmt.c (assign_parms): Determine parm stack-size from
    the DECL_ARG_TYPE, not from the TREE_TYPE.
    Else loses when parm is declared `float' but passed as `double'.

    * emit-rtl.c (make_safe_from): Constants are already safe.
    Use proper machine mode for temp reg when needed.

Thu Mar 10 14:35:14 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (emit_push_insn): Don't pass wrong type to plus_constant
    (case where there is no PUSH_ROUNDING).

    * expr.c (expand_call): Round partial[i] down to multiple of
    PARM_BOUNDARY before subtracting it from arg size on stack.
    Compute these sizes just once and keep them in vector `arg_size'.
    * expr.c (emit_push_insn): Handle `partial' uniformly, in accord
    with this new convention for how it affects the stack size.
    * stmt.c (assign_parms): Round NREGS down to PARM_BOUNDARY likewise.

    * obstack.h (obstack_free macro) [Not __GNUC__ but __STDC__]:
    Don't cast result of (obstack_free) to (int); just ignore it.

    * reload.c (find_reloads): Initialize operand_reloadnum.

    * optabs.c (emit_unop_insn): New argument CODE, used to make
    a REG_EQUAL note from operand OP0 if more than one insn results.
    Also a REG_RETVAL note.
    * expr.c (convert_move): Pass CODE arg to emit_unop_insn.
    * flow.c (propagate_block): Use insn_dead_p to decide whether
    to handle a REG_RETVAL note by skipping some insns.
    Always pass 1 for STRICT_LOW_OK for an insn that has a REG_RETVAL note.
    Handle case where REG_RETVAL points at an insn that's deleted.
    * flow.c (insn_dead_p): New operand STRICT_LOW_OK says an insn
    that sets STRICT_LOW_PART may be considered dead.

    * expr.c (expand_expr): Once again canonicalize X-C to X+(-C).
    Change on March 1 made it stop doing this.

Wed Mar  9 01:25:35 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * loop.c (move_movables): Don't always mark the moved reg
    as equivalent to a constant value: not if it is being cleared
    to zero-extend something or if it is used outside the loop.

    * expr.c (move_by_pieces_1): Finish last change.

    * stmt.c (assign_parms): Update stack_args_size properly.
    Figure FIRST_PARM_OFFSET when making the stack mem refs.

    * cse.c (insert): Build the related_value lists in the opposite order
    so that the oldest element in the chain is the one that follows
    the most basic element.

    * expr.c (expand_expr): COMPONENT_REF case: criterion for
    converting the the result is if MODE1 (its mode of arrival) isn't
    a mode we want.

    * toplev.c (rest_of_compilation): Fix typo setting TREE_ASM_WRITTEN.

Tue Mar  8 13:18:37 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * cse'ing of library calls.

    * expr.h: type `optab' is now a ptr to a struct.
    The old contents are now the `handlers' element.
    The `code' element gives the RTL code for the kind of expression
    this optab makes (PLUS for add_optab, etc.)
    Every var formerly declared `struct optab *' is now just `optab'.

    * optabs.c (init_optab, init_optabs): New function to init an optab
    and set its `code'.  Used in init_optabs.

    * optabs.c (expand_binop, expand_unop): Use the `code' field
    to add a REG_EQUAL note to the insn that copies a libcall's
    value into a pseudo.  Also a REG_RETVAL note pointing at the
    first insn for setting up args for the call.

    * cse.c (cse_insn): Process REG_EQUIV and REG_EQUAL datum almost like
    another set-src; put the actual src into the equivalence class of that.

    * flow.c (propagate_block): If a dead insn has a REG_RETVAL reg-note,
    either ignore or delete all the insns back to the insn the REG_ARG
    note points to.

    * local-alloc.c (block_alloc): Don't refrain from allocating a
    "constant" register if the constant value isn't ok for an immediate op.


    * dbxout.c (CONTIN): If DBX_CONTIN_LENGTH is <= 0, do nothing.

    * cccp.c: Extra default include dirs for C++.
    * cccp.c (main): For -M, strip dirs from object file name.

    * rtl.c (find_reg_note): New function.

    * expmed.c (store_fixed_bit_field): Don't AND with VALUE
    if VALUE's original mode had no more bits than we want.

    * expr.c (emit_library_call): Use varargs.

    * integrate.c (copy_and_substitute_rtx): Recognize arg_pointer_rtx
    and translate it just like frame_pointer_rtx.

Mon Mar  7 00:48:33 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expmed.c (extract_fixed_bit_field):
    Shift counts were wrong for narrow MODE in signed case.
    Do the sign-extending shifts in the narrowest mode possible.
    Reduce big-endian case to little-endian case.
    Delete SLOW_ZERO_EXTEND conditional.

    * Implement constants in memory for RISC machines
    with limited abilities for immediate args and constant addresses.

    * genoutput.c (output_epilogue): Empty predicate-name
    is output as 0 in insn_operand_predicate.

    * expr.c (expand_expr): Change 4th arg to an `enum expand_modifier'
    Value EXPAND_SUM corresponds to old nonzero 4th arg.
    Value EXPAND_CONST_ADDRESS means ok to return an invalid MEM
    whose address is a constant.  Changes for this case in ADDR_EXPR,
    COMPONENT_REF and ..._DECL.

    * varasm.c (output_arith_constant): Function deleted.
    * tm-*.h: (ASM_OUTPUT_{INT,SHORT,CHAR}): 2nd arg is now an RTX
    and output it using `output_addr_const'.
    * varasm.c (output_constant): Change uses of those macros.

    * varasm.c (init_const_rtx_hash_table): Initialize constant pool
    for a new function.  Called from `expand_function_start'.
    * varasm.c (force_const_mem): Turn a constant rtx into a MEM rtx
    which refers to the constant pool.  Other new subroutines too.
    (force_const_double_mem): Use force_const_mem to make the MEM.
    (immed_real_const): No longer record the REAL_CST node in the rtx.

    * explow.c (force_reg): If arg is a constant and not legitimate,
    put it in the constant pool with force_const_mem.
    Mark the register as equivalent to the constant value.
    * expr.c (emit_move_insn): Likewise.
    * explow.c (break_out_mem_refs): Use force_reg to put into a reg.
    * explow.c (memory_address): Likewise.
    * expr.c (expand_expr): ADDR_EXPR case: likewise.

    * expr.c (expand_call): Do force_reg on each register-operand
    so it will go through a pseudo and can be cse'd.

    * recog.c (immediate_operand, nonmemory_operand, general_operand):
    For constant operands, use LEGITIMATE_CONSTANT_P to decide value.
    * tm-*.h: Define LEGITIMATE_CONSTANT_P.

    * reload1.c (reload): Invalid constants can't go in reg_equiv_constant.

Sun Mar  6 22:49:06 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * reload.c (push_reloads): If IN occurs within OUT,
    don't reuse an existing input-only reload.  Otherwise would lose on
    (set (mem (plus R C)) (plus R C1)) if R is available in a spill reg.

    * reload1.c (choose_reload_targets): Don't choose an inherited
    reload register that's in use for another reload.
    Without this, above change doesn't have an effect.

    * Implement the `unchanging' flag in MEM and REG rtx's.
    Also simplify code with a new subroutine `change_address'.

    * emit-rtl.c (change_address): Return new memory ref like an old
    one but with specified mode and address.
    * expmed.c (extract{,_split,_fixed}_bit_field): Use change_address.
    (store{,_split,_fixed}_bit_field): Likewise.
    * expr.c (store_expr, expand_expr): Likewise.

    * expr.c (move_by_pieces): Args now memrefs, not addresses.
    Eliminate the FROM_VOL and TO_VOL args since the memrefs indicate.
    Change the structure `struct move_by_pieces' similarly.
    (move_by_pieces_1): Same changes; use change_address.
    (emit_block_move, emit_push_insn): Calls to move_by_pieces changed.

    * integrate.c (copy_rtx_and_substitute): Use change_address;
    handle ->unchanging field.

    * rtl.c (rtx_varies_p): Regs or memrefs with ->unchanging don't vary.
    (copy_rtx): Perserve ->unchanging.
    (print_rtx): Print ->unchanging as /u.

    * stmt.c (expand_decl): Set ->unchanging on `const' decls.
    (fixup_memory_subreg): Use change_address.
    (assign_parms): Record in the rtl which parms are volatile or const.

    * varasm.c (assemble_variable): Set ->unchanging on `const' decls.
    (output_constant_def): Always set ->unchanging for constant refs.

    * cse.c (canon_hash): Don't treat a MEM as "in memory"
    if its ->unchanging bit is set.

    * loop.c (invariant_p): A REG or MEM with ->unchanging is invariant
    (for a MEM, the address must be invariant).

Sat Mar  5 13:22:11 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * genconfig.c (walk_insn_part): DO consider MATCH_DUPs
    when calculating MAX_RECOG_OPERANDS.
    (gen_expand): define_expand is now different from define_insn.
    Compute max # SETs or CLOBBERs for any one sub-insn in a define_expand,
    instead of summing them all.  And don't count the MATCH_DUPs at all.

    * genemit.c (max_operand_1): Record largest opno in a MATCH_DUP
    separately from largest in a MATCH_OPERAND.
    (gen_expand): An operand # with only MATCH_DUPs gets
    a local variable in the gen_ function we output.

    * integrate.c (save_for_inline): Delete vestige of NOTE_INSN_IS_DECL.

    * cse.c (invalidate): Handle subregs.
    (cse_ins, invalidate_from_clobbers): Do call `invalidate' for subregs.
    (insert_regs): When assigning one subreg from a like one,
    make the two regs equivalent.
    (cse_insn): Do call insert_regs when dest is a subreg.

    * expr.c (expand_call): Precompute all args going via hard regs
    since even arithmetic could require a library call.

Fri Mar  4 15:48:17 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * stor-layout.c (layout_parms): Function deleted.
    * stmt.c (expand_function_start): Don't call it.

    * stmt.c (assign_parms):
    stack_args_size counts size of args so far passed on stack.
    Use PARM_BOUNDARY when counting it; derive stack offsets from it.
    Set current_function_args_size from it.

    When an arg is split between regs and stack, make stack space
    for the rest of it, and count it.
    In a varargs function, push the last arg onto the stack.
    When an arg is passed in regs alone, don't remember a stack slot
    for it, and if it needs one, use assign_stack_local.

    Set DECL_OFFSET to the stack offset, or -1 if parm came in regs.

    * expr.c (expand_call): Anonymous args of a varargs function
    are always passed on the stack.

    * varasm.c (force_const_double_mem): Copy the MEM rtx
    if it may need to be smashed by reloading.

    * genemit.c (gen_expand): define_expand must have nonempty pattern
    even though, due to `return' statements in the code-to-run,
    that pattern may not be used to generate code.

Thu Mar  3 17:08:43 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_expr): If supposed to sign-extend an enum
    which is never negative, zero-extend instead (unless SLOW_ZERO_EXTEND).
    (store_expr): Likewise.

    * reload.c (find_reloads): 'm' for CONST_DOUBLE: clear BADOP, not BAD.
    After force_const_double_mem, do find_reloads_toplev on the MEM.
    (find_reloads_address): Handle constant addresses (on machines
    that don't allow them).

    * final.c (set_current_gdbfile): New fn, get the gdbfile structure
    for specified filename.
    (output_source_line): Use set_current_gdbfile for the file.
    * varasm.c (assemble_variable): Call set_current_gdbfile
    for the declaration's source file, so GDB won't ignore the file.

    * varasm.c (force_const_double_mem): Build a new REAL_CST node
    and get its data type from the machine mode of the CONST_DOUBLE.
    (immed_real_const): Don't save the REAL_CST tree node.
    * typecheck.c (get_floating_type): Return float type for given mode.

    * integrate.c (expand_inline_function): Ignore the (USE (REG...))
    (for the return-register) at the end of the inline function.
    After a CALL_INSN, imagine the (SET (REG ...) (REG ...)) for
    the return-register if the return-register isn't explicitly used.

Wed Mar  2 22:08:49 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * typecheck.c (build_array_ref): Do default_conversion on INDEX.

Tue Mar  1 15:49:34 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_call): Always get a SYMBOL_REF for a fixed function.
    If may be alloca, set may_call_alloca.
    (gen_call_1): Never put a SYMBOL_REF through `memory_address';
    but if function cse is wanted, just copy it to a register.
    If NO_FUNCTION_CSE is defined, never do function cse.

    * expr.c (init_expr): New function, does init_queue and inits
    other things.

    * stmt.c (expand_function_start): Call init_expr, not init_queue.

    * optabs.c (expand_binop): Don't clobber OP0 and OP1
    if may call delete_insns_since later.

    * expr.c (emit_library_call): PUSH_ARGS_REVERSE test was backwards.

    * cse.c (cse_insn): Do canon_reg on the size and position operands
    in a ZERO_EXTEND or SIGN_EXTEND that is a destination.

    * tm-*.h: Define SLOW_BYTE_ACCESS.
    * expmed.c ({store,extract}_fixed_bit_field):
    If SLOW_BYTE_ACCESS, get/set all bit fields from full words.

    * combine.c (subst): Simplify
    (zero_extend:SI (subreg:QI (zero_extract ...))).
    * combine.c (simplify_and_const_int): Simplify
    (and (zero_extract ...) (const_int ...)).

    * local-alloc.c (qty_compare{,_1}): Test of qty_phys_sugg was reversed.
    (combine_regs): If one pseudo gets two suggested hard regs
    (one at birth and one at death), prefer the one from birth
    unless we see at death that it's no good.

    * expr.c (expand_expr): Ignore sum_ok unless mode is Pmode.
    Don't use force_operand unless sum_ok is set.

Mon Feb 29 19:23:50 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (emit_move_insn): When a CONST_DOUBLE needs moving
    by pieces, force it into memory, unless it is dconst0_rtx,
    in which case each piece is const0_rtx.
    (emit_push_insn): Likewise.  Also, write code for pushing a
    non-BLK mode which has no "mov" insn defined, but only
    in the case where there is no PUSH_ROUNDING.

    * expr.c (do_tablejump): Put constant term in address last.

    * toplev.c (xrealloc): On error, call fatal instead of abort.

    * optabs.c (emit_cmp_insn): If genning from tst_optab,
    make the operand fit its predicate.

    * optabs.c (expand_float): Don't adjust stack between cmp and jump.

    * optabs.c (expand_binop): Recursive calls can return 0; handle
    that event by deleting any preparatory insns.  Also don't smash
    TARGET when this happens.

    * reload.c (push_reload): If IN != *INLOC, set reload_nocombine.
    (combine_reloads): Don't combine an input reload with reload_nocombine.

    * jump.c (jump_optimize): Don't delete stack adjusts unless
    EXIT_IGNORE_STACK is nonzero.
    * expr.c (clear_pending_stack_adjust): Likewise.
    * tm-*.h: When EXIT_IGNORE_STACK is defined, give it `1' as defn.

    * expr.c (expand_call): Initialize args_size.
    Don't push a block if args_size is 0.
    (emit_library_call): Don't include register-args (or reg-parts
    of partial ones) in args_size.
    Don't push a block if args_size is 0.

    * expr.c (expand_expr): For DECLs in memory, check the address
    validity with memory_address_p, and preserve volatility info.

    * stmt.c (expand_function_end): fixup_gotos needs 2 args.

    * jump.c (mark_jump_label): If INSN is 0, don't set its JUMP_LABEL.
    Inside an ADDR_VEC or ADDR_DIFF_VEC, recurse with 0 for INSN.

    * varasm.c (force_const_double_mem): Must zero TREE_CST_RTL
    before output, or nothing will happen.

Sun Feb 28 01:08:53 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * optabs.c (emit_unop_insn): Generate and emit an insn
    given the insn-code and the two operands (one out, one in).
    Can move the operands into registers when needed for various
    reasons.
    * expr.c (convert_move): Use emit_unop_insn for outputting the
    conversion insns.

    * expr.c (emit_library_call): Use arg's nominal mode to choose
    a reg to pass it in, not actual mode (which can be VOIDmode).

    * insn-emit.c (emit_insn): If arg is empty SEQUENCE, do nothing.

    * genemit.c (gen_expand): Scan the rtl-pattern for predicates
    and machine modes of the operands.

    * m68k.d (dbra patterns): Add HPUX_ASM conditionals.

    * rtl.c (reg_mentioned_p): Use "equal", not "eq", when
    REG isn't a register.
    * reload.c (combine_reloads): Verify not reg_mentioned_p even if
    the input reload's value isn't a register.

    * reload.c (operands_match_p): If successful and 2nd arg
    has a pre-increment that matches a non-increment, return 2.

    * reload1.c (reload): At end, clobber a pseudoreg to a MEM
    even if it's an out-of-range address.  It doesn't affect the
    assembler code in this case, but it makes the dbx output correct.

    * recog.c (constrain_operands): When operands_match_p returns 2,
    in the constraint alternative that is ultimately successful,
    copy the output operand from the input that it matched
    so that the assembler insn that is output shows the pre-increment.

Sat Feb 27 15:16:47 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * combine.c (subst): When optimizing
        (set (zero_extract ...) (and (zero_extract ...) const))
        must arrange to have 1's, not 0's, shifted into low bits of const.

    * decl.c (grokdeclarator): When return-type defaults to int,
    don't warn, just set warn_about_return_type.
    (start_function): See that variable and warn, after starting function.

    * toplev.c (count_error): No longer print newline if not quiet.
    (report_error_function): If not quiet, print a newline if
    printing anything, and don't print the function name.

    * reload1.c (choose_reload_targets):
    Fix the loop that checks for consecutive available spill regs.
    Set `have_groups' nonzero if any reload wants a group.
    In that case, for non-group reloads, prefer a reg that can't be in
    group, or else one that has only one available neighbor.

    * reload1.c (reload): Find separately the max need for each class
    for single registers, groups of registers, and single registers
    not in any group.  (The last one counts non-group reloads
    in insns that have at least one group reload.)
    Then make sure enough of each kind are found.

    * expmed.c: Now needs flags.h and recog.h (therefore insn-config.h).

    * expmed.c (store_bit_field):
    Delete redundant protect_from_queue.
    Force VALUE out of memory if -fforce-mem.
    If insv's predicate for VALUE wants a register, put it there.

    * expmed.c (extract_bit_field):
    Force TARGET out of memory if -fforce-mem.
    If insv's predicate for TARGET wants a register, put it there.

Fri Feb 26 00:12:48 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * reload1.c (eliminate_frame_pointer): Don't check for pushes
    unless PUSH_ROUNDING is defined.

    * reload.c: Don't define REG_OK_FOR_{INDEX,BASE}_P
    (since the tm file is supposed to do it).

    * expr.c (emit_push_insn, expand_call):
    Don't use PUSH_ROUNDING if it's not defined.

    * expr.c (preexpand_calls): Do nothing for constants and decls.

    * expr.c (expand_call, emit_library_call): When PUSH_ROUNDING
    is not defined, use ROUND_CALL_BLOCK_SIZE to round the size
    of the block of arguments.

    * expr.c (expand_call): Don't count register-args in ARGS_SIZE.

    * rtl.h, emit-rtl.c: Create static_chain_incoming_rtx
    and struct_value_incoming_rtx.
    * stmt.c (expand_function_start): Use ..._incoming_rtx where needed.

    * expr.c (expand_call): Use new macros INIT_CUMULATIVE_ARGS,
    CUMULATIVE_ARGS and FUNCTION_ARG_ADVANCE to update data
    on args scanned so far.
    (emit_library_call): Likewise.
    * stmt.c (assign_parms): Likewise.
    * tm-spur.h, tm-m68k.h: Define these macros.

    * rtl.h (NUM_MACHINE_MODES): NUM_MACHINE_MODE renamed.
    * rtl.c, genrecog.c: Change places it is used.

    * cccp.c (output_line_command): line_cmd_buf should be chars, not ints.

Thu Feb 25 13:33:29 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * genemit.c (gen_expand): Don't lose if pattern is empty-vector.

    * genconfig.c (gen_insn): Don't lose if pattern is empty-vector.

    * expr.c (expand_expr): For COMPONENT_REF, don't convert to tmode
    unless the mode we get is unacceptable.

    * loop.c (scan_loop, move_movables): New field `partial' is 1 for
    zero-extending clr insn; don't make the reg invariant when it's moved.

    * optabs.c (expand_unop, expand_binop, emit_cmp_insn):
    mode-argument to predicates was missing.

    * optabs.c (expand_binop): If gen-function returns 0, this means
    the insn wasn't available.

    * reload.c (find_reloads): Don't make optional reloads for operands
    that match other operands.

    * reload.c (combine_reloads): Reject optional output reload.

    * reload.c (find_equiv_reg): Know that CALL_INSNs clobber memory.

    * typecheck.c (build_binary_op_nodefault):
    If doing a short shift, leave the shift-count as a fullword.

Tue Feb 23 14:43:46 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * combine.c (subst): Count, in n_occurrences, # times FROM is seen.
    (try_combine): Refuse to combine x=*y++ into z = x*x.

    * loop.c (invariant_p): Frame pointer and arg pointer are invariant.
    (move_movables): Don't forget to set ->done!
    When moving the matching movables, don't forget to set n_times_set.

    * expmed.c (expand_shift): Reorder strategies for logical shift;
    if widening, try all ashift strategies before extzv.

    * typecheck.c (build_binary_op_nodefault):
    Always return error_mark if either operand is one.

    * recog.c (nonmemory_operand): New predicate.

    * optabs.c (expand_unop, expand_binop, emit_cmp_insn):
    Don't treat `register_operand' as special.  Apply the predicate
    to the rtx; if the predicate fails, use a register instead.

Mon Feb 22 22:37:32 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * expr.c (expand_calls): Preexpand all calls in arguments
    that are passed in regs before copying any of them into the regs.

    * expr.c (emit_push_insn): Three more args.
    EXTRA for extra space to leave.
    ARGS_ADDR and ARGS_SO_FAR for using move-insns on machines
    that lack true push insns.

    * expr.c (emit_library_call, expand_call):
    Use the new arguments of `emit_push_insn'.

    * expr.c (PUSH_ARGS_REVERSED): defined if handle args last-to-firs.

Sun Feb 21 12:17:59 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * toplev.c (rest_of_compilation): Set TREE_ASM_WRITTEN
    when a function is really output as assembler code.
    Don't do inlining of a function that is already made inline;
    instead, output it as assembler code, because this must be
    the second call for that function.

    * decl.c (finish_compilation): Delete it.
    * toplev.c (compile_file): Output pending inline functions at the end
    in the same way tentative-defined variables are output.

    * emit-rtl.c (restore_reg_data): New fn: given chain of insns,
    restore emit-rtl's data on registers from the regs they use.

    * integrate.c (output_inline_function): Use restore_reg_data.
    (fill_regno_reg_rtx_as_needed): Now restore_reg_data_1 in emit-rtl.c.

    * tree.c (build_decl): Function moved from decl.c.
    No longer set attributes of function decls specially.

    * decl.c (implicitly_declare, builtin_function, grokdeclarator):
    Don't expect build_decl to set attributes of FUNCTION_DECL.

    * tree.c (preserve_data): New fn, make all data now on
    maybepermanent_obstack last permanently.

    * cse.c (cse_insn): Remove a STRICT_LOW_PART from the dest rtx
    before putting it in the hash table.

    * symout.c (symout_block): Fix the args to `symout_block_symbols'.

Sat Feb 20 00:07:52 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    Start of changes for inline functions.
    Changes received from Tiemann, then slightly rearranged for simplicity.

    * integrate.c: New file (Tiemann's rtl2.c).
    * integrate.c (function_cannot_integrate_p):
    New fn, only checks whether current fn is safe and good to inline.
    Returns an error message string if not.

    * expr.c (current_args_size): Var made static.
    (store_expr): Fn no longer static.
    (stack_pointer_rtx): Use this var for all refs to the stack pointer.
    (struct_value_rtx, static_chain_rtx): Likewise

    * expr.c (expand_call): Detect calls to integrable functions
    and integrate them.
    **If fn is not named "alloca" then assume it is not `alloca'. **

    * emit-rtl.c (max_label_num): New fn, returns number for next label.
    (get_first_label_num): New fn, returns first label of current fn.
    (init_emit): Save first label number of this fn.

    * emit-rtl.c (gen_inline_header_rtx): New fn, make an INLINE_HEADER.

    * emit-rtl.c (emit_declaration): New fn to emit new kind of NOTE.

    * emit-rtl.c (init_emit_once): New fn.
    Move inits of unique rtl objects here, from init_emit.

    * decl.c (finish_compilation): New fn to compile separately
    any nonglobal inline functions that need to be addressable.

    * decl.c (grokdeclarator): Handle `inline' kwd among the declspecs.
    Set TREE_INLINE if it's safe.

    * decl.c (finish_function): If fn was inlined, don't clear
    the DECL_ARGUMENTS or DECL_RESULT or DECL_INITIAL.

    * gen*.c: Provide rtl_obstack, not current_obstack.

    * rtl.c (rtl_obstack): Variable: ptr to obstack to use for making rtl.
    * rtl.c (rtx_alloc, rtvec_alloc): Use that obstack.
    * rtl.c (copy_rtx): Copy the `integrated' flag.
    * rtl.c (print_rtx): Print that flag as `/i'.

    * rtl.def: New rtx code    INLINE_HEADER.

    * rtl.h (struct rtx_def): Add `integrated' field.
    * rtl.h: Define macros for fields in an inline_header rtx.

    * stmt.c (max_parm_reg_num, get_first_function_insn):
    New fns, return info on parm regs and the insns that init them.

    * stmt.c (expand_decl): Simplify with new local `type'.

    * stmt.c (stack_pointer_rtx): Replace all refs to stack pointer
    with this shared rtx.
    * stmt.c (struct_value_rtx): Likewise.

    * stmt.c (expand_start_function): Call init_pending_stack_adjust
    instead of clear_pending_stack_adjust.
    If not using a return-label, set `return_label' to 0.

    * stmt.c (expand_null_return, expand_end_function):
    Call clear_pending_stack_adjust unconditionally.

    * expr.c (clear_pending_stack_adjust): Move the conditionals here.
    For now, this fn is a no-op, since it's not safe in an inline fn
    and the stack adjusts are deleted by jump.c in if optimizing.

    * expr.c (init_pending_stack_adjust): New fn.

Fri Feb 19 14:30:13 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * toplev.c (main): Decode -finline-functions, -fkeep-inline-functions.

    * toplev.c (rest_of_compilation):
    At start, save the rtl if function should be inline.
    For inline function, if we don't yet know whether it should be
    compiled on its own, don't do so.

    * toplev.c (compile_file): Clear, and later print, `integration_time'.
    Call `init_emit_rtl' when starting.
    Call `finish_compilation' at the end.

    [Add an extra arg to the error and warning functions?]

    * tree.c ({push,pop,clear}_momentary):
    Change momentary_stack from a char ** to a struct momentary_level *.

    * tree.c (build_pointer_type): Put temporary type in `saveable_obstack'
    * tree.c (build_type_variant): Likewise.
    * tree.c (make_node): Likewise.  Also put decls and LET_STMTs there.
    * tree.c (type_hash_canon): Free a temporary type in `saveable_obstack'

    * tree.c (perm_tree_cons): Like `tree_cons' but on perm. obstack.

    * tree.c (init_tree, {{end_,}temporary,permanent}_allocation):
    Handle `maybepermanent_obstack' and `saveable_obstack' and
    `rtl_obstack'.

    * tree.h (TREE_INLINE): New attribute macro.
    * tree.h (DECL_SAVED_INSNS, DECL_FRAME_SIZE):
    New components in a FUNCTION_DECL.
    Delete the `unused` slot in a `struct tree_decl'.

    * typecheck.c (mark_addressable): Set TREE_ADDRESSABLE
    even in FUNCTION_DECLs.

    * typecheck.c (build_function_call):
    If function is a FUNCTION_DECL, avoid setting TREE_ADDRESSABLE
    when taking its address.

    * parse.h: Define RID_INLINE.
    * parse.y: Define keyword `inline'; set up ridpointers for it.
    (yylex): Don't recognize `inline' of -fno-asm or -ftraditional.

    * flags.h: New vars flag_inline_functions
    and flag_keep_inline_functions.

  End of changes for inline functions.

    * tree.c (convert): If EXPR's type is an error_mark, return error_mark.

    * Makefile (install): Don't strip the executables.

    * jump.c (delete_insn): Deleting a label's target
    can delete either NEXT and PREV!  So must search for a
    following nondeleted insn to return.

    * typecheck.c (build_function_call): Typo in validating
    data type of function.

    * genoutput.c (gen_expand): Must create a `struct data' even
    for a define_expand, so we can output the proper insn_gen_function
    and leave zeros in the other tables.

    * loop.c (scan_loop): Replace the code for handling zero-extends
    with unconditional code that checks for a pair of insns.

    * m68k.md: Do zero-extend using define_expand to generate
    a pair of insns, to set all to zero and then copy the low part.

Thu Feb 18 15:54:00 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * emit-rtl.c (emit_insn): If arg is a SEQUENCE, emit several insns.
    * emit-rtl.c (classify_insn): Given an RTX, return the rtx-code for
    an insn containing it: CODE_LABEL, INSN, JUMP_INSN or CALL_INSN.

    * rtl.def: New RTX types DEFINE_EXPAND and SEQUENCE.
    * gen*.c: Handle DEFINE_EXPAND.  Only genemit.c does real work.

    * make.com, make-cc1.com, make-cccp.com: New, VMS command files.

    * tm-vms.h: New file, used as tm.h to generate VMS code.

    * tm-vax.h (FUNCTION_PROLOGUE): Turn off no bits in the mask;
    let call_used_registers alone control this.
    Call MAYBE_VMS_FUNCTION_PROLOGUE, and define that as no-op.

    * tm-vax.h (TARGET_VAXC_ALIGNMENT): New target-flag bit.
    BIGGEST_ALIGNMENT, EMPTY_FIELD_BOUNDARY and POINTER_BOUNDARY use it.

    * varasm.c (assemble_function): Use ASM_DECLARE_FUNCTION_NAME
    if it is defined.

    * varasm.c (assemble_variable): On an external,
    use ASM_OUTPUT_EXTERNAL if defined.  Default is do nothing, as before.

    * toplev.c:
    Use FATAL_EXIT_CODE and SUCCESS_EXIT_CODE.
    Don't include time.h and resource.h on VMS.
    (main) Define __VERSION__ if not already defined.
    Conditionalize setrlimit on RLIMIT_STACK.
    Test __GNUC__, not __GNU__.
    Don't do `ps v' on VMS.
    (gettime): Conditional code for VMS.

    * gcc.c: Define __GNUC__ as well as __GNU__.
    __GNU__ will be deleted in a future version.

    * symout.c (symout_finish) [VMS]: Don't refer to `getwd' on VMS.
    * symout.c (symout_init) [VMS]: Fatal error; GDB syms not supported.

    * parse.y (yylex): Handle DOLLARS_IN_IDENTIFIERS.

    * genoutput.c (gen_insn): Workaround for VMS printf %s bug.

    * gen*.c: Include config.h.  Whenever exiting, use
    SUCCESS_EXIT_CODE or FATAL_EXIT_CODE.

    * config-*.h: Define SUCCESS_EXIT_CODE and FATAL_EXIT_CODE.
    * config-vms.h: New file, mostly like config-vax.h.

Wed Feb 17 13:35:34 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * cccp.c: VMS support from Kashtan.
    Some #include files are conditional.
    Use file_size_and_mode instead of fstat.
    When reading file contents, the size we get from that
    is just an upper bound; don't assume it must match.
    Replacement definitions of read and write for VMS.
    Different default include directories.
    Conditionalize the setrlimit code on RLIMIT_STACK.
    Use SUCCESS_EXIT_CODE when exiting if no errors;
    both that and FATAL_EXIT_CODE are not #defined if already defined.

    Treat $ as an identifier-character if DOLLARS_IN_IDENTIFIERS.
    Rename the `delete' function as `delete_macro'
    to avoid VMS name conflict.

    * cexp.y: Treat $ as an identifier-character if DOLLARS_IN_IDENTIFIERS.

    * stmt.c (fixup_memory_offset): Do big-endian compensation
    only within a word, not for DImode vs SImode.

    * stmt.c (fixup_var_refs): Don't fix up the insn to load the var
    from its own stack slot; delete it instead.

    * tm-ns32k.h (MODES_TIEABLE_P): DImode is like DFmode.

    * tree.c (MAX_HASH_TABLE): 1009 (more prime) instead of 1008.

    * decl.c (duplicate_decls): If merged type is OLD's type,
    keep OLD's DECL_SIZE and DECL_SIZE_UNIT.

    * gen*.c (xmalloc, xrealloc): Call `fatal' if memory is full.

    * reload1.c (choose_reload_targets): If a mode doesn't fit the
    reload register, and the insn is an ASM_OPERANDS, ignore the reload.
    Otherwise, final would crash.

    * expmed.c (expand_shift): Two new strategies for lshr on short/char:
    widen and do ashr, or widen and do extzv.

    * vax.md (peepholes): Use dead_or_set_p to check for eliminable
    intermediate result, rather than requiring a match with final result.

    * local-alloc.c (block_alloc): Testing frame_pointer_needed is
    enough; no need to test FRAME_POINTER_REQUIRED, etc.
    * global-alloc.c (find_reg): Likewise.
    * reload1.c (reload): Likewise for flag_omit_frame_pointer

    * jump.c (delete_insn): If not `optimize', don't complain
    about finding an already-deleted insn in the chain.

Tue Feb 16 17:14:54 1988  Richard Stallman  (rms at wheaties.ai.mit.edu)

    * final.c: Don't define N_SOL and N_SLINE if already defined.

    * final.c (output_source_line):
    Typo calling ASM_OUTPUT_SOURCE_FILENAME.

    * flow.c (INSN_VOLATILE): fix a typo.

Fri Feb 12 16:48:16 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * final.c (final): for `asm' without operands, output literally.

Thu Feb 11 12:44:41 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * symout.c (symout_record_fields): Handle nameless fields.
    * symout.c (symout_record_field_names): Likewise.

    * typecheck.c (require_complete_type): `void' is a complete type.
    * typecheck.c (build_function_call): Don't complain if result is void.

    * tm-hp9k320.h: Change definition of ASM_SPEC to +X, not -X.

    * cccp.c (main): Expected object file name for foo.cc is foo.o.

Wed Feb 10 16:04:58 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * reload1.c (reload): Initialize `regmask' to zero.
    Class number is in I, not in CLASS, when setting its elements.
    Don't let J+K be too large.

    * reload1.c (potential_reload_regs): Make it a `short'
    since that can't be unsigned.

    * cccp.c (warning): New function, called like `error'.
    * cccp.c (do_define): Make redefinition just a warning.

Tue Feb  9 13:28:00 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * decl.c (grokdeclarator): Don't be fooled by ERROR_MARK as a declspec.

    * toplev.c (compile_file): Strip final .c or .co from .sym file name.

    * gcc.c: When running `as', specify the .sym file if -gg.

Mon Feb  8 11:26:26 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * expmed.c (store_fixed_bit_field): Don't try gen_lowpart on VALUE
    if it's a subreg since it might lose; use convert_to_mode instead.

    * tm-hp9k320.h: Define TARGET_MEM_FUNCTIONS.
    * expr.c (emit_block_move, emit_push_insn, clear_storage):
    If TARGET_MEM_FUNCTIONS, generate calls to memcpy and memset
    instead of bcopy and bzero.
    * optabs.c (emit_cmp_insn): Likewise for memcmp vs bcmp.

    * stmt.c (expand_goto): New temp var to avoid RT/PC compiler bug.

Sun Feb  7 12:20:23 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * flow.c (mark_used_regs, mark_set_regs):
    Handle hard regs in multiword modes: set the bits for each
    distinct register-number that makes up the multiword mode.
    Necessary because function arg registers can inevitably
    live across basic blocks.

    * cse.c (canon_hash): Function arg and value registers no longer
    considered volatile, because flow should now handle the code that
    can result from cse'ing them.

    * cse.c (make_regs_eqv): Abort if OLD is invalid.
    * cse.c (reg_invalidate): Abort if reg already invalid has eqvs.

Sat Feb  6 16:25:32 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * gcc.c (main): Specific error msg if no input files.

Fri Feb  5 17:56:00 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * stmt.c (expand_decl, put_var_into_stack, assign_parms):
    Set in_struct on a MEM if the variable is an aggregate or union.
    * varasm.c (assemble_variable): Set in_struct on aggregate vars.

Thu Feb  4 11:52:30 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * m68k.md (movsf): Correct two fmove.x to fmove.s.

    * expmed.c (extract_fixed_bit_field):
    Must always generate an `and' to mask the bitfield
    unless its width is the same as the output machine mode.

    * version 1.18 released.

Wed Feb  3 08:41:20 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * fold-const.c (fold): Convert EXPR's operands before returning them.

Tue Feb  2 15:35:18 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * reload.c (find_reloads_address_1):

    * typecheck.c (default_conversion): Handle COMPOUND_EXPR arrays.

Mon Feb  1 18:53:05 1988  Richard Stallman  (rms at frosted-flakes.ai.mit.edu)

    * ns32k.md: operand 0 of all unsigned divide/modulus insns
    is now register_operand.

    * stdarg.h: Make va_list be char *, not char *[1].
    Latest draft doesn't say it must be an array type.

End: