		SIM Maintainers

The simulator is part of the GDB project, so see the file
gdb/MAINTAINERS for general information about maintaining these files.

If you are considering contributing a patch, please see the file
gdb/CONTRIBUTE.  Patches to these files should be posted to:
gdb-patches@sources.redhat.com 

        Global Maintainers

Mike Frysinger			vapier@gentoo.org
	
	Maintainers for particular sims:

arm	        Nick Clifton <nickc@redhat.com>
bfin		Mike Frysinger <vapier@gentoo.org>
cr16	        M R Swami Reddy <MR.Swami.Reddy@nsc.com>
frv		Dave Brolley <brolley@redhat.com>
igen		(igen simulators)
lm32		Jon Beniston <jon@beniston.com>
rl78		DJ Delorie <dj@redhat.com>
m32c		DJ Delorie <dj@redhat.com>
m32r		Doug Evans <dje@sebabeach.org>
m68hc11		Stephane Carrez <Stephane.Carrez@gmail.com>
microblaze	Michael Eager <eager@eagercon.com>
moxie		Anthony Green <green@moxielogic.com>
rx		DJ Delorie <dj@redhat.com>
sh		(global maintainers)
sh64		Dave Brolley <brolley@redhat.com>
common		Frank Ch. Eigler <fche@redhat.com>
*		(target, then global maintainers)

	Authorized committers for particular sims:
v850		DJ Delorie <dj@redhat.com>
*		Hans-Peter Nilsson <hp@axis.com>

	Past sim maintainers:

common		Ben Elliston <bje@gnu.org>
mips		Andrew Cagney <ac131313@redhat.com>
mips		Chris Demetriou <cgd@netbsd.org>
ppc		Geoff Keating <geoffk@geoffk.org>
ppc		Andrew Cagney <cagney@gnu.org>
