2021-06-03   Ben Asselstine  <benasselstine@gmail.com>

	PR 4283
	* gprof.texi (Executing): Note GMON_OUT_PREFIX environment variable.

2021-05-08  Mike Frysinger  <vapier@gentoo.org>

	* Makefile.am (html-local, doc/gprof/index.html): New targets.
	* Makefile.in: Regenerate.

2021-05-08  Mike Frysinger  <vapier@gentoo.org>

	* Makefile.am (AM_MAKEINFOFLAGS): Add --no-split.
	* Makefile.in: Regenerate.

2021-04-14  Alan Modra  <amodra@gmail.com>

	PR 27716
	* gprof.h (PATH_MAX): Don't define.
	* corefile.c (core_create_line_syms): Don't use PATH_MAX for initial
	file name size.
	* source.c (annotate_source): Malloc file name buffer.  Always
	trim off "-ann" when dos 8.3 annotate file matches original.
	* utils.c (print_name_only): Malloc file name buffer.

2021-04-05  Alan Modra  <amodra@gmail.com>

	* configure.ac: Check for sys/time.h and setitimer.  Don't invoke
	AC_ISC_POSIX.  Don't check for setmode.
	* gprof.c: Don't test HAVE_SETLOCALE.
	* gprof.h: Include sys/time.h.
	* configure: Regenerate.
	* gconfig.in: Regenerate.

2021-03-31  Alan Modra  <amodra@gmail.com>

	* basic_blocks.c: Replace bfd_boolean with bool, FALSE with false,
	and TRUE with true throughout.
	* basic_blocks.h: Likewise.
	* cg_arcs.c: Likewise.
	* cg_dfn.c: Likewise.
	* cg_print.c: Likewise.
	* corefile.c: Likewise.
	* gmon_io.c: Likewise.
	* gprof.c: Likewise.
	* gprof.h: Likewise.
	* hist.c: Likewise.
	* mips.c: Likewise.
	* source.c: Likewise.
	* source.h: Likewise.
	* sym_ids.c: Likewise.
	* sym_ids.h: Likewise.
	* symtab.h: Likewise.
	* vax.c: Likewise.

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

	* Makefile.in: Regenerate.

2021-01-12  H.J. Lu  <hongjiu.lu@intel.com>

	PR binutils/26792
	* configure.ac: Use GNU_MAKE_JOBSERVER.
	* aclocal.m4: Regenerated.
	* configure: Likewise.

2021-01-11  H.J. Lu  <hongjiu.lu@intel.com>

	PR ld/27173
	* configure: Regenerated.

2021-01-09  H.J. Lu  <hongjiu.lu@intel.com>

	* configure: Regenerated.

2021-01-09  Nick Clifton  <nickc@redhat.com>

	* configure: Regenerate.
	* po/gprof.pot: Regenerate.

2021-01-09  Nick Clifton  <nickc@redhat.com>

	* 2.36 release branch crated.

2021-01-09  Alan Modra  <amodra@gmail.com>

	* configure: Regenerate.

2021-01-07  Samuel Thibault  <samuel.thibault@gnu.org>

	* configure: Regenerate.

2021-01-01  Nicolas Boulenguez  <nicolas@debian.org>

	* README: Correct grammar.
	* gprof.texi: Likewise.

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

	Update year range in copyright notice of all files.

For older changes see ChangeLog-2020

Copyright (C) 2021 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:
