2014-09-24  David Malcolm  <dmalcolm@redhat.com>

	* ChangeLog.jit: Add copyright footer.

2013-10-07  David Malcolm  <dmalcolm@redhat.com>

	* Makefile.am: Add PICFLAG to libz_a_CFLAGS.
	* configure.ac (--enable-host-shared): Set up PICFLAG rather
	than attempting to append -fPIC to CFLAGS.
	* Makefile.in: Regenerate.
	* configure: Regenerate.

2013-10-03  David Malcolm  <dmalcolm@redhat.com>

	* configure.ac: Add --enable-host-shared.
	* configure: Regenerate.

Copyright (C) 2013-2014 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.
