changelog.1

早期freebsd实现

Thu May 10 22:48:31 1990  Richard Kenner  (kenner at vlsi1.ultra.nyu.edu)

	* rtl.def (DEFINE_DELAY): Change description to describe annulling.

	* genattr.c (main): Write out definitions for annulling, if present.

	* genattrab.c (expand_delays): Build internal attributes for
	which insns can be annulled in a delay slot.
	(gen_delay): Validate number of elements in DEFINE_DELAY list.
	(write_eligible_delay): Write out routines for validating annulled
	insns as well as those in normal delay slot.
	(main): Call write_eligible_delays to output annulling information,
	if it exists for this machine.

	* out-m68k.c (not_sp_operand): New function.
	* m68k.md (andsi3): Don't allow sp as ourput to avoid reload
	inefficiency.

	* calls.c (struct arg_data): Delete field STORED; add fields
	PASS_ON_STACK and SAVE_AREA.
	(prepare_call_address): Static chain value can't have QUEUED.
	(expand_call): Rework to support additional calling sequence options.

	Major changes include:
	Call FUNCTION_ARG_PASS_BY_REFERENCE to determine whether an 
	object should be passed by invisible reference.
	Handle arguments passed both on stack and in a register; this can be
	used to allow arguments that are hard to compute directly into
	registers to be passed.
	Support option (ACCUMULATE_OUTGOING_ARGS) where the largest amount
	of stack for outgoing arguments is computer and pushed during the
	function prologue.  Stack space usage is tracked and any location
	that would need to be reused will be saved and restored.
	If preallocating arg block, compute address where each arg will be
	placed and pass it as target to expand_expr.

	Other changes:
	Use virtual regs to see if structure value address isn't stable.
	If inlined, return TARGET if TARGET and TEMP are equivalent.
	UNNAMED_ARGS_IN_REGISTERS is redundant with the NAMED parameter to
	FUNCTION_ARG and has been deleted.
	Use virtual_outgoing_stack_rtx instead of FIRST_PARM_CALLER_OFFSET.
	Use locate_and_pad_parm to compute any needed padding for argument.
	If REG_PARM_STACK_SPACE is defined, allocate backing stack locations
	for args passed in registers; these are not included in the length
	of stack space required unless OUTGOING_REG_PARM_STACK_SPACE is also
	defined.
	When precomputing register parameters, can stop computation when we
	obtain any rtx, not necessarily a register.
	No longer need code to protect data written below bottom of stack;
	this is taken care of by preexpanding calls in argument.
	target_for_arg no longer needed; its function is performed by
	store_one_arg.
	Always copy function return result to our target since they cannot
	possibly be the same.
	(target_for_arg): No longer used.
	(store_one_arg): Save and restore in-use argument list location.
	Support args passed both in register and on stack.
	No need for explicit code for preallocated area; now pass location
	as target to expand_expr; only copy if result in different place.
	Put sequence point after expanding one value.

	* cse.c (struct write_data): Add bit to indicate stack pointer changed.
	(canon_hash): Allow recording of stack pointer.
	(cse_insn): Indicate stack pointer invalidated by subroutine calls.
	Pass stack push and pop operations to note_mem_written.
	Process stack pointer assignment as normal operation.
	Finish change of April 7th that excludes ap and fp from being marked
	as clobbered by calls.  Also exclude sp; if it is clobbered by a
	call, an explicit CLOBBER will be written.
	(note_mem_written): Look for adjustment of stack pointer.
	(invalidate_from_clobbers): Invalidate stack pointer, if required.

	* emit-rtl.c (gen_inline_header_rtx): Add field for outgoing args size.
	(copy_rtx_if_shared): Check for any virtual register instead of frame
	or argument pointer.
	(init_emit): Start normal pseudos after virtual pseudos.
	Copy the unique virtual regs into regno_reg_rtx.
	(init_emit_once): Incoming and outgoing static chain can be the same;
	inlining of nested functions won't need the distinction.
	Create unique copies of virtual registers.

	* explow.c (memory_address): Don't worry about refs to fp or ap;
	force_reg knows how to handle them correctly.
	(fix_lexical_addr): Moved to function.c
	(adjust_stack, anti_adjust_stack): Do nothing for adjustment of zero.
	(allocate_dynamic_stack_space): New function copied from
	expand_builtin.  Handle STACK_POINTER_OFFSET via
	virtual_stack_dynamic_rtx.  When STACK_POINTER_OFFSET is defined,
	perform alignment by always reserving a multiple of STACK_BOUNDARY
	stack bits.  This avoids concern about whether sp itself or the top of
	stack needs to be aligned; if we start with an aligned stack, we keep
	it aligned.
	(round_push): Use ADD and AND rather than DIV and MULT.

	* expr.c (init_expr): Initialize some more vars.
	(push_block): Use virtual_outgoing_args_rtx so don't need
	STACK_POINTER_OFFSET here.
	Merge extra and size more efficiently; no need to call force_operand
	since memory_address is called.
	(emit_push_insn): Pass type for FUNCTION_ARG_PADDING.
	Use REG_PARM_STACK_SPACE instead of FIRST_PARM_CALLER_OFFSET.
	To see if must copy address, check if it is a virtual register that
	will be mapped to sp; only need check if not accumulating space
	space for outgoing parms.
	Ignore EXTRA if argument block has already been allocated.
	(emit_library_call): Major rework to support calling sequences similar
	to expand_call in calls.c, but only support a very small subset of
	the conventions; abort if something outside our subset occurs.
	Abort if incorrect mode is passed; we can't convert here since we don't
	know the signedness.
	(store_field): Check for virtual registers instead of hard registers
	when seeing if stable.
	(safe_from_p): Location in outgoing stack area is known to be safe.
	(expand_builtin, BUILT_IN_ALLOCA): Use allocate_dynamic_stack_space.

	* expr.h: Define current_function_outgoing_args_size and
	locate_and_pad_parm; delete definition of get_structure_value_addr.
	(ARGS_SIZE_RTX): Always return a valid operand.
	(ARGS_SIZE_TREE): New macro.
	(FUNCTION_ARG_PADDING): Accept MODE and TYPE like other
	FUNCTION_ARG_... macros.
	(FUNCTION_ARG_BOUNDARY): Provide default for new macro.
	(MUST_PASS_IN_STACK): New macro.
	(allocate_dynamic_stack_space): New function.
	* tm-3b1.h, tm-3b1g.h, tm-apollo68.h, tm-crds.h, tm-mot3300.h:
	Change definition of FUNCTION_ARG_PADDING to use TYPE instead of SIZE.

	* function.c (current_function_outgoing_args_size): New var.
	(arg_pointer_save_area, virtuals_instantiated): Likewise.
	(invalid_stack_slot): No longer used.
	(push_function_context, pop_function_context): Save and restore
	outgoing args size and arg pointer save area.
	No longer save or restore invalid_stack_slot.
	(pop_function_context): Set up variables whose value is constant
	throughout rtl generation.
	(get_frame_size): No longer adjust by STARTING_FRAME_OFFSET.
	(assign_stack_local): Use virtual_stack_vars_rtx instead of fp
	until virtuals have been instantiated, then use fp.
	Remove reference to obsolete invalid_stack_slot.
	Can no longer be called with size == 0.
	(assign_outer_stack_loc): Use virtual_stack_vars_rtx instead of fp.
	Remove references to obsolete invalid_stack_slot.
	Push to obstack of containing function when allocating rtx.
	(put_var_into_stack): Only switch obstacks around making of
	queue entry.
	Replace call to parm_stack_loc with reference to info in proper
	function.
	(fixup_stack_1): Handle any virtual register instead of handling
	just fp.
	(instantiate_virtual_regs, instantiate_virtual_regs_1): New functions.
	(use_variable, use_variable_after): Check for virtual register
	instead of checking against ap and fp.
	(parm_stack_loc): Function deleted.
	(assign_parms): No longer need internal_arg_pointer.
	Accept SECOND_TIME argument that suppresses rtl generation and
	assignments to DECL_RTL.  Used by integrate.c to recompute vars.
	Don't use FIRST_PARM_OFFSET here; use virtual_incoming_args_rtx.
	Replace test for nonstable incoming arg pointer.
	If structure value address is treated as the first argument, add
	it into the list of arguments; this means we can have a RESULT_DECL
	in with the PARM_DECL's.
	DECL_OFFSET is no longer needed by integrate.c.
	Handle args passed by invisible reference.
	Support new macro, SETUP_INCOMING_VARARGS, to save all registers used
	for args including and beyond those for the current arg.  Used for
	non-ANSI varargs.
	Pass locate_and_pad_parm data it needs to handle reg->stack boundary
	if register parameters have assigned stack space.
	If we received the function's incoming structure pointer as a
	normal argument, update DECL_RTL of DECL_RESULT.
	Round total argument size if required; similarly, always use at
	least REG_PARM_STACK_SPACE bytes if defined.
	(locate_and_pad_parm): Do not need PARM.
	Major rework to do much of the job of aligning and padding stack
	location.  Now a void function wich is passed pointers to struct 
	args_size vars that are set to the argument position, size, and
	initial offset.
	Accept flag denoting if a parm was passed in a register and also
	the current function declaration.
	If register parameters are assigned stack locations and there is a
	minimum required size for the area assigned to register parameters,
	pad the stack position when a parameter not assigned to a register
	is encountered.
	Remove redundant code in MAX_PARM_BOUNDARY case.
	(lookup_static_chain): Use virtual_stack_vars_rtx instead of fp.
	(fix_lexical_addr): Move from explow.c.
	If referencing variable that lives in the incoming argument area
	of its parent and a separate ap is required, allocate a save area in
	the parent for it and use it here.  If no separate ap is require,
	compute offset between ap and fp.
	(trampoline_address): No need to push obstacks here.
	(init_function_start): Initialize new vars; delete obsolete vars.
	(expand_function_start): Don't need to handle case where incoming
	structure return address is passed as hidden parameter here; now done
	completely in assign_parms.
	(expand_function_end): Save ap if a save area was made for it.
	Set REG_FUNCTION_VALUE_P when copying address of returned
	structure.
	Be consistent in use of FUNCTION_... macros vs. hard_function_value.

	* function.h (outgoing_args_size, arg_pointer_save_area): New fields.
	(invalid_stack_slot): Obsolete, deleted.

	* integrate.c: Major rework and simplification.
	Split up vars into two classes.  Those used for expand_inline_function
	and children are now part of struct inline_remap.  Most of the others
	are for save_for_inline and its children.
	(function_cannot_inline_p): The only type of arguments that will
	cause us to reject inlining are variable-sized arguments; also
	reject functions that return variable-sized objects.
	For now, don't inline a nested function.  We'll support this shortly.
	Use current_function_returns_pcc_struct instead of duplicating test.
	(save_for_inline): No need to set TREE_VOLATILE for parms.
	Save outgoing args size in header.
	Use unique copy of virtual reg rtx's.
	Handle any required fixups for INSN_LIST forward-references.
	Don't bother resetting dead static vars when we are done.
	Need not save current_function_pretend_args_size.
	(copy_for_inline): First copy all insns, then all REG_NOTES to avoid
	problems with forward references.
	(struct inline_remap): Move all previously-static vars used by
	expand_inline_function and children into this structure.  This avoids
	potential problems due to recursive calls to expand_inline_function.
	(expand_inline_function and children): Allocate a struct inline_remap
	and pass to all children.
	(expand_inline_function): Rework parameter handling by looking at
	DECL_RTL and using it to determine what types of mappings need to be
	done.  Support objects passed by invisible reference.  Put any
	constant memory addresses into const_equiv_map.  parm_map is no longer
	used.
	Likewise for the return value: consult DECL_RTL (DECL_RESULT)).
	Don't allocate space for called function's frame until referenced.
	No longer need special handling for insn following CALL.
	Ignore USE whose argument has REG_FUNCTION_VALUE_P true.
	Ignore setting function register if we don't have a mapping for it
	(e.g., we are ignoring the result of the call).
	Look at new SET_SRC for constant equivalences.  Some new ones may
	have resulted from constant folding.
	Pass both new and old rtx to try_constants.
	Discard NOTE_INSN_DELETED notes.
	Copy insns first, then REG_NOTES, to avoid problems with forward refs.
	(copy_parm_decls): Compute new address of parameter using the
	constant equivalence map, which will contain the remapping of
	the frame and argument pointer.
	(copy_decl_tree): Likewise.
	(copy_rtx_and_substitute): Handle references to frame and argument
	pointers by allocating a space equal to the size of the frame and
	incoming arguments, respectively, and setting a pseudo to point to
	the start of each area.  Set up an equivalence in CONST_EQUIV_MAP
	between fp or ap and the actual address.  Return the pseudo.
	Don't need to deal with possibility of (SUBREG (CONST_INT)) since
	we are only replacing register with other registers here.
	No longer need to special-case PLUS and MEM;  subst_constants will do
	this work.
	Update detection of sets of ap and fp.
	(try_constants, subst_constants): Accept old and new rtx.  They will
	be isomorphic, with only register numbers changed.  Use old rtx to
	look up register in CONST_EQUIV_MAP and new rtx for substitution.
	Correctly handle SUBREG of CONST_INT and CONST_DOUBLE.
	Fix typos in handling of PLUS.
	(access_parm_map, copy_address): Delete functions.
	(try_fold_cc0): Handle both compare and test.
	(fold_out_cnst_cc0): Rework to simplify and remove dubious cases.
	(output_inline_function): Call assign_parms to perform any needed
	setups.
	Need not restore pretend arg size (will be computed by assign_parms).
	Restore outgoing argument size.

	* output.h (current_function_outgoing_args_size): New var.

	* rtl.h (OUTGOING_ARGS_SIZE): New field in INLINE_HEADER.
	(PRETEND_ARGS_SIZE): No longer needed.
	(virtual_..., VIRTUAL_...): Define virtual register numbers and rtx.

	* rtlanal.c (rtx_equal_p): Update comment on use of
	REG_FUNCTION_VALUE_P.

	* stmt.c (expand_goto): Just restore fp; non-local goto handler
	will restore ap if needed.
	(expand_return): Don't use STARTING_FRAME_OFFSET here.
	(expand_end_bindings): Adjust fp in nonlocal-goto handler.  If needed,
	reload ap from its save area in the frame; allocate save area if none.
	(expand_decl): Use new function allocate_dynamic_stack_space.

	* toplev.c (rest_of_compilation): Instantiate virtual registers.
	Clear rtx_equal_function_value_matters immediately after possibly
	saving current routine for inlining.

	* stupid.c (stupid_life_analysis): Don't try to allocate virtual
	registers (which don't exist any more).

Thu May 10 13:59:11 1990  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

	* reload1.c (modes_equiv_for_class_p): Don't compare HARD_REGNO_NREGS.

	* combine.c (subst): Simplify
	(sign_extend:M (subreg:N (ashiftrt:M (sign_extend:M (any:N ...))))).

	* fixincludes: Verify that a link leads back to /usr/include
	by checking name of dir it arrives in.  If so, use rest of dirname
	as target for new link.

	* Makefile.in (tmpgnulib): Put dummy entry in loop with LIBFUNCS_EXTRA
	so loop is never null.  Then ignore that entry when it comes up.

	* gcc.c (default_compilers): Add explicit suffix to arg of -dumpbase.

Tue May  8 13:54:37 1990  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

	* tm-ultrix.h: New file.

Mon May  7 18:47:47 1990  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

	* i386.md (test... recognizers): Output symbolic constant first.

Sun May  6 22:51:06 1990  Richard Stallman  (rms at sugar-bombs.ai.mit.edu)

	* function.c (fixup_memory_subreg): Make a sequence if -fforce-addr.

	* fixincludes: When going to directory of link name, don't lose  
	if name has no directory.
	Move the code to fix netinet/ip.h; was in the middle of something.