2004-01-22  Thiemo Seufer <seufer@csv.ica.uni-stuttgart.de>

	* config/tc-mips.c (append_insn): Don't do r3900 interlock
	optimization for -mtune=r3900, as this will break on other CPUs.

2004-01-11  Tom Rix   <tcrix@worldnet.att.net>

	* config/tc-m68hc11.c (build_indexed_byte): movb and movw cannot
	be relaxed, use fixup. 
	(md_apply_fix3): Use 5 bit reloc from movb and movw fixup.

2004-01-19  Jakub Jelinek  <jakub@redhat.com>

	* config/tc-sparc.c (sparc_ip): Disallow %f32-%f63 for single
	precision operands.

2004-01-14  Maciej W. Rozycki  <macro@ds2.pg.gda.pl>

	* config/tc-mips.c (append_insn): Properly detect variant frags
	that preclude swapping of relaxed branches.  Correctly swap
	instructions between frags when dealing with relaxed branches.

2004-01-14  Maciej W. Rozycki  <macro@ds2.pg.gda.pl>

	* acinclude.m4: Quote names of macros to be defined by AC_DEFUN
	throughout.
	* aclocal.m4: Regenerate.
	* configure: Regenerate.

2004-01-12  Anil Paranjpe  <anilp1@KPITCummins.com>
	
	* config/tc-h8300.c (build_bytes): Apply relaxation to bit
	manipulation insns.

2004-01-12  Richard Sandiford  <rsandifo@redhat.com>

	* config/tc-mips.c (macro_build_jalr): When adding an R_MIPS_JALR
	reloc, reserve space for the delay slot as well as the jalr itself.

2004-01-09  Paul Brook  <paul@codesourcery.com>

	* config/tc-arm.c (do_vfp_reg2_from_sp2): Rename from do_vfp_sp_reg2.
	(do_vfp_sp2_from_reg2): New function.
	(insns): Use them.
	(do_vfp_dp_from_reg2): Check return values properly.

2004-01-08  Ian Lance Taylor  <ian@wasabisystems.com>

	* config/tc-mips.c (warn_nops): Remove static variable.
	(macro): Remove test of warn_nops.
	(md_shortops): Remove 'n'.
	(md_parse_option): Remove 'n' case.
	(md_show_usage): Remove -n.
	* doc/as.texinfo (Overview): Remove MIPS -n option.
	* doc/c-mips.texi (MIPS Opts): Remove mention -n.
	* NEWS: Mention removal of MIPS -n option.

	* config/tc-mips.c (ISA_HAS_COPROC_DELAYS): Remove.
	(cop_interlocks): Check ISA level.
	(cop_mem_interlocks): Define.
	(reg_needs_delay): Check cop_interlocks rather than
	ISA_HAS_COPROC_DELAYS.
	(append_insn): Likewise.  Use cop_mem_interlocks rather than
	directly checking mips_opts.isa.
	(mips_emit_delays): Likewise.

2004-01-07  H.J. Lu  <hongjiu.lu@intel.com>

	* config/tc-ia64.c (unwind): Move next_slot_number and
	next_slot_frag to ...
	(unw_rec_list): Here.
	(free_list_records): Removed.
	(output_unw_records): Likewise.
	(generate_unwind_image): Make it void.
	(alloc_record): Initialize next_slot_number and next_slot_frag.
	(slot_index): Take .org, .space and .align into account.
	(fixup_unw_records): Don't set slot_number to 0. Use
	list->next_slot_number and list->next_slot_frag instead of
	unwind.next_slot_number and unwind.next_slot_frag.
	(ia64_convert_frag): New.
	(generate_unwind_image): Generate a rs_machine_dependent frag
	for unwind record.
	(emit_one_bundle): Use list->next_slot_number and
	list->next_slot_frag instead of unwind.next_slot_number and
	unwind.next_slot_frag.

	* config/tc-ia64.h (md_convert_frag): Defined as
	ia64_convert_frag.
	(md_estimate_size_before_relax): Defined as (f)->fr_var.

2004-01-06  Alexandre Oliva  <aoliva@redhat.com>

	2003-12-19  Alexandre Oliva  <aoliva@redhat.com>
	* config/tc-frv.h (md_apply_fix3): Don't define.
	* config/tc-frv.c (md_apply_fix3): New.  Shift/truncate %hi/%lo
	operands.
	* config/tc-frv.h (TC_FORCE_RELOCATION_SUB_LOCAL): Define.
	2003-10-07  Alexandre Oliva  <aoliva@redhat.com>
	* config/tc-frv.c (line_separator_chars): Add `!'.
	2003-09-19  Alexandre Oliva  <aoliva@redhat.com>
	* config/tc-frv.c (md_assemble): Clear insn upfront.
	2003-09-18  Alexandre Oliva  <aoliva@redhat.com>
	* config/tc-frv.c (OPTION_FDPIC): New macro.
	(md_longopts): Add mfdpic.
	(md_parse_option): Handle it.
	2003-08-04  Alexandre Oliva  <aoliva@redhat.com>
	* config/tc-frv.c (md_cgen_lookup_reloc) <FRV_OPERAND_D12,
	FRV_OPERAND_S12>: Use reloc type encoded in fix-up.
	(frv_pic_ptr): Parse funcdesc.

2004-01-05  Maciej W. Rozycki  <macro@ds2.pg.gda.pl>

	* doc/as.texinfo: Let texi2pod parse asconfig.texi and
	gasver.texi.  Remove duplicate symbol definitions for texi2pod.

2004-01-05  Maciej W. Rozycki  <macro@ds2.pg.gda.pl>

	* Makefile.am (Makefile): Move the dependency on
	$(BFDDIR)/configure.in to...
	(CONFIG_STATUS_DEPENDENCIES): ... here.
	(AUTOMAKE_OPTIONS): Require automake 1.8.
	* Makefile.in: Regenerate.
	* doc/Makefile.am (BASEDIR, BFDDIR): Define.
	(CONFIG_STATUS_DEPENDENCIES): Add a dependency on
	$(BFDDIR)/configure.in here as well.
	* doc/Makefile.in: Regenerate.

2004-01-05  Maciej W. Rozycki  <macro@ds2.pg.gda.pl>

	* Makefile.am (install, install-info, RECURSIVE_TARGETS): Remove.
	* Makefile.in: Regenerate.
	* aclocal.m4: Regenerate.
	* doc/Makefile.am (install, install-info): Remove.
	(install-data-local): A new hook for install-info.
	(AUTOMAKE_OPTIONS): Require automake 1.8.
	* doc/Makefile.in: Regenerate.

2004-01-02  Nutan Singh <nutan@kpitcummins.com>

	* doc/c-sh.texi: Update description about floating point behavior
	of SH family.

2004-01-02  Bernardo Innocenti  <bernie@develer.com>

	* configure.in: Add m68k-uClinux target.
	* configure: Regenerate.

For older changes see ChangeLog-0203

Local Variables:
mode: change-log
left-margin: 8
fill-column: 74
version-control: never
End:
