2008-06-12  David S. Miller  <davem@davemloft.net>

	* powerpc.h: New file.
	* elfcpp.h (SHT_ORDERED): New enum constant.
	(DT_PPC_GOT, DT_PPC64_GLINK, DT_PPC64_OPD, DT_PPC64_OPDSZ): Same.

2008-05-28  Caleb Howe  <cshowe@google.com>

	* dwarf.h (enum DW_FORM): Define.

2008-04-19  Ian Lance Taylor  <iant@google.com>

	* elfcpp_file.h (class Elf_file): Add large_shndx_offset_ field.
	(Elf_file::large_shndx_offset): New function.
	(Elf_file::construct): Initialize large_shndx_offset_.
	(Elf_File::initialize_shnum): If necessary, adjust shstrndx_ and
	set large_shndx_offset_.

2008-04-16  David S. Miller  <davem@davemloft.net>

	* elfcpp.h (DF_1_NOW, DF_1_GLOBAL, DF_1_GROUP,
	DF_1_NODELETE, DF_1_LOADFLTR, DF_1_INITFIRST,
	DF_1_NOOPEN, DF_1_ORIGIN, DF_1_DIRECT, DF_1_TRANS,
	DF_1_INTERPOSE, DF_1_NODEFLIB, DF_1_NODUMP,
	DF_1_CONLFAT): New enum constants.

2008-04-15  David S. Miller  <davem@davemloft.net>

	* sparc.h (EF_SPARC_EXT_MASK, EF_SPARC_32PLUS_MASK,
	EF_SPARC_32PLUS, EF_SPARC_SUN_US1, EF_SPARC_HAL_R1,
	EF_SPARC_SUN_US3, EF_SPARC_LEDATA, EF_SPARCV9_MM,
	EF_SPARCV9_TSO, EF_SPARCV9_PSO, EF_SPARCV9_RMO):
	Define as enum constants.

2008-04-11  David S. Miller  <davem@davemloft.net>

	* sparc.h: New file
	* elfcpp.h (SHN_BEFORE, SHN_AFTER): New enum constants.
	(SHT_SPARC_GOTDATA, SHF_ORDERED, SHF_EXCLUDE,
	STT_SPARC_REGISTER, DT_SPARC_REGISTER): Likewise.

2008-04-03  Ian Lance Taylor  <iant@google.com>

	* elfcpp_swap.h (Swap_unaligned<64, true>::writeval): Correct
	byte order.

2008-03-24  Ian Lance Taylor  <iant@google.com>

	* elfcpp.h (NT_VERSION, NT_ARCH): Define as enum constants.
	(NT_GNU_ABI_TAG, NT_GNU_HWCAP): Likewise.
	(NT_GNU_BUILD_ID, NT_GNU_GOLD_VERSION): Likewise.
	(ELF_NOTE_OS_LINUX, ELF_NOTE_OS_GNU): Likewise.
	(ELF_NOTE_OS_SOLARIS2, ELF_NOTE_OS_NETBSD): Likewise.
	(ELF_NOTE_OS_SYLLABLE): Likewise.

2008-03-21  Ian Lance Taylor  <iant@google.com>

	* Added source code to GNU binutils.

