2020-03-03  Luis Machado  <luis.machado@linaro.org>

	* elf/common.h (AT_L1I_CACHESIZE, AT_L1I_CACHEGEOMETRY)
	(AT_L1D_CACHESIZE, AT_L1D_CACHEGEOMETRY, AT_L2_CACHESIZE)
	(AT_L2_CACHEGEOMETRY, AT_L3_CACHESIZE, AT_L3_CACHEGEOMETRY)
	(AT_MINSIGSTKSZ): New defines, imported from glibc.

2020-02-25  Andrew Burgess  <andrew.burgess@embecosm.com>

	Import from gcc mainline:
	2020-02-05  Andrew Burgess  <andrew.burgess@embecosm.com>

	* hashtab.h (htab_remove_elt): Make a parameter const.
	(htab_remove_elt_with_hash): Likewise.

2020-02-20  Nelson Chu  <nelson.chu@sifive.com>

	* opcode/riscv-opc.h: Extend DECLARE_CSR and DECLARE_CSR_ALIAS to
	record riscv_csr_class.

2020-02-10  Stam Markianos-Wright  <stam.markianos-wright@arm.com>
	    Matthew Malcomson  <matthew.malcomson@arm.com>

	* opcode/arm.h (ARM_EXT2_CDE): New extension macro.
	(ARM_EXT2_CDE0): New extension macro.
	(ARM_EXT2_CDE1): New extension macro.
	(ARM_EXT2_CDE2): New extension macro.
	(ARM_EXT2_CDE3): New extension macro.
	(ARM_EXT2_CDE4): New extension macro.
	(ARM_EXT2_CDE5): New extension macro.
	(ARM_EXT2_CDE6): New extension macro.
	(ARM_EXT2_CDE7): New extension macro.

2020-02-07  Sergey Belyashov  <sergey.belyashov@gmail.com>

	PR 25469
	* coff/internal.h (R_IMM16BE): Define.
	* elf/z80.h (EF_Z80_MACH_Z80N): Define.
	(R_Z80_16_BE): New reloc.

2020-02-04  Alan Modra  <amodra@gmail.com>

	* opcode/d30v.h (struct pd_reg): Make value field unsigned.

2020-01-16  Jon Turney  <jon.turney@dronecode.org.uk>

	* coff/internal.h (PE_IMAGE_DEBUG_TYPE_VC_FEATURE)
	(PE_IMAGE_DEBUG_TYPE_POGO, PE_IMAGE_DEBUG_TYPE_ILTCG)
	(PE_IMAGE_DEBUG_TYPE_MPX, PE_IMAGE_DEBUG_TYPE_REPRO): Add.

2020-01-18  Nick Clifton  <nickc@redhat.com>

	Binutils 2.34 branch created.

2020-01-17  Nick Clifton  <nickc@redhat.com>

	* Import from gcc mainline:
	2019-06-10  Martin Liska  <mliska@suse.cz>

	* ansidecl.h (ATTRIBUTE_WARN_UNUSED_RESULT): New macro.
	* libiberty.h (xmalloc): Use it.
	(xrealloc): Likewise.
	(xcalloc): Likewise.
	(xstrdup): Likewise.
	(xstrndup): Likewise.
	(xmemdup): Likewise.

	2019-06-10  Martin Liska  <mliska@suse.cz>

	* ansidecl.h:
	(ATTRIBUTE_RESULT_SIZE_1): Define new macro.
	(ATTRIBUTE_RESULT_SIZE_2): Likewise.
	(ATTRIBUTE_RESULT_SIZE_1_2): Likewise.
	* libiberty.h (xmalloc): Add RESULT_SIZE attribute.
	(xrealloc): Likewise.
	(xcalloc): Likewise.

	2019-11-16  Tim Ruehsen  <tim.ruehsen@gmx.de>

	* demangle.h (struct demangle_component): Add member
	d_counting.

	2019-11-16  Eduard-Mihai Burtescu  <eddyb@lyken.rs>

	* demangle.h (rust_demangle_callback): Add.

	2019-07-18  Eduard-Mihai Burtescu  <eddyb@lyken.rs>

	* demangle.h (rust_is_mangled): Move to libiberty/rust-demangle.h.
	(rust_demangle_sym): Move to libiberty/rust-demangle.h.

2020-01-16  Andre Vieira  <andre.simoesdiasvieira@arm.com>

	PR 25376
	* opcodes/arm.h (FPU_MVE, FPU_MVE_FPU): Move these features to...
	(ARM_EXT2_MVE, ARM_EXT2_MVE_FP): ... the CORE_HIGH space.
	(ARM_ANY): Redefine to not include any MVE bits.
	(ARM_FEATURE_ALL): Removed.

2020-01-15  Jozef Lawrynowicz  <jozef.l@mittosystems.com>

	* opcode/msp430.h (enum msp430_expp_e): New.
	(struct msp430_operand_s): Add expp member to struct.

2020-01-13  Claudiu Zissulescu  <claziss@gmail.com>

	* elf/arc-cpu.def: Update ARC cpu list.

2020-01-13  Alan Modra  <amodra@gmail.com>

	* opcode/tic4x.h (EXTR): Delete.
	(EXTRU, EXTRS, INSERTU, INSERTS): Rewrite without zero/sign
	extension using shifts.  Do trim INSERTU value to specified bitfield.

2020-01-10  Alan Modra  <amodra@gmail.com>

	* opcode/spu.h: Formatting.
	(UNSIGNED_EXTRACT): Use 1u.
	(SIGNED_EXTRACT): Don't sign extend with shifts.
	(DECODE_INSN_I9a, DECODE_INSN_I9b): Avoid left shift of signed value.
	Keep result signed.
	(DECODE_INSN_U9a, DECODE_INSN_U9b): Delete.

2020-01-07  Shahab Vahedi  <shahab@synopsys.com>

	* opcode/arc.h (insn_class_t): Add 'LLOCK' and 'SCOND'.

2020-01-02  Sergey Belyashov  <sergey.belyashov@gmail.com>

	* coff/internal.h: Add defintions of Z80 reloc names.

2020-01-02  Christian Biesinger  <cbiesinger@google.com>

	* opcode/s12z.h: Undef REG_Y.

2020-01-01  Alan Modra  <amodra@gmail.com>

	Update year range in copyright notice of all files.

For older changes see ChangeLog-2019

Copyright (C) 2020 Free Software Foundation, Inc.

Copying and distribution of this file, with or without modification,
are permitted in any medium without royalty provided the copyright
notice and this notice are preserved.

Local Variables:
mode: change-log
left-margin: 8
fill-column: 74
version-control: never
End:
