diff options
Diffstat (limited to 'gdb')
242 files changed, 58343 insertions, 0 deletions
diff --git a/gdb/.gdbinit b/gdb/.gdbinit new file mode 100644 index 0000000..bcacd5d --- /dev/null +++ b/gdb/.gdbinit @@ -0,0 +1,15 @@ +echo Setting up the environment for debugging gdb.\n + +b fatal + +b info_command +commands + silent + return +end + +define rr + run +end + +set prompt (top-gdb) diff --git a/gdb/Convex.notes b/gdb/Convex.notes new file mode 100644 index 0000000..28d336b --- /dev/null +++ b/gdb/Convex.notes @@ -0,0 +1,163 @@ + +@node Convex,,, Top +@appendix Convex-specific info +@cindex Convex notes + +Scalar registers are 64 bits long, which is a pain since +left half of an S register frequently contains noise. +Therefore there are two ways to obtain the value of an S register. + +@table @kbd +@item $s0 +returns the low half of the register as an int + +@item $S0 +returns the whole register as a long long +@end table + +You can print the value in floating point by using @samp{p/f $s0} or @samp{p/f $S0} +to print a single or double precision value. + +@cindex vector registers +Vector registers are handled similarly, with @samp{$V0} denoting the whole +64-bit register and @kbd{$v0} denoting the 32-bit low half; @samp{p/f $v0} +or @samp{p/f $V0} can be used to examine the register in floating point. +The length of the vector registers is taken from @samp{$vl}. + +Individual elements of a vector register are denoted in the obvious way; +@samp{print $v3[9]} prints the tenth element of register @kbd{v3}, and +@samp{set $v3[9] = 1234} alters it. + +@kbd{$vl} and @kbd{$vs} are int, and @kbd{$vm} is an int vector. +Elements of @kbd{$vm} can't be assigned to. + +@cindex communication registers +@kindex info comm-registers +Communication registers have names @kbd{$C0 .. $C63}, with @kbd{$c0 .. $c63} +denoting the low-order halves. @samp{info comm-registers} will print them +all out, and tell which are locked. (A communication register is +locked when a value is sent to it, and unlocked when the value is +received.) Communication registers are, of course, global to all +threads, so it does not matter what the currently selected thread is. +@samp{info comm-reg @var{name}} prints just that one communication +register; @samp{name} may also be a communication register number +@samp{nn} or @samp{0xnn}. +@samp{info comm-reg @var{address}} prints the contents of the resource +structure at that address. + +@kindex info psw +The command @samp{info psw} prints the processor status word @kbd{$ps} +bit by bit. + +@kindex set base +GDB normally prints all integers in base 10, but the leading +@kbd{0x80000000} of pointers is intolerable in decimal, so the default +output radix has been changed to try to print addresses appropriately. +The @samp{set base} command can be used to change this. + +@table @code +@item set base 10 +Integer values always print in decimal. + +@item set base 16 +Integer values always print in hex. + +@item set base +Go back to the initial state, which prints integer values in hex if they +look like pointers (specifically, if they start with 0x8 or 0xf in the +stack), otherwise in decimal. +@end table + +@kindex set pipeline +When an exception such as a bus error or overflow happens, usually the PC +is several instructions ahead by the time the exception is detected. +The @samp{set pipe} command will disable this. + +@table @code +@item set pipeline off +Forces serial execution of instructions; no vector chaining and no +scalar instruction overlap. With this, exceptions are detected with +the PC pointing to the instruction after the one in error. + +@item set pipeline on +Returns to normal, fast, execution. This is the default. +@end table + +@cindex parallel +In a parallel program, multiple threads may be executing, each +with its own registers, stack, and local memory. When one of them +hits a breakpoint, that thread is selected. Other threads do +not run while the thread is in the breakpoint. + +@kindex 1cont +The selected thread can be single-stepped, given signals, and so +on. Any other threads remain stopped. When a @samp{cont} command is given, +all threads are resumed. To resume just the selected thread, use +the command @samp{1cont}. + +@kindex thread +The @samp{thread} command will show the active threads and the +instruction they are about to execute. The selected thread is marked +with an asterisk. The command @samp{thread @var{n}} will select thread @var{n}, +shifting the debugger's attention to it for single-stepping, +registers, local memory, and so on. + +@kindex info threads +The @samp{info threads} command will show what threads, if any, have +invisibly hit breakpoints or signals and are waiting to be noticed. + +@kindex set parallel +The @samp{set parallel} command controls how many threads can be active. + +@table @code +@item set parallel off +One thread. Requests by the program that other threads join in +(spawn and pfork instructions) do not cause other threads to start up. +This does the same thing as the @samp{limit concurrency 1} command. + +@item set parallel fixed +All CPUs are assigned to your program whenever it runs. When it +executes a pfork or spawn instruction, it begins parallel execution +immediately. This does the same thing as the @samp{mpa -f} command. + +@item set parallel on +One or more threads. Spawn and pfork cause CPUs to join in when and if +they are free. This is the default. It is very good for system +throughput, but not very good for finding bugs in parallel code. If you +suspect a bug in parallel code, you probably want @samp{set parallel fixed.} +@end table + +@subsection Limitations + +WARNING: Convex GDB evaluates expressions in long long, because S +registers are 64 bits long. However, GDB expression semantics are not +exactly C semantics. This is a bug, strictly speaking, but it's not one I +know how to fix. If @samp{x} is a program variable of type int, then it +is also type int to GDB, but @samp{x + 1} is long long, as is @samp{x + y} +or any other expression requiring computation. So is the expression +@samp{1}, or any other constant. You only really have to watch out for +calls. The innocuous expression @samp{list_node (0x80001234)} has an +argument of type long long. You must explicitly cast it to int. + +It is not possible to continue after an uncaught fatal signal by using +@samp{signal 0}, @samp{return}, @samp{jump}, or anything else. The difficulty is with +Unix, not GDB. + +I have made no big effort to make such things as single-stepping a +@kbd{join} instruction do something reasonable. If the program seems to +hang when doing this, type @kbd{ctrl-c} and @samp{cont}, or use +@samp{thread} to shift to a live thread. Single-stepping a @kbd{spawn} +instruction apparently causes new threads to be born with their T bit set; +this is not handled gracefully. When a thread has hit a breakpoint, other +threads may have invisibly hit the breakpoint in the background; if you +clear the breakpoint gdb will be surprised when threads seem to continue +to stop at it. All of these situations produce spurious signal 5 traps; +if this happens, just type @samp{cont}. If it becomes a nuisance, use +@samp{handle 5 nostop}. (It will ask if you are sure. You are.) + +There is no way in GDB to store a float in a register, as with +@kbd{set $s0 = 3.1416}. The identifier @kbd{$s0} denotes an integer, +and like any C expression which assigns to an integer variable, the +right-hand side is casted to type int. If you should need to do +something like this, you can assign the value to @kbd{@{float@} ($sp-4)} +and then do @kbd{set $s0 = $sp[-4]}. Same deal with @kbd{set $v0[69] = 6.9}. diff --git a/gdb/Makefile.dist b/gdb/Makefile.dist new file mode 100755 index 0000000..7b4e3ce --- /dev/null +++ b/gdb/Makefile.dist @@ -0,0 +1,506 @@ +##Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# Place to install binaries. +bindir=/usr/local/bin + +# System V: If you compile gdb with a compiler which uses the coff +# encapsulation feature (this is a function of the compiler used, NOT +# of the m-?.h file selected by config.gdb), you must make sure that +# the GNU nm is the one that is used by munch. + +# If you are compiling with GCC, make sure that either 1) You use the +# -traditional flag, or 2) You have the fixed include files where GCC +# can reach them. Otherwise the ioctl calls in inflow.c and readline.c +# will be incorrectly compiled. The "fixincludes" script in the gcc +# distribution will fix your include files up. +#CC=cc +#CC=gcc -traditional +GCC=gcc + +VPATH=$(srcdir) + +# It is also possible that you will need to add -I/usr/include/sys to the +# CFLAGS section if your system doesn't have fcntl.h in /usr/include (which +# is where it should be according to Posix). + +YACC=bison -y +# YACC=yacc +SHELL=/bin/sh +MAKE=make + +# Set this up with gcc if you have gnu ld and the loader will print out +# line numbers for undefinded refs. +#CC-LD=gcc -static +CC-LD=${CC} + +# define this to be "gmalloc.o" if you want to use the gnu malloc routine +# (useful for debugging memory allocation problems in gdb). To use your +# system malloc, uncomment the following two lines. +#GNU_MALLOC = +#MALLOC_CFLAGS = -DNO_MALLOC_CHECK +GNU_MALLOC = gmalloc.o mcheck.o +MALLOC_CFLAGS = + +# Where is the "include" directory? Traditionally ../include or ./include +INCLUDE_DIR = ${srcdir}/../include +INCLUDE_DEP = $$(INCLUDE_DIR) + +# Where is the BFD library? Traditionally ../bfd or ./bfd +BFD_DIR = ${srcdir}/../bfd +BFD_DEP = $$(BFD_DIR) + +# All the includes used for CFLAGS and for lint. +# -I. for config files. +# -I${srcdir} for <obstack.h>, possibly regex.h also. +INCLUDE_CFLAGS = -I. -I${srcdir} -I$(INCLUDE_DIR) -I${srcdir}/vx-share + +# {X,T}M_CFLAGS, if defined, has system-dependent CFLAGS. +# CFLAGS for both GDB and readline. +GLOBAL_CFLAGS = -g ${TM_CFLAGS} ${XM_CFLAGS} +#PROFILE_CFLAGS = -pg + +CFLAGS = ${GLOBAL_CFLAGS} ${PROFILE_CFLAGS} ${MALLOC_CFLAGS} ${INCLUDE_CFLAGS} +# None of the things in CFLAGS will do any harm, and on some systems +# (e.g. SunOS4) it is important to use the M_CFLAGS. +LDFLAGS = $(CFLAGS) + +# define this to be "obstack.o" if you don't have the obstack library installed +# so that the dependencies work right. +OBSTACK = obstack.o + +# Requires GNU getopt_long features. +GETOPT = getopt.o getopt1.o +# Where is the getopt directory? Traditionally ../getopt or ./getopt +GETOPT_DIR = ${srcdir}/../getopt +GETOPT_DEP = $$(GETOPT_DIR) + +# Flags that describe where you can find the termcap library. +# You may need to make other arrangements for USG. +TERMCAP = -ltermcap + +# You must define REGEX and REGEX1 on USG machines. +# If your sysyem is missing alloca(), or, more likely, it's there but +# it doesn't work, define ALLOCA & ALLOCA1 + +# {X,T}M_CLIBS, if defined, has system-dependent libs +# For example, -lPW for System V to get alloca(). +# FIXME STOPGAP FOR BFD LIBRARY: BFD stuff +CLIBS = ${TERMCAP} $(XM_CLIBS) ${TM_CLIBS} ${BFD_DIR}/libbfd.a +CDEPS = ${XM_CDEPS} ${TM_CDEPS} ${BFD_DIR}/libbfd.a + +ADD_FILES = ${OBSTACK} ${REGEX} ${ALLOCA} ${GNU_MALLOC} ${GETOPT} +ADD_DEPS = ${OBSTACK} ${REGEX1} ${ALLOCA1} ${GNU_MALLOC} ${GETOPT} + +VERSION = 3.94.2 +DIST=gdb-$(VERSION) + +LINT=/usr/5bin/lint +LINTFLAGS= + +# Source files in the main directory. +# Files which are included via a tconfig/* or xconfig/* file +# should *not* be specified here; they're in "ALLDEPFILES". +SFILES_MAINDIR = \ + blockframe.c breakpoint.c command.c core.c \ + environ.c eval.c expprint.c findvar.c infcmd.c inflow.c infrun.c \ + main.c printcmd.c \ + remote.c source.c stack.c symmisc.c symtab.c symfile.c \ + utils.c valarith.c valops.c valprint.c values.c expread.y \ + signame.c cplus-dem.c mem-break.c target.c inftarg.c \ + dbxread.c coffread.c \ + ieee-float.c + +# Source files in subdirectories (which will be handled separately by +# 'make gdb.tar.Z'). +# Files which are included via a tconfig/* or xconfig/* file +# should *not* be specified here; they're in "ALLDEPFILES". +SFILES_SUBDIR = \ + ${srcdir}/vx-share/dbgRpcLib.h \ + ${srcdir}/vx-share/ptrace.h \ + ${srcdir}/vx-share/reg.h \ + ${srcdir}/vx-share/vxTypes.h \ + ${srcdir}/vx-share/vxWorks.h \ + ${srcdir}/vx-share/wait.h \ + ${srcdir}/vx-share/xdr_ld.h \ + ${srcdir}/vx-share/xdr_ptrace.h \ + ${srcdir}/vx-share/xdr_rdb.h \ + ${srcdir}/vx-share/xdr_regs.h \ + ${srcdir}/nindy-share/Makefile \ + ${srcdir}/nindy-share/VERSION \ + ${srcdir}/nindy-share/b.out.h \ + ${srcdir}/nindy-share/block_io.h \ + ${srcdir}/nindy-share/coff.h \ + ${srcdir}/nindy-share/demux.h \ + ${srcdir}/nindy-share/env.h \ + ${srcdir}/nindy-share/stop.h \ + ${srcdir}/nindy-share/ttycntl.h + +# All source files that go into linking GDB, except config-specified files. +SFILES = $(SFILES_MAINDIR) $(SFILES_SUBDIR) + +# All source files that lint should look at +LINTFILES = $(SFILES) expread.tab.c init.c + +# Any additional files specified on these lines should also be added to +# the OTHERS = definition below, so they go in the tar files. +SFILES_STAND = $(SFILES) standalone.c +SFILES_KGDB = $(SFILES) stuff.c kdb-start.c + +# Header files that are not named in tconfig/* or xconfig/* go here. +HFILES= breakpoint.h command.h defs.h environ.h \ + expression.h frame.h gdbcmd.h gdbcore.h \ + getpagesize.h ieee-float.h inferior.h param-no-tm.h param.h \ + signals.h signame.h symfile.h symtab.h \ + target.h tdesc.h terminal.h tm-68k.h tm-i960.h tm-sunos.h \ + value.h + +OPCODES = pn-opcode.h np1-opcode.h sparc-opcode.h vax-opcode.h m68k-opcode.h \ + ns32k-opcode.h convex-opcode.h pyr-opcode.h mips-opcode.h \ + am29k-opcode.h + +REMOTE_EXAMPLES = remote-sa.m68k.shar remote-multi.shar + +MALLOCSRC = gmalloc.c mcheck.c ansidecl.h stdlib.h gmalloc.h stddef.h +GETOPTSRC = $(GETOPT_DIR)/getopt.c $(GETOPT_DIR)/getopt1.c + +POSSLIBS_MAINDIR = obstack.h obstack.c regex.c regex.h alloca.c \ + $(MALLOCSRC) +POSSLIBS = $(POSSLIBS_MAINDIR) $(GETOPTSRC) + +TESTS = testbpt.c testfun.c testrec.c testreg.c testregs.c + +# tdesc-lib cannot be named simply tdesc, because if if it were GNU make +# would try to make it from tdesc.c. +# tdesc-lib removed from the list due to Motorola copyrights...gnu@cygnus.com +OTHERS = Makefile.dist depend alldeps.mak Makefile.srcdir \ + createtags munch config.gdb config.status \ + ChangeLog ChangeLog-3.x \ + README TODO TAGS WHATS.NEW \ + gdb.texinfo gdb-int.texinfo gdbrc.tex threecol.tex \ + .gdbinit COPYING expread.tab.c stab.def \ + copying.c Projects Convex.notes copying.awk \ + saber.suppress standalone.c stuff.c kdb-start.c \ + hp-include # tests + +DEPFILES= ${TDEPFILES} ${XDEPFILES} + +SOURCES=$(SFILES) $(ALLDEPFILES) +TAGFILES = $(SOURCES) ${HFILES} ${OPCODES} ${ALLPARAM} ${POSSLIBS} +TAGFILES_MAINDIR = $(SFILES_MAINDIR) $(ALLDEPFILES_MAINDIR) \ + ${HFILES} ${OPCODES} ${ALLPARAM} ${POSSLIBS_MAINDIR} +TARFILES = ${TAGFILES_MAINDIR} ${OTHERS} ${REMOTE_EXAMPLES} + +OBS = main.o blockframe.o breakpoint.o findvar.o stack.o source.o \ + values.o eval.o valops.o valarith.o valprint.o printcmd.o \ + symtab.o symfile.o symmisc.o infcmd.o infrun.o remote.o \ + command.o utils.o expread.o expprint.o environ.o version.o \ + copying.o $(DEPFILES) signame.o cplus-dem.o mem-break.o target.o \ + inftarg.o ieee-float.o \ + dbxread.o coffread.o # mipsread.o + +RAPP_OBS = rgdb.o rudp.o rserial.o serial.o udp.o $(XDEPFILES) + +TSOBS = core.o inflow.o + +NTSOBS = standalone.o + +TSSTART = /lib/crt0.o + +NTSSTART = kdb-start.o + +RL_LIB = readline/libreadline.a +RL_LIB_DEP = $(RL_LIB) + +# Prevent Sun make from putting in the machine type. Setting +# TARGET_ARCH to nothing works for SunOS 3, 4.0, but not for 4.1. +.c.o: + ${CC} -c ${CFLAGS} $< + +all: gdb + +install: gdb + cp gdb $(bindir)/gdb.new + mv $(bindir)/gdb.new $(bindir)/gdb + $(M_INSTALL) + +init.c: $(srcdir)/munch $(MUNCH_DEFINE) $(OBS) $(TSOBS) + $(srcdir)/munch ${MUNCH_DEFINE} $(OBS) $(TSOBS) > init.c + +gdb: $(OBS) $(TSOBS) ${ADD_DEPS} ${RL_LIB_DEP} ${CDEPS} init.o + ${CC-LD} $(LDFLAGS) -o gdb init.o $(OBS) $(TSOBS) $(ADD_FILES) \ + ${RL_LIB} $(CLIBS) + +saber_gdb: $(SFILES) $(GETOPTSRC) $(DEPFILES) copying.c obstack.c version.c + #setopt load_flags $(CFLAGS) -I$(BFD_DIR) + #load ./init.c $(SFILES) + #unload ${srcdir}/expread.y + #load ${srcdir}/expread.tab.c readline/libreadline.a + #load copying.c version.c + #load obstack.c $(GETOPTSRC) + #load `echo " "$(DEPFILES) | sed -e 's/\.o/.c/g' -e 's, , ../,g'` + #load ${BFD_DIR}/libbfd.a -ltermcap + ##void mcheck(a) void (*a)(); { } + + + +# This is useful when debugging GDB, because some Unix's don't let you run GDB +# on itself without copying the executable. So "make gdb1" will make +# gdb and put a copy in gdb1, and you can run it with "gdb gdb1". +# Removing gdb1 before the copy is the right thing if gdb1 is open +# in another process. +gdb1: gdb + rm -f gdb1 + cp gdb gdb1 + +# This is a remote stub which runs under unix and starts up an +# inferior process. This is at least useful for debugging GDB's +# remote support. +rapp: $(RAPP_OBS) + rm -f rapp_init.c + ${srcdir}/munch ${RAPP_OBS} > rapp_init.c + ${CC-LD} $(LDFLAGS) -o $@ rapp_init.c $(RAPP_OBS) + +Makefiles= Makefile.srcdir $(M_MAKEFILE) \ + ${srcdir}/alldeps.mak ${srcdir}/Makefile.dist + +MAKE_MAKEFILE= echo "M_MAKEFILE=$(M_MAKEFILE)" | \ + cat - ${Makefiles} ${srcdir}/depend >Makefile + +Makefile: $(Makefiles) + $(MAKE_MAKEFILE) + +alldeps.mak: ${srcdir}/tconfig ${srcdir}/xconfig + rm -f alldeps.mak alldeps.tmp allparam.tmp allconfig.tmp + for i in `ls -d ${srcdir}/tconfig/*[0-9A-Za-z] \ + ${srcdir}/xconfig/*[0-9A-Za-z] | grep -v RCS` ; do \ + echo $$i >>allconfig.tmp; \ + awk <$$i ' \ + $$1 == "TDEPFILES=" || $$1 == "XDEPFILES=" { \ + for (i = 2; i <= NF; i++) \ + print $$i >> "alldeps.tmp" ; \ + } \ + $$1 == "TM_FILE=" || $$1 == "XM_FILE=" { \ + print $$2 >> "allparam.tmp" }' ; \ + done + sort <alldeps.tmp | uniq | \ + sed -e 's/arm-convert.o/arm-convert.s/' \ + -e 's!^Onindy.o!nindy-share/Onindy.c!' \ + -e 's!^nindy.o!nindy-share/nindy.c!' \ + -e 's!ttybreak.o!nindy-share/ttybreak.c!' \ + -e 's!ttyflush.o!nindy-share/ttyflush.c!' \ + -e 's!xdr_ld.o!vx-share/xdr_ld.c!' \ + -e 's!xdr_ptrace.o!vx-share/xdr_ptrace.c!' \ + -e 's!xdr_rdb.o!vx-share/xdr_rdb.c!' \ + -e 's!xdr_regs.o!vx-share/xdr_regs.c!' \ + -e 's/\.o/.c/' \ + >alldeps2.tmp + echo 'ALLDEPFILES = $$(ALLDEPFILES_MAINDIR) $$(ALLDEPFILES_SUBDIR)' \ + >>alldeps.mak; + grep -v / alldeps2.tmp | \ + awk 'BEGIN {printf "ALLDEPFILES_MAINDIR="} \ + NR == 0 {printf $$0;} \ + NR != 0 {printf "\\\n" $$0} \ + END {printf "\n\n"}' >>alldeps.mak; + grep / alldeps2.tmp | \ + awk 'BEGIN {printf "ALLDEPFILES_SUBDIR="} \ + NR == 0 {printf $$0;} \ + NR != 0 {printf "\\\n" $$0} \ + END {printf "\n\n"}' >>alldeps.mak; + sort <allparam.tmp | uniq | awk 'BEGIN {printf "ALLPARAM="} \ + NR == 0 {printf $$0;} \ + NR != 0 {printf "\\\n" $$0} \ + END {printf "\n\n"}' >>alldeps.mak; + sort <allconfig.tmp | uniq | awk 'BEGIN {printf "ALLCONFIG="} \ + NR == 0 {printf $$0;} \ + NR != 0 {printf "\\\n" $$0} \ + END {printf "\n\n"}' >>alldeps.mak; + rm -f alldeps.tmp alldeps2.tmp allparam.tmp allconfig.tmp + +# The sed script makes everything which depends on {x,t}m.h depend on +# config.status as well, in case someone reconfigures gdb out from +# under an already compiled gdb. +depend: $(SOURCES) Makefile.dist + @echo Ignore errors about non-existent system-supplied include files + @echo for systems other than the one you are using. + @echo "If xm.h and tm.h don't exist, the error messages saying so" + @echo can safely be ignored. + @echo Also ignore parse errors in valops.c, and any errors in + @echo arm-convert.s. + -$(GCC) -MM $(CFLAGS) -I$(BFD_DIR) \ + `ls $(SOURCES) | sort -u` >depend.tmp + <depend.tmp sed -e 's/ [xt]m.h/& config.status/g' \ + -e 's; vx-share/; $${srcdir}/vx-share/;g' \ + -e 's; nindy-share/; $${srcdir}/nindy-share/;g' \ + -e 's; $(INCLUDE_DIR)/; $(INCLUDE_DEP)/;g' \ + -e 's; [a-z0-9./]*bfd/; $(BFD_DEP)/;g' \ + -e 's; [a-z0-9./]*getopt/; $(GETOPT_DEP)/;g' \ + -e 's; \./; $${srcdir}/;g' \ + >depend + $(MAKE_MAKEFILE) + rm depend.tmp + +config.status: + @echo "You must configure gdb. Look at the README file for details." + @false + +# These are not generated by "make depend" because they only are there +# for some machines. +tm-isi.h tm-sun3.h tm-news.h tm-hp300bsd.h tm-altos.h : tm-68k.h +tm-hp300hpux.h tm-sun2.h tm-3b1.h : tm-68k.h +xm-news1000.h : xm-news.h +xm-i386-sv32.h : xm-i386.h +tm-i386gas.h: tm-i386.h +xm-sun4os4.h : xm-sparc.h +tm-sun4os4.h : tm-sparc.h + +kdb : $(NTSSTART) $(OBS) $(NTSOBS) ${ADD_DEPS} ${RL_LIB_DEP} + rm -f init.c + $(srcdir)/munch ${MUNCH_DEFINE} $(OBS) $(NTSOBS) > init.c + $(CC) $(LDFLAGS) -c init.c $(CLIBS) + ld -o kdb $(NTSSTART) $(OBS) $(NTSOBS) init.o $(ADD_FILES) \ + ${RL_LIB} -lc $(CLIBS) + +# Put the proper machine-specific files first. +# createtags will edit the .o in DEPFILES into .c +TAGS: ${TAGFILES} + $(srcdir)/createtags $(TM_FILE) ${XM_FILE} $(DEPFILES) ${TAGFILES} +tags: TAGS + +# FIXME: Get alldeps.mak up to date, config.gdb none, THEN make gdb.tar.Z! +gdb.tar.Z: ${TARFILES} + rm -f gdb.tar; rm -rf $(DIST) + cd readline ; make readline.tar + mkdir $(DIST) + cd $(DIST) ; for i in ${TARFILES} ; do ln -s ../$$i . ; done + mkdir $(DIST)/readline + cd $(DIST)/readline ; tar xf ../../readline/readline.tar + mkdir $(DIST)/xconfig ${DIST}/tconfig + cd $(DIST)/tconfig ; \ + for i in $(ALLCONFIG) ; do ln -s ../../$$i ../$$i ; done + mkdir $(DIST)/vx-share $(DIST)/nindy-share + cd $(DIST)/tconfig ; \ + for i in $(SFILES_SUBDIR) $(ALLDEPFILES_SUBDIR); \ + do ln -s ../../$$i ../$$i ; done + tar chf - $(DIST) | compress >gdb.tar.Z + rm -rf $(DIST) + +clean: + rm -f ${OBS} ${TSOBS} ${NTSOBS} ${ADD_FILES} + rm -f init.c init.o version.c + rm -f gdb core gdb.tar gdb.tar.Z make.log + rm -f gdb[0-9] + cd readline ; make clean + +distclean: clean expread.tab.c TAGS + rm -f tm.h xm.h config.status + rm -f y.output yacc.acts yacc.tmp + rm -f ${TESTS} Makefile + +realclean: clean + rm -f expread.tab.c TAGS + rm -f tm.h xm.h config.status + rm -f Makefile + +gdb.dvi : gdb.texinfo + tex gdb.texinfo + texindex gdb.?? + tex gdb.texinfo + +# Make copying.c from COPYING +copying.c : COPYING copying.awk + awk -f copying.awk < COPYING > copying.c + +version.c : Makefile.dist + echo 'char *version = "$(VERSION)";' >version.c + +${srcdir}/expread.tab.c : $(srcdir)/expread.y + @echo 'Expect 4 shift/reduce conflict.' + ${YACC} $(srcdir)/expread.y + mv y.tab.c ${srcdir}/expread.tab.c + +expread.o : ${srcdir}/expread.tab.c defs.h param.h symtab.h \ + frame.h expression.h + $(CC) -c ${CFLAGS} `echo ${srcdir}/expread.tab.c | sed 's,^\./,,'` + mv expread.tab.o expread.o + +# dbxread, coffread, mipsread have dependencies on BFD header files. +dbxread.o: ${srcdir}/dbxread.c + ${CC} -c ${CFLAGS} -I$(BFD_DIR) ${srcdir}/dbxread.c + +coffread.o: ${srcdir}/coffread.c + ${CC} -c ${CFLAGS} -I$(BFD_DIR) ${srcdir}/coffread.c + +mipsread.o: ${srcdir}/mipsread.c + ${CC} -c ${CFLAGS} -I$(BFD_DIR) ${srcdir}/mipsread.c + +# Drag in the files that are in another directory. + +getopt1.o: $(GETOPT_DIR)/getopt1.c + ${CC} -c ${CFLAGS} $(GETOPT_DIR)/getopt1.c + +getopt.o: $(GETOPT_DIR)/getopt.c + ${CC} -c ${CFLAGS} $(GETOPT_DIR)/getopt.c + +xdr_ld.o: ${srcdir}/vx-share/xdr_ld.c + ${CC} -c ${CFLAGS} ${srcdir}/vx-share/xdr_ld.c + +xdr_ptrace.o: ${srcdir}/vx-share/xdr_ptrace.c + ${CC} -c ${CFLAGS} ${srcdir}/vx-share/xdr_ptrace.c + +xdr_rdb.o: ${srcdir}/vx-share/xdr_rdb.c + ${CC} -c ${CFLAGS} ${srcdir}/vx-share/xdr_rdb.c + +xdr_regs.o: ${srcdir}/vx-share/xdr_regs.c + ${CC} -c ${CFLAGS} ${srcdir}/vx-share/xdr_regs.c + +nindy.o: ${srcdir}/nindy-share/nindy.c + ${CC} -c ${CFLAGS} ${srcdir}/nindy-share/nindy.c + +Onindy.o: ${srcdir}/nindy-share/Onindy.c + ${CC} -c ${CFLAGS} ${srcdir}/nindy-share/Onindy.c + +ttybreak.o: ${srcdir}/nindy-share/ttybreak.c + ${CC} -c ${CFLAGS} ${srcdir}/nindy-share/ttybreak.c + +ttyflush.o: ${srcdir}/nindy-share/ttyflush.c + ${CC} -c ${CFLAGS} ${srcdir}/nindy-share/ttyflush.c + +tdesc-lib/libdc.o : force_update + cd tdesc-lib ; ${MAKE} "SYSV_DEFINE=${SYSV_DEFINE}" + +# In LOCAL_INCLUDES, -I${srcdir} is right if srcdir is an absolute path, +# and -I../${srcdir} is right if it is relative (e.g. ".."), so search both. +readline/libreadline.a : force_update + cd readline ; ${MAKE} "SYSV=${SYSV_DEFINE}"\ + "VPATH=${srcdir}/readline:../${srcdir}/readline"\ + "LOCAL_INCLUDES=-I../ -I${srcdir}/ -I../${srcdir}/"\ + "DEBUG_FLAGS=${GLOBAL_CFLAGS}" "CC=${CC}" libreadline.a + +lint: $(LINTFILES) + $(LINT) $(INCLUDE_CFLAGS) $(LINTFLAGS) $(LINTFILES) + +gdb.cxref: $(SFILES) + cxref -I. $(SFILES) >gdb.cxref + +force_update : + +# When used with GDB, the demangler should never look for leading underscores +# because GDB strips them off during symbol read-in. Thus -Dnounderscore. +cplus-dem.o : cplus-dem.c + ${CC} -c -Dnounderscore `echo ${srcdir}/cplus-dem.c | sed 's,^\./,,'` diff --git a/gdb/Makefile.srcdir b/gdb/Makefile.srcdir new file mode 100755 index 0000000..b5fb6b3 --- /dev/null +++ b/gdb/Makefile.srcdir @@ -0,0 +1 @@ +srcdir=. diff --git a/gdb/Projects b/gdb/Projects new file mode 100644 index 0000000..b30d268 --- /dev/null +++ b/gdb/Projects @@ -0,0 +1,97 @@ + + Suggested projects for aspiring or current GDB hackers + ====================================================== + + (You should probably chat with bug-gdb@cygnus.com to make sure that + no one else is doing the project you chose). + +Rewrite proceed, wait_for_inferior, and normal_stop to clean them up. +Suggestions: + + 1) Make each test in wait_for_inferior a seperate subroutine + call. + 2) Combine wait_for_inferior and normal_stop to clean up + communication via global variables. + 3) See if you can find some way to clean up the global + variables that are used; possibly group them by data flow + and information content? + +Work out some kind of way to allow running the inferior to be done as +a sub-execution of, eg. breakpoint command lists. Currently running +the inferior interupts any command list execution. This would require +some rewriting of wait_for_inferior & friends, and hence should +probably be done in concert with the above. + +Add function arguments to gdb user defined functions. + +Add convenience variables that refer to exec file, symbol file, +selected frame source file, selected frame function, selected frame +line number, etc. + +Add a "suspend" subcommand of the "continue" command to suspend gdb +while continuing execution of the subprocess. Useful when you are +debugging servers and you want to dodge out and initiate a connection +to a server running under gdb. + +Work out and implement a reasonably general mechanism for multi-threaded +processies. There are parts of one implemented in convex-dep.c, if +you want an example. + +Add stab information to allow reasonable debugging of inline functions +(possibly they should show up on a stack backtrace? With a note +indicating that they weren't "real"?). + +Implement support for specifying arbitrary locations of stack frames +(in practice, this usually requires specification of both the top and +bottom of the stack frame (fp and sp), since you *must* retrieve the +pc that was saved in the innermost frame). + +Modify the naked "until" command to step until past the current source +line, rather than past the current pc value. This is tricky simply +because the low level routines have no way of specifying a multi-line +step range, and there is no way of saying "don't print stuff when we +stop" from above (otherwise could just call step many times). + +Modify the handling of symbols grouped through BINCL/EINCL stabs to +allocate a partial symtab for each BINCL/EINCL grouping. This will +seriously decrease the size of inter-psymtab dependencies and hence +lessen the amount that needs to be read in when a new source file is +accessed. + +Do an "x/i $pc" after each stepi or nexti. + +Modify all of the disassemblers to use printf_filtered to get correct +more filtering. + +Modify gdb to work correctly with Pascal. + +Rewrite macros that handle frame chaining and frameless functions. +They should be able to tell the difference between start, main, and a +frameless function called from main. + +Work out what information would need to be included in an executable +by the compiler to allow gdb to debug functions which do not have a +frame pointer. Modify gdb and gcc to do this. + +When `attached' to a program (via either OS support or remote +debugging), gdb should arrange to catch signals which the terminal +might send, as it is unlikely that the program will be able to notice +them. SIGINT and SIGTSTP are obvious examples. + +Enhance the gdb manual with extra examples where needed. + +Arrange for list_command not to use decode_line_1 and thus not require +symbols to be read in simply to read a source file. + +Allow patching of executables, a la "adb -w". + +Improve the target interface so that targets can be stacked; e.g. an +exec file and a core file (memory references that the core file can't +satisfy are directed to the exec file); those two plus a child process. +The child doesn't let any refs through, but when the child terminates, +you are back to debugging the core file -- you might even want to swap +back and forth between the two, or between two core files. + +# Local Variables: +# mode: text +# End: diff --git a/gdb/TODO b/gdb/TODO new file mode 100644 index 0000000..93dce62 --- /dev/null +++ b/gdb/TODO @@ -0,0 +1,325 @@ + + gdb bug list + John Gilmore, gnu@cygnus.com + +This bug list is probably not up to date or accurate, but it reflects +some known bugs in gdb, if you are into bug-hunting. + + +Update the TODO list with all the lists of gdb bugs lying around on paper. + +"share" command should not need to be manually run. It should be run +as soon as possible, automatically, both on "run" and on core files. + +It should be possible to use symbols from shared libraries before we know +exactly where the libraries will be loaded. E.g. "b perror" before running +the program. This could maybe be done as an extension of the "breakpoint +re-evaluation" after new symbols are loaded. + +Make single_step() insert and remove breakpoints in one operation. + +Speed up single stepping by avoiding extraneous ptrace calls. + +Speed up single stepping by not inserting and removing breakpoints +each time the inferior starts and stops. + +Speed up watchpoints by not single-stepping them, but do something +faster like single-line execution. + +Update gdb.texinfo to include doc on the directory structure and +the various tricks of building gdb. + +Do a tutorial in gdb.texinfo on how to do simple things in gdb. +E.g. how to set a breakpoint that just prints something and continues. +How to break on aborts. Etc. + +Do a "new features" section for release 4. + +Provide "voodoo" debugging of core files. This creates a zombie +process as a child of the debugger, and loads it up with the data, +stack, and regs of the core file. This allows you to call functions +in the executable, to manipulate the data in the core file. + +GDB reopens the source file on every line, as you "next" through it. + +Referencing the vtbl member of a struct doesn't work. It prints OK +if you print the struct, but it gets 0 if you try to deref it. + +Persistent command history: A feature where you could save off a list +of the commands you did, so you can edit it into something that will bring +the target to the same place every time you source it. Sun wants it. +This would also be useful for automated fast watchpointing; if you go +past the place where it watchpoints, you just start it over again and +do it more carefully. + +Deal with the Sun ptrace bug that loses the registers if the stack is +paged out. + +Finish the C++ exception handling stub routines. Lint points them out +as unused statics functions. + +"i source" only shows you info about files that it can read. When it +can't read a file and complains, you can't see any info about it, like +where it was compiled. Perhaps "i source" should take an argument +like that of "list". + +See if coredep.c's fetch_core_registers can be used on more machines. +E.g. MIPS (mips-xdep.c). + +coredep.c is completely broken. Needs work just to compile, it uses +"u" and doesn't declare it, etc. + +unpack_double() does not handle IEEE float on the target unless the host +is also IEEE. Death on a vax. + +Test cross-debugging Unix-to-Unix. + +Check the RAPP remote protocol. What is it? It's in Makefile.dist +and one ChangeLog entry. + +Set up interface between GDB and INFO so that you can hop into interactive +INFO and back out again. When running under Emacs, should use Emacs +info, else fork the info program. Installation of GDB should install +its texinfo files into the info tree automagically, including the readline +texinfo files.. + +Improve backtrace output to avoid line wraps. Prettify it. + +"help address" ought to find the "help set addressprint" entry. + +Remove the VTBL internal guts from printouts of C++ structs, unless +vtblprint is set. + +Remove "at 0xnnnn" from the "b foo" response, if !addressprint and if +it matches the source line indicated. + +The prompt at end of screen should accept space as well as CR. + +"List" should put you into a pseudo-"more" where you can hit space +to get more, forever to eof. + +Check STORE_RETURN_VALUE on all architectures. Check near it in tm-sparc.h +for other bogosities. + +Check for storage leaks in GDB, I'm sure there are a lot! + +vtblprint of a vtbl should demangle the names it's printing. + +Backtrace should point out what the currently selected frame is, in its +display, perhaps showing ">3 foo (bar, ...)" rather than "#3 foo (bar, ...)". + +"i program" should work for core files, and display more info, like what +actually caused it to die. + +Hitting ^Z to an inferior doesn't work right, it takes several continues +to make it actually go. + +"i fun" doesn't show misc function vector symbols. + +"x/10i" should shorten the long name, if any, on subsequent lines. + +Check through the code for FIXME comments and fix them. dbxread.c, +blockframe.c, and plenty more. + +"next" over a function that longjumps, never stops until next time you happen +to get to that spot by accident. E.g. "n" over execute_command which has +an error. + +Watchpoints seem not entirely reliable. + +"set zeroprint off", don't bother printing members of structs which are entirely +zero. Useful for those big structs with few useful members. + +GDB does four ioctl's for every command, probably switching terminal modes +to/from inferior or for readline or something. + +terminal_ours versus terminal_inferior: cache state. Switch should be a noop +if the state is the same, too. + +ptype $i6 = void??! + +Clean up invalid_float handling so gdb doesn't coredump when it tries to +access a NaN. While this might work on SPARC, other machines are not +configured right. + +"b value_at ; commands ; continue ; end" stops EVERY OTHER TIME! +Then once you enter a command, it does the command, runs two more +times, and then stops again! Bizarre... (This behaviour has been +modified, but it is not yet 100% predictable when e.g. the commands +call functions in the child, and while there, the child is interrupted +with a signal, or hits a breakpoint.) + +Symbol completion with TAB does not unmangle names! + +help completion, help history should work. + +Symbol completion doesn't handle e.g. W::f. (symtab.c, +make_symbol_completion_list). + +AMD version: ^C should do ^Ak to stop ebmon. + +Check that we can handle stack trace through varargs AND alloca in same +function, on 29K. + +wait_for_inferior loops forever if wait() gives it an error. + +"i frame" arg formatting sucks. Should wrap lines. +"bt" arg formatting needs the same treatment . + +"i frame" shows wrong "arglist at" location, doesn't show where the args +should be found, only their actual values. + +Symbolic display of addrs, (& disassembly prefixes), don't show static +fns, e.g. enable_command in gdb. + +'ptype yylval' ==> "union YYSTYPE { ..... }". However, it is not a +union YYSTYPE, but is simply a YYSTYPE, which is a typedef for an +unnamed union. + +"show all" should work. + +There should be a way for "set" commands to validate the new setting +before it takes effect. + +The "display" command should become the "always" command, e.g. + "always print XXX" + "always p/xxx XXX" + "always echo foo" + "always call XXX" + "always x/i $pc", etc. + +A mess of floating point opcodes are missing from sparc-opcode.h. +Also, a little program should test the table for bits that are +overspecified or underspecified. E.g. if the must-be-ones bits +and the must-be-zeroes bits leave some fields unexamined, and the format +string leaves them unprinted, then point this out. If multiple +non-alias patterns match, point this out too. Finally, there should +be a sparc-optest.s file that tries each pattern out. This file +should end up coming back the same (modulo transformation comments) +if fed to "gas" then the .o is fed to gdb for disassembly. + +Merge the xxx-opcode.h files with gas again... + +Eliminate all the core_file_command's in all the xdep files. +Eliminate separate declarations of registers[] everywhere. + +"ena d" is ambiguous, why? "ena delete" seems to think it is a command! + +Line numbers are off in some spots. In proceed() at 1st "oneproc = 1", +it seems to run that statement, but it doesn't actually. + +Perhaps the tdep and xdep files, and the tm and xm files, into a config +subdirectory. If not, at least straighten out their names so that +they all start with the machine name. + +inferior_status should include stop_print_frame. It won't need to be +reset in wait_for_inferior after bpstat_stop_status call, then. + +i line VAR produces "Line number not known for symbol ``var''.". I +thought we were stashing that info now! + +Make sure we can handle executables with no symbol info, e.g. /bin/csh. + +We should be able to write to executables that aren't running. + +We should be able to write to random files at hex offsets like adb. + +Tiemann: It is very painful to look at fp registers that hold +double precision values. GDB is happy to show them to you as single +precision, but you cannot look at them as doubles. Perhaps casting +should be changed to make this work; or maybe a new "set" option that +sets the default fp precision to single, double, or quad. This is not +urgent, but would be nice to get into GDB 4.0. + +Make "target xxx" command interruptible. + +Handle add_file with separate text, data, and bss addresses. Maybe +handle separate addresses for each segment in the object file? + +Handle free_named_symtab to cope with multiply-loaded object files +in a dynamic linking environment. Should remember the last copy loaded, +but not get too snowed if it finds references to the older copy. + +Implement have_memory, have_stack, have_registers, have_execution. +Memory: core, exec, child, vxworks even without child. +stack: core, child, vxworks with child +registers: core, child, vxworks with child +execution: child, vxworks with child. + +The original BFD core dump reading routine would itself coredump when fed +a garbage file as a core file. Does the current one? + +Breakpoints should not be inserted and deleted all the time. Only the +one(s) there should be removed when we have to step over one. Support +breakpoints that don't have to be removed to step over them. + +Stop reading stop_registers! + +Generalize and Standardize the RPC interface to a target program, +improve it beyond the "ptrace" interface, and see if it can become a standard +for remote debugging. Is WRS interested in donating their target-end +code? + +Remove all references to: + text_offset + data_offset + text_data_start + text_end + exec_data_offset + ... +now that we have BFD. All remaining are in machine dependent files. + +When quitting with a running program, if a core file was previously +examined, you get "Couldn't read float regs from core file"...if +indeed it can't. generic_mourn_inferior... + +... + +Check signal argument to remote proceed's and error if set. + +Handle floating point registers in core files under BFD. Currently +they are punted. + +Sort help and info output. + +Re-organize help categories into things that tend to fit on a screen +and hang together. + +When trying to print source lines but you can't find the file, +print the file name and line number, and leave it selected anyway +so "i source" will show it. + +renote-nindy.c handles interrupts poorly; it error()s out of badly +chosen places, e.g. leaving current_frame zero, which causes core dumps +on the next command. + +Add in commands like ADB's for searching for patterns, etc. We should +be able to examine and patch raw unsymboled binaries as well in gdb as +we can in adb. (E.g. increase the timeout in /bin/login without source). + +Those xdep files that call register_addr without defining it are +probably simply broken. When reconfiguring this part of gdb, I could +only make guesses about how to redo some of those files, and I +probably guessed wrong, or left them "for later" when I have a +machine that can attempt to build them. + +Use the complain() mechanism for handling all the error() calls in dbxread.c, +and in similar situations in coffread.c and mipsread.c. + +When doing "step" or "next", if a few lines of source are skipped between +the previous line and the current one, print those lines, not just the +last line of a multiline statement. + +When searching for C++ superclasses in value_cast in valops.c, we must +not search the "fields", only the "superclasses". There might be a +struct with a field name that matches the superclass name. This can +happen when the struct was defined before the superclass (before the +name became a typedef). + +For "float point[15];": +ptype &point[4] ==> Attempt to take address of non-lvalue. +p &point[4] ==> Dereferences point[4] rather than giving you point+4. + +Fix symbol reading in the presence of interrupts. It currently leaves a +cleanup to blow away the entire symbol table when a QUIT occurs. + diff --git a/gdb/WHATS.NEW b/gdb/WHATS.NEW new file mode 100755 index 0000000..97b0415 --- /dev/null +++ b/gdb/WHATS.NEW @@ -0,0 +1,223 @@ + GDB 4.0 -- what has changed since 3.5? + + * New Facilities + +Gdb now paginates its output, with a ``more''-like interface. You can +set the screen width and screen height with new ``set'' commands; they +default to your terminal settings. Wide output is wrapped at good +places to make the output more readable. + +Gdb now reads its input via the ``readline'' interface. This provides +inline editing of commands, using familiar Emacs or VI commands (like +``tcsh'' or the korn shell); history substitutions a la the C shell; +and storage and recall of your command history across debugging +sessions. The default is Emacs mode; to switch temporarily to vi mode, +use control-meta-J or ESC control-j. You can switch permanently to vi +mode by putting the line ``set editing-mode vi'' in the file .inputrc +in your home directory. For full details, see the description in +readline/inc-readline.texinfo and readline/inc-history.texinfo. + +Gdb now supports cross-debugging from a host machine of one type to a +target machine of another type. Communication with the target system +is over serial lines. The ``target'' command handles connecting to the +remote system; the ``load'' command will download a program into the +remote system. It also supports debugging of realtime processes +running under VxWorks, using SunRPC Remote Procedure Calls over TCP/IP +to talk to a debugger stub on the target system. + +New CPUs supported include the AMD 29000 and Intel 960. + +GDB now reads object files and symbol tables via a ``binary file'' +library, which allows a single copy of GDB to debug programs of multiple +object file types such as a.out and coff. + +There is now a GDB reference card in "gdbrc.tex". + + + * Control-Variable user interface simplified + +All variables that control the operation of the debugger can be set +by the ``set'' command, and displayed by the ``show'' command. + +For example, ``set prompt new-gdb=>'' will change your prompt to new-gdb=>. +``Show prompt'' produces the response: +Gdb's prompt is new-gdb=>. + +What follows are the NEW set commands. The command ``help set'' will +print a complete list of old and new set commands. ``help set FOO'' +will give a longer description of the variable FOO. + +caution on/off: Enables warning questions for operations that are + hard to recover from, e.g. rerunning the program while + it is already running. Default is ON. + +editing on/off: Enables EMACS style command line editing + of input. Previous lines can be recalled with + control-P, the current line can be edited with control-B, + you can search for commands with control-R, etc. + Default is ON. + +history filename NAME: NAME is where the gdb command history + will be stored. The default is .gdb_history, + or the value of the environment variable + GDBHISTFILE. + +history size N: The size, in commands, of the command history. The + default is 256, or the value of the environment variable + HISTSIZE. + +history write on/off: If this value is set to ON, the history file will + be saved after exiting gdb. If set to OFF, the + file will not be saved. The default is OFF. + +history expansion on/off: If this value is set to ON, then csh-like + history expansion will be performed on + command line input. The default is OFF. + +radix N: Sets the default radix for input and output. It can be set + to 8, 10, or 16. Note that the argument to "radix" is interpreted + in the current radix, so "set radix 10" is always a no-op. + +screen-height N: This integer value is the number of lines on a page. Default + is 24, the current `stty rows'' setting, or the ``li#'' + setting from the termcap entry matching the environment + variable TERM. + +screen-width N: This integer value is the number of characters on a line. + Default is 80, the current `stty cols'' setting, or the ``co#'' + setting from the termcap entry matching the environment + variable TERM. + +Note: ``set screensize'' is obsolete. Use ``set screen-height'' and +``set screen-width'' instead. + +addressprint on/off: Print memory addresses in various command displays, + such as stack traces and structure values. Gdb looks + more ``symbolic'' if you turn this off; it looks more + ``machine level'' with it on. Default is ON. + +arrayprint on/off: Prettyprint arrays. New convenient format! Default + is OFF. + +demangle on/off: Print C++ symbols in "source" form if on, "raw" form if off. + +asm-demangle on/off: Same, for assembler level printouts like instructions. + +vtblprint on/off: Prettyprint C++ virtual function tables. Default is OFF. + + + * Support for Epoch Environment. + +The epoch environment is a version of Emacs v18 with windowing. One +new command, ``inspect'', is identical to ``print'', except that if you +are running in the epoch environment, the value is printed in its own +window. + + + * Support for Shared Libraries + +GDB can now debug programs and core files that use SunOS shared libraries. +Symbols from a shared library cannot be referenced +before the shared library has been linked with the program (this +happens after you type ``run'' and before the function main() is entered). +At any time after this linking (including when examining core files +from dynamically linked programs), gdb reads the symbols from each +shared library when you type the ``sharedlibrary'' command. +It can be abbreviated ``share''. + +sharedlibrary REGEXP: Load shared object library symbols for files + matching a unix regular expression. No argument + indicates to load symbols for all shared libraries. + +info sharedlibrary: Status of loaded shared libraries. + + + * Watchpoints + +A watchpoint stops execution of a program whenever the value of an +expression changes. Checking for this slows down execution +tremendously whenever you are in the scope of the expression, but is +quite useful for catching tough ``bit-spreader'' or pointer misuse +problems. Some machines such as the 386 have hardware for doing this +more quickly, and future versions of gdb will use this hardware. + +watch EXP: Set a watchpoint (breakpoint) for an expression. + +info watchpoints: Information about your watchpoints. + +delete N: Deletes watchpoint number N (same as breakpoints). +disable N: Temporarily turns off watchpoint number N (same as breakpoints). +enable N: Re-enables watchpoint number N (same as breakpoints). + + + * C++ multiple inheritance + +When used with a GCC version 2 compiler, GDB supports multiple inheritance +for C++ programs. + + * C++ exception handling + +Gdb now supports limited C++ exception handling. Besides the existing +ability to breakpoint on an exception handler, gdb can breakpoint on +the raising of an exception (before the stack is peeled back to the +handler's context). + +catch FOO: If there is a FOO exception handler in the dynamic scope, + set a breakpoint to catch exceptions which may be raised there. + Multiple exceptions (``catch foo bar baz'') may be caught. + +info catch: Lists all exceptions which may be caught in the + current stack frame. + + + * Minor command changes + +The command ``call func (arg, arg, ...)'' now acts like the print +command, except it does not print or save a value if the function's result +is void. This is similar to dbx usage. + +The ``up'' and ``down'' commands now always print the frame they end up +at; ``up-silently'' and `down-silently'' can be used in scripts to change +frames without printing. + + * New directory command + +'dir' now adds directories to the FRONT of the source search path. +The path starts off empty. Source files that contain debug information +about the directory in which they were compiled can be found even +with an empty path; GCC includes this information. If GDB can't find +your source file in the current directory, type "dir .". + + * Features removed in this release + +``info types'' has been removed, since it printed builtin types in a +confusing fashion, and did not do useful things with typedefs. ``ptype'' +or ``whatis'' are more useful commands for dealing with types.. + + + * Configuring GDB for compilation + +For normal use, type ``config.gdb host''. Hosts now handled are: + +3b1 altos altosgas arm bigmips convex hp300bsd hp300hpux i386v i386v-g +i386v32 i386v32-g isi littlemips m88k merlin news news1000 none np1 pn +pyramid sun2os3 sun2os4 sun386 sun3os3 sun3os4 sun4os3 sun4os4 symmetry +umax vax + +Type config.gdb +host to get a full description of each host. + +You can now build gdb conveniently for several architectures from the +same sources. If config.gdb is run from a subdirectory, it configures +the Makefile to use source files from '..'. Each subdirectory can be +indpendently configured. An explicit source file directory can also +be specified with the +srcdir=xxx option. Due to obscure search rules +in the C preprocessor, if you have previously built gdb in the main +directory, run 'make cleanconfig' in the top level directory before +building it in a subdirectory. + +GDB now handles cross debugging. If you are remotely debugging between +two different machines, type ``config.gdb host target''. +Host is the machine where gdb will run; target is the machine +where the program that you are debugging will run. + +Type config.gdb +target to get a full description of each target. diff --git a/gdb/alldeps.mak b/gdb/alldeps.mak new file mode 100644 index 0000000..73e6cb8 --- /dev/null +++ b/gdb/alldeps.mak @@ -0,0 +1,196 @@ +ALLDEPFILES = $(ALLDEPFILES_MAINDIR) $(ALLDEPFILES_SUBDIR) +ALLDEPFILES_MAINDIR=\ +altos-xdep.c\ +am29k-pinsn.c\ +am29k-tdep.c\ +arm-convert.s\ +arm-pinsn.c\ +arm-tdep.c\ +arm-xdep.c\ +convex-pinsn.c\ +convex-tdep.c\ +convex-xdep.c\ +coredep.c\ +exec.c\ +gould-pinsn.c\ +gould-xdep.c\ +hp300hpux-xdep.c\ +i386-pinsn.c\ +i386-tdep.c\ +i386-xdep.c\ +i960-pinsn.c\ +i960-tdep.c\ +infptrace.c\ +m68k-pinsn.c\ +m68k-tdep.c\ +mips-pinsn.c\ +mips-tdep.c\ +mips-xdep.c\ +mipsread.c\ +news-xdep.c\ +nindy-tdep.c\ +ns32k-pinsn.c\ +pyr-pinsn.c\ +pyr-tdep.c\ +pyr-xdep.c\ +remote-eb.c\ +remote-nindy.c\ +remote-vx.c\ +solib.c\ +sparc-pinsn.c\ +sparc-tdep.c\ +sparc-xdep.c\ +sun3-xdep.c\ +sun386-xdep.c\ +symmetry-tdep.c\ +symmetry-xdep.c\ +tdesc.c\ +umax-xdep.c\ +vax-pinsn.c + +ALLDEPFILES_SUBDIR=\ +nindy-share/Onindy.c\ +nindy-share/nindy.c\ +nindy-share/ttybreak.c\ +nindy-share/ttyflush.c\ +vx-share/xdr_ld.c\ +vx-share/xdr_ptrace.c\ +vx-share/xdr_rdb.c\ +vx-share/xdr_regs.c + +ALLPARAM=\ +tm-29k.h\ +tm-3b1.h\ +tm-88k.h\ +tm-altos.h\ +tm-altosgas.h\ +tm-arm.h\ +tm-bigmips.h\ +tm-convex.h\ +tm-hp300bsd.h\ +tm-hp300hpux.h\ +tm-i386v-g.h\ +tm-i386v.h\ +tm-isi.h\ +tm-merlin.h\ +tm-mips.h\ +tm-news.h\ +tm-nindy960.h\ +tm-np1.h\ +tm-pn.h\ +tm-pyr.h\ +tm-sparc.h\ +tm-sun2.h\ +tm-sun2os4.h\ +tm-sun3.h\ +tm-sun386.h\ +tm-sun3os4.h\ +tm-sun4os4.h\ +tm-symmetry.h\ +tm-umax.h\ +tm-vax.h\ +tm-vxworks68.h\ +tm-vxworks960.h\ +xm-3b1.h\ +xm-88k.h\ +xm-altos.h\ +xm-arm.h\ +xm-bigmips.h\ +xm-convex.h\ +xm-hp300bsd.h\ +xm-hp300hpux.h\ +xm-i386v.h\ +xm-i386v32.h\ +xm-isi.h\ +xm-merlin.h\ +xm-mips.h\ +xm-news.h\ +xm-news1000.h\ +xm-np1.h\ +xm-pn.h\ +xm-pyr.h\ +xm-sparc.h\ +xm-sun2.h\ +xm-sun3.h\ +xm-sun386.h\ +xm-sun3os4.h\ +xm-sun4os4.h\ +xm-symmetry.h\ +xm-umax.h\ +xm-vax.h + +ALLCONFIG=\ +./tconfig/3b1\ +./tconfig/altos\ +./tconfig/altosgas\ +./tconfig/am29k\ +./tconfig/arm\ +./tconfig/bigmips\ +./tconfig/convex\ +./tconfig/hp300bsd\ +./tconfig/hp300hpux\ +./tconfig/i386v\ +./tconfig/i386v-g\ +./tconfig/i386v32\ +./tconfig/i386v32-g\ +./tconfig/i960\ +./tconfig/isi\ +./tconfig/littlemips\ +./tconfig/m88k\ +./tconfig/merlin\ +./tconfig/news\ +./tconfig/news1000\ +./tconfig/nindy960\ +./tconfig/none\ +./tconfig/np1\ +./tconfig/pn\ +./tconfig/pyramid\ +./tconfig/sun2os3\ +./tconfig/sun2os4\ +./tconfig/sun3\ +./tconfig/sun386\ +./tconfig/sun3os3\ +./tconfig/sun3os4\ +./tconfig/sun4\ +./tconfig/sun4os3\ +./tconfig/sun4os4\ +./tconfig/symmetry\ +./tconfig/umax\ +./tconfig/vax\ +./tconfig/vxworks68\ +./tconfig/vxworks960\ +./xconfig/3b1\ +./xconfig/altos\ +./xconfig/altosgas\ +./xconfig/arm\ +./xconfig/bigmips\ +./xconfig/convex\ +./xconfig/hp300bsd\ +./xconfig/hp300hpux\ +./xconfig/i386v\ +./xconfig/i386v-g\ +./xconfig/i386v32\ +./xconfig/i386v32-g\ +./xconfig/isi\ +./xconfig/littlemips\ +./xconfig/m88k\ +./xconfig/merlin\ +./xconfig/news\ +./xconfig/news1000\ +./xconfig/none\ +./xconfig/np1\ +./xconfig/pn\ +./xconfig/pyramid\ +./xconfig/sun2os3\ +./xconfig/sun2os4\ +./xconfig/sun3\ +./xconfig/sun386\ +./xconfig/sun3os3\ +./xconfig/sun3os4\ +./xconfig/sun4\ +./xconfig/sun4os3\ +./xconfig/sun4os4\ +./xconfig/symmetry\ +./xconfig/umax\ +./xconfig/vax + diff --git a/gdb/alloca.c b/gdb/alloca.c new file mode 100644 index 0000000..d5de3de --- /dev/null +++ b/gdb/alloca.c @@ -0,0 +1,191 @@ +/* + alloca -- (mostly) portable public-domain implementation -- D A Gwyn + + last edit: 86/05/30 rms + include config.h, since on VMS it renames some symbols. + Use xmalloc instead of malloc. + + This implementation of the PWB library alloca() function, + which is used to allocate space off the run-time stack so + that it is automatically reclaimed upon procedure exit, + was inspired by discussions with J. Q. Johnson of Cornell. + + It should work under any C implementation that uses an + actual procedure stack (as opposed to a linked list of + frames). There are some preprocessor constants that can + be defined when compiling for your specific system, for + improved efficiency; however, the defaults should be okay. + + The general concept of this implementation is to keep + track of all alloca()-allocated blocks, and reclaim any + that are found to be deeper in the stack than the current + invocation. This heuristic does not reclaim storage as + soon as it becomes invalid, but it will do so eventually. + + As a special case, alloca(0) reclaims storage without + allocating any. It is a good idea to use alloca(0) in + your main control loop, etc. to force garbage collection. +*/ +#ifndef lint +static char SCCSid[] = "@(#)alloca.c 1.1"; /* for the "what" utility */ +#endif + +#ifdef emacs +#include "config.h" +#ifdef static +/* actually, only want this if static is defined as "" + -- this is for usg, in which emacs must undefine static + in order to make unexec workable + */ +#ifndef STACK_DIRECTION +you +lose +-- must know STACK_DIRECTION at compile-time +#endif /* STACK_DIRECTION undefined */ +#endif static +#endif emacs + +#ifdef __STDC__ +typedef void *pointer; /* generic pointer type */ +#else +typedef char *pointer; /* generic pointer type */ +#endif + +#define NULL 0 /* null pointer constant */ + +extern void free(); +extern pointer xmalloc(); + +/* + Define STACK_DIRECTION if you know the direction of stack + growth for your system; otherwise it will be automatically + deduced at run-time. + + STACK_DIRECTION > 0 => grows toward higher addresses + STACK_DIRECTION < 0 => grows toward lower addresses + STACK_DIRECTION = 0 => direction of growth unknown +*/ + +#ifndef STACK_DIRECTION +#define STACK_DIRECTION 0 /* direction unknown */ +#endif + +#if STACK_DIRECTION != 0 + +#define STACK_DIR STACK_DIRECTION /* known at compile-time */ + +#else /* STACK_DIRECTION == 0; need run-time code */ + +static int stack_dir; /* 1 or -1 once known */ +#define STACK_DIR stack_dir + +static void +find_stack_direction (/* void */) +{ + static char *addr = NULL; /* address of first + `dummy', once known */ + auto char dummy; /* to get stack address */ + + if (addr == NULL) + { /* initial entry */ + addr = &dummy; + + find_stack_direction (); /* recurse once */ + } + else /* second entry */ + if (&dummy > addr) + stack_dir = 1; /* stack grew upward */ + else + stack_dir = -1; /* stack grew downward */ +} + +#endif /* STACK_DIRECTION == 0 */ + +/* + An "alloca header" is used to: + (a) chain together all alloca()ed blocks; + (b) keep track of stack depth. + + It is very important that sizeof(header) agree with malloc() + alignment chunk size. The following default should work okay. +*/ + +#ifndef ALIGN_SIZE +#define ALIGN_SIZE sizeof(double) +#endif + +typedef union hdr +{ + char align[ALIGN_SIZE]; /* to force sizeof(header) */ + struct + { + union hdr *next; /* for chaining headers */ + char *deep; /* for stack depth measure */ + } h; +} header; + +/* + alloca( size ) returns a pointer to at least `size' bytes of + storage which will be automatically reclaimed upon exit from + the procedure that called alloca(). Originally, this space + was supposed to be taken from the current stack frame of the + caller, but that method cannot be made to work for some + implementations of C, for example under Gould's UTX/32. +*/ + +static header *last_alloca_header = NULL; /* -> last alloca header */ + +pointer +alloca (size) /* returns pointer to storage */ + unsigned size; /* # bytes to allocate */ +{ + auto char probe; /* probes stack depth: */ + register char *depth = &probe; + +#if STACK_DIRECTION == 0 + if (STACK_DIR == 0) /* unknown growth direction */ + find_stack_direction (); +#endif + + /* Reclaim garbage, defined as all alloca()ed storage that + was allocated from deeper in the stack than currently. */ + + { + register header *hp; /* traverses linked list */ + + for (hp = last_alloca_header; hp != NULL;) + if (STACK_DIR > 0 && hp->h.deep > depth + || STACK_DIR < 0 && hp->h.deep < depth) + { + register header *np = hp->h.next; + + free ((pointer) hp); /* collect garbage */ + + hp = np; /* -> next header */ + } + else + break; /* rest are not deeper */ + + last_alloca_header = hp; /* -> last valid storage */ + } + + if (size == 0) + return NULL; /* no allocation required */ + + /* Allocate combined header + user data storage. */ + + { + register pointer new = xmalloc (sizeof (header) + size); + /* address of header */ + + ((header *)new)->h.next = last_alloca_header; + ((header *)new)->h.deep = depth; + + last_alloca_header = (header *)new; + + /* User storage begins just after header. */ + + return (pointer)((char *)new + sizeof(header)); + } +} + diff --git a/gdb/altos-xdep.c b/gdb/altos-xdep.c new file mode 100644 index 0000000..1949c8d --- /dev/null +++ b/gdb/altos-xdep.c @@ -0,0 +1,166 @@ +/* Low level interface to ptrace, for GDB when running under m68k SVR2 Unix + on Altos 3068. Report bugs to Jyrki Kuoppala <jkp@cs.hut.fi> + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +#ifdef USG +#include <sys/types.h> +#endif + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/ioctl.h> +#include <fcntl.h> +#ifdef USG +#include <sys/page.h> +#ifdef ALTOS +#include <sys/net.h> +#include <errno.h> +#endif +#endif + +#include "gdbcore.h" +#include <sys/user.h> /* After a.out.h */ +#include <sys/file.h> +#include <sys/stat.h> + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct user u; + + unsigned int reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name ("Not a core file: reading upage"); + if (val != sizeof u) + error ("Not a core file: could only read %d bytes", val); + data_start = exec_data_start; + +#if !defined (NBPG) +#define NBPG NBPP +#endif +#if !defined (UPAGES) +#define UPAGES USIZE +#endif + + data_end = data_start + NBPG * u.u_dsize; + stack_start = stack_end - NBPG * u.u_ssize; + data_offset = NBPG * UPAGES + exec_data_start % NBPG /* Not sure about this //jkp */; + stack_offset = NBPG * (UPAGES + u.u_dsize); + + /* Some machines put an absolute address in here and some put + the offset in the upage of the regs. */ + reg_offset = (int) u.u_state; + if (reg_offset > NBPG * UPAGES) + reg_offset -= KERNEL_U_ADDR; + + bcopy (&u.u_exdata, &core_aouthdr, sizeof (AOUTHDR)); + printf ("Core file is from \"%s\".\n", u.u_comm); + + /* I don't know where to find this info. + So, for now, mark it as not available. */ + N_SET_MAGIC (core_aouthdr, 0); + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = lseek (corechan, register_addr (regno, reg_offset), 0); + if (val < 0 + || (val = myread (corechan, buf, sizeof buf)) < 0) + { + char * buffer = (char *) alloca (strlen (reg_names[regno]) + + 30); + strcpy (buffer, "Reading register "); + strcat (buffer, reg_names[regno]); + + perror_with_name (buffer); + } + + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} diff --git a/gdb/am29k-opcode.h b/gdb/am29k-opcode.h new file mode 100644 index 0000000..96aff40 --- /dev/null +++ b/gdb/am29k-opcode.h @@ -0,0 +1,271 @@ +/* Table of opcodes for the AMD 29000 + Copyright (C) 1990, 1991 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +struct am29k_opcode { + /* Name of the instruction. */ + char *name; + + /* Opcode (i.e. most significant byte of the word). */ + unsigned char opcode; + + /* A string of characters which describe the operands. + Valid characters are: + , Itself. The character appears in the assembly code. + a RA. The register number is in bits 8-15 of the instruction. + b RB. The register number is in bits 0-7 of the instruction. + c RC. The register number is in bits 16-23 of the instruction. + i An immediate operand is in bits 0-7 of the instruction. + x Bits 0-7 and 16-23 of the instruction are bits 0-7 and 8-15 + (respectively) of the immediate operand. + h Same as x but the instruction contains bits 16-31 of the + immediate operand. + X Same as x but bits 16-31 of the signed immediate operand + are set to 1 (thus the operand is always negative). + P,A Bits 0-7 and 16-23 of the instruction are bits 2-9 and 10-17 + (respectively) of the immediate operand. + P=PC-relative, sign-extended to 32 bits. + A=Absolute, zero-extended to 32 bits. + e CE bit (bit 23) for a load/store instruction. + n Control field (bits 16-22) for a load/store instruction. + v Immediate operand in bits 16-23 of the instruction. + (used for trap numbers). + s SA. Special-purpose register number in bits 8-15 + of the instruction. + u UI--bit 7 of the instruction. + r RND--bits 4-6 of the instruction. + d FD--bits 2-3 of the instruction. + f FS--bits 0-1 of the instruction. */ + char *args; +}; + +static struct am29k_opcode am29k_opcodes[] = +{ + +{ "add", 0x14, "c,a,b" }, +{ "add", 0x15, "c,a,i" }, +{ "addc", 0x1c, "c,a,b" }, +{ "addc", 0x1d, "c,a,i" }, +{ "addcs", 0x18, "c,a,b" }, +{ "addcs", 0x19, "c,a,i" }, +{ "addcu", 0x1a, "c,a,b" }, +{ "addcu", 0x1b, "c,a,i" }, +{ "adds", 0x10, "c,a,b" }, +{ "adds", 0x11, "c,a,i" }, +{ "addu", 0x12, "c,a,b" }, +{ "addu", 0x13, "c,a,i" }, +{ "and", 0x90, "c,a,b" }, +{ "and", 0x91, "c,a,i" }, +{ "andn", 0x9c, "c,a,b" }, +{ "andn", 0x9d, "c,a,i" }, +{ "aseq", 0x70, "v,a,b" }, +{ "aseq", 0x71, "v,a,i" }, +{ "asge", 0x5c, "v,a,b" }, +{ "asge", 0x5d, "v,a,i" }, +{ "asgeu", 0x5e, "v,a,b" }, +{ "asgeu", 0x5f, "v,a,i" }, +{ "asgt", 0x58, "v,a,b" }, +{ "asgt", 0x59, "v,a,i" }, +{ "asgtu", 0x5a, "v,a,b" }, +{ "asgtu", 0x5b, "v,a,i" }, +{ "asle", 0x54, "v,a,b" }, +{ "asle", 0x55, "v,a,i" }, +{ "asleu", 0x56, "v,a,b" }, +{ "asleu", 0x57, "v,a,i" }, +{ "aslt", 0x50, "v,a,b" }, +{ "aslt", 0x51, "v,a,i" }, +{ "asltu", 0x52, "v,a,b" }, +{ "asltu", 0x53, "v,a,i" }, +{ "asneq", 0x72, "v,a,b" }, +{ "asneq", 0x73, "v,a,i" }, +{ "call", 0xa8, "a,P" }, +{ "call", 0xa9, "a,A" }, +{ "calli", 0xc8, "a,b" }, +{ "class", 0xe6, "c,a,f" }, +{ "clz", 0x08, "c,b" }, +{ "clz", 0x09, "c,i" }, +{ "const", 0x03, "a,x" }, +{ "consth", 0x02, "a,h" }, +{ "consthz", 0x05, "a,h" }, +{ "constn", 0x01, "a,X" }, +{ "convert", 0xe4, "c,a,u,r,d,f" }, +{ "cpbyte", 0x2e, "c,a,b" }, +{ "cpbyte", 0x2f, "c,a,i" }, +{ "cpeq", 0x60, "c,a,b" }, +{ "cpeq", 0x61, "c,a,i" }, +{ "cpge", 0x4c, "c,a,b" }, +{ "cpge", 0x4d, "c,a,i" }, +{ "cpgeu", 0x4e, "c,a,b" }, +{ "cpgeu", 0x4f, "c,a,i" }, +{ "cpgt", 0x48, "c,a,b" }, +{ "cpgt", 0x49, "c,a,i" }, +{ "cpgtu", 0x4a, "c,a,b" }, +{ "cpgtu", 0x4b, "c,a,i" }, +{ "cple", 0x44, "c,a,b" }, +{ "cple", 0x45, "c,a,i" }, +{ "cpleu", 0x46, "c,a,b" }, +{ "cpleu", 0x47, "c,a,i" }, +{ "cplt", 0x40, "c,a,b" }, +{ "cplt", 0x41, "c,a,i" }, +{ "cpltu", 0x42, "c,a,b" }, +{ "cpltu", 0x43, "c,a,i" }, +{ "cpneq", 0x62, "c,a,b" }, +{ "cpneq", 0x63, "c,a,i" }, +{ "dadd", 0xf1, "c,a,b" }, +{ "ddiv", 0xf7, "c,a,b" }, +{ "deq", 0xeb, "c,a,b" }, +{ "dge", 0xef, "c,a,b" }, +{ "dgt", 0xed, "c,a,b" }, +{ "div", 0x6a, "c,a,b" }, +{ "div", 0x6b, "c,a,i" }, +{ "div0", 0x68, "c,b" }, +{ "div0", 0x69, "c,i" }, +{ "divide", 0xe1, "c,a,b" }, +{ "dividu", 0xe3, "c,a,b" }, +{ "divl", 0x6c, "c,a,b" }, +{ "divl", 0x6d, "c,a,i" }, +{ "divrem", 0x6e, "c,a,b" }, +{ "divrem", 0x6f, "c,a,i" }, +{ "dmac", 0xd9, "F,C,a,b" }, +{ "dmsm", 0xdb, "c,a,b" }, +{ "dmul", 0xf5, "c,a,b" }, +{ "dsub", 0xf3, "c,a,b" }, +{ "emulate", 0xd7, "v,a,b" }, +{ "exbyte", 0x0a, "c,a,b" }, +{ "exbyte", 0x0b, "c,a,i" }, +{ "exhw", 0x7c, "c,a,b" }, +{ "exhw", 0x7d, "c,a,i" }, +{ "exhws", 0x7e, "c,a" }, +{ "extract", 0x7a, "c,a,b" }, +{ "extract", 0x7b, "c,a,i" }, +{ "fadd", 0xf0, "c,a,b" }, +{ "fdiv", 0xf6, "c,a,b" }, +{ "fdmul", 0xf9, "c,a,b" }, +{ "feq", 0xea, "c,a,b" }, +{ "fge", 0xee, "c,a,b" }, +{ "fgt", 0xec, "c,a,b" }, +{ "fmac", 0xd8, "F,C,a,b" }, +{ "fmsm", 0xda, "c,a,b" }, +{ "fmul", 0xf4, "c,a,b" }, +{ "fsub", 0xf2, "c,a,b" }, +{ "halt", 0x89, "" }, +{ "inbyte", 0x0c, "c,a,b" }, +{ "inbyte", 0x0d, "c,a,i" }, +{ "inhw", 0x78, "c,a,b" }, +{ "inhw", 0x79, "c,a,i" }, +{ "inv", 0x9f, "" }, +{ "iret", 0x88, "" }, +{ "iretinv", 0x8c, "" }, +{ "jmp", 0xa0, "P" }, +{ "jmp", 0xa1, "A" }, +{ "jmpf", 0xa4, "a,P" }, +{ "jmpf", 0xa5, "a,A" }, +{ "jmpfdec", 0xb4, "a,P" }, +{ "jmpfdec", 0xb5, "a,A" }, +{ "jmpfi", 0xc4, "a,b" }, +{ "jmpi", 0xc0, "b" }, +{ "jmpt", 0xac, "a,P" }, +{ "jmpt", 0xad, "a,A" }, +{ "jmpti", 0xcc, "a,b" }, +{ "load", 0x16, "e,n,a,b" }, +{ "load", 0x17, "e,n,a,i" }, +{ "loadl", 0x06, "e,n,a,b" }, +{ "loadl", 0x07, "e,n,a,i" }, +{ "loadm", 0x36, "e,n,a,b" }, +{ "loadm", 0x37, "e,n,a,i" }, +{ "loadset", 0x26, "e,n,a,b" }, +{ "loadset", 0x27, "e,n,a,i" }, +{ "mfacc", 0xe9, "c,d,f" }, +{ "mfsr", 0xc6, "c,s" }, +{ "mftlb", 0xb6, "c,a" }, +{ "mtacc", 0xe8, "c,d,f" }, +{ "mtsr", 0xce, "s,b" }, +{ "mtsrim", 0x04, "s,x" }, +{ "mttlb", 0xbe, "a,b" }, +{ "mul", 0x64, "c,a,b" }, +{ "mul", 0x65, "c,a,i" }, +{ "mull", 0x66, "c,a,b" }, +{ "mull", 0x67, "c,a,i" }, +{ "multiplu", 0xe2, "c,a,b" }, +{ "multiply", 0xe0, "c,a,b" }, +{ "multm", 0xde, "c,a,b" }, +{ "multmu", 0xdf, "c,a,b" }, +{ "mulu", 0x74, "c,a,b" }, +{ "mulu", 0x75, "c,a,i" }, +{ "nand", 0x9a, "c,a,b" }, +{ "nand", 0x9b, "c,a,i" }, +{ "nor", 0x98, "c,a,b" }, +{ "nor", 0x99, "c,a,i" }, +{ "or", 0x92, "c,a,b" }, +{ "or", 0x93, "c,a,i" }, +{ "orn", 0xaa, "c,a,b" }, +{ "orn", 0xab, "c,a,i" }, + +/* The description of "setip" in Chapter 8 ("instruction set") of the user's + manual claims that these are absolute register numbers. But section + 7.2.1 explains that they are not. The latter is correct, so print + these normally ("lr0", "lr5", etc.). */ +{ "setip", 0x9e, "c,a,b" }, + +{ "sll", 0x80, "c,a,b" }, +{ "sll", 0x81, "c,a,i" }, +{ "sqrt", 0xe5, "c,a,f" }, +{ "sra", 0x86, "c,a,b" }, +{ "sra", 0x87, "c,a,i" }, +{ "srl", 0x82, "c,a,b" }, +{ "srl", 0x83, "c,a,i" }, +{ "store", 0x1e, "e,n,a,b" }, +{ "store", 0x1f, "e,n,a,i" }, +{ "storel", 0x0e, "e,n,a,b" }, +{ "storel", 0x0f, "e,n,a,i" }, +{ "storem", 0x3e, "e,n,a,b" }, +{ "storem", 0x3f, "e,n,a,i" }, +{ "sub", 0x24, "c,a,b" }, +{ "sub", 0x25, "c,a,i" }, +{ "subc", 0x2c, "c,a,b" }, +{ "subc", 0x2d, "c,a,i" }, +{ "subcs", 0x28, "c,a,b" }, +{ "subcs", 0x29, "c,a,i" }, +{ "subcu", 0x2a, "c,a,b" }, +{ "subcu", 0x2b, "c,a,i" }, +{ "subr", 0x34, "c,a,b" }, +{ "subr", 0x35, "c,a,i" }, +{ "subrc", 0x3c, "c,a,b" }, +{ "subrc", 0x3d, "c,a,i" }, +{ "subrcs", 0x38, "c,a,b" }, +{ "subrcs", 0x39, "c,a,i" }, +{ "subrcu", 0x3a, "c,a,b" }, +{ "subrcu", 0x3b, "c,a,i" }, +{ "subrs", 0x30, "c,a,b" }, +{ "subrs", 0x31, "c,a,i" }, +{ "subru", 0x32, "c,a,b" }, +{ "subru", 0x33, "c,a,i" }, +{ "subs", 0x20, "c,a,b" }, +{ "subs", 0x21, "c,a,i" }, +{ "subu", 0x22, "c,a,b" }, +{ "subu", 0x23, "c,a,i" }, +{ "xnor", 0x96, "c,a,b" }, +{ "xnor", 0x97, "c,a,i" }, +{ "xor", 0x94, "c,a,b" }, +{ "xor", 0x95, "c,a,i" } + +}; + +#define NUM_OPCODES ((sizeof am29k_opcodes) / (sizeof am29k_opcodes[0])) + diff --git a/gdb/am29k-pinsn.c b/gdb/am29k-pinsn.c new file mode 100644 index 0000000..c933629 --- /dev/null +++ b/gdb/am29k-pinsn.c @@ -0,0 +1,296 @@ +/* Instruction printing code for the AMD 29000 + Copyright (C) 1990 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "target.h" +#include "am29k-opcode.h" + +/* Print a symbolic representation of a general-purpose + register number NUM on STREAM. + NUM is a number as found in the instruction, not as found in + debugging symbols; it must be in the range 0-255. */ +static void +print_general (num, stream) + int num; + FILE *stream; +{ + if (num < 128) + fprintf_filtered (stream, "gr%d", num); + else + fprintf_filtered (stream, "lr%d", num - 128); +} + +/* Like print_general but a special-purpose register. + + The mnemonics used by the AMD assembler are not quite the same + as the ones in the User's Manual. We use the ones that the + assembler uses. */ +static void +print_special (num, stream) + int num; + FILE *stream; +{ + /* Register names of registers 0-SPEC0_NUM-1. */ + static char *spec0_names[] = { + "vab", "ops", "cps", "cfg", "cha", "chd", "chc", "rbp", "tmc", "tmr", + "pc0", "pc1", "pc2", "mmu", "lru" + }; +#define SPEC0_NUM ((sizeof spec0_names) / (sizeof spec0_names[0])) + + /* Register names of registers 128-128+SPEC128_NUM-1. */ + static char *spec128_names[] = { + "ipc", "ipa", "ipb", "q", "alu", "bp", "fc", "cr" + }; +#define SPEC128_NUM ((sizeof spec128_names) / (sizeof spec128_names[0])) + + /* Register names of registers 160-160+SPEC160_NUM-1. */ + static char *spec160_names[] = { + "fpe", "inte", "fps", "sr163", "exop" + }; +#define SPEC160_NUM ((sizeof spec160_names) / (sizeof spec160_names[0])) + + if (num < SPEC0_NUM) + fprintf_filtered (stream, spec0_names[num]); + else if (num >= 128 && num < 128 + SPEC128_NUM) + fprintf_filtered (stream, spec128_names[num-128]); + else if (num >= 160 && num < 160 + SPEC160_NUM) + fprintf_filtered (stream, spec160_names[num-160]); + else + fprintf_filtered (stream, "sr%d", num); +} + +/* Is an instruction with OPCODE a delayed branch? */ +static int +is_delayed_branch (opcode) + int opcode; +{ + return (opcode == 0xa8 || opcode == 0xa9 || opcode == 0xa0 || opcode == 0xa1 + || opcode == 0xa4 || opcode == 0xa5 + || opcode == 0xb4 || opcode == 0xb5 + || opcode == 0xc4 || opcode == 0xc0 + || opcode == 0xac || opcode == 0xad + || opcode == 0xcc); +} + +/* Now find the four bytes of INSN and put them in *INSN{0,8,16,24}. + Note that the amd can be set up as either + big or little-endian (the tm file says which) and we can't assume + the host machine is the same. */ +static void +find_bytes (insn, insn0, insn8, insn16, insn24) + char *insn; + unsigned char *insn0; + unsigned char *insn8; + unsigned char *insn16; + unsigned char *insn24; +{ +#if TARGET_BYTE_ORDER == BIG_ENDIAN + *insn24 = insn[0]; + *insn16 = insn[1]; + *insn8 = insn[2]; + *insn0 = insn[3]; +#else /* Little-endian. */ + *insn24 = insn[3]; + *insn16 = insn[2]; + *insn8 = insn[1]; + *insn0 = insn[0]; +#endif /* Little-endian. */ +} + +/* Print one instruction from MEMADDR on STREAM. + Return the size of the instruction (always 4 on am29k). */ +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + /* The raw instruction. */ + char insn[4]; + + /* The four bytes of the instruction. */ + unsigned char insn24, insn16, insn8, insn0; + + struct am29k_opcode *opcode; + + read_memory (memaddr, &insn[0], 4); + + find_bytes (insn, &insn0, &insn8, &insn16, &insn24); + + /* The opcode is always in insn24. */ + for (opcode = &am29k_opcodes[0]; + opcode < &am29k_opcodes[NUM_OPCODES]; + ++opcode) + { + if (insn24 == opcode->opcode) + { + char *s; + + fprintf_filtered (stream, "%s ", opcode->name); + for (s = opcode->args; *s != '\0'; ++s) + { + switch (*s) + { + case 'a': + print_general (insn8, stream); + break; + + case 'b': + print_general (insn0, stream); + break; + + case 'c': + print_general (insn16, stream); + break; + + case 'i': + fprintf_filtered (stream, "%d", insn0); + break; + + case 'x': + fprintf_filtered (stream, "%d", (insn16 << 8) + insn0); + break; + + case 'h': + fprintf_filtered (stream, "0x%x", + (insn16 << 24) + (insn0 << 16)); + break; + + case 'X': + fprintf_filtered (stream, "%d", + ((insn16 << 8) + insn0) | 0xffff0000); + break; + + case 'P': + /* This output looks just like absolute addressing, but + maybe that's OK (it's what the GDB 68k and EBMON + 29k disassemblers do). */ + /* All the shifting is to sign-extend it. p*/ + print_address + (memaddr + + (((int)((insn16 << 10) + (insn0 << 2)) << 14) >> 14), + stream); + break; + + case 'A': + print_address ((insn16 << 10) + (insn0 << 2), stream); + break; + + case 'e': + fprintf_filtered (stream, "%d", insn16 >> 7); + break; + + case 'n': + fprintf_filtered (stream, "0x%x", insn16 & 0x7f); + break; + + case 'v': + fprintf_filtered (stream, "%#x", insn16); + break; + + case 's': + print_special (insn8, stream); + break; + + case 'u': + fprintf_filtered (stream, "%d", insn0 >> 7); + break; + + case 'r': + fprintf_filtered (stream, "%d", (insn0 >> 4) & 7); + break; + + case 'd': + fprintf_filtered (stream, "%d", (insn0 >> 2) & 3); + break; + + case 'f': + fprintf_filtered (stream, "%d", insn0 & 3); + break; + + case 'F': + fprintf_filtered (stream, "%d", (insn0 >> 18) & 15); + break; + + case 'C': + fprintf_filtered (stream, "%d", (insn0 >> 16) & 3); + break; + + default: + fprintf_filtered (stream, "%c", *s); + } + } + + /* Now we look for a const,consth pair of instructions, + in which case we try to print the symbolic address. */ + if (insn24 == 2) /* consth */ + { + int errcode; + char prev_insn[4]; + unsigned char prev_insn0, prev_insn8, prev_insn16, prev_insn24; + + errcode = target_read_memory (memaddr - 4, + &prev_insn[0], + 4); + if (errcode == 0) + { + /* If it is a delayed branch, we need to look at the + instruction before the delayed brach to handle + things like + + const _foo + call _printf + consth _foo + */ + find_bytes (prev_insn, &prev_insn0, &prev_insn8, + &prev_insn16, &prev_insn24); + if (is_delayed_branch (prev_insn24)) + { + errcode = target_read_memory + (memaddr - 8, &prev_insn[0], 4); + find_bytes (prev_insn, &prev_insn0, &prev_insn8, + &prev_insn16, &prev_insn24); + } + } + + /* If there was a problem reading memory, then assume + the previous instruction was not const. */ + if (errcode == 0) + { + /* Is it const to the same register? */ + if (prev_insn24 == 3 + && prev_insn8 == insn8) + { + fprintf_filtered (stream, "\t; "); + print_address (((insn16 << 24) + (insn0 << 16) + + (prev_insn16 << 8) + (prev_insn0)), + stream); + } + } + } + + return 4; + } + } + fprintf_filtered (stream, ".word %#8x", + (insn24 << 24) + (insn16 << 16) + (insn8 << 8) + insn0); + return 4; +} diff --git a/gdb/am29k-tdep.c b/gdb/am29k-tdep.c new file mode 100644 index 0000000..e58847b --- /dev/null +++ b/gdb/am29k-tdep.c @@ -0,0 +1,695 @@ +/* Target-machine dependent code for the AMD 29000 + Copyright (C) 1990 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "gdbcore.h" +#include <stdio.h> +#include "frame.h" +#include "value.h" +#include "param.h" +#include "symtab.h" +#include "inferior.h" + +/* Structure to hold cached info about function prologues. */ +struct prologue_info +{ + CORE_ADDR pc; /* First addr after fn prologue */ + unsigned rsize, msize; /* register stack frame size, mem stack ditto */ + unsigned mfp_used : 1; /* memory frame pointer used */ + unsigned rsize_valid : 1; /* Validity bits for the above */ + unsigned msize_valid : 1; + unsigned mfp_valid : 1; +}; + +/* Examine the prologue of a function which starts at PC. Return + the first addess past the prologue. If MSIZE is non-NULL, then + set *MSIZE to the memory stack frame size. If RSIZE is non-NULL, + then set *RSIZE to the register stack frame size (not including + incoming arguments and the return address & frame pointer stored + with them). If no prologue is found, *RSIZE is set to zero. + If no prologue is found, or a prologue which doesn't involve + allocating a memory stack frame, then set *MSIZE to zero. + + Note that both msize and rsize are in bytes. This is not consistent + with the _User's Manual_ with respect to rsize, but it is much more + convenient. + + If MFP_USED is non-NULL, *MFP_USED is set to nonzero if a memory + frame pointer is being used. */ +CORE_ADDR +examine_prologue (pc, rsize, msize, mfp_used) + CORE_ADDR pc; + unsigned *msize; + unsigned *rsize; + int *mfp_used; +{ + long insn; + CORE_ADDR p = pc; + int misc_index = find_pc_misc_function (pc); + struct prologue_info *mi = 0; + + if (misc_index >= 0) + mi = (struct prologue_info *)misc_function_vector[misc_index].misc_info; + + if (mi != 0) + { + int valid = 1; + if (rsize != NULL) + { + *rsize = mi->rsize; + valid &= mi->rsize_valid; + } + if (msize != NULL) + { + *msize = mi->msize; + valid &= mi->msize_valid; + } + if (mfp_used != NULL) + { + *mfp_used = mi->mfp_used; + valid &= mi->mfp_valid; + } + if (valid) + return mi->pc; + } + + if (rsize != NULL) + *rsize = 0; + if (msize != NULL) + *msize = 0; + if (mfp_used != NULL) + *mfp_used = 0; + + /* Prologue must start with subtracting a constant from gr1. + Normally this is sub gr1,gr1,<rsize * 4>. */ + insn = read_memory_integer (p, 4); + if ((insn & 0xffffff00) != 0x25010100) + { + /* If the frame is large, instead of a single instruction it + might be a pair of instructions: + const <reg>, <rsize * 4> + sub gr1,gr1,<reg> + */ + int reg; + /* Possible value for rsize. */ + unsigned int rsize0; + + if ((insn & 0xff000000) != 0x03000000) + { + p = pc; + goto done; + } + reg = (insn >> 8) & 0xff; + rsize0 = (((insn >> 8) & 0xff00) | (insn & 0xff)); + p += 4; + insn = read_memory_integer (p, 4); + if ((insn & 0xffffff00) != 0x24010100 + || (insn & 0xff) != reg) + { + p = pc; + goto done; + } + if (rsize != NULL) + *rsize = rsize0; + } + else + { + if (rsize != NULL) + *rsize = (insn & 0xff); + } + p += 4; + + /* Next instruction must be asgeu V_SPILL,gr1,rab. */ + insn = read_memory_integer (p, 4); + if (insn != 0x5e40017e) + { + p = pc; + goto done; + } + p += 4; + + /* Next instruction usually sets the frame pointer (lr1) by adding + <size * 4> from gr1. However, this can (and high C does) be + deferred until anytime before the first function call. So it is + OK if we don't see anything which sets lr1. */ + /* Normally this is just add lr1,gr1,<size * 4>. */ + insn = read_memory_integer (p, 4); + if ((insn & 0xffffff00) == 0x15810100) + p += 4; + else + { + /* However, for large frames it can be + const <reg>, <size *4> + add lr1,gr1,<reg> + */ + int reg; + CORE_ADDR q; + + if ((insn & 0xff000000) == 0x03000000) + { + reg = (insn >> 8) & 0xff; + q = p + 4; + insn = read_memory_integer (q, 4); + if ((insn & 0xffffff00) == 0x14810100 + && (insn & 0xff) == reg) + p = q; + } + } + + /* Next comes "add lr{<rsize-1>},msp,0", but only if a memory + frame pointer is in use. We just check for add lr<anything>,msp,0; + we don't check this rsize against the first instruction, and + we don't check that the trace-back tag indicates a memory frame pointer + is in use. + + The recommended instruction is actually "sll lr<whatever>,msp,0". + We check for that, too. Originally Jim Kingdon's code seemed + to be looking for a "sub" instruction here, but the mask was set + up to lose all the time. */ + insn = read_memory_integer (p, 4); + if (((insn & 0xff80ffff) == 0x15807d00) /* add */ + || ((insn & 0xff80ffff) == 0x81807d00) ) /* sll */ + { + p += 4; + if (mfp_used != NULL) + *mfp_used = 1; + } + + /* Next comes a subtraction from msp to allocate a memory frame, + but only if a memory frame is + being used. We don't check msize against the trace-back tag. + + Normally this is just + sub msp,msp,<msize> + */ + insn = read_memory_integer (p, 4); + if ((insn & 0xffffff00) == 0x257d7d00) + { + p += 4; + if (msize != NULL) + *msize = insn & 0xff; + } + else + { + /* For large frames, instead of a single instruction it might + be + + const <reg>, <msize> + consth <reg>, <msize> ; optional + sub msp,msp,<reg> + */ + int reg; + unsigned msize0; + CORE_ADDR q = p; + + if ((insn & 0xff000000) == 0x03000000) + { + reg = (insn >> 8) & 0xff; + msize0 = ((insn >> 8) & 0xff00) | (insn & 0xff); + q += 4; + insn = read_memory_integer (q, 4); + /* Check for consth. */ + if ((insn & 0xff000000) == 0x02000000 + && (insn & 0x0000ff00) == reg) + { + msize0 |= (insn << 8) & 0xff000000; + msize0 |= (insn << 16) & 0x00ff0000; + q += 4; + insn = read_memory_integer (q, 4); + } + /* Check for sub msp,msp,<reg>. */ + if ((insn & 0xffffff00) == 0x247d7d00 + && (insn & 0xff) == reg) + { + p = q + 4; + if (msize != NULL) + *msize = msize0; + } + } + } + + done: + if (misc_index >= 0) + { + if (mi == 0) + { + /* Add a new cache entry. */ + mi = (struct prologue_info *)xmalloc (sizeof (struct prologue_info)); + misc_function_vector[misc_index].misc_info = (char *)mi; + mi->rsize_valid = 0; + mi->msize_valid = 0; + mi->mfp_valid = 0; + } + /* else, cache entry exists, but info is incomplete. */ + mi->pc = p; + if (rsize != NULL) + { + mi->rsize = *rsize; + mi->rsize_valid = 1; + } + if (msize != NULL) + { + mi->msize = *msize; + mi->msize_valid = 1; + } + if (mfp_used != NULL) + { + mi->mfp_used = *mfp_used; + mi->mfp_valid = 1; + } + } + return p; +} + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +CORE_ADDR +skip_prologue (pc) + CORE_ADDR pc; +{ + return examine_prologue (pc, (unsigned *)NULL, (unsigned *)NULL, + (int *)NULL); +} + +/* Initialize the frame. In addition to setting "extra" frame info, + we also set ->frame because we use it in a nonstandard way, and ->pc + because we need to know it to get the other stuff. See the diagram + of stacks and the frame cache in tm-29k.h for more detail. */ +static void +init_frame_info (innermost_frame, fci) + int innermost_frame; + struct frame_info *fci; +{ + CORE_ADDR p; + long insn; + unsigned rsize; + unsigned msize; + int mfp_used; + struct symbol *func; + + p = fci->pc; + + if (innermost_frame) + fci->frame = read_register (GR1_REGNUM); + else + fci->frame = fci->next_frame + fci->next->rsize; + +#if CALL_DUMMY_LOCATION == ON_STACK + This wont work; +#else + if (PC_IN_CALL_DUMMY (p, 0, 0)) +#endif + { + fci->rsize = DUMMY_FRAME_RSIZE; + /* This doesn't matter since we never try to get locals or args + from a dummy frame. */ + fci->msize = 0; + /* Dummy frames always use a memory frame pointer. */ + fci->saved_msp = + read_register_stack_integer (fci->frame + DUMMY_FRAME_RSIZE - 4, 4); + return; + } + + func = find_pc_function (p); + if (func != NULL) + p = BLOCK_START (SYMBOL_BLOCK_VALUE (func)); + else + { + /* Search backward to find the trace-back tag. However, + do not trace back beyond the start of the text segment + (just as a sanity check to avoid going into never-never land). */ + while (p >= text_start + && ((insn = read_memory_integer (p, 4)) & 0xff000000) != 0) + p -= 4; + + if (p < text_start) + { + /* Couldn't find the trace-back tag. + Something strange is going on. */ + fci->saved_msp = 0; + fci->rsize = 0; + fci->msize = 0; + return; + } + else + /* Advance to the first word of the function, i.e. the word + after the trace-back tag. */ + p += 4; + } + /* We've found the start of the function. Since High C interchanges + the meanings of bits 23 and 22 (as of Jul 90), and we + need to look at the prologue anyway to figure out + what rsize is, ignore the contents of the trace-back tag. */ + examine_prologue (p, &rsize, &msize, &mfp_used); + fci->rsize = rsize; + fci->msize = msize; + if (innermost_frame) + { + fci->saved_msp = read_register (MSP_REGNUM) + msize; + } + else + { + if (mfp_used) + fci->saved_msp = + read_register_stack_integer (fci->frame + rsize - 1, 4); + else + fci->saved_msp = fci->next->saved_msp + msize; + } +} + +void +init_extra_frame_info (fci) + struct frame_info *fci; +{ + if (fci->next == 0) + /* Assume innermost frame. May produce strange results for "info frame" + but there isn't any way to tell the difference. */ + init_frame_info (1, fci); + else + /* We're in get_prev_frame_info. + Take care of everything in init_frame_pc. */ + ; +} + +void +init_frame_pc (fromleaf, fci) + int fromleaf; + struct frame_info *fci; +{ + fci->pc = (fromleaf ? SAVED_PC_AFTER_CALL (fci->next) : + fci->next ? FRAME_SAVED_PC (fci->next) : read_pc ()); + init_frame_info (0, fci); +} + +/* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their + offsets being relative to the memory stack pointer (high C) or + saved_msp (gcc). */ + +CORE_ADDR +frame_locals_address (fi) + struct frame_info *fi; +{ + struct block *b = block_for_pc (fi->pc); + /* If compiled without -g, assume GCC. */ + if (b == NULL || BLOCK_GCC_COMPILED (b)) + return fi->saved_msp; + else + return fi->saved_msp - fi->msize; +} + +/* Routines for reading the register stack. The caller gets to treat + the register stack as a uniform stack in memory, from address $gr1 + straight through $rfb and beyond. */ + +/* Analogous to read_memory except the length is understood to be 4. + Also, myaddr can be NULL (meaning don't bother to read), and + if actual_mem_addr is non-NULL, store there the address that it + was fetched from (or if from a register the offset within + registers). Set *LVAL to lval_memory or lval_register, depending + on where it came from. */ +void +read_register_stack (memaddr, myaddr, actual_mem_addr, lval) + CORE_ADDR memaddr; + char *myaddr; + CORE_ADDR *actual_mem_addr; + enum lval_type *lval; +{ + long rfb = read_register (RFB_REGNUM); + long rsp = read_register (RSP_REGNUM); + if (memaddr < rfb) + { + /* It's in a register. */ + int regnum = (memaddr - rsp) / 4 + LR0_REGNUM; + if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127) + error ("Attempt to read register stack out of range."); + if (myaddr != NULL) + read_register_gen (regnum, myaddr); + if (lval != NULL) + *lval = lval_register; + if (actual_mem_addr != NULL) + *actual_mem_addr = REGISTER_BYTE (regnum); + } + else + { + /* It's in the memory portion of the register stack. */ + if (myaddr != NULL) + read_memory (memaddr, myaddr, 4); + if (lval != NULL) + *lval = lval_memory; + if (actual_mem_addr != NULL) + *actual_mem_addr == memaddr; + } +} + +/* Analogous to read_memory_integer + except the length is understood to be 4. */ +long +read_register_stack_integer (memaddr, len) + CORE_ADDR memaddr; + int len; +{ + long buf; + read_register_stack (memaddr, &buf, NULL, NULL); + SWAP_TARGET_AND_HOST (&buf, 4); + return buf; +} + +/* Copy 4 bytes from GDB memory at MYADDR into inferior memory + at MEMADDR and put the actual address written into in + *ACTUAL_MEM_ADDR. */ +static void +write_register_stack (memaddr, myaddr, actual_mem_addr) + CORE_ADDR memaddr; + char *myaddr; + CORE_ADDR *actual_mem_addr; +{ + long rfb = read_register (RFB_REGNUM); + long rsp = read_register (RSP_REGNUM); + if (memaddr < rfb) + { + /* It's in a register. */ + int regnum = (memaddr - rsp) / 4 + LR0_REGNUM; + if (regnum < LR0_REGNUM || regnum > LR0_REGNUM + 127) + error ("Attempt to read register stack out of range."); + if (myaddr != NULL) + write_register (regnum, *(long *)myaddr); + if (actual_mem_addr != NULL) + *actual_mem_addr = NULL; + } + else + { + /* It's in the memory portion of the register stack. */ + if (myaddr != NULL) + write_memory (memaddr, myaddr, 4); + if (actual_mem_addr != NULL) + *actual_mem_addr == memaddr; + } +} + +/* Find register number REGNUM relative to FRAME and put its + (raw) contents in *RAW_BUFFER. Set *OPTIMIZED if the variable + was optimized out (and thus can't be fetched). If the variable + was fetched from memory, set *ADDRP to where it was fetched from, + otherwise it was fetched from a register. + + The argument RAW_BUFFER must point to aligned memory. */ +void +get_saved_register (raw_buffer, optimized, addrp, frame, regnum, lvalp) + char *raw_buffer; + int *optimized; + CORE_ADDR *addrp; + FRAME frame; + int regnum; + enum lval_type *lvalp; +{ + struct frame_info *fi = get_frame_info (frame); + CORE_ADDR addr; + enum lval_type lval; + + /* Once something has a register number, it doesn't get optimized out. */ + if (optimized != NULL) + *optimized = 0; + if (regnum == RSP_REGNUM) + { + if (raw_buffer != NULL) + *(CORE_ADDR *)raw_buffer = fi->frame; + if (lvalp != NULL) + *lvalp = not_lval; + return; + } + else if (regnum == PC_REGNUM) + { + if (raw_buffer != NULL) + *(CORE_ADDR *)raw_buffer = fi->pc; + + /* Not sure we have to do this. */ + if (lvalp != NULL) + *lvalp = not_lval; + + return; + } + else if (regnum == MSP_REGNUM) + { + if (raw_buffer != NULL) + { + if (fi->next != NULL) + *(CORE_ADDR *)raw_buffer = fi->next->saved_msp; + else + *(CORE_ADDR *)raw_buffer = read_register (MSP_REGNUM); + } + /* The value may have been computed, not fetched. */ + if (lvalp != NULL) + *lvalp = not_lval; + return; + } + else if (regnum < LR0_REGNUM || regnum >= LR0_REGNUM + 128) + { + /* These registers are not saved over procedure calls, + so just print out the current values. */ + if (raw_buffer != NULL) + *(CORE_ADDR *)raw_buffer = read_register (regnum); + if (lvalp != NULL) + *lvalp = lval_register; + if (addrp != NULL) + *addrp = REGISTER_BYTE (regnum); + return; + } + + addr = fi->frame + (regnum - LR0_REGNUM) * 4; + if (raw_buffer != NULL) + read_register_stack (addr, raw_buffer, &addr, &lval); + if (lvalp != NULL) + *lvalp = lval; + if (addrp != NULL) + *addrp = addr; +} + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +void +pop_frame () +{ + FRAME frame = get_current_frame (); + struct frame_info *fi = get_frame_info (frame); + CORE_ADDR rfb = read_register (RFB_REGNUM); + CORE_ADDR gr1 = fi->frame + fi->rsize; + CORE_ADDR lr1; + CORE_ADDR ret_addr; + int i; + + /* If popping a dummy frame, need to restore registers. */ + if (PC_IN_CALL_DUMMY (read_register (PC_REGNUM), + read_register (SP_REGNUM), + FRAME_FP (fi))) + { + for (i = 0; i < DUMMY_SAVE_SR128; ++i) + write_register + (SR_REGNUM (i + 128), + read_register (LR0_REGNUM + DUMMY_ARG / 4 + i)); + for (i = 0; i < DUMMY_SAVE_GR96; ++i) + write_register + (GR96_REGNUM + i, + read_register (LR0_REGNUM + DUMMY_ARG / 4 + DUMMY_SAVE_SR128 + i)); + } + + /* Restore the memory stack pointer. */ + write_register (MSP_REGNUM, fi->saved_msp); + /* Restore the register stack pointer. */ + write_register (GR1_REGNUM, gr1); + /* Check whether we need to fill registers. */ + lr1 = read_register (LR0_REGNUM + 1); + if (lr1 > rfb) + { + /* Fill. */ + int num_bytes = lr1 - rfb; + int i; + long word; + write_register (RAB_REGNUM, read_register (RAB_REGNUM) + num_bytes); + write_register (RFB_REGNUM, lr1); + for (i = 0; i < num_bytes; i += 4) + { + /* Note: word is in host byte order. */ + word = read_memory_integer (rfb + i, 4); + write_register (LR0_REGNUM + ((rfb - gr1) % 0x80) + i / 4, word); + } + } + ret_addr = read_register (LR0_REGNUM); + write_register (PC_REGNUM, ret_addr); + write_register (NPC_REGNUM, ret_addr + 4); + flush_cached_frames (); + set_current_frame (create_new_frame (0, read_pc())); +} + +/* Push an empty stack frame, to record the current PC, etc. */ + +void +push_dummy_frame () +{ + long w; + CORE_ADDR rab, gr1; + CORE_ADDR msp = read_register (MSP_REGNUM); + int i; + + /* Save the PC. */ + write_register (LR0_REGNUM, read_register (PC_REGNUM)); + + /* Allocate the new frame. */ + gr1 = read_register (GR1_REGNUM) - DUMMY_FRAME_RSIZE; + write_register (GR1_REGNUM, gr1); + + rab = read_register (RAB_REGNUM); + if (gr1 < rab) + { + /* We need to spill registers. */ + int num_bytes = rab - gr1; + CORE_ADDR rfb = read_register (RFB_REGNUM); + int i; + long word; + + write_register (RFB_REGNUM, rfb - num_bytes); + write_register (RAB_REGNUM, gr1); + for (i = 0; i < num_bytes; i += 4) + { + /* Note: word is in target byte order. */ + read_register_gen (LR0_REGNUM + i / 4, &word, 4); + write_memory (rfb - num_bytes + i, &word, 4); + } + } + + /* There are no arguments in to the dummy frame, so we don't need + more than rsize plus the return address and lr1. */ + write_register (LR0_REGNUM + 1, gr1 + DUMMY_FRAME_RSIZE + 2 * 4); + + /* Set the memory frame pointer. */ + write_register (LR0_REGNUM + DUMMY_FRAME_RSIZE / 4 - 1, msp); + + /* Allocate arg_slop. */ + write_register (MSP_REGNUM, msp - 16 * 4); + + /* Save registers. */ + for (i = 0; i < DUMMY_SAVE_SR128; ++i) + write_register (LR0_REGNUM + DUMMY_ARG / 4 + i, + read_register (SR_REGNUM (i + 128))); + for (i = 0; i < DUMMY_SAVE_GR96; ++i) + write_register (LR0_REGNUM + DUMMY_ARG / 4 + DUMMY_SAVE_SR128 + i, + read_register (GR96_REGNUM + i)); +} diff --git a/gdb/ansidecl.h b/gdb/ansidecl.h new file mode 100755 index 0000000..9e8f390 --- /dev/null +++ b/gdb/ansidecl.h @@ -0,0 +1,93 @@ +/* Copyright (C) 1989 Free Software Foundation, Inc. +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with the GNU C Library; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* ANSI and traditional C compatibility macros + + ANSI C is assumed if __STDC__ is #defined. + + Macros + PTR - Generic pointer type + LONG_DOUBLE - `long double' type + CONST - `const' keyword + VOLATILE - `volatile' keyword + SIGNED - `signed' keyword + PTRCONST - Generic const pointer (void *const) + + EXFUN(name, prototype) - declare external function NAME + with prototype PROTOTYPE + DEFUN(name, arglist, args) - define function NAME with + args ARGLIST of types in ARGS + DEFUN_VOID(name) - define function NAME with no args + AND - argument separator for ARGS + NOARGS - null arglist + DOTS - `...' in args + + For example: + extern int EXFUN(printf, (CONST char *format DOTS)); + int DEFUN(fprintf, (stream, format), + FILE *stream AND CONST char *format DOTS) { ... } + void DEFUN_VOID(abort) { ... } +*/ + +#ifndef _ANSIDECL_H + +#define _ANSIDECL_H 1 + + +/* Every source file includes this file, + so they will all get the switch for lint. */ +/* LINTLIBRARY */ + + +#ifdef __STDC__ + +#define PTR void * +#define PTRCONST void *CONST +#define LONG_DOUBLE long double + +#define AND , +#define NOARGS void +#define CONST const +#define VOLATILE volatile +#define SIGNED signed +#define DOTS , ... + +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(NOARGS) + +#else /* Not ANSI C. */ + +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +#define AND ; +#define NOARGS +#define CONST +#define VOLATILE +#define SIGNED +#define DOTS + +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() + +#endif /* ANSI C. */ + + +#endif /* ansidecl.h */ diff --git a/gdb/arm-convert.s b/gdb/arm-convert.s new file mode 100644 index 0000000..416132b --- /dev/null +++ b/gdb/arm-convert.s @@ -0,0 +1,16 @@ + .text + .global _convert_from_extended + +_convert_from_extended: + + ldfe f0,[a1] + stfd f0,[a2] + movs pc,lr + + .global _convert_to_extended + +_convert_to_extended: + + ldfd f0,[a1] + stfe f0,[a2] + movs pc,lr diff --git a/gdb/arm-pinsn.c b/gdb/arm-pinsn.c new file mode 100644 index 0000000..2da8fdc --- /dev/null +++ b/gdb/arm-pinsn.c @@ -0,0 +1,271 @@ +/* Print ARM instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <ctype.h> +#include <assert.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "arm-opcode.h" + +extern char *reg_names[]; + +static char *shift_names[] = { + "lsl", "lsr", "asr", "ror", +}; + +static char *cond_names[] = { + "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc", + "hi", "ls", "ge", "lt", "gt", "le", "", "nv" +}; + +static char float_precision[] = "sdep"; +static char float_rounding[] = " pmz"; +static float float_immed[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0.5, 10.0 }; + +static void print_ldr_str_offset(); +static void print_ldc_stc_offset(); +static long immediate_value(); + +/* Print the ARM instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned long ins; + register struct opcode *op; + register char *p; + register int i, c; + int s, e, val; + + ins = read_memory_integer(memaddr, 4); + for (i = 0, op = opcodes; i < N_OPCODES; i++, op++) + if ((ins & op->mask) == op->value) break; + assert(i != N_OPCODES); + + for (p = op->assembler; *p;) { + c = *p++; + if (c == '%') { + s = e = 0; + while (isdigit(*p)) + s = s*10 + (*p++ - '0'); + if (*p == '-') { + p++; + while (isdigit(*p)) + e = e*10 + (*p++ - '0'); + } else + e = s; + assert(s >= 0 && s <= 31 && e >= 0 && e <= 31); + val = (ins >> s) & ((1 << (e + 1 - s)) - 1); + switch (*p++) { + case '%' : + putc('%', stream); + break; + case 'd' : + fprintf(stream, "%d", val); + break; + case 'x' : + fprintf(stream, "%x", val); + break; + case 'r' : + assert(val >= 0 && val <= 15); + fprintf(stream, "%s", reg_names[val]); + break; + case 'c' : + fprintf(stream, "%s", cond_names[ins >> 28]); + break; + case '\'' : + assert(*p); + c = *p++; + if (val) + putc(c, stream); + break; + case '`' : + assert(*p); + c = *p++; + if (!val) + putc(c, stream); + break; + case '?' : + assert(*p); + c = *p++; + assert(*p); + if (val) + p++; + else + c = *p++; + putc(c, stream); + break; + case 'p' : + if (((ins >> 12) & 0xf) == 0xf) + putc('p', stream); + break; + case 'o' : + if (ins & (1<<25)) { + int immed = immediate_value(ins & 0xfff); + fprintf (stream, "#%d (0x%x)", immed, immed); + } else { + int operand2 = ins & 0xfff; + /* in operand2 : + bits 0-3 are the base register + bits 5-6 are the shift (0=lsl, 1=lsr, 2=asr, 3=ror) + if bit 4 is zero then bits 7-11 are an immediate shift count + else bit 7 must be zero and bits 8-11 are the register + to be used as a shift count. + Note: no shift at all is encoded as "reg lsl #0" */ + fprintf (stream, "%s", reg_names[operand2 & 0xf]); + if (operand2 & 0xff0) { + /* ror #0 is really rrx (rotate right extend) */ + if ((operand2 & 0xff0) == 0x060) + fprintf (stream, ", rrx"); + else { + fprintf (stream, ", %s ", + shift_names[(operand2 >> 5) & 3]); + if (operand2 & (1<<4)) /* register shift */ + fprintf (stream, "%s", + reg_names[operand2 >> 8]); + else /* immediate shift */ + fprintf (stream, "#%d", + operand2 >> 7); + } + } + } + break; + case 'a' : + fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]); + if (ins & (1<<24)) { + fprintf (stream, ", "); + print_ldr_str_offset (ins, stream); + putc (']', stream); + if (ins & (1<<21)) putc('!', stream); + /* If it is a pc relative load, then it is probably + a constant so print it */ + if (((ins >> 16) & 0xf) == 15 && + (ins & (1<<25)) == 0 && + (ins & (1<<20))) { + int addr = memaddr + 8 + + (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1); + fprintf (stream, " (contents="); + print_address (read_memory_integer(addr, 4), stream); + fprintf (stream, ")"); + } + } else { + fprintf (stream, "]," ); + print_ldr_str_offset (ins, stream); + } + break; + case 'b' : + print_address (memaddr + 8 + (((int)ins << 8) >> 6), stream); + break; + case 'A' : + fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]); + if (ins & (1<<24)) { + fprintf (stream, ", "); + print_ldc_stc_offset (ins, stream); + putc(']', stream); + if (ins & (1<<21)) + putc('!', stream); + } else { + fprintf (stream, "], "); + print_ldc_stc_offset (ins, stream); + } + break; + case 'm' : + { + int regnum, first = 1; + putc('{', stream); + for (regnum = 0; regnum < 16; regnum++) + if (ins & (1<<regnum)) { + if (!first) + putc (',', stream); + first = 0; + fprintf (stream, "%s", reg_names[regnum]); + } + putc('}', stream); + } + break; + case 'P' : + val = ((ins >> 18) & 2) | ((ins >> 7) & 1); + putc(float_precision[val], stream); + break; + case 'Q' : + val = ((ins >> 21) & 2) | ((ins >> 15) & 1); + putc(float_precision[val], stream); + break; + case 'R' : + val = ((ins >> 5) & 3); + if (val) putc(float_rounding[val], stream); + break; + case 'f' : + assert(val >= 0 && val <= 15); + if (val > 7) + fprintf (stream, "#%3.1f", float_immed[val - 8]); + else + fprintf (stream, "f%d", val); + break; + default: + abort(); + } + } else + putc(c, stream); + } + return 4; +} + +static long +immediate_value(operand) +int operand; +{ + int val = operand & 0xff; + int shift = 2*(operand >> 8); + /* immediate value is (val ror shift) */ + return (val >> shift) | (val << (32 - shift)); +} + +static void +print_ldr_str_offset(ins, stream) +unsigned long ins; +FILE *stream; +{ + if ((ins & (1<<25)) == 0) + fprintf (stream, "#%d", + (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1)); + else { + fprintf (stream, "%s%s", reg_names[ins & 0xf], + (ins & (1<<23)) ? "" : "-"); + if (ins & 0xff0) + fprintf (stream, ", %s #%d", + shift_names[(ins >> 5) & 3], + (ins >> 7) & 0x1f); + } +} + +static void +print_ldc_stc_offset(ins, stream) +unsigned long ins; +FILE *stream; +{ + fprintf (stream, "#%d", + 4 * (ins & 0xff) * ((ins & (1<<23)) ? 1 : -1)); +} diff --git a/gdb/arm-xdep.c b/gdb/arm-xdep.c new file mode 100644 index 0000000..b397974 --- /dev/null +++ b/gdb/arm-xdep.c @@ -0,0 +1,274 @@ +/* Acorn Risc Machine host machine support. + Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "arm-opcode.h" + +#include <stdio.h> +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/ioctl.h> +#include <sys/ptrace.h> +#include <machine/reg.h> + +#define N_TXTADDR(hdr) 0x8000 +#define N_DATADDR(hdr) (hdr.a_text + 0x8000) + +#include "gdbcore.h" + +#include <sys/user.h> /* After a.out.h */ +#include <sys/file.h> +#include <sys/stat.h> + +#include <errno.h> + +void +fetch_inferior_registers (regno) + int regno; +{ + register int regno; + register unsigned int regaddr; + char buf[MAX_REGISTER_RAW_SIZE]; + register int i; + + struct user u; + unsigned int offset = (char *) &u.u_ar0 - (char *) &u; + offset = ptrace (PT_READ_U, inferior_pid, offset, 0) - KERNEL_U_ADDR; + + registers_fetched (); + + for (regno = 0; regno < 16; regno++) + { + regaddr = offset + regno * 4; + *(int *)&buf[0] = ptrace (PT_READ_U, inferior_pid, regaddr, 0); + if (regno == PC_REGNUM) + *(int *)&buf[0] = GET_PC_PART(*(int *)&buf[0]); + supply_register (regno, buf); + } + *(int *)&buf[0] = ptrace (PT_READ_U, inferior_pid, offset + PC*4); + supply_register (PS_REGNUM, buf); /* set virtual register ps same as pc */ + + /* read the floating point registers */ + offset = (char *) &u.u_fp_regs - (char *)&u; + *(int *)buf = ptrace (PT_READ_U, inferior_pid, offset, 0); + supply_register (FPS_REGNUM, buf); + for (regno = 16; regno < 24; regno++) { + regaddr = offset + 4 + 12 * (regno - 16); + for (i = 0; i < 12; i += sizeof(int)) + *(int *) &buf[i] = ptrace (PT_READ_U, inferior_pid, regaddr + i, 0); + supply_register (regno, buf); + } +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + register unsigned int regaddr; + char buf[80]; + + struct user u; + unsigned long value; + unsigned int offset = (char *) &u.u_ar0 - (char *) &u; + offset = ptrace (PT_READ_U, inferior_pid, offset, 0) - KERNEL_U_ADDR; + + if (regno >= 0) { + if (regno >= 16) return; + regaddr = offset + 4 * regno; + errno = 0; + value = read_register(regno); + if (regno == PC_REGNUM) + value = SET_PC_PART(read_register (PS_REGNUM), value); + ptrace (PT_WRITE_U, inferior_pid, regaddr, value); + if (errno != 0) + { + sprintf (buf, "writing register number %d", regno); + perror_with_name (buf); + } + } + else for (regno = 0; regno < 15; regno++) + { + regaddr = offset + regno * 4; + errno = 0; + value = read_register(regno); + if (regno == PC_REGNUM) + value = SET_PC_PART(read_register (PS_REGNUM), value); + ptrace (6, inferior_pid, regaddr, value); + if (errno != 0) + { + sprintf (buf, "writing all regs, number %d", regno); + perror_with_name (buf); + } + } +} + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +/* Structure to describe the chain of shared libraries used + by the execfile. + e.g. prog shares Xt which shares X11 which shares c. */ + +struct shared_library { + struct exec_header header; + char name[SHLIBLEN]; + CORE_ADDR text_start; /* CORE_ADDR of 1st byte of text, this file */ + long data_offset; /* offset of data section in file */ + int chan; /* file descriptor for the file */ + struct shared_library *shares; /* library this one shares */ +}; +static struct shared_library *shlib = 0; + +/* Hook for `exec_file_command' command to call. */ + +extern void (*exec_file_display_hook) (); + +static CORE_ADDR unshared_text_start; + +/* extended header from exec file (for shared library info) */ + +static struct exec_header exec_header; + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct user u; + + unsigned int reg_offset, fp_reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name ("Not a core file: reading upage"); + if (val != sizeof u) + error ("Not a core file: could only read %d bytes", val); + + /* We are depending on exec_file_command having been called + previously to set exec_data_start. Since the executable + and the core file share the same text segment, the address + of the data segment will be the same in both. */ + data_start = exec_data_start; + + data_end = data_start + NBPG * u.u_dsize; + stack_start = stack_end - NBPG * u.u_ssize; + data_offset = NBPG * UPAGES; + stack_offset = NBPG * (UPAGES + u.u_dsize); + + /* Some machines put an absolute address in here and some put + the offset in the upage of the regs. */ + reg_offset = (int) u.u_ar0; + if (reg_offset > NBPG * UPAGES) + reg_offset -= KERNEL_U_ADDR; + fp_reg_offset = (char *) &u.u_fp_regs - (char *)&u; + + /* I don't know where to find this info. + So, for now, mark it as not available. */ + N_SET_MAGIC (core_aouthdr, 0); + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + if (regno < 16) + val = lseek (corechan, reg_offset + 4 * regno, 0); + else if (regno < 24) + val = lseek (corechan, fp_reg_offset + 4 + 12*(regno - 24), 0); + else if (regno == 24) + val = lseek (corechan, fp_reg_offset, 0); + else if (regno == 25) + val = lseek (corechan, reg_offset + 4 * PC, 0); + if (val < 0 + || (val = myread (corechan, buf, sizeof buf)) < 0) + { + char * buffer = (char *) alloca (strlen (reg_names[regno]) + + 30); + strcpy (buffer, "Reading register "); + strcat (buffer, reg_names[regno]); + + perror_with_name (buffer); + } + + if (regno == PC_REGNUM) + *(int *)buf = GET_PC_PART(*(int *)buf); + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} diff --git a/gdb/command.c b/gdb/command.c new file mode 100644 index 0000000..0b541a7 --- /dev/null +++ b/gdb/command.c @@ -0,0 +1,1150 @@ +/* Library for reading command lines and decoding commands. + Copyright (C) 1986, 1989, 1990 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "command.h" +#include "symtab.h" +#include "value.h" +#include <stdio.h> +#include <ctype.h> +#include <string.h> + +extern char *getenv (); + +/* Add element named NAME to command list *LIST. + FUN should be the function to execute the command; + it will get a character string as argument, with leading + and trailing blanks already eliminated. + + DOC is a documentation string for the command. + Its first line should be a complete sentence. + It should start with ? for a command that is an abbreviation + or with * for a command that most users don't need to know about. */ + +struct cmd_list_element * +add_cmd (name, class, fun, doc, list) + char *name; + enum command_class class; + void (*fun) (); + char *doc; + struct cmd_list_element **list; +{ + register struct cmd_list_element *c + = (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element)); + + delete_cmd (name, list); + c->next = *list; + c->name = name; + c->class = class; + c->function = fun; + c->doc = doc; + c->prefixlist = 0; + c->prefixname = (char *)NULL; + c->allow_unknown = 0; + c->abbrev_flag = 0; + c->aux = 0; + c->type = not_set_cmd; + c->completer = make_symbol_completion_list; + c->var = 0; + c->var_type = var_boolean; + c->user_commands = 0; + *list = c; + return c; +} + +/* Same as above, except that the abbrev_flag is set. */ + +struct cmd_list_element * +add_abbrev_cmd (name, class, fun, doc, list) + char *name; + enum command_class class; + void (*fun) (); + char *doc; + struct cmd_list_element **list; +{ + register struct cmd_list_element *c + = add_cmd (name, class, fun, doc, list); + + c->abbrev_flag = 1; + return c; +} + +struct cmd_list_element * +add_alias_cmd (name, oldname, class, abbrev_flag, list) + char *name; + char *oldname; + enum command_class class; + int abbrev_flag; + struct cmd_list_element **list; +{ + /* Must do this since lookup_cmd tries to side-effect its first arg */ + char *copied_name; + register struct cmd_list_element *old; + register struct cmd_list_element *c; + copied_name = (char *) alloca (strlen (oldname) + 1); + strcpy (copied_name, oldname); + old = lookup_cmd (&copied_name, *list, "", 1, 1); + + if (old == 0) + { + delete_cmd (name, list); + return 0; + } + + c = add_cmd (name, class, old->function, old->doc, list); + c->prefixlist = old->prefixlist; + c->prefixname = old->prefixname; + c->allow_unknown = old->allow_unknown; + c->abbrev_flag = abbrev_flag; + c->aux = old->aux; + return c; +} + +/* Like add_cmd but adds an element for a command prefix: + a name that should be followed by a subcommand to be looked up + in another command list. PREFIXLIST should be the address + of the variable containing that list. */ + +struct cmd_list_element * +add_prefix_cmd (name, class, fun, doc, prefixlist, prefixname, + allow_unknown, list) + char *name; + enum command_class class; + void (*fun) (); + char *doc; + struct cmd_list_element **prefixlist; + char *prefixname; + int allow_unknown; + struct cmd_list_element **list; +{ + register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list); + c->prefixlist = prefixlist; + c->prefixname = prefixname; + c->allow_unknown = allow_unknown; + return c; +} + +/* Like add_prefix_cmd butsets the abbrev_flag on the new command. */ + +struct cmd_list_element * +add_abbrev_prefix_cmd (name, class, fun, doc, prefixlist, prefixname, + allow_unknown, list) + char *name; + enum command_class class; + void (*fun) (); + char *doc; + struct cmd_list_element **prefixlist; + char *prefixname; + int allow_unknown; + struct cmd_list_element **list; +{ + register struct cmd_list_element *c = add_cmd (name, class, fun, doc, list); + c->prefixlist = prefixlist; + c->prefixname = prefixname; + c->allow_unknown = allow_unknown; + c->abbrev_flag = 1; + return c; +} + +void +not_just_help_class_command (args, from_tty, c) + char *args; + int from_tty; + struct cmd_list_element *c; +{ +} + +/* Add element named NAME to command list LIST (the list for set + or some sublist thereof). + CLASS is as in add_cmd. + VAR_TYPE is the kind of thing we are setting. + VAR is address of the variable being controlled by this command. + DOC is the documentation string. */ +struct cmd_list_element * +add_set_cmd (name, class, var_type, var, doc, list) + char *name; + enum command_class class; + var_types var_type; + char *var; + char *doc; + struct cmd_list_element **list; +{ + /* For set/show, we have to call do_setshow_command + differently than an ordinary function (take commandlist as + well as arg), so the function field isn't helpful. However, + function == NULL means that it's a help class, so set the function + to not_just_help_class_command. */ + struct cmd_list_element *c + = add_cmd (name, class, not_just_help_class_command, doc, list); + + c->type = set_cmd; + c->var_type = var_type; + c->var = var; + return c; +} + +/* Where SETCMD has already been added, add the corresponding show + command to LIST and return a pointer to it. */ +struct cmd_list_element * +add_show_from_set (setcmd, list) + struct cmd_list_element *setcmd; + struct cmd_list_element **list; +{ + struct cmd_list_element *showcmd = + (struct cmd_list_element *) xmalloc (sizeof (struct cmd_list_element)); + + bcopy (setcmd, showcmd, sizeof (struct cmd_list_element)); + delete_cmd (showcmd->name, list); + showcmd->type = show_cmd; + + /* Replace "set " at start of docstring with "show ". */ + if (setcmd->doc[0] == 'S' && setcmd->doc[1] == 'e' + && setcmd->doc[2] == 't' && setcmd->doc[3] == ' ') + showcmd->doc = concat ("Show ", setcmd->doc + 4, ""); + else + fprintf (stderr, "GDB internal error: Bad docstring for set command\n"); + + showcmd->next = *list; + *list = showcmd; + return showcmd; +} + +/* Remove the command named NAME from the command list. */ + +void +delete_cmd (name, list) + char *name; + struct cmd_list_element **list; +{ + register struct cmd_list_element *c; + struct cmd_list_element *p; + + while (*list && !strcmp ((*list)->name, name)) + { + p = (*list)->next; + free (*list); + *list = p; + } + + if (*list) + for (c = *list; c->next;) + { + if (!strcmp (c->next->name, name)) + { + p = c->next->next; + free (c->next); + c->next = p; + } + else + c = c->next; + } +} + +void help_cmd (), help_list (), help_cmd_list (); + +/* This command really has to deal with two things: + * 1) I want documentation on *this string* (usually called by + * "help commandname"). + * 2) I want documentation on *this list* (usually called by + * giving a command that requires subcommands. Also called by saying + * just "help".) + * + * I am going to split this into two seperate comamnds, help_cmd and + * help_list. + */ + +void +help_cmd (command, stream) + char *command; + FILE *stream; +{ + struct cmd_list_element *c; + extern struct cmd_list_element *cmdlist; + + if (!command) + { + help_list (cmdlist, "", all_classes, stream); + return; + } + + c = lookup_cmd (&command, cmdlist, "", 0, 0); + + if (c == 0) + return; + + /* There are three cases here. + If c->prefixlist is nonzero, we have a prefix command. + Print its documentation, then list its subcommands. + + If c->function is nonzero, we really have a command. + Print its documentation and return. + + If c->function is zero, we have a class name. + Print its documentation (as if it were a command) + and then set class to the number of this class + so that the commands in the class will be listed. */ + + fputs_filtered (c->doc, stream); + fputs_filtered ("\n", stream); + + if (c->prefixlist == 0 && c->function != 0) + return; + fprintf_filtered (stream, "\n"); + + /* If this is a prefix command, print it's subcommands */ + if (c->prefixlist) + help_list (*c->prefixlist, c->prefixname, all_commands, stream); + + /* If this is a class name, print all of the commands in the class */ + if (c->function == 0) + help_list (cmdlist, "", c->class, stream); +} + +/* + * Get a specific kind of help on a command list. + * + * LIST is the list. + * CMDTYPE is the prefix to use in the title string. + * CLASS is the class with which to list the nodes of this list (see + * documentation for help_cmd_list below), As usual, ALL_COMMANDS for + * everything, ALL_CLASSES for just classes, and non-negative for only things + * in a specific class. + * and STREAM is the output stream on which to print things. + * If you call this routine with a class >= 0, it recurses. + */ +void +help_list (list, cmdtype, class, stream) + struct cmd_list_element *list; + char *cmdtype; + enum command_class class; + FILE *stream; +{ + int len; + char *cmdtype1, *cmdtype2; + + /* If CMDTYPE is "foo ", CMDTYPE1 gets " foo" and CMDTYPE2 gets "foo sub" */ + len = strlen (cmdtype); + cmdtype1 = (char *) alloca (len + 1); + cmdtype1[0] = 0; + cmdtype2 = (char *) alloca (len + 4); + cmdtype2[0] = 0; + if (len) + { + cmdtype1[0] = ' '; + strncpy (cmdtype1 + 1, cmdtype, len - 1); + cmdtype1[len] = 0; + strncpy (cmdtype2, cmdtype, len - 1); + strcpy (cmdtype2 + len - 1, " sub"); + } + + if (class == all_classes) + fprintf_filtered (stream, "List of classes of %scommands:\n\n", cmdtype2); + else + fprintf_filtered (stream, "List of %scommands:\n\n", cmdtype2); + + help_cmd_list (list, class, cmdtype, (int)class >= 0, stream); + + if (class == all_classes) + fprintf_filtered (stream, "\n\ +Type \"help%s\" followed by a class name for a list of commands in that class.", + cmdtype1); + + fprintf_filtered (stream, "\n\ +Type \"help%s\" followed by %scommand name for full documentation.\n\ +Command name abbreviations are allowed if unambiguous.\n", + cmdtype1, cmdtype2); +} + +/* Print only the first line of STR on STREAM. */ +static void +print_doc_line (stream, str) + FILE *stream; + char *str; +{ + static char *line_buffer = 0; + static int line_size; + register char *p; + + if (!line_buffer) + { + line_size = 80; + line_buffer = (char *) xmalloc (line_size); + } + + p = str; + while (*p && *p != '\n' && *p != '.' && *p != ',') + p++; + if (p - str > line_size - 1) + { + line_size = p - str + 1; + free (line_buffer); + line_buffer = (char *) xmalloc (line_size); + } + strncpy (line_buffer, str, p - str); + line_buffer[p - str] = '\0'; + if (islower (line_buffer[0])) + line_buffer[0] = toupper (line_buffer[0]); + fputs_filtered (line_buffer, stream); +} + +/* + * Implement a help command on command list LIST. + * RECURSE should be non-zero if this should be done recursively on + * all sublists of LIST. + * PREFIX is the prefix to print before each command name. + * STREAM is the stream upon which the output should be written. + * CLASS should be: + * A non-negative class number to list only commands in that + * class. + * ALL_COMMANDS to list all commands in list. + * ALL_CLASSES to list all classes in list. + * + * Note that RECURSE will be active on *all* sublists, not just the + * ones seclected by the criteria above (ie. the selection mechanism + * is at the low level, not the high-level). + */ +void +help_cmd_list (list, class, prefix, recurse, stream) + struct cmd_list_element *list; + enum command_class class; + char *prefix; + int recurse; + FILE *stream; +{ + register struct cmd_list_element *c; + + for (c = list; c; c = c->next) + { + if (c->abbrev_flag == 0 && + (class == all_commands + || (class == all_classes && c->function == 0) + || (class == c->class && c->function != 0))) + { + fprintf_filtered (stream, "%s%s -- ", prefix, c->name); + print_doc_line (stream, c->doc); + fputs_filtered ("\n", stream); + } + if (recurse + && c->prefixlist != 0 + && c->abbrev_flag == 0) + help_cmd_list (*c->prefixlist, class, c->prefixname, 1, stream); + } +} + +/* This routine takes a line of TEXT and a CLIST in which to + start the lookup. When it returns it will have incremented the text + pointer past the section of text it matched, set *RESULT_LIST to + the list in which the last word was matched, and will return the + cmd list element which the text matches. It will return 0 if no + match at all was possible. It will return -1 if ambigous matches are + possible; in this case *RESULT_LIST will be set to the list in which + there are ambiguous choices (and text will be set to the ambiguous + text string). + + It does no error reporting whatsoever; control will always return + to the superior routine. + + In the case of an ambiguous return (-1), *RESULT_LIST will be set to + point at the prefix_command (ie. the best match) *or* (special + case) will be 0 if no prefix command was ever found. For example, + in the case of "info a", "info" matches without ambiguity, but "a" + could be "args" or "address", so *RESULT_LIST is set to + the cmd_list_element for "info". So in this case + result list should not be interpeted as a pointer to the beginning + of a list; it simply points to a specific command. + + If RESULT_LIST is NULL, don't set *RESULT_LIST (but don't otherwise + affect the operation). + + This routine does *not* modify the text pointed to by TEXT. + + If IGNORE_HELP_CLASSES is nonzero, ignore any command list + elements which are actually help classes rather than commands (i.e. + the function field of the struct cmd_list_element is 0). */ + +struct cmd_list_element * +lookup_cmd_1 (text, clist, result_list, ignore_help_classes) + char **text; + struct cmd_list_element *clist, **result_list; + int ignore_help_classes; +{ + char *p, *command; + int len, tmp, nfound; + struct cmd_list_element *found, *c; + + while (**text == ' ' || **text == '\t') + (*text)++; + + /* Treating underscores as part of command words is important + so that "set args_foo()" doesn't get interpreted as + "set args _foo()". */ + for (p = *text; + *p && (isalnum(*p) || *p == '-' || *p == '_'); + p++) + ; + + /* If nothing but whitespace, return 0. */ + if (p == *text) + return 0; + + len = p - *text; + + /* *text and p now bracket the first command word to lookup (and + it's length is len). We copy this into a local temporary, + converting to lower case as we go. */ + + command = (char *) alloca (len + 1); + for (tmp = 0; tmp < len; tmp++) + { + char x = (*text)[tmp]; + command[tmp] = (x >= 'A' && x <= 'Z') ? x - 'A' + 'a' : x; + } + command[len] = '\0'; + + /* Look it up. */ + found = 0; + nfound = 0; + for (c = clist; c; c = c->next) + if (!strncmp (command, c->name, len) + && (!ignore_help_classes || c->function)) + { + found = c; + nfound++; + if (c->name[len] == '\0') + { + nfound = 1; + break; + } + } + + /* If nothing matches, we have a simple failure. */ + if (nfound == 0) + return 0; + + if (nfound > 1) + { + if (result_list != NULL) + /* Will be modified in calling routine + if we know what the prefix command is. */ + *result_list = 0; + return (struct cmd_list_element *) -1; /* Ambiguous. */ + } + + /* We've matched something on this list. Move text pointer forward. */ + + *text = p; + if (found->prefixlist) + { + c = lookup_cmd_1 (text, *found->prefixlist, result_list, + ignore_help_classes); + if (!c) + { + /* Didn't find anything; this is as far as we got. */ + if (result_list != NULL) + *result_list = clist; + return found; + } + else if (c == (struct cmd_list_element *) -1) + { + /* We've gotten this far properley, but the next step + is ambiguous. We need to set the result list to the best + we've found (if an inferior hasn't already set it). */ + if (result_list != NULL) + if (!*result_list) + /* This used to say *result_list = *found->prefixlist + If that was correct, need to modify the documentation + at the top of this function to clarify what is supposed + to be going on. */ + *result_list = found; + return c; + } + else + { + /* We matched! */ + return c; + } + } + else + { + if (result_list != NULL) + *result_list = clist; + return found; + } +} + +/* Look up the contents of *LINE as a command in the command list LIST. + LIST is a chain of struct cmd_list_element's. + If it is found, return the struct cmd_list_element for that command + and update *LINE to point after the command name, at the first argument. + If not found, call error if ALLOW_UNKNOWN is zero + otherwise (or if error returns) return zero. + Call error if specified command is ambiguous, + unless ALLOW_UNKNOWN is negative. + CMDTYPE precedes the word "command" in the error message. + + If INGNORE_HELP_CLASSES is nonzero, ignore any command list + elements which are actually help classes rather than commands (i.e. + the function field of the struct cmd_list_element is 0). */ + +struct cmd_list_element * +lookup_cmd (line, list, cmdtype, allow_unknown, ignore_help_classes) + char **line; + struct cmd_list_element *list; + char *cmdtype; + int allow_unknown; + int ignore_help_classes; +{ + struct cmd_list_element *last_list = 0; + struct cmd_list_element *c = + lookup_cmd_1 (line, list, &last_list, ignore_help_classes); + char *ptr = (*line) + strlen (*line) - 1; + + /* Clear off trailing whitespace. */ + while (ptr >= *line && (*ptr == ' ' || *ptr == '\t')) + ptr--; + *(ptr + 1) = '\0'; + + if (!c) + { + if (!allow_unknown) + { + if (!*line) + error ("Lack of needed %scommand", cmdtype); + else + { + char *p = *line, *q; + + while (isalnum(*p) || *p == '-') + p++; + + q = (char *) alloca (p - *line + 1); + strncpy (q, *line, p - *line); + q[p-*line] = '\0'; + + error ("Undefined %scommand: \"%s\".", cmdtype, q); + } + } + else + return 0; + } + else if (c == (struct cmd_list_element *) -1) + { + /* Ambigous. Local values should be off prefixlist or called + values. */ + int local_allow_unknown = (last_list ? last_list->allow_unknown : + allow_unknown); + char *local_cmdtype = last_list ? last_list->prefixname : cmdtype; + struct cmd_list_element *local_list = + (last_list ? *(last_list->prefixlist) : list); + + if (local_allow_unknown < 0) + { + if (last_list) + return last_list; /* Found something. */ + else + return 0; /* Found nothing. */ + } + else + { + /* Report as error. */ + int amb_len; + char ambbuf[100]; + + for (amb_len = 0; + ((*line)[amb_len] && (*line)[amb_len] != ' ' + && (*line)[amb_len] != '\t'); + amb_len++) + ; + + ambbuf[0] = 0; + for (c = local_list; c; c = c->next) + if (!strncmp (*line, c->name, amb_len)) + { + if (strlen (ambbuf) + strlen (c->name) + 6 < (int)sizeof ambbuf) + { + if (strlen (ambbuf)) + strcat (ambbuf, ", "); + strcat (ambbuf, c->name); + } + else + { + strcat (ambbuf, ".."); + break; + } + } + error ("Ambiguous %scommand \"%s\": %s.", local_cmdtype, + *line, ambbuf); + return 0; /* lint */ + } + } + else + { + /* We've got something. It may still not be what the caller + wants (if this command *needs* a subcommand). */ + while (**line == ' ' || **line == '\t') + (*line)++; + + if (c->prefixlist && **line && !c->allow_unknown) + error ("Undefined %scommand: \"%s\".", c->prefixname, *line); + + /* Seems to be what he wants. Return it. */ + return c; + } + return 0; +} + +#if 0 +/* Look up the contents of *LINE as a command in the command list LIST. + LIST is a chain of struct cmd_list_element's. + If it is found, return the struct cmd_list_element for that command + and update *LINE to point after the command name, at the first argument. + If not found, call error if ALLOW_UNKNOWN is zero + otherwise (or if error returns) return zero. + Call error if specified command is ambiguous, + unless ALLOW_UNKNOWN is negative. + CMDTYPE precedes the word "command" in the error message. */ + +struct cmd_list_element * +lookup_cmd (line, list, cmdtype, allow_unknown) + char **line; + struct cmd_list_element *list; + char *cmdtype; + int allow_unknown; +{ + register char *p; + register struct cmd_list_element *c, *found; + int nfound; + char ambbuf[100]; + char *processed_cmd; + int i, cmd_len; + + /* Skip leading whitespace. */ + + while (**line == ' ' || **line == '\t') + (*line)++; + + /* Clear out trailing whitespace. */ + + p = *line + strlen (*line); + while (p != *line && (p[-1] == ' ' || p[-1] == '\t')) + p--; + *p = 0; + + /* Find end of command name. */ + + p = *line; + while (*p == '-' + || (*p >= 'a' && *p <= 'z') + || (*p >= 'A' && *p <= 'Z') + || (*p >= '0' && *p <= '9')) + p++; + + /* Look up the command name. + If exact match, keep that. + Otherwise, take command abbreviated, if unique. Note that (in my + opinion) a null string does *not* indicate ambiguity; simply the + end of the argument. */ + + if (p == *line) + { + if (!allow_unknown) + error ("Lack of needed %scommand", cmdtype); + return 0; + } + + /* Copy over to a local buffer, converting to lowercase on the way. + This is in case the command being parsed is a subcommand which + doesn't match anything, and that's ok. We want the original + untouched for the routine of the original command. */ + + processed_cmd = (char *) alloca (p - *line + 1); + for (cmd_len = 0; cmd_len < p - *line; cmd_len++) + { + char x = (*line)[cmd_len]; + if (x >= 'A' && x <= 'Z') + processed_cmd[cmd_len] = x - 'A' + 'a'; + else + processed_cmd[cmd_len] = x; + } + processed_cmd[cmd_len] = '\0'; + + /* Check all possibilities in the current command list. */ + found = 0; + nfound = 0; + for (c = list; c; c = c->next) + { + if (!strncmp (processed_cmd, c->name, cmd_len)) + { + found = c; + nfound++; + if (c->name[cmd_len] == 0) + { + nfound = 1; + break; + } + } + } + + /* Report error for undefined command name. */ + + if (nfound != 1) + { + if (nfound > 1 && allow_unknown >= 0) + { + ambbuf[0] = 0; + for (c = list; c; c = c->next) + if (!strncmp (processed_cmd, c->name, cmd_len)) + { + if (strlen (ambbuf) + strlen (c->name) + 6 < sizeof ambbuf) + { + if (strlen (ambbuf)) + strcat (ambbuf, ", "); + strcat (ambbuf, c->name); + } + else + { + strcat (ambbuf, ".."); + break; + } + } + error ("Ambiguous %scommand \"%s\": %s.", cmdtype, + processed_cmd, ambbuf); + } + else if (!allow_unknown) + error ("Undefined %scommand: \"%s\".", cmdtype, processed_cmd); + return 0; + } + + /* Skip whitespace before the argument. */ + + while (*p == ' ' || *p == '\t') p++; + *line = p; + + if (found->prefixlist && *p) + { + c = lookup_cmd (line, *found->prefixlist, found->prefixname, + found->allow_unknown); + if (c) + return c; + } + + return found; +} +#endif + +/* Helper function for SYMBOL_COMPLETION_FUNCTION. */ + +/* Return a vector of char pointers which point to the different + possible completions in LIST of TEXT. */ + +char ** +complete_on_cmdlist (list, text) + struct cmd_list_element *list; + char *text; +{ + struct cmd_list_element *ptr; + char **matchlist; + int sizeof_matchlist; + int matches; + int textlen = strlen (text); + + sizeof_matchlist = 10; + matchlist = (char **) xmalloc (sizeof_matchlist * sizeof (char *)); + matches = 0; + + for (ptr = list; ptr; ptr = ptr->next) + if (!strncmp (ptr->name, text, textlen) + && !ptr->abbrev_flag + && (ptr->function + || ptr->prefixlist)) + { + if (matches == sizeof_matchlist) + { + sizeof_matchlist *= 2; + matchlist = (char **) xrealloc ((char *)matchlist, + (sizeof_matchlist + * sizeof (char *))); + } + + matchlist[matches] = (char *) + xmalloc (strlen (ptr->name) + 1); + strcpy (matchlist[matches++], ptr->name); + } + + if (matches == 0) + { + free (matchlist); + matchlist = 0; + } + else + { + matchlist = (char **) xrealloc ((char *)matchlist, ((matches + 1) + * sizeof (char *))); + matchlist[matches] = (char *) 0; + } + + return matchlist; +} + +static int +parse_binary_operation (arg) + char *arg; +{ + int length; + + if (!arg || !*arg) + return 1; + + length = strlen (arg); + + while (arg[length - 1] == ' ' || arg[length - 1] == '\t') + length--; + + if (!strncmp (arg, "on", length) + || !strncmp (arg, "1", length) + || !strncmp (arg, "yes", length)) + return 1; + else + if (!strncmp (arg, "off", length) + || !strncmp (arg, "0", length) + || !strncmp (arg, "no", length)) + return 0; + else + { + error ("\"on\" or \"off\" expected."); + return 0; + } +} + +/* Do a "set" or "show" command. ARG is NULL if no argument, or the text + of the argument, and FROM_TTY is nonzero if this command is being entered + directly by the user (i.e. these are just like any other + command). C is the command list element for the command. */ +void +do_setshow_command (arg, from_tty, c) + char *arg; + int from_tty; + struct cmd_list_element *c; +{ + if (c->type == set_cmd) + { + switch (c->var_type) + { + case var_string: + { + char *new; + char *p; + char *q; + int ch; + + if (arg == NULL) + arg = ""; + new = (char *) xmalloc (strlen (arg) + 2); + p = arg; q = new; + while (ch = *p++) + { + if (ch == '\\') + { + /* \ at end of argument is used after spaces + so they won't be lost. */ + if (*p == 0) + break; + ch = parse_escape (&p); + if (ch == 0) + break; /* C loses */ + else if (ch > 0) + *q++ = ch; + } + else + *q++ = ch; + } + if (*(p - 1) != '\\') + *q++ = ' '; + *q++ = '\0'; + new = (char *) xrealloc (new, q - new); + if (*(char **)c->var != NULL) + free (*(char **)c->var); + *(char **) c->var = new; + } + break; + case var_string_noescape: + if (arg == NULL) + arg = ""; + if (*(char **)c->var != NULL) + free (*(char **)c->var); + *(char **) c->var = savestring (arg, strlen (arg)); + break; + case var_filename: + if (arg == NULL) + error_no_arg ("filename to set it to."); + if (*(char **)c->var != NULL) + free (*(char **)c->var); + *(char **)c->var = tilde_expand (arg); + break; + case var_boolean: + *(int *) c->var = parse_binary_operation (arg); + break; + case var_uinteger: + if (arg == NULL) + error_no_arg ("integer to set it to."); + *(int *) c->var = parse_and_eval_address (arg); + if (*(int *) c->var == 0) + *(int *) c->var = UINT_MAX; + break; + case var_zinteger: + if (arg == NULL) + error_no_arg ("integer to set it to."); + *(int *) c->var = parse_and_eval_address (arg); + break; + default: + error ("gdb internal error: bad var_type in do_setshow_command"); + } + } + else if (c->type == show_cmd) + { + /* Print doc minus "show" at start. */ + print_doc_line (stdout, c->doc + 5); + + fputs_filtered (" is ", stdout); + wrap_here (" "); + switch (c->var_type) + { + case var_string: + { + unsigned char *p; + fputs_filtered ("\"", stdout); + for (p = *(unsigned char **) c->var; *p != '\0'; p++) + printchar (*p, stdout, '"'); + fputs_filtered ("\"", stdout); + } + break; + case var_string_noescape: + case var_filename: + fputs_filtered ("\"", stdout); + fputs_filtered (*(char **) c->var, stdout); + fputs_filtered ("\"", stdout); + break; + case var_boolean: + fputs_filtered (*(int *) c->var ? "on" : "off", stdout); + break; + case var_uinteger: + if (*(unsigned int *) c->var == UINT_MAX) { + fputs_filtered ("unlimited", stdout); + break; + } + /* else fall through */ + case var_zinteger: + fprintf_filtered (stdout, "%d", *(unsigned int *) c->var); + break; + default: + error ("gdb internal error: bad var_type in do_setshow_command"); + } + fputs_filtered (".\n", stdout); + } + else + error ("gdb internal error: bad cmd_type in do_setshow_command"); + (*c->function) (NULL, from_tty, c); +} + +/* Show all the settings in a list of show commands. */ + +void +cmd_show_list (list, from_tty, prefix) + struct cmd_list_element *list; + int from_tty; + char *prefix; +{ + for (; list != NULL; list = list->next) { + /* If we find a prefix, run its list, prefixing our output by its + prefix (with "show " skipped). */ + if (list->prefixlist && !list->abbrev_flag) + cmd_show_list (*list->prefixlist, from_tty, list->prefixname + 5); + if (list->type == show_cmd) + { + fputs_filtered (prefix, stdout); + fputs_filtered (list->name, stdout); + fputs_filtered (": ", stdout); + do_setshow_command ((char *)NULL, from_tty, list); + } + } +} + +static void +shell_escape (arg, from_tty) + char *arg; + int from_tty; +{ + int rc, status, pid; + char *p, *user_shell; + extern char *rindex (); + + if ((user_shell = (char *) getenv ("SHELL")) == NULL) + user_shell = "/bin/sh"; + + /* Get the name of the shell for arg0 */ + if ((p = rindex (user_shell, '/')) == NULL) + p = user_shell; + else + p++; /* Get past '/' */ + + if ((pid = fork()) == 0) + { + if (!arg) + execl (user_shell, p, 0); + else + execl (user_shell, p, "-c", arg, 0); + + fprintf (stderr, "Exec of shell failed\n"); + exit (0); + } + + if (pid != -1) + while ((rc = wait (&status)) != pid && rc != -1) + ; + else + error ("Fork failed"); +} + +static void +make_command (arg, from_tty) + char *arg; + int from_tty; +{ + char *p; + + if (arg == 0) + p = "make"; + else + { + p = xmalloc (sizeof("make ") + strlen(arg)); + strcpy (p, "make "); + strcpy (p + sizeof("make ")-1, arg); + } + + shell_escape (p, from_tty); +} + +void +_initialize_command () +{ + add_com ("shell", class_support, shell_escape, + "Execute the rest of the line as a shell command. \n\ +With no arguments, run an inferior shell."); + + add_com ("make", class_support, make_command, + "Run the ``make'' program using the rest of the line as arguments."); +} diff --git a/gdb/config.gdb b/gdb/config.gdb new file mode 100755 index 0000000..917d94e --- /dev/null +++ b/gdb/config.gdb @@ -0,0 +1,185 @@ +#!/bin/sh + +# Shell script to do machine-dependent things in +# preparation for compiling gdb. +# +# Usage: config.gdb machine +# +# If config.gdb succeeds, it leaves its status in config.status. +# If config.gdb fails after disturbing the status quo, +# config.status is removed. + +progname=$0 +host= +target= +list_hosts= +list_targets= +srcdir= + +for arg in $*; do + case $arg in + -srcdir=*|+srcdir=*) + srcdir=`echo $arg | sed 's/[+-]srcdir=//'` + ;; + -host|+host) + list_hosts=true + ;; + -target|+target) + list_targets=true + ;; + -host=*|+host=*) + if [ "$host" = "" ]; then + host=`echo $arg | sed 's/[+-]host=//'` + else + echo Error: Attempt to specify host machine twice + bad=true + fi + ;; + -target=*|+target=*) + if [ "$target" = "" ]; then + target=`echo $arg | sed 's/[+-]target=//'` + else + echo Error: Attempt to specify target machine twice + bad=true + fi + ;; + *) + if [ "$host" = "" ]; then + host=$arg + else + if [ "$target" = "" ]; then + target=$arg + else + echo Error: More arguments than host and target machine names + bad=true + fi + fi + ;; + esac +done + +if [ "$target" = "" ]; then target=$host; fi +if [ "$host" = "" ]; then bad=true; fi + +# Find the source files, if location was not specified +if [ "$srcdir" = "" ]; then + srcdirdefaulted=true + srcdir=. + if [ ! -r main.c ]; then + srcdir=.. + fi +fi +if [ ! -r ${srcdir}/main.c ]; then + if [ "$srcdirdefaulted" != "true" ]; then + echo "$progname: Can't find debugger sources in \`${srcdir}'." 1>&2 + else + echo "$progname: Can't find debugger sources in \`.' or \`..'." 1>&2 + fi + exit 1 +fi + +if [ "$list_hosts" = "true" ]; then + cd $srcdir/xconfig + for i in * ; do +# The {} in ${i} are required or else /bin/sh in sony newsos 3.2 removes +# the quote after it. + awk <$i "NR == 1 { lastchar = substr(\"${i}\", length(\"${i}\"), 1) +if (lastchar != \"~\" && lastchar != \"#\") \ +printf \"%-12s %s\n\", \"${i}\", substr(\$0,2) }" + done +fi + +if [ "$list_targets" = "true" ]; then + cd $srcdir/tconfig + for i in * ; do + awk <$i "NR == 1 { lastchar = substr(\"${i}\", length(\"${i}\"), 1) +if (lastchar != \"~\" && lastchar != \"#\") \ +printf \"%-12s %s\n\", \"${i}\", substr(\$0,2) }" + done +fi + +if [ "$list_hosts" = "true" -o "$list_targets" = "true" ]; then + exit 0 +fi + +if [ "$host" != "" -a ! -f $srcdir/xconfig/$host ]; then + echo "No such host $host" + bad=true +fi + +if [ "$target" != "" -a ! -f $srcdir/tconfig/$target ]; then + echo "No such target $target" + bad=true +fi + +if [ "$bad" = "true" ] ; then + echo "Usage: " + echo " $progname [+srcdir=\`dir'] machine" + echo " For normal usage" + echo " $progname [+srcdir=\`dir'] \`host' \`target'" + echo " $progname [+srcdir=\`dir'] +host=\`host' +target=\`target'" + echo " If you are doing remote debugging between machines of two" + echo " different types (cross-debugging). \`host' is the type of" + echo " machine on which GDB will be running. \`target' is the" + echo " machine that the program you are debugging will be" + echo " running on." + echo " $progname +host" + echo " Print a list of valid host machine types." + echo " $progname +target" + echo " Print a list of valid target machine types." + echo + echo " +srcdir=\`dir' means that the sources are in \`dir'. For" + echo " example, \`cd /obj/hp300; config.gdb +srcdir=/src/gdb hp300'" + echo " If +srcdir is not specified, sources can either be in \`.'" + echo " or \`..'." + echo + + if [ -r config.status ] + then + cat config.status + fi + exit 1 +fi + +rm -f tm.h xm.h + +cat $srcdir/xconfig/$host $srcdir/tconfig/$target | awk '$1 == "#msg" { + print substr($0,6)}' +paramfile=${srcdir}/`awk ' + $1 == "TM_FILE=" { print $2 }' <$srcdir/tconfig/$target` +if [ "$paramfile" != "${srcdir}/" ] ; then + # Make a symlink if possible, otherwise try a hard link + ln -s $paramfile tm.h 2>/dev/null || ln $paramfile tm.h +fi + +paramfile=${srcdir}/`awk ' + $1 == "XM_FILE=" { print $2 }' <$srcdir/xconfig/$host` +if [ "$paramfile" != "${srcdir}/" ] ; then + # Make a symlink if possible, otherwise try a hard link + ln -s $paramfile xm.h 2>/dev/null || ln $paramfile xm.h +fi + +rm -f config.status + +case ${srcdir} in + .) + ;; + *) + echo "srcdir=${srcdir}" >./Makefile.srcdir + grep -s "source ${srcdir}/.gdbinit" .gdbinit 2>/dev/null || \ + echo "source ${srcdir}/.gdbinit" >> .gdbinit + if [ ! -d readline ]; then + mkdir readline + # This could be a symlink, but getting the name right (because + # srcdir can be either relative or absolute) would be hairy. + cp ${srcdir}/readline/Makefile readline + fi +esac + +make "srcdir=${srcdir}" \ + "M_MAKEFILE=$srcdir/tconfig/$target $srcdir/xconfig/$host" \ + -f $srcdir/Makefile.dist Makefile + +echo "GDB is now set up for host machine $host and target machine $target." \ + | tee config.status +exit 0 diff --git a/gdb/config.status b/gdb/config.status new file mode 100755 index 0000000..ec87176 --- /dev/null +++ b/gdb/config.status @@ -0,0 +1 @@ +GDB is now set up for host machine none and target machine none. diff --git a/gdb/config/3b1.mh b/gdb/config/3b1.mh new file mode 100644 index 0000000..76fc51d --- /dev/null +++ b/gdb/config/3b1.mh @@ -0,0 +1,27 @@ +# AT&T 3b1/Unix pc +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# I don't think cc has been tried. -traditional for <sys/ioctl.h> +# (not sure whether necessary). +CC= gcc -traditional +# GCC runs out of virtual memory. +PINSN_CC= cc + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-3b1.h diff --git a/gdb/config/3b1.mt b/gdb/config/3b1.mt new file mode 100644 index 0000000..8a73b46 --- /dev/null +++ b/gdb/config/3b1.mt @@ -0,0 +1,21 @@ +# AT&T 3b1/Unix pc +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o +TM_FILE= tm-3b1.h diff --git a/gdb/config/altos.mh b/gdb/config/altos.mh new file mode 100644 index 0000000..03f93bf --- /dev/null +++ b/gdb/config/altos.mh @@ -0,0 +1,24 @@ +# Altos 3068 (68k, System V release 2) +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o altos-xdep.o +XM_FILE= xm-altos.h +REGEX=regex.o +REGEX1=regex.o +SYSV_DEFINE=-DSYSV diff --git a/gdb/config/altos.mt b/gdb/config/altos.mt new file mode 100644 index 0000000..5d43893 --- /dev/null +++ b/gdb/config/altos.mt @@ -0,0 +1,21 @@ +# Altos 3068 (68k, System V release 2) +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= m68k-pinsn.o exec.o +TM_FILE= tm-altos.h diff --git a/gdb/config/altosgas.mh b/gdb/config/altosgas.mh new file mode 100644 index 0000000..2ade447 --- /dev/null +++ b/gdb/config/altosgas.mh @@ -0,0 +1,27 @@ +# Altos 3068 (68k, System V release 2), using COFF encapsulation +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Use of the coff encapsulation features require the GNU binutils utilities +#msg To be ahead of their System V counterparts in your path. + +XDEPFILES= infptrace.o altos-xdep.o +XM_FILE= xm-altos.h +REGEX=regex.o +REGEX1=regex.o +SYSV_DEFINE=-DSYSV diff --git a/gdb/config/altosgas.mt b/gdb/config/altosgas.mt new file mode 100644 index 0000000..3c502fc --- /dev/null +++ b/gdb/config/altosgas.mt @@ -0,0 +1,24 @@ +# Altos 3068 (68k, System V release 2), using COFF encapsulation +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Use of the coff encapsulation features require the GNU binutils utilities +#msg To be ahead of their System V counterparts in your path. + +TDEPFILES= m68k-pinsn.o exec.o +TM_FILE= tm-altosgas.h diff --git a/gdb/config/am29k b/gdb/config/am29k new file mode 100755 index 0000000..8a9b475 --- /dev/null +++ b/gdb/config/am29k @@ -0,0 +1,23 @@ +# AMD 29000 on EB29K board over a serial line. +# Copyright (C) 1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o am29k-pinsn.o remote-eb.o am29k-tdep.o +TM_FILE= tm-29k.h +# The following is for ../include/a.out.encap.h +TM_CFLAGS = -DCOFF_ENCAPSULATE -DTARGET=TARGET_AM29K diff --git a/gdb/config/arm.mh b/gdb/config/arm.mh new file mode 100644 index 0000000..8dc057a --- /dev/null +++ b/gdb/config/arm.mh @@ -0,0 +1,21 @@ +# Acorn RISC machine running RISCiX (4.3bsd) +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o arm-xdep.o arm-convert.o +XM_FILE= xm-arm.h diff --git a/gdb/config/arm.mt b/gdb/config/arm.mt new file mode 100644 index 0000000..d26c862 --- /dev/null +++ b/gdb/config/arm.mt @@ -0,0 +1,21 @@ +# Acorn RISC machine running RISCiX (4.3bsd) +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= arm-tdep.o arm-pinsn.o +TM_FILE= tm-arm.h diff --git a/gdb/config/bigmips.mh b/gdb/config/bigmips.mh new file mode 100644 index 0000000..1b1cd48 --- /dev/null +++ b/gdb/config/bigmips.mh @@ -0,0 +1,21 @@ +# Big-endian MIPS machine such as Sony News +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o mips-xdep.o coredep.o +XM_FILE= xm-bigmips.h diff --git a/gdb/config/bigmips.mt b/gdb/config/bigmips.mt new file mode 100644 index 0000000..0e594d8 --- /dev/null +++ b/gdb/config/bigmips.mt @@ -0,0 +1,21 @@ +# Big-endian MIPS machine such as Sony News +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= mips-pinsn.o mips-tdep.o mipsread.o exec.o +TM_FILE= tm-bigmips.h diff --git a/gdb/config/convex.mh b/gdb/config/convex.mh new file mode 100644 index 0000000..b681f28 --- /dev/null +++ b/gdb/config/convex.mh @@ -0,0 +1,21 @@ +# Convex Unix (4bsd) +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= convex-xdep.o +XM_FILE= xm-convex.h diff --git a/gdb/config/convex.mt b/gdb/config/convex.mt new file mode 100644 index 0000000..f7938a2 --- /dev/null +++ b/gdb/config/convex.mt @@ -0,0 +1,21 @@ +# Convex Unix (4bsd) +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= convex-tdep.o convex-pinsn.o +TM_FILE= tm-convex.h diff --git a/gdb/config/hp300bsd.mh b/gdb/config/hp300bsd.mh new file mode 100644 index 0000000..ae3bb82 --- /dev/null +++ b/gdb/config/hp300bsd.mh @@ -0,0 +1,21 @@ +# Hewlett-Packard 9000 series 300, running BSD +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-hp300bsd.h diff --git a/gdb/config/hp300bsd.mt b/gdb/config/hp300bsd.mt new file mode 100644 index 0000000..ea03374 --- /dev/null +++ b/gdb/config/hp300bsd.mt @@ -0,0 +1,21 @@ +# Hewlett-Packard 9000 series 300, running BSD +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o +TM_FILE= tm-hp300bsd.h diff --git a/gdb/config/hp300hpux.mh b/gdb/config/hp300hpux.mh new file mode 100644 index 0000000..3488ef0 --- /dev/null +++ b/gdb/config/hp300hpux.mh @@ -0,0 +1,33 @@ +# Hewlett-Packard 9000 series 300, running HPUX +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The following is true because gcc uses a different .o file format +# than the native HPUX compiler +#msg If you compile GDB with GCC on HPUX, you must make sure +#msg that the `nm' used in `munch' is GNU nm +#msg + +# The headers in the directory hp-include override system headers +# and tell GDB to use BSD executable file format (hence -Ihp-include) +XDEPFILES= infptrace.o hp300hpux-xdep.o +XM_FILE= xm-hp300hpux.h +SYSV_DEFINE=-DSYSV +REGEX=regex.o +REGEX1=regex.o +ALLOCA=alloca.o diff --git a/gdb/config/hp300hpux.mt b/gdb/config/hp300hpux.mt new file mode 100644 index 0000000..cee6ba7 --- /dev/null +++ b/gdb/config/hp300hpux.mt @@ -0,0 +1,28 @@ +# Hewlett-Packard 9000 series 300, running HPUX +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Note that GDB only can read symbols from programs that were +#msg compiled with GCC +#msg + +# The headers in the directory hp-include override system headers +# and tell GDB to use BSD executable file format (hence -Ihp-include) +TM_CFLAGS=-Ihp-include +TDEPFILES= exec.o m68k-pinsn.o +TM_FILE= tm-hp300hpux.h diff --git a/gdb/config/i386v-g.mh b/gdb/config/i386v-g.mh new file mode 100644 index 0000000..a14a85e --- /dev/null +++ b/gdb/config/i386v-g.mh @@ -0,0 +1,25 @@ +# Intel 386 running System V, using COFF encapsulation +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o i386-xdep.o +XM_FILE= xm-i386v.h +XM_CLIBS= -lPW +SYSV_DEFINE=-DSYSV +REGEX=regex.o +REGEX1=regex.o diff --git a/gdb/config/i386v-g.mt b/gdb/config/i386v-g.mt new file mode 100644 index 0000000..b93b9ce --- /dev/null +++ b/gdb/config/i386v-g.mt @@ -0,0 +1,25 @@ +# Intel 386 running System V, using COFF encapsulation +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Use of the COFF encapsulation features requires the GNU binary utilities +#msg to be ahead of their System V counterparts in your path. +#msg + +TDEPFILES= exec.o i386-tdep.o i386-pinsn.o +TM_FILE= tm-i386v-g.h diff --git a/gdb/config/i386v.mh b/gdb/config/i386v.mh new file mode 100644 index 0000000..c65cd37 --- /dev/null +++ b/gdb/config/i386v.mh @@ -0,0 +1,25 @@ +# Intel 386 running System V +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o i386-xdep.o +XM_FILE= xm-i386v.h +XM_CLIBS= -lPW +SYSV_DEFINE=-DSYSV +REGEX=regex.o +REGEX1=regex.o diff --git a/gdb/config/i386v.mt b/gdb/config/i386v.mt new file mode 100644 index 0000000..14d9b59 --- /dev/null +++ b/gdb/config/i386v.mt @@ -0,0 +1,21 @@ +# Intel 386 running System V +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o i386-tdep.o i386-pinsn.o +TM_FILE= tm-i386v.h diff --git a/gdb/config/i386v32-g.mh b/gdb/config/i386v32-g.mh new file mode 100644 index 0000000..4dfb1a4 --- /dev/null +++ b/gdb/config/i386v32-g.mh @@ -0,0 +1,25 @@ +# Intel 386 running System V release 2, using COFF encapsulation +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o i386-xdep.o +XM_FILE= xm-i386v32.h +XM_CLIBS= -lPW +SYSV_DEFINE=-DSYSV +REGEX=regex.o +REGEX1=regex.o diff --git a/gdb/config/i386v32-g.mt b/gdb/config/i386v32-g.mt new file mode 100644 index 0000000..2432551 --- /dev/null +++ b/gdb/config/i386v32-g.mt @@ -0,0 +1,24 @@ +# Intel 386 running System V release 2, using COFF encapsulation +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Use of the COFF encapsulation features requires the GNU binary utilities +#msg to be ahead of their System V counterparts in your path. + +TDEPFILES= exec.o i386-tdep.o i386-pinsn.o +TM_FILE= tm-i386v-g.h diff --git a/gdb/config/i386v32.mh b/gdb/config/i386v32.mh new file mode 100644 index 0000000..c184745 --- /dev/null +++ b/gdb/config/i386v32.mh @@ -0,0 +1,25 @@ +# Intel 386 running System V release 2 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o i386-xdep.o +XM_FILE= xm-i386v32.h +XM_CLIBS= -lPW +SYSV_DEFINE=-DSYSV +REGEX=regex.o +REGEX1=regex.o diff --git a/gdb/config/i386v32.mt b/gdb/config/i386v32.mt new file mode 100644 index 0000000..5cca19d --- /dev/null +++ b/gdb/config/i386v32.mt @@ -0,0 +1,21 @@ +# Intel 386 running System V release 2 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o i386-tdep.o i386-pinsn.o +TM_FILE= tm-i386v.h diff --git a/gdb/config/i960.mt b/gdb/config/i960.mt new file mode 100644 index 0000000..d92b73e --- /dev/null +++ b/gdb/config/i960.mt @@ -0,0 +1,23 @@ +# Intel 80960, under NINDY or under VxWorks, selected at runtime. +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg +#msg You must specify either "nindy960" or "vxworks960"; there is no +#msg generic i960 target any more. +#msg diff --git a/gdb/config/isi.mh b/gdb/config/isi.mh new file mode 100644 index 0000000..1ae1c7a --- /dev/null +++ b/gdb/config/isi.mh @@ -0,0 +1,21 @@ +# ISI Optimum V (3.05) under 4.3bsd. +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-isi.h diff --git a/gdb/config/isi.mt b/gdb/config/isi.mt new file mode 100644 index 0000000..aab33e1 --- /dev/null +++ b/gdb/config/isi.mt @@ -0,0 +1,21 @@ +# ISI Optimum V (3.05) under 4.3bsd. +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o +TM_FILE= tm-isi.h diff --git a/gdb/config/littlemips.mh b/gdb/config/littlemips.mh new file mode 100644 index 0000000..2d4298c --- /dev/null +++ b/gdb/config/littlemips.mh @@ -0,0 +1,21 @@ +# Little-endian MIPS machine such as DECstation. +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o mips-xdep.o coredep.o +XM_FILE= xm-mips.h diff --git a/gdb/config/littlemips.mt b/gdb/config/littlemips.mt new file mode 100644 index 0000000..709bc57 --- /dev/null +++ b/gdb/config/littlemips.mt @@ -0,0 +1,21 @@ +# Little-endian MIPS machine such as DECstation. +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= mips-pinsn.o mips-tdep.o mipsread.o exec.o +TM_FILE= tm-mips.h diff --git a/gdb/config/m88k.mh b/gdb/config/m88k.mh new file mode 100644 index 0000000..a703d1a --- /dev/null +++ b/gdb/config/m88k.mh @@ -0,0 +1,21 @@ +# Motorola 88000 running DGUX +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= +XM_FILE= xm-88k.h diff --git a/gdb/config/m88k.mt b/gdb/config/m88k.mt new file mode 100644 index 0000000..f3b67dc --- /dev/null +++ b/gdb/config/m88k.mt @@ -0,0 +1,23 @@ +# Motorola 88000 running DGUX +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= tdesc.o +TM_CLIBS= tdesc/libdc.o +TM_CDEPS= tdesc/libdc.o +TM_FILE= tm-88k.h diff --git a/gdb/config/merlin.mh b/gdb/config/merlin.mh new file mode 100644 index 0000000..ecb8cf9 --- /dev/null +++ b/gdb/config/merlin.mh @@ -0,0 +1,24 @@ +# Merlin running utek 2.1 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-merlin.h +# See SHELL_FILE in m-merlin.h for a explanation of this. +M_INSTALL=cp /bin/sh /usr/local/lib/gdb-sh; \ +chmod ogu+rw /usr/local/lib/gdb-sh diff --git a/gdb/config/merlin.mt b/gdb/config/merlin.mt new file mode 100644 index 0000000..1ed8caa --- /dev/null +++ b/gdb/config/merlin.mt @@ -0,0 +1,21 @@ +# Merlin running utek 2.1 +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o ns32k-pinsn.o +TM_FILE= tm-merlin.h diff --git a/gdb/config/mh-vax b/gdb/config/mh-vax new file mode 100755 index 0000000..8dbb707 --- /dev/null +++ b/gdb/config/mh-vax @@ -0,0 +1,28 @@ +# DEC VAX running BSD or Ultrix +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The following types of /bin/cc failures have been observed: +# 1. Something in readline.c which I have never seen +# 2. ``"values.c", line 816: compiler error: schain botch'' +#msg /bin/cc has been known to fail on VAXen running BSD4.3 +#msg If this occurs, use gcc +#msg (but see comments in Makefile.dist about compiling with gcc). + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-vax.h diff --git a/gdb/config/news.mh b/gdb/config/news.mh new file mode 100644 index 0000000..1bb7765 --- /dev/null +++ b/gdb/config/news.mh @@ -0,0 +1,21 @@ +# Sony news series 700/800/900 (68020) running NewsOS version 3. +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o news-xdep.o +XM_FILE= xm-news.h diff --git a/gdb/config/news.mt b/gdb/config/news.mt new file mode 100644 index 0000000..c26465a --- /dev/null +++ b/gdb/config/news.mt @@ -0,0 +1,21 @@ +# Sony news series 700/800/900 (68020) running NewsOS version 3. +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= m68k-pinsn.o exec.o +TM_FILE= tm-news.h diff --git a/gdb/config/news1000.mh b/gdb/config/news1000.mh new file mode 100644 index 0000000..940aaee --- /dev/null +++ b/gdb/config/news1000.mh @@ -0,0 +1,21 @@ +# Sony news series 1000 (68030) running NewsOS version 3. +# Copyright (C) 1989, 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o news-xdep.o +XM_FILE= xm-news1000.h diff --git a/gdb/config/news1000.mt b/gdb/config/news1000.mt new file mode 100644 index 0000000..d390504 --- /dev/null +++ b/gdb/config/news1000.mt @@ -0,0 +1,21 @@ +# Sony news series 1000 (68030) running NewsOS version 3. +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= m68k-pinsn.o exec.o +TM_FILE= tm-news.h diff --git a/gdb/config/nindy960.mt b/gdb/config/nindy960.mt new file mode 100644 index 0000000..f7dc6f7 --- /dev/null +++ b/gdb/config/nindy960.mt @@ -0,0 +1,22 @@ +# Intel 80960, in an embedded system under the NINDY monitor +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o i960-pinsn.o i960-tdep.o nindy-tdep.o remote-nindy.o nindy.o Onindy.o ttybreak.o ttyflush.o +TM_FILE= tm-nindy960.h +TM_CFLAGS= diff --git a/gdb/config/none.mh b/gdb/config/none.mh new file mode 100644 index 0000000..74e7048 --- /dev/null +++ b/gdb/config/none.mh @@ -0,0 +1,21 @@ +# Target config file for "no target". This can be used to build you +# a Makefile that only runs administrative commands like 'clean', +# 'gdb.tar.Z', etc. +# +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. diff --git a/gdb/config/none.mt b/gdb/config/none.mt new file mode 100644 index 0000000..c6b5db9 --- /dev/null +++ b/gdb/config/none.mt @@ -0,0 +1,3 @@ +# "no target". +# This can be used to build you a Makefile that only runs administrative +# commands like 'clean', 'gdb.tar.Z', etc. diff --git a/gdb/config/np1.mh b/gdb/config/np1.mh new file mode 100644 index 0000000..fcf88f2 --- /dev/null +++ b/gdb/config/np1.mh @@ -0,0 +1,21 @@ +# Gould NP1 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o gould-xdep.o +XM_FILE= xm-np1.h diff --git a/gdb/config/np1.mt b/gdb/config/np1.mt new file mode 100644 index 0000000..4fafd7b --- /dev/null +++ b/gdb/config/np1.mt @@ -0,0 +1,21 @@ +# Gould NP1 +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o gould-pinsn.o +TM_FILE= tm-np1.h diff --git a/gdb/config/pn.mh b/gdb/config/pn.mh new file mode 100644 index 0000000..7e8f807 --- /dev/null +++ b/gdb/config/pn.mh @@ -0,0 +1,21 @@ +# Gould Powernode +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o coredep.o +XM_FILE= xm-pn.h diff --git a/gdb/config/pn.mt b/gdb/config/pn.mt new file mode 100644 index 0000000..ad26b9c --- /dev/null +++ b/gdb/config/pn.mt @@ -0,0 +1,21 @@ +# Gould Powernode +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o gould-pinsn.o +TM_FILE= tm-pn.h diff --git a/gdb/config/pyramid.mh b/gdb/config/pyramid.mh new file mode 100644 index 0000000..59561ec --- /dev/null +++ b/gdb/config/pyramid.mh @@ -0,0 +1,25 @@ +# Pyramidax under OSx 4.0 (4.2bsd). +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg If you don't compile GDB with GCC, you'll need to add +#msg ALLOCA=alloca.o and ALLOCA1=alloca.o to the Makefile. +#msg + +XDEPFILES= pyr-xdep.o infptrace.o +XM_FILE= xm-pyr.h diff --git a/gdb/config/pyramid.mt b/gdb/config/pyramid.mt new file mode 100644 index 0000000..d62e88e --- /dev/null +++ b/gdb/config/pyramid.mt @@ -0,0 +1,25 @@ +# Pyramid under OSx 4.0 (4.2bsd). +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +#msg Note that GDB on Pyramids only works with GCC, +#msg at least for some programs. +#msg + +TDEPFILES= pyr-pinsn.o pyr-tdep.o exec.o +TM_FILE= tm-pyr.h diff --git a/gdb/config/sun2os3.mh b/gdb/config/sun2os3.mh new file mode 100644 index 0000000..87f8130 --- /dev/null +++ b/gdb/config/sun2os3.mh @@ -0,0 +1,21 @@ +# Sun 2, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sun3-xdep.o +XM_FILE= xm-sun2.h diff --git a/gdb/config/sun2os3.mt b/gdb/config/sun2os3.mt new file mode 100644 index 0000000..99dc7f7 --- /dev/null +++ b/gdb/config/sun2os3.mt @@ -0,0 +1,26 @@ +# Sun 2, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o m68k-pinsn.o m68k-tdep.o +TM_FILE= tm-sun2.h diff --git a/gdb/config/sun2os4.mh b/gdb/config/sun2os4.mh new file mode 100644 index 0000000..f525cf6 --- /dev/null +++ b/gdb/config/sun2os4.mh @@ -0,0 +1,21 @@ +# Sun 2, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sun3-xdep.o +XM_FILE= xm-sun2.h diff --git a/gdb/config/sun2os4.mt b/gdb/config/sun2os4.mt new file mode 100644 index 0000000..d70dd81 --- /dev/null +++ b/gdb/config/sun2os4.mt @@ -0,0 +1,26 @@ +# Sun 2, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o m68k-pinsn.o solib.o m68k-tdep.o +TM_FILE= tm-sun2os4.h diff --git a/gdb/config/sun3.mh b/gdb/config/sun3.mh new file mode 100644 index 0000000..6a91b49 --- /dev/null +++ b/gdb/config/sun3.mh @@ -0,0 +1,26 @@ +# Sun 3, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +XDEPFILES= infptrace.o sun3-xdep.o +XM_FILE= xm-sun3os4.h diff --git a/gdb/config/sun3.mt b/gdb/config/sun3.mt new file mode 100644 index 0000000..ae6e351 --- /dev/null +++ b/gdb/config/sun3.mt @@ -0,0 +1,21 @@ +# Sun 3, running SunOS 4, as a target system +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o solib.o m68k-tdep.o +TM_FILE= tm-sun3os4.h diff --git a/gdb/config/sun386.mh b/gdb/config/sun386.mh new file mode 100644 index 0000000..a2cb431 --- /dev/null +++ b/gdb/config/sun386.mh @@ -0,0 +1,21 @@ +# Sun 386i +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sun386-xdep.o +XM_FILE= xm-sun386.h diff --git a/gdb/config/sun386.mt b/gdb/config/sun386.mt new file mode 100644 index 0000000..1a0bca5 --- /dev/null +++ b/gdb/config/sun386.mt @@ -0,0 +1,21 @@ +# Sun 386i target configuration file. +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o i386-pinsn.o solib.o +TM_FILE= tm-sun386.h diff --git a/gdb/config/sun3os3.mh b/gdb/config/sun3os3.mh new file mode 100644 index 0000000..4408552 --- /dev/null +++ b/gdb/config/sun3os3.mh @@ -0,0 +1,21 @@ +# Sun 3, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sun3-xdep.o +XM_FILE= xm-sun3.h diff --git a/gdb/config/sun3os3.mt b/gdb/config/sun3os3.mt new file mode 100644 index 0000000..3eea3bf --- /dev/null +++ b/gdb/config/sun3os3.mt @@ -0,0 +1,26 @@ +# Sun 3, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o m68k-pinsn.o m68k-tdep.o +TM_FILE= tm-sun3.h diff --git a/gdb/config/sun3os4.mh b/gdb/config/sun3os4.mh new file mode 100644 index 0000000..6a91b49 --- /dev/null +++ b/gdb/config/sun3os4.mh @@ -0,0 +1,26 @@ +# Sun 3, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +XDEPFILES= infptrace.o sun3-xdep.o +XM_FILE= xm-sun3os4.h diff --git a/gdb/config/sun3os4.mt b/gdb/config/sun3os4.mt new file mode 100644 index 0000000..ae6e351 --- /dev/null +++ b/gdb/config/sun3os4.mt @@ -0,0 +1,21 @@ +# Sun 3, running SunOS 4, as a target system +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o solib.o m68k-tdep.o +TM_FILE= tm-sun3os4.h diff --git a/gdb/config/sun4.mh b/gdb/config/sun4.mh new file mode 100644 index 0000000..8054271 --- /dev/null +++ b/gdb/config/sun4.mh @@ -0,0 +1,21 @@ +# Sun 4 or Sparcstation, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sparc-xdep.o +XM_FILE= xm-sun4os4.h diff --git a/gdb/config/sun4.mt b/gdb/config/sun4.mt new file mode 100644 index 0000000..030872d --- /dev/null +++ b/gdb/config/sun4.mt @@ -0,0 +1,26 @@ +# Sun 4 or Sparcstation, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o sparc-tdep.o sparc-pinsn.o solib.o +TM_FILE= tm-sun4os4.h diff --git a/gdb/config/sun4os3.mh b/gdb/config/sun4os3.mh new file mode 100644 index 0000000..fdb0ddd --- /dev/null +++ b/gdb/config/sun4os3.mh @@ -0,0 +1,21 @@ +# Sun 4 or Sparcstation, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sparc-xdep.o +XM_FILE= xm-sparc.h diff --git a/gdb/config/sun4os3.mt b/gdb/config/sun4os3.mt new file mode 100644 index 0000000..b90a65c --- /dev/null +++ b/gdb/config/sun4os3.mt @@ -0,0 +1,26 @@ +# Sun 4 or Sparcstation, running SunOS 3 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o sparc-tdep.o sparc-pinsn.o +TM_FILE= tm-sparc.h diff --git a/gdb/config/sun4os4.mh b/gdb/config/sun4os4.mh new file mode 100644 index 0000000..8054271 --- /dev/null +++ b/gdb/config/sun4os4.mh @@ -0,0 +1,21 @@ +# Sun 4 or Sparcstation, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o sparc-xdep.o +XM_FILE= xm-sun4os4.h diff --git a/gdb/config/sun4os4.mt b/gdb/config/sun4os4.mt new file mode 100644 index 0000000..030872d --- /dev/null +++ b/gdb/config/sun4os4.mt @@ -0,0 +1,26 @@ +# Sun 4 or Sparcstation, running SunOS 4 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +# The system-supplied assembler re-orders the symbols so that gdb +# can't find "gcc_compiled.". +#msg If you compile your program with GCC, use the GNU assembler. +#msg + +TDEPFILES= exec.o sparc-tdep.o sparc-pinsn.o solib.o +TM_FILE= tm-sun4os4.h diff --git a/gdb/config/symmetry.mh b/gdb/config/symmetry.mh new file mode 100644 index 0000000..514c527 --- /dev/null +++ b/gdb/config/symmetry.mh @@ -0,0 +1,21 @@ +# Sequent Symmetry running Dynix 3.0, with Weitek 1167 or i387. +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o symmetry-xdep.o +XM_FILE= xm-symmetry.h diff --git a/gdb/config/symmetry.mt b/gdb/config/symmetry.mt new file mode 100644 index 0000000..4f2f37b --- /dev/null +++ b/gdb/config/symmetry.mt @@ -0,0 +1,21 @@ +# Sequent Symmetry running Dynix 3.0, with Weitek 1167 or i387. +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= symmetry-tdep.o i386-pinsn.o +TM_FILE= tm-symmetry.h diff --git a/gdb/config/umax.mh b/gdb/config/umax.mh new file mode 100644 index 0000000..34e74d5 --- /dev/null +++ b/gdb/config/umax.mh @@ -0,0 +1,21 @@ +# Encore running umax 4.2 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +XDEPFILES= infptrace.o umax-xdep.o +XM_FILE= xm-umax.h diff --git a/gdb/config/umax.mt b/gdb/config/umax.mt new file mode 100644 index 0000000..994da6d --- /dev/null +++ b/gdb/config/umax.mt @@ -0,0 +1,21 @@ +# Encore running umax 4.2 +# Copyright (C) 1990 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o ns32k-pinsn.o +TM_FILE= tm-umax.h diff --git a/gdb/config/vax.mt b/gdb/config/vax.mt new file mode 100644 index 0000000..a8e749a --- /dev/null +++ b/gdb/config/vax.mt @@ -0,0 +1,21 @@ +# DEC VAX running BSD or Ultrix +# Copyright (C) 1989-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= vax-pinsn.o exec.o +TM_FILE= tm-vax.h diff --git a/gdb/config/vxworks68.mt b/gdb/config/vxworks68.mt new file mode 100644 index 0000000..1514c0e --- /dev/null +++ b/gdb/config/vxworks68.mt @@ -0,0 +1,21 @@ +# VxWorks running on a 68000, as a target system +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o m68k-pinsn.o m68k-tdep.o remote-vx.o xdr_ld.o xdr_ptrace.o xdr_rdb.o xdr_regs.o +TM_FILE= tm-vxworks68.h diff --git a/gdb/config/vxworks960.mt b/gdb/config/vxworks960.mt new file mode 100644 index 0000000..1cc95e0 --- /dev/null +++ b/gdb/config/vxworks960.mt @@ -0,0 +1,23 @@ +# VxWorks running on an Intel 960, as a target system +# Copyright (C) 1990-1991 Free Software Foundation, Inc. + +# This file is part of GDB. + +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. + +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. + +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. + +TDEPFILES= exec.o i960-pinsn.o i960-tdep.o remote-vx.o xdr_ld.o xdr_ptrace.o xdr_rdb.o xdr_regs.o +TM_FILE= tm-vxworks960.h +# Define this for the vx-share routines, which don't see param.h. +TM_CFLAGS= -DI80960 diff --git a/gdb/convex-opcode.h b/gdb/convex-opcode.h new file mode 100755 index 0000000..523c874 --- /dev/null +++ b/gdb/convex-opcode.h @@ -0,0 +1,1677 @@ +/* Include information for instruction dissasembly on the Convex. + Copyright (C) 1989, Free Software Foundation. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define xxx 0 +#define rrr 1 +#define rr 2 +#define rxr 3 +#define r 4 +#define nops 5 +#define nr 6 +#define pcrel 7 +#define lr 8 +#define rxl 9 +#define rlr 10 +#define rrl 11 +#define iml 12 +#define imr 13 +#define a1r 14 +#define a1l 15 +#define a2r 16 +#define a2l 17 +#define a3 18 +#define a4 19 +#define a5 20 +#define V 1 +#define S 2 +#define VM 3 +#define A 4 +#define VL 5 +#define VS 6 +#define VLS 7 +#define PSW 8 +/* Prevent an error during "make depend". */ +#if !defined (PC) +#define PC 9 +#endif +#define ITR 10 +#define VV 11 +#define ITSR 12 +#define TOC 13 +#define CIR 14 +#define TTR 15 +#define VMU 16 +#define VML 17 +#define ICR 18 +#define TCPU 19 +#define CPUID 20 +#define TID 21 +char *op[] = { + "", + "v0\0v1\0v2\0v3\0v4\0v5\0v6\0v7", + "s0\0s1\0s2\0s3\0s4\0s5\0s6\0s7", + "vm", + "sp\0a1\0a2\0a3\0a4\0a5\0ap\0fp", + "vl", + "vs", + "vls", + "psw", + "pc", + "itr", + "vv", + "itsr", + "toc", + "cir", + "ttr", + "vmu", + "vml", + "icr", + "tcpu", + "cpuid", + "tid", +}; +struct formstr format0[] = { + {0,0,rrr,V,S,S}, /* mov */ + {0,0,rrr,S,S,V}, /* mov */ + {1,1,rrr,V,V,V}, /* merg.t */ + {2,1,rrr,V,V,V}, /* mask.t */ + {1,2,rrr,V,S,V}, /* merg.f */ + {2,2,rrr,V,S,V}, /* mask.f */ + {1,1,rrr,V,S,V}, /* merg.t */ + {2,1,rrr,V,S,V}, /* mask.t */ + {3,3,rrr,V,V,V}, /* mul.s */ + {3,4,rrr,V,V,V}, /* mul.d */ + {4,3,rrr,V,V,V}, /* div.s */ + {4,4,rrr,V,V,V}, /* div.d */ + {3,3,rrr,V,S,V}, /* mul.s */ + {3,4,rrr,V,S,V}, /* mul.d */ + {4,3,rrr,V,S,V}, /* div.s */ + {4,4,rrr,V,S,V}, /* div.d */ + {5,0,rrr,V,V,V}, /* and */ + {6,0,rrr,V,V,V}, /* or */ + {7,0,rrr,V,V,V}, /* xor */ + {8,0,rrr,V,V,V}, /* shf */ + {5,0,rrr,V,S,V}, /* and */ + {6,0,rrr,V,S,V}, /* or */ + {7,0,rrr,V,S,V}, /* xor */ + {8,0,rrr,V,S,V}, /* shf */ + {9,3,rrr,V,V,V}, /* add.s */ + {9,4,rrr,V,V,V}, /* add.d */ + {10,3,rrr,V,V,V}, /* sub.s */ + {10,4,rrr,V,V,V}, /* sub.d */ + {9,3,rrr,V,S,V}, /* add.s */ + {9,4,rrr,V,S,V}, /* add.d */ + {10,3,rrr,V,S,V}, /* sub.s */ + {10,4,rrr,V,S,V}, /* sub.d */ + {9,5,rrr,V,V,V}, /* add.b */ + {9,6,rrr,V,V,V}, /* add.h */ + {9,7,rrr,V,V,V}, /* add.w */ + {9,8,rrr,V,V,V}, /* add.l */ + {9,5,rrr,V,S,V}, /* add.b */ + {9,6,rrr,V,S,V}, /* add.h */ + {9,7,rrr,V,S,V}, /* add.w */ + {9,8,rrr,V,S,V}, /* add.l */ + {10,5,rrr,V,V,V}, /* sub.b */ + {10,6,rrr,V,V,V}, /* sub.h */ + {10,7,rrr,V,V,V}, /* sub.w */ + {10,8,rrr,V,V,V}, /* sub.l */ + {10,5,rrr,V,S,V}, /* sub.b */ + {10,6,rrr,V,S,V}, /* sub.h */ + {10,7,rrr,V,S,V}, /* sub.w */ + {10,8,rrr,V,S,V}, /* sub.l */ + {3,5,rrr,V,V,V}, /* mul.b */ + {3,6,rrr,V,V,V}, /* mul.h */ + {3,7,rrr,V,V,V}, /* mul.w */ + {3,8,rrr,V,V,V}, /* mul.l */ + {3,5,rrr,V,S,V}, /* mul.b */ + {3,6,rrr,V,S,V}, /* mul.h */ + {3,7,rrr,V,S,V}, /* mul.w */ + {3,8,rrr,V,S,V}, /* mul.l */ + {4,5,rrr,V,V,V}, /* div.b */ + {4,6,rrr,V,V,V}, /* div.h */ + {4,7,rrr,V,V,V}, /* div.w */ + {4,8,rrr,V,V,V}, /* div.l */ + {4,5,rrr,V,S,V}, /* div.b */ + {4,6,rrr,V,S,V}, /* div.h */ + {4,7,rrr,V,S,V}, /* div.w */ + {4,8,rrr,V,S,V}, /* div.l */ +}; +struct formstr format1[] = { + {11,0,xxx,0,0,0}, /* exit */ + {12,0,a3,0,0,0}, /* jmp */ + {13,2,a3,0,0,0}, /* jmpi.f */ + {13,1,a3,0,0,0}, /* jmpi.t */ + {14,2,a3,0,0,0}, /* jmpa.f */ + {14,1,a3,0,0,0}, /* jmpa.t */ + {15,2,a3,0,0,0}, /* jmps.f */ + {15,1,a3,0,0,0}, /* jmps.t */ + {16,0,a3,0,0,0}, /* tac */ + {17,0,a1r,A,0,0}, /* ldea */ + {18,8,a1l,VLS,0,0}, /* ld.l */ + {18,9,a1l,VM,0,0}, /* ld.x */ + {19,0,a3,0,0,0}, /* tas */ + {20,0,a3,0,0,0}, /* pshea */ + {21,8,a2l,VLS,0,0}, /* st.l */ + {21,9,a2l,VM,0,0}, /* st.x */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {22,0,a3,0,0,0}, /* call */ + {23,0,a3,0,0,0}, /* calls */ + {24,0,a3,0,0,0}, /* callq */ + {25,0,a1r,A,0,0}, /* pfork */ + {26,5,a2r,S,0,0}, /* ste.b */ + {26,6,a2r,S,0,0}, /* ste.h */ + {26,7,a2r,S,0,0}, /* ste.w */ + {26,8,a2r,S,0,0}, /* ste.l */ + {18,5,a1r,A,0,0}, /* ld.b */ + {18,6,a1r,A,0,0}, /* ld.h */ + {18,7,a1r,A,0,0}, /* ld.w */ + {27,7,a1r,A,0,0}, /* incr.w */ + {21,5,a2r,A,0,0}, /* st.b */ + {21,6,a2r,A,0,0}, /* st.h */ + {21,7,a2r,A,0,0}, /* st.w */ + {27,8,a1r,S,0,0}, /* incr.l */ + {18,5,a1r,S,0,0}, /* ld.b */ + {18,6,a1r,S,0,0}, /* ld.h */ + {18,7,a1r,S,0,0}, /* ld.w */ + {18,8,a1r,S,0,0}, /* ld.l */ + {21,5,a2r,S,0,0}, /* st.b */ + {21,6,a2r,S,0,0}, /* st.h */ + {21,7,a2r,S,0,0}, /* st.w */ + {21,8,a2r,S,0,0}, /* st.l */ + {18,5,a1r,V,0,0}, /* ld.b */ + {18,6,a1r,V,0,0}, /* ld.h */ + {18,7,a1r,V,0,0}, /* ld.w */ + {18,8,a1r,V,0,0}, /* ld.l */ + {21,5,a2r,V,0,0}, /* st.b */ + {21,6,a2r,V,0,0}, /* st.h */ + {21,7,a2r,V,0,0}, /* st.w */ + {21,8,a2r,V,0,0}, /* st.l */ +}; +struct formstr format2[] = { + {28,5,rr,A,A,0}, /* cvtw.b */ + {28,6,rr,A,A,0}, /* cvtw.h */ + {29,7,rr,A,A,0}, /* cvtb.w */ + {30,7,rr,A,A,0}, /* cvth.w */ + {28,5,rr,S,S,0}, /* cvtw.b */ + {28,6,rr,S,S,0}, /* cvtw.h */ + {29,7,rr,S,S,0}, /* cvtb.w */ + {30,7,rr,S,S,0}, /* cvth.w */ + {28,3,rr,S,S,0}, /* cvtw.s */ + {31,7,rr,S,S,0}, /* cvts.w */ + {32,3,rr,S,S,0}, /* cvtd.s */ + {31,4,rr,S,S,0}, /* cvts.d */ + {31,8,rr,S,S,0}, /* cvts.l */ + {32,8,rr,S,S,0}, /* cvtd.l */ + {33,3,rr,S,S,0}, /* cvtl.s */ + {33,4,rr,S,S,0}, /* cvtl.d */ + {34,0,rr,A,A,0}, /* ldpa */ + {8,0,nr,A,0,0}, /* shf */ + {18,6,nr,A,0,0}, /* ld.h */ + {18,7,nr,A,0,0}, /* ld.w */ + {33,7,rr,S,S,0}, /* cvtl.w */ + {28,8,rr,S,S,0}, /* cvtw.l */ + {35,1,rr,S,S,0}, /* plc.t */ + {36,0,rr,S,S,0}, /* tzc */ + {37,6,rr,A,A,0}, /* eq.h */ + {37,7,rr,A,A,0}, /* eq.w */ + {37,6,nr,A,0,0}, /* eq.h */ + {37,7,nr,A,0,0}, /* eq.w */ + {37,5,rr,S,S,0}, /* eq.b */ + {37,6,rr,S,S,0}, /* eq.h */ + {37,7,rr,S,S,0}, /* eq.w */ + {37,8,rr,S,S,0}, /* eq.l */ + {38,6,rr,A,A,0}, /* leu.h */ + {38,7,rr,A,A,0}, /* leu.w */ + {38,6,nr,A,0,0}, /* leu.h */ + {38,7,nr,A,0,0}, /* leu.w */ + {38,5,rr,S,S,0}, /* leu.b */ + {38,6,rr,S,S,0}, /* leu.h */ + {38,7,rr,S,S,0}, /* leu.w */ + {38,8,rr,S,S,0}, /* leu.l */ + {39,6,rr,A,A,0}, /* ltu.h */ + {39,7,rr,A,A,0}, /* ltu.w */ + {39,6,nr,A,0,0}, /* ltu.h */ + {39,7,nr,A,0,0}, /* ltu.w */ + {39,5,rr,S,S,0}, /* ltu.b */ + {39,6,rr,S,S,0}, /* ltu.h */ + {39,7,rr,S,S,0}, /* ltu.w */ + {39,8,rr,S,S,0}, /* ltu.l */ + {40,6,rr,A,A,0}, /* le.h */ + {40,7,rr,A,A,0}, /* le.w */ + {40,6,nr,A,0,0}, /* le.h */ + {40,7,nr,A,0,0}, /* le.w */ + {40,5,rr,S,S,0}, /* le.b */ + {40,6,rr,S,S,0}, /* le.h */ + {40,7,rr,S,S,0}, /* le.w */ + {40,8,rr,S,S,0}, /* le.l */ + {41,6,rr,A,A,0}, /* lt.h */ + {41,7,rr,A,A,0}, /* lt.w */ + {41,6,nr,A,0,0}, /* lt.h */ + {41,7,nr,A,0,0}, /* lt.w */ + {41,5,rr,S,S,0}, /* lt.b */ + {41,6,rr,S,S,0}, /* lt.h */ + {41,7,rr,S,S,0}, /* lt.w */ + {41,8,rr,S,S,0}, /* lt.l */ + {9,7,rr,S,A,0}, /* add.w */ + {8,0,rr,A,A,0}, /* shf */ + {0,0,rr,A,A,0}, /* mov */ + {0,0,rr,S,A,0}, /* mov */ + {0,7,rr,S,S,0}, /* mov.w */ + {8,0,rr,S,S,0}, /* shf */ + {0,0,rr,S,S,0}, /* mov */ + {0,0,rr,A,S,0}, /* mov */ + {5,0,rr,A,A,0}, /* and */ + {6,0,rr,A,A,0}, /* or */ + {7,0,rr,A,A,0}, /* xor */ + {42,0,rr,A,A,0}, /* not */ + {5,0,rr,S,S,0}, /* and */ + {6,0,rr,S,S,0}, /* or */ + {7,0,rr,S,S,0}, /* xor */ + {42,0,rr,S,S,0}, /* not */ + {40,3,rr,S,S,0}, /* le.s */ + {40,4,rr,S,S,0}, /* le.d */ + {41,3,rr,S,S,0}, /* lt.s */ + {41,4,rr,S,S,0}, /* lt.d */ + {9,3,rr,S,S,0}, /* add.s */ + {9,4,rr,S,S,0}, /* add.d */ + {10,3,rr,S,S,0}, /* sub.s */ + {10,4,rr,S,S,0}, /* sub.d */ + {37,3,rr,S,S,0}, /* eq.s */ + {37,4,rr,S,S,0}, /* eq.d */ + {43,6,rr,A,A,0}, /* neg.h */ + {43,7,rr,A,A,0}, /* neg.w */ + {3,3,rr,S,S,0}, /* mul.s */ + {3,4,rr,S,S,0}, /* mul.d */ + {4,3,rr,S,S,0}, /* div.s */ + {4,4,rr,S,S,0}, /* div.d */ + {9,6,rr,A,A,0}, /* add.h */ + {9,7,rr,A,A,0}, /* add.w */ + {9,6,nr,A,0,0}, /* add.h */ + {9,7,nr,A,0,0}, /* add.w */ + {9,5,rr,S,S,0}, /* add.b */ + {9,6,rr,S,S,0}, /* add.h */ + {9,7,rr,S,S,0}, /* add.w */ + {9,8,rr,S,S,0}, /* add.l */ + {10,6,rr,A,A,0}, /* sub.h */ + {10,7,rr,A,A,0}, /* sub.w */ + {10,6,nr,A,0,0}, /* sub.h */ + {10,7,nr,A,0,0}, /* sub.w */ + {10,5,rr,S,S,0}, /* sub.b */ + {10,6,rr,S,S,0}, /* sub.h */ + {10,7,rr,S,S,0}, /* sub.w */ + {10,8,rr,S,S,0}, /* sub.l */ + {3,6,rr,A,A,0}, /* mul.h */ + {3,7,rr,A,A,0}, /* mul.w */ + {3,6,nr,A,0,0}, /* mul.h */ + {3,7,nr,A,0,0}, /* mul.w */ + {3,5,rr,S,S,0}, /* mul.b */ + {3,6,rr,S,S,0}, /* mul.h */ + {3,7,rr,S,S,0}, /* mul.w */ + {3,8,rr,S,S,0}, /* mul.l */ + {4,6,rr,A,A,0}, /* div.h */ + {4,7,rr,A,A,0}, /* div.w */ + {4,6,nr,A,0,0}, /* div.h */ + {4,7,nr,A,0,0}, /* div.w */ + {4,5,rr,S,S,0}, /* div.b */ + {4,6,rr,S,S,0}, /* div.h */ + {4,7,rr,S,S,0}, /* div.w */ + {4,8,rr,S,S,0}, /* div.l */ +}; +struct formstr format3[] = { + {32,3,rr,V,V,0}, /* cvtd.s */ + {31,4,rr,V,V,0}, /* cvts.d */ + {33,4,rr,V,V,0}, /* cvtl.d */ + {32,8,rr,V,V,0}, /* cvtd.l */ + {0,0,rrl,S,S,VM}, /* mov */ + {0,0,rlr,S,VM,S}, /* mov */ + {0,0,0,0,0,0}, + {44,0,rr,S,S,0}, /* lop */ + {36,0,rr,V,V,0}, /* tzc */ + {44,0,rr,V,V,0}, /* lop */ + {0,0,0,0,0,0}, + {42,0,rr,V,V,0}, /* not */ + {8,0,rr,S,V,0}, /* shf */ + {35,1,rr,V,V,0}, /* plc.t */ + {45,2,rr,V,V,0}, /* cprs.f */ + {45,1,rr,V,V,0}, /* cprs.t */ + {37,3,rr,V,V,0}, /* eq.s */ + {37,4,rr,V,V,0}, /* eq.d */ + {43,3,rr,V,V,0}, /* neg.s */ + {43,4,rr,V,V,0}, /* neg.d */ + {37,3,rr,S,V,0}, /* eq.s */ + {37,4,rr,S,V,0}, /* eq.d */ + {43,3,rr,S,S,0}, /* neg.s */ + {43,4,rr,S,S,0}, /* neg.d */ + {40,3,rr,V,V,0}, /* le.s */ + {40,4,rr,V,V,0}, /* le.d */ + {41,3,rr,V,V,0}, /* lt.s */ + {41,4,rr,V,V,0}, /* lt.d */ + {40,3,rr,S,V,0}, /* le.s */ + {40,4,rr,S,V,0}, /* le.d */ + {41,3,rr,S,V,0}, /* lt.s */ + {41,4,rr,S,V,0}, /* lt.d */ + {37,5,rr,V,V,0}, /* eq.b */ + {37,6,rr,V,V,0}, /* eq.h */ + {37,7,rr,V,V,0}, /* eq.w */ + {37,8,rr,V,V,0}, /* eq.l */ + {37,5,rr,S,V,0}, /* eq.b */ + {37,6,rr,S,V,0}, /* eq.h */ + {37,7,rr,S,V,0}, /* eq.w */ + {37,8,rr,S,V,0}, /* eq.l */ + {40,5,rr,V,V,0}, /* le.b */ + {40,6,rr,V,V,0}, /* le.h */ + {40,7,rr,V,V,0}, /* le.w */ + {40,8,rr,V,V,0}, /* le.l */ + {40,5,rr,S,V,0}, /* le.b */ + {40,6,rr,S,V,0}, /* le.h */ + {40,7,rr,S,V,0}, /* le.w */ + {40,8,rr,S,V,0}, /* le.l */ + {41,5,rr,V,V,0}, /* lt.b */ + {41,6,rr,V,V,0}, /* lt.h */ + {41,7,rr,V,V,0}, /* lt.w */ + {41,8,rr,V,V,0}, /* lt.l */ + {41,5,rr,S,V,0}, /* lt.b */ + {41,6,rr,S,V,0}, /* lt.h */ + {41,7,rr,S,V,0}, /* lt.w */ + {41,8,rr,S,V,0}, /* lt.l */ + {43,5,rr,V,V,0}, /* neg.b */ + {43,6,rr,V,V,0}, /* neg.h */ + {43,7,rr,V,V,0}, /* neg.w */ + {43,8,rr,V,V,0}, /* neg.l */ + {43,5,rr,S,S,0}, /* neg.b */ + {43,6,rr,S,S,0}, /* neg.h */ + {43,7,rr,S,S,0}, /* neg.w */ + {43,8,rr,S,S,0}, /* neg.l */ +}; +struct formstr format4[] = { + {46,0,nops,0,0,0}, /* nop */ + {47,0,pcrel,0,0,0}, /* br */ + {48,2,pcrel,0,0,0}, /* bri.f */ + {48,1,pcrel,0,0,0}, /* bri.t */ + {49,2,pcrel,0,0,0}, /* bra.f */ + {49,1,pcrel,0,0,0}, /* bra.t */ + {50,2,pcrel,0,0,0}, /* brs.f */ + {50,1,pcrel,0,0,0}, /* brs.t */ +}; +struct formstr format5[] = { + {51,5,rr,V,V,0}, /* ldvi.b */ + {51,6,rr,V,V,0}, /* ldvi.h */ + {51,7,rr,V,V,0}, /* ldvi.w */ + {51,8,rr,V,V,0}, /* ldvi.l */ + {28,3,rr,V,V,0}, /* cvtw.s */ + {31,7,rr,V,V,0}, /* cvts.w */ + {28,8,rr,V,V,0}, /* cvtw.l */ + {33,7,rr,V,V,0}, /* cvtl.w */ + {52,5,rxr,V,V,0}, /* stvi.b */ + {52,6,rxr,V,V,0}, /* stvi.h */ + {52,7,rxr,V,V,0}, /* stvi.w */ + {52,8,rxr,V,V,0}, /* stvi.l */ + {52,5,rxr,S,V,0}, /* stvi.b */ + {52,6,rxr,S,V,0}, /* stvi.h */ + {52,7,rxr,S,V,0}, /* stvi.w */ + {52,8,rxr,S,V,0}, /* stvi.l */ +}; +struct formstr format6[] = { + {53,0,r,A,0,0}, /* ldsdr */ + {54,0,r,A,0,0}, /* ldkdr */ + {55,3,r,S,0,0}, /* ln.s */ + {55,4,r,S,0,0}, /* ln.d */ + {56,0,nops,0,0,0}, /* patu */ + {57,0,r,A,0,0}, /* pate */ + {58,0,nops,0,0,0}, /* pich */ + {59,0,nops,0,0,0}, /* plch */ + {0,0,lr,PSW,A,0}, /* mov */ + {0,0,rxl,A,PSW,0}, /* mov */ + {0,0,lr,PC,A,0}, /* mov */ + {60,0,r,S,0,0}, /* idle */ + {0,0,lr,ITR,S,0}, /* mov */ + {0,0,rxl,S,ITR,0}, /* mov */ + {0,0,0,0,0,0}, + {0,0,rxl,S,ITSR,0}, /* mov */ + {61,0,nops,0,0,0}, /* rtnq */ + {62,0,nops,0,0,0}, /* cfork */ + {63,0,nops,0,0,0}, /* rtn */ + {64,0,nops,0,0,0}, /* wfork */ + {65,0,nops,0,0,0}, /* join */ + {66,0,nops,0,0,0}, /* rtnc */ + {67,3,r,S,0,0}, /* exp.s */ + {67,4,r,S,0,0}, /* exp.d */ + {68,3,r,S,0,0}, /* sin.s */ + {68,4,r,S,0,0}, /* sin.d */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {69,3,r,S,0,0}, /* cos.s */ + {69,4,r,S,0,0}, /* cos.d */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {70,7,r,A,0,0}, /* psh.w */ + {0,0,0,0,0,0}, + {71,7,r,A,0,0}, /* pop.w */ + {0,0,0,0,0,0}, + {70,7,r,S,0,0}, /* psh.w */ + {70,8,r,S,0,0}, /* psh.l */ + {71,7,r,S,0,0}, /* pop.w */ + {71,8,r,S,0,0}, /* pop.l */ + {72,0,nops,0,0,0}, /* eni */ + {73,0,nops,0,0,0}, /* dsi */ + {74,0,nops,0,0,0}, /* bkpt */ + {75,0,nops,0,0,0}, /* msync */ + {76,0,r,S,0,0}, /* mski */ + {77,0,r,S,0,0}, /* xmti */ + {0,0,rxl,S,VV,0}, /* mov */ + {78,0,nops,0,0,0}, /* tstvv */ + {0,0,lr,VS,A,0}, /* mov */ + {0,0,rxl,A,VS,0}, /* mov */ + {0,0,lr,VL,A,0}, /* mov */ + {0,0,rxl,A,VL,0}, /* mov */ + {0,7,lr,VS,S,0}, /* mov.w */ + {0,7,rxl,S,VS,0}, /* mov.w */ + {0,7,lr,VL,S,0}, /* mov.w */ + {0,7,rxl,S,VL,0}, /* mov.w */ + {79,0,r,A,0,0}, /* diag */ + {80,0,nops,0,0,0}, /* pbkpt */ + {81,3,r,S,0,0}, /* sqrt.s */ + {81,4,r,S,0,0}, /* sqrt.d */ + {82,0,nops,0,0,0}, /* casr */ + {0,0,0,0,0,0}, + {83,3,r,S,0,0}, /* atan.s */ + {83,4,r,S,0,0}, /* atan.d */ +}; +struct formstr format7[] = { + {84,5,r,V,0,0}, /* sum.b */ + {84,6,r,V,0,0}, /* sum.h */ + {84,7,r,V,0,0}, /* sum.w */ + {84,8,r,V,0,0}, /* sum.l */ + {85,0,r,V,0,0}, /* all */ + {86,0,r,V,0,0}, /* any */ + {87,0,r,V,0,0}, /* parity */ + {0,0,0,0,0,0}, + {88,5,r,V,0,0}, /* max.b */ + {88,6,r,V,0,0}, /* max.h */ + {88,7,r,V,0,0}, /* max.w */ + {88,8,r,V,0,0}, /* max.l */ + {89,5,r,V,0,0}, /* min.b */ + {89,6,r,V,0,0}, /* min.h */ + {89,7,r,V,0,0}, /* min.w */ + {89,8,r,V,0,0}, /* min.l */ + {84,3,r,V,0,0}, /* sum.s */ + {84,4,r,V,0,0}, /* sum.d */ + {90,3,r,V,0,0}, /* prod.s */ + {90,4,r,V,0,0}, /* prod.d */ + {88,3,r,V,0,0}, /* max.s */ + {88,4,r,V,0,0}, /* max.d */ + {89,3,r,V,0,0}, /* min.s */ + {89,4,r,V,0,0}, /* min.d */ + {90,5,r,V,0,0}, /* prod.b */ + {90,6,r,V,0,0}, /* prod.h */ + {90,7,r,V,0,0}, /* prod.w */ + {90,8,r,V,0,0}, /* prod.l */ + {35,2,lr,VM,S,0}, /* plc.f */ + {35,1,lr,VM,S,0}, /* plc.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr formatx[] = { + {0,0,0,0,0,0}, +}; +struct formstr format1a[] = { + {91,0,imr,A,0,0}, /* halt */ + {92,0,a4,0,0,0}, /* sysc */ + {18,6,imr,A,0,0}, /* ld.h */ + {18,7,imr,A,0,0}, /* ld.w */ + {5,0,imr,A,0,0}, /* and */ + {6,0,imr,A,0,0}, /* or */ + {7,0,imr,A,0,0}, /* xor */ + {8,0,imr,A,0,0}, /* shf */ + {9,6,imr,A,0,0}, /* add.h */ + {9,7,imr,A,0,0}, /* add.w */ + {10,6,imr,A,0,0}, /* sub.h */ + {10,7,imr,A,0,0}, /* sub.w */ + {3,6,imr,A,0,0}, /* mul.h */ + {3,7,imr,A,0,0}, /* mul.w */ + {4,6,imr,A,0,0}, /* div.h */ + {4,7,imr,A,0,0}, /* div.w */ + {18,7,iml,VL,0,0}, /* ld.w */ + {18,7,iml,VS,0,0}, /* ld.w */ + {0,0,0,0,0,0}, + {8,7,imr,S,0,0}, /* shf.w */ + {93,0,a5,0,0,0}, /* trap */ + {0,0,0,0,0,0}, + {37,6,imr,A,0,0}, /* eq.h */ + {37,7,imr,A,0,0}, /* eq.w */ + {38,6,imr,A,0,0}, /* leu.h */ + {38,7,imr,A,0,0}, /* leu.w */ + {39,6,imr,A,0,0}, /* ltu.h */ + {39,7,imr,A,0,0}, /* ltu.w */ + {40,6,imr,A,0,0}, /* le.h */ + {40,7,imr,A,0,0}, /* le.w */ + {41,6,imr,A,0,0}, /* lt.h */ + {41,7,imr,A,0,0}, /* lt.w */ +}; +struct formstr format1b[] = { + {18,4,imr,S,0,0}, /* ld.d */ + {18,10,imr,S,0,0}, /* ld.u */ + {18,8,imr,S,0,0}, /* ld.l */ + {18,7,imr,S,0,0}, /* ld.w */ + {5,0,imr,S,0,0}, /* and */ + {6,0,imr,S,0,0}, /* or */ + {7,0,imr,S,0,0}, /* xor */ + {8,0,imr,S,0,0}, /* shf */ + {9,6,imr,S,0,0}, /* add.h */ + {9,7,imr,S,0,0}, /* add.w */ + {10,6,imr,S,0,0}, /* sub.h */ + {10,7,imr,S,0,0}, /* sub.w */ + {3,6,imr,S,0,0}, /* mul.h */ + {3,7,imr,S,0,0}, /* mul.w */ + {4,6,imr,S,0,0}, /* div.h */ + {4,7,imr,S,0,0}, /* div.w */ + {9,3,imr,S,0,0}, /* add.s */ + {10,3,imr,S,0,0}, /* sub.s */ + {3,3,imr,S,0,0}, /* mul.s */ + {4,3,imr,S,0,0}, /* div.s */ + {40,3,imr,S,0,0}, /* le.s */ + {41,3,imr,S,0,0}, /* lt.s */ + {37,6,imr,S,0,0}, /* eq.h */ + {37,7,imr,S,0,0}, /* eq.w */ + {38,6,imr,S,0,0}, /* leu.h */ + {38,7,imr,S,0,0}, /* leu.w */ + {39,6,imr,S,0,0}, /* ltu.h */ + {39,7,imr,S,0,0}, /* ltu.w */ + {40,6,imr,S,0,0}, /* le.h */ + {40,7,imr,S,0,0}, /* le.w */ + {41,6,imr,S,0,0}, /* lt.h */ + {41,7,imr,S,0,0}, /* lt.w */ +}; +struct formstr e0_format0[] = { + {10,3,rrr,S,V,V}, /* sub.s */ + {10,4,rrr,S,V,V}, /* sub.d */ + {4,3,rrr,S,V,V}, /* div.s */ + {4,4,rrr,S,V,V}, /* div.d */ + {10,11,rrr,S,V,V}, /* sub.s.f */ + {10,12,rrr,S,V,V}, /* sub.d.f */ + {4,11,rrr,S,V,V}, /* div.s.f */ + {4,12,rrr,S,V,V}, /* div.d.f */ + {3,11,rrr,V,V,V}, /* mul.s.f */ + {3,12,rrr,V,V,V}, /* mul.d.f */ + {4,11,rrr,V,V,V}, /* div.s.f */ + {4,12,rrr,V,V,V}, /* div.d.f */ + {3,11,rrr,V,S,V}, /* mul.s.f */ + {3,12,rrr,V,S,V}, /* mul.d.f */ + {4,11,rrr,V,S,V}, /* div.s.f */ + {4,12,rrr,V,S,V}, /* div.d.f */ + {5,2,rrr,V,V,V}, /* and.f */ + {6,2,rrr,V,V,V}, /* or.f */ + {7,2,rrr,V,V,V}, /* xor.f */ + {8,2,rrr,V,V,V}, /* shf.f */ + {5,2,rrr,V,S,V}, /* and.f */ + {6,2,rrr,V,S,V}, /* or.f */ + {7,2,rrr,V,S,V}, /* xor.f */ + {8,2,rrr,V,S,V}, /* shf.f */ + {9,11,rrr,V,V,V}, /* add.s.f */ + {9,12,rrr,V,V,V}, /* add.d.f */ + {10,11,rrr,V,V,V}, /* sub.s.f */ + {10,12,rrr,V,V,V}, /* sub.d.f */ + {9,11,rrr,V,S,V}, /* add.s.f */ + {9,12,rrr,V,S,V}, /* add.d.f */ + {10,11,rrr,V,S,V}, /* sub.s.f */ + {10,12,rrr,V,S,V}, /* sub.d.f */ + {9,13,rrr,V,V,V}, /* add.b.f */ + {9,14,rrr,V,V,V}, /* add.h.f */ + {9,15,rrr,V,V,V}, /* add.w.f */ + {9,16,rrr,V,V,V}, /* add.l.f */ + {9,13,rrr,V,S,V}, /* add.b.f */ + {9,14,rrr,V,S,V}, /* add.h.f */ + {9,15,rrr,V,S,V}, /* add.w.f */ + {9,16,rrr,V,S,V}, /* add.l.f */ + {10,13,rrr,V,V,V}, /* sub.b.f */ + {10,14,rrr,V,V,V}, /* sub.h.f */ + {10,15,rrr,V,V,V}, /* sub.w.f */ + {10,16,rrr,V,V,V}, /* sub.l.f */ + {10,13,rrr,V,S,V}, /* sub.b.f */ + {10,14,rrr,V,S,V}, /* sub.h.f */ + {10,15,rrr,V,S,V}, /* sub.w.f */ + {10,16,rrr,V,S,V}, /* sub.l.f */ + {3,13,rrr,V,V,V}, /* mul.b.f */ + {3,14,rrr,V,V,V}, /* mul.h.f */ + {3,15,rrr,V,V,V}, /* mul.w.f */ + {3,16,rrr,V,V,V}, /* mul.l.f */ + {3,13,rrr,V,S,V}, /* mul.b.f */ + {3,14,rrr,V,S,V}, /* mul.h.f */ + {3,15,rrr,V,S,V}, /* mul.w.f */ + {3,16,rrr,V,S,V}, /* mul.l.f */ + {4,13,rrr,V,V,V}, /* div.b.f */ + {4,14,rrr,V,V,V}, /* div.h.f */ + {4,15,rrr,V,V,V}, /* div.w.f */ + {4,16,rrr,V,V,V}, /* div.l.f */ + {4,13,rrr,V,S,V}, /* div.b.f */ + {4,14,rrr,V,S,V}, /* div.h.f */ + {4,15,rrr,V,S,V}, /* div.w.f */ + {4,16,rrr,V,S,V}, /* div.l.f */ +}; +struct formstr e0_format1[] = { + {0,0,0,0,0,0}, + {94,0,a3,0,0,0}, /* tst */ + {95,0,a3,0,0,0}, /* lck */ + {96,0,a3,0,0,0}, /* ulk */ + {17,0,a1r,S,0,0}, /* ldea */ + {97,0,a1r,A,0,0}, /* spawn */ + {98,0,a1r,A,0,0}, /* ldcmr */ + {99,0,a2r,A,0,0}, /* stcmr */ + {100,0,a1r,A,0,0}, /* popr */ + {101,0,a2r,A,0,0}, /* pshr */ + {102,7,a1r,A,0,0}, /* rcvr.w */ + {103,7,a2r,A,0,0}, /* matm.w */ + {104,7,a2r,A,0,0}, /* sndr.w */ + {104,8,a2r,S,0,0}, /* sndr.l */ + {102,8,a1r,S,0,0}, /* rcvr.l */ + {103,8,a2r,S,0,0}, /* matm.l */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {105,7,a2r,A,0,0}, /* putr.w */ + {105,8,a2r,S,0,0}, /* putr.l */ + {106,7,a1r,A,0,0}, /* getr.w */ + {106,8,a1r,S,0,0}, /* getr.l */ + {26,13,a2r,S,0,0}, /* ste.b.f */ + {26,14,a2r,S,0,0}, /* ste.h.f */ + {26,15,a2r,S,0,0}, /* ste.w.f */ + {26,16,a2r,S,0,0}, /* ste.l.f */ + {107,7,a2r,A,0,0}, /* matr.w */ + {108,7,a2r,A,0,0}, /* mat.w */ + {109,7,a1r,A,0,0}, /* get.w */ + {110,7,a1r,A,0,0}, /* rcv.w */ + {0,0,0,0,0,0}, + {111,7,a1r,A,0,0}, /* inc.w */ + {112,7,a2r,A,0,0}, /* put.w */ + {113,7,a2r,A,0,0}, /* snd.w */ + {107,8,a2r,S,0,0}, /* matr.l */ + {108,8,a2r,S,0,0}, /* mat.l */ + {109,8,a1r,S,0,0}, /* get.l */ + {110,8,a1r,S,0,0}, /* rcv.l */ + {0,0,0,0,0,0}, + {111,8,a1r,S,0,0}, /* inc.l */ + {112,8,a2r,S,0,0}, /* put.l */ + {113,8,a2r,S,0,0}, /* snd.l */ + {18,13,a1r,V,0,0}, /* ld.b.f */ + {18,14,a1r,V,0,0}, /* ld.h.f */ + {18,15,a1r,V,0,0}, /* ld.w.f */ + {18,16,a1r,V,0,0}, /* ld.l.f */ + {21,13,a2r,V,0,0}, /* st.b.f */ + {21,14,a2r,V,0,0}, /* st.h.f */ + {21,15,a2r,V,0,0}, /* st.w.f */ + {21,16,a2r,V,0,0}, /* st.l.f */ +}; +struct formstr e0_format2[] = { + {28,5,rr,V,V,0}, /* cvtw.b */ + {28,6,rr,V,V,0}, /* cvtw.h */ + {29,7,rr,V,V,0}, /* cvtb.w */ + {30,7,rr,V,V,0}, /* cvth.w */ + {28,13,rr,V,V,0}, /* cvtw.b.f */ + {28,14,rr,V,V,0}, /* cvtw.h.f */ + {29,15,rr,V,V,0}, /* cvtb.w.f */ + {30,15,rr,V,V,0}, /* cvth.w.f */ + {31,8,rr,V,V,0}, /* cvts.l */ + {32,7,rr,V,V,0}, /* cvtd.w */ + {33,3,rr,V,V,0}, /* cvtl.s */ + {28,4,rr,V,V,0}, /* cvtw.d */ + {31,16,rr,V,V,0}, /* cvts.l.f */ + {32,15,rr,V,V,0}, /* cvtd.w.f */ + {33,11,rr,V,V,0}, /* cvtl.s.f */ + {28,12,rr,V,V,0}, /* cvtw.d.f */ + {114,0,rr,S,S,0}, /* enal */ + {8,7,rr,S,S,0}, /* shf.w */ + {115,0,rr,S,S,0}, /* enag */ + {0,0,0,0,0,0}, + {28,4,rr,S,S,0}, /* cvtw.d */ + {32,7,rr,S,S,0}, /* cvtd.w */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {116,3,rr,S,S,0}, /* frint.s */ + {116,4,rr,S,S,0}, /* frint.d */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {116,3,rr,V,V,0}, /* frint.s */ + {116,4,rr,V,V,0}, /* frint.d */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {116,11,rr,V,V,0}, /* frint.s.f */ + {116,12,rr,V,V,0}, /* frint.d.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {81,3,rr,V,V,0}, /* sqrt.s */ + {81,4,rr,V,V,0}, /* sqrt.d */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {81,11,rr,V,V,0}, /* sqrt.s.f */ + {81,12,rr,V,V,0}, /* sqrt.d.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e0_format3[] = { + {32,11,rr,V,V,0}, /* cvtd.s.f */ + {31,12,rr,V,V,0}, /* cvts.d.f */ + {33,12,rr,V,V,0}, /* cvtl.d.f */ + {32,16,rr,V,V,0}, /* cvtd.l.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {36,2,rr,V,V,0}, /* tzc.f */ + {44,2,rr,V,V,0}, /* lop.f */ + {117,2,rr,V,V,0}, /* xpnd.f */ + {42,2,rr,V,V,0}, /* not.f */ + {8,2,rr,S,V,0}, /* shf.f */ + {35,17,rr,V,V,0}, /* plc.t.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {37,11,rr,V,V,0}, /* eq.s.f */ + {37,12,rr,V,V,0}, /* eq.d.f */ + {43,11,rr,V,V,0}, /* neg.s.f */ + {43,12,rr,V,V,0}, /* neg.d.f */ + {37,11,rr,S,V,0}, /* eq.s.f */ + {37,12,rr,S,V,0}, /* eq.d.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {40,11,rr,V,V,0}, /* le.s.f */ + {40,12,rr,V,V,0}, /* le.d.f */ + {41,11,rr,V,V,0}, /* lt.s.f */ + {41,12,rr,V,V,0}, /* lt.d.f */ + {40,11,rr,S,V,0}, /* le.s.f */ + {40,12,rr,S,V,0}, /* le.d.f */ + {41,11,rr,S,V,0}, /* lt.s.f */ + {41,12,rr,S,V,0}, /* lt.d.f */ + {37,13,rr,V,V,0}, /* eq.b.f */ + {37,14,rr,V,V,0}, /* eq.h.f */ + {37,15,rr,V,V,0}, /* eq.w.f */ + {37,16,rr,V,V,0}, /* eq.l.f */ + {37,13,rr,S,V,0}, /* eq.b.f */ + {37,14,rr,S,V,0}, /* eq.h.f */ + {37,15,rr,S,V,0}, /* eq.w.f */ + {37,16,rr,S,V,0}, /* eq.l.f */ + {40,13,rr,V,V,0}, /* le.b.f */ + {40,14,rr,V,V,0}, /* le.h.f */ + {40,15,rr,V,V,0}, /* le.w.f */ + {40,16,rr,V,V,0}, /* le.l.f */ + {40,13,rr,S,V,0}, /* le.b.f */ + {40,14,rr,S,V,0}, /* le.h.f */ + {40,15,rr,S,V,0}, /* le.w.f */ + {40,16,rr,S,V,0}, /* le.l.f */ + {41,13,rr,V,V,0}, /* lt.b.f */ + {41,14,rr,V,V,0}, /* lt.h.f */ + {41,15,rr,V,V,0}, /* lt.w.f */ + {41,16,rr,V,V,0}, /* lt.l.f */ + {41,13,rr,S,V,0}, /* lt.b.f */ + {41,14,rr,S,V,0}, /* lt.h.f */ + {41,15,rr,S,V,0}, /* lt.w.f */ + {41,16,rr,S,V,0}, /* lt.l.f */ + {43,13,rr,V,V,0}, /* neg.b.f */ + {43,14,rr,V,V,0}, /* neg.h.f */ + {43,15,rr,V,V,0}, /* neg.w.f */ + {43,16,rr,V,V,0}, /* neg.l.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e0_format4[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e0_format5[] = { + {51,13,rr,V,V,0}, /* ldvi.b.f */ + {51,14,rr,V,V,0}, /* ldvi.h.f */ + {51,15,rr,V,V,0}, /* ldvi.w.f */ + {51,16,rr,V,V,0}, /* ldvi.l.f */ + {28,11,rr,V,V,0}, /* cvtw.s.f */ + {31,15,rr,V,V,0}, /* cvts.w.f */ + {28,16,rr,V,V,0}, /* cvtw.l.f */ + {33,15,rr,V,V,0}, /* cvtl.w.f */ + {52,13,rxr,V,V,0}, /* stvi.b.f */ + {52,14,rxr,V,V,0}, /* stvi.h.f */ + {52,15,rxr,V,V,0}, /* stvi.w.f */ + {52,16,rxr,V,V,0}, /* stvi.l.f */ + {52,13,rxr,S,V,0}, /* stvi.b.f */ + {52,14,rxr,S,V,0}, /* stvi.h.f */ + {52,15,rxr,S,V,0}, /* stvi.w.f */ + {52,16,rxr,S,V,0}, /* stvi.l.f */ +}; +struct formstr e0_format6[] = { + {0,0,rxl,S,CIR,0}, /* mov */ + {0,0,lr,CIR,S,0}, /* mov */ + {0,0,lr,TOC,S,0}, /* mov */ + {0,0,lr,CPUID,S,0}, /* mov */ + {0,0,rxl,S,TTR,0}, /* mov */ + {0,0,lr,TTR,S,0}, /* mov */ + {118,0,nops,0,0,0}, /* ctrsl */ + {119,0,nops,0,0,0}, /* ctrsg */ + {0,0,rxl,S,VMU,0}, /* mov */ + {0,0,lr,VMU,S,0}, /* mov */ + {0,0,rxl,S,VML,0}, /* mov */ + {0,0,lr,VML,S,0}, /* mov */ + {0,0,rxl,S,ICR,0}, /* mov */ + {0,0,lr,ICR,S,0}, /* mov */ + {0,0,rxl,S,TCPU,0}, /* mov */ + {0,0,lr,TCPU,S,0}, /* mov */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {120,0,nops,0,0,0}, /* stop */ + {0,0,0,0,0,0}, + {0,0,rxl,S,TID,0}, /* mov */ + {0,0,lr,TID,S,0}, /* mov */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e0_format7[] = { + {84,13,r,V,0,0}, /* sum.b.f */ + {84,14,r,V,0,0}, /* sum.h.f */ + {84,15,r,V,0,0}, /* sum.w.f */ + {84,16,r,V,0,0}, /* sum.l.f */ + {85,2,r,V,0,0}, /* all.f */ + {86,2,r,V,0,0}, /* any.f */ + {87,2,r,V,0,0}, /* parity.f */ + {0,0,0,0,0,0}, + {88,13,r,V,0,0}, /* max.b.f */ + {88,14,r,V,0,0}, /* max.h.f */ + {88,15,r,V,0,0}, /* max.w.f */ + {88,16,r,V,0,0}, /* max.l.f */ + {89,13,r,V,0,0}, /* min.b.f */ + {89,14,r,V,0,0}, /* min.h.f */ + {89,15,r,V,0,0}, /* min.w.f */ + {89,16,r,V,0,0}, /* min.l.f */ + {84,11,r,V,0,0}, /* sum.s.f */ + {84,12,r,V,0,0}, /* sum.d.f */ + {90,11,r,V,0,0}, /* prod.s.f */ + {90,12,r,V,0,0}, /* prod.d.f */ + {88,11,r,V,0,0}, /* max.s.f */ + {88,12,r,V,0,0}, /* max.d.f */ + {89,11,r,V,0,0}, /* min.s.f */ + {89,12,r,V,0,0}, /* min.d.f */ + {90,13,r,V,0,0}, /* prod.b.f */ + {90,14,r,V,0,0}, /* prod.h.f */ + {90,15,r,V,0,0}, /* prod.w.f */ + {90,16,r,V,0,0}, /* prod.l.f */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e1_format0[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {10,18,rrr,S,V,V}, /* sub.s.t */ + {10,19,rrr,S,V,V}, /* sub.d.t */ + {4,18,rrr,S,V,V}, /* div.s.t */ + {4,19,rrr,S,V,V}, /* div.d.t */ + {3,18,rrr,V,V,V}, /* mul.s.t */ + {3,19,rrr,V,V,V}, /* mul.d.t */ + {4,18,rrr,V,V,V}, /* div.s.t */ + {4,19,rrr,V,V,V}, /* div.d.t */ + {3,18,rrr,V,S,V}, /* mul.s.t */ + {3,19,rrr,V,S,V}, /* mul.d.t */ + {4,18,rrr,V,S,V}, /* div.s.t */ + {4,19,rrr,V,S,V}, /* div.d.t */ + {5,1,rrr,V,V,V}, /* and.t */ + {6,1,rrr,V,V,V}, /* or.t */ + {7,1,rrr,V,V,V}, /* xor.t */ + {8,1,rrr,V,V,V}, /* shf.t */ + {5,1,rrr,V,S,V}, /* and.t */ + {6,1,rrr,V,S,V}, /* or.t */ + {7,1,rrr,V,S,V}, /* xor.t */ + {8,1,rrr,V,S,V}, /* shf.t */ + {9,18,rrr,V,V,V}, /* add.s.t */ + {9,19,rrr,V,V,V}, /* add.d.t */ + {10,18,rrr,V,V,V}, /* sub.s.t */ + {10,19,rrr,V,V,V}, /* sub.d.t */ + {9,18,rrr,V,S,V}, /* add.s.t */ + {9,19,rrr,V,S,V}, /* add.d.t */ + {10,18,rrr,V,S,V}, /* sub.s.t */ + {10,19,rrr,V,S,V}, /* sub.d.t */ + {9,20,rrr,V,V,V}, /* add.b.t */ + {9,21,rrr,V,V,V}, /* add.h.t */ + {9,22,rrr,V,V,V}, /* add.w.t */ + {9,23,rrr,V,V,V}, /* add.l.t */ + {9,20,rrr,V,S,V}, /* add.b.t */ + {9,21,rrr,V,S,V}, /* add.h.t */ + {9,22,rrr,V,S,V}, /* add.w.t */ + {9,23,rrr,V,S,V}, /* add.l.t */ + {10,20,rrr,V,V,V}, /* sub.b.t */ + {10,21,rrr,V,V,V}, /* sub.h.t */ + {10,22,rrr,V,V,V}, /* sub.w.t */ + {10,23,rrr,V,V,V}, /* sub.l.t */ + {10,20,rrr,V,S,V}, /* sub.b.t */ + {10,21,rrr,V,S,V}, /* sub.h.t */ + {10,22,rrr,V,S,V}, /* sub.w.t */ + {10,23,rrr,V,S,V}, /* sub.l.t */ + {3,20,rrr,V,V,V}, /* mul.b.t */ + {3,21,rrr,V,V,V}, /* mul.h.t */ + {3,22,rrr,V,V,V}, /* mul.w.t */ + {3,23,rrr,V,V,V}, /* mul.l.t */ + {3,20,rrr,V,S,V}, /* mul.b.t */ + {3,21,rrr,V,S,V}, /* mul.h.t */ + {3,22,rrr,V,S,V}, /* mul.w.t */ + {3,23,rrr,V,S,V}, /* mul.l.t */ + {4,20,rrr,V,V,V}, /* div.b.t */ + {4,21,rrr,V,V,V}, /* div.h.t */ + {4,22,rrr,V,V,V}, /* div.w.t */ + {4,23,rrr,V,V,V}, /* div.l.t */ + {4,20,rrr,V,S,V}, /* div.b.t */ + {4,21,rrr,V,S,V}, /* div.h.t */ + {4,22,rrr,V,S,V}, /* div.w.t */ + {4,23,rrr,V,S,V}, /* div.l.t */ +}; +struct formstr e1_format1[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {26,20,a2r,S,0,0}, /* ste.b.t */ + {26,21,a2r,S,0,0}, /* ste.h.t */ + {26,22,a2r,S,0,0}, /* ste.w.t */ + {26,23,a2r,S,0,0}, /* ste.l.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {18,20,a1r,V,0,0}, /* ld.b.t */ + {18,21,a1r,V,0,0}, /* ld.h.t */ + {18,22,a1r,V,0,0}, /* ld.w.t */ + {18,23,a1r,V,0,0}, /* ld.l.t */ + {21,20,a2r,V,0,0}, /* st.b.t */ + {21,21,a2r,V,0,0}, /* st.h.t */ + {21,22,a2r,V,0,0}, /* st.w.t */ + {21,23,a2r,V,0,0}, /* st.l.t */ +}; +struct formstr e1_format2[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {28,20,rr,V,V,0}, /* cvtw.b.t */ + {28,21,rr,V,V,0}, /* cvtw.h.t */ + {29,22,rr,V,V,0}, /* cvtb.w.t */ + {30,22,rr,V,V,0}, /* cvth.w.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {31,23,rr,V,V,0}, /* cvts.l.t */ + {32,22,rr,V,V,0}, /* cvtd.w.t */ + {33,18,rr,V,V,0}, /* cvtl.s.t */ + {28,19,rr,V,V,0}, /* cvtw.d.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {116,18,rr,V,V,0}, /* frint.s.t */ + {116,19,rr,V,V,0}, /* frint.d.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {81,18,rr,V,V,0}, /* sqrt.s.t */ + {81,19,rr,V,V,0}, /* sqrt.d.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e1_format3[] = { + {32,18,rr,V,V,0}, /* cvtd.s.t */ + {31,19,rr,V,V,0}, /* cvts.d.t */ + {33,19,rr,V,V,0}, /* cvtl.d.t */ + {32,23,rr,V,V,0}, /* cvtd.l.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {36,1,rr,V,V,0}, /* tzc.t */ + {44,1,rr,V,V,0}, /* lop.t */ + {117,1,rr,V,V,0}, /* xpnd.t */ + {42,1,rr,V,V,0}, /* not.t */ + {8,1,rr,S,V,0}, /* shf.t */ + {35,24,rr,V,V,0}, /* plc.t.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {37,18,rr,V,V,0}, /* eq.s.t */ + {37,19,rr,V,V,0}, /* eq.d.t */ + {43,18,rr,V,V,0}, /* neg.s.t */ + {43,19,rr,V,V,0}, /* neg.d.t */ + {37,18,rr,S,V,0}, /* eq.s.t */ + {37,19,rr,S,V,0}, /* eq.d.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {40,18,rr,V,V,0}, /* le.s.t */ + {40,19,rr,V,V,0}, /* le.d.t */ + {41,18,rr,V,V,0}, /* lt.s.t */ + {41,19,rr,V,V,0}, /* lt.d.t */ + {40,18,rr,S,V,0}, /* le.s.t */ + {40,19,rr,S,V,0}, /* le.d.t */ + {41,18,rr,S,V,0}, /* lt.s.t */ + {41,19,rr,S,V,0}, /* lt.d.t */ + {37,20,rr,V,V,0}, /* eq.b.t */ + {37,21,rr,V,V,0}, /* eq.h.t */ + {37,22,rr,V,V,0}, /* eq.w.t */ + {37,23,rr,V,V,0}, /* eq.l.t */ + {37,20,rr,S,V,0}, /* eq.b.t */ + {37,21,rr,S,V,0}, /* eq.h.t */ + {37,22,rr,S,V,0}, /* eq.w.t */ + {37,23,rr,S,V,0}, /* eq.l.t */ + {40,20,rr,V,V,0}, /* le.b.t */ + {40,21,rr,V,V,0}, /* le.h.t */ + {40,22,rr,V,V,0}, /* le.w.t */ + {40,23,rr,V,V,0}, /* le.l.t */ + {40,20,rr,S,V,0}, /* le.b.t */ + {40,21,rr,S,V,0}, /* le.h.t */ + {40,22,rr,S,V,0}, /* le.w.t */ + {40,23,rr,S,V,0}, /* le.l.t */ + {41,20,rr,V,V,0}, /* lt.b.t */ + {41,21,rr,V,V,0}, /* lt.h.t */ + {41,22,rr,V,V,0}, /* lt.w.t */ + {41,23,rr,V,V,0}, /* lt.l.t */ + {41,20,rr,S,V,0}, /* lt.b.t */ + {41,21,rr,S,V,0}, /* lt.h.t */ + {41,22,rr,S,V,0}, /* lt.w.t */ + {41,23,rr,S,V,0}, /* lt.l.t */ + {43,20,rr,V,V,0}, /* neg.b.t */ + {43,21,rr,V,V,0}, /* neg.h.t */ + {43,22,rr,V,V,0}, /* neg.w.t */ + {43,23,rr,V,V,0}, /* neg.l.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e1_format4[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e1_format5[] = { + {51,20,rr,V,V,0}, /* ldvi.b.t */ + {51,21,rr,V,V,0}, /* ldvi.h.t */ + {51,22,rr,V,V,0}, /* ldvi.w.t */ + {51,23,rr,V,V,0}, /* ldvi.l.t */ + {28,18,rr,V,V,0}, /* cvtw.s.t */ + {31,22,rr,V,V,0}, /* cvts.w.t */ + {28,23,rr,V,V,0}, /* cvtw.l.t */ + {33,22,rr,V,V,0}, /* cvtl.w.t */ + {52,20,rxr,V,V,0}, /* stvi.b.t */ + {52,21,rxr,V,V,0}, /* stvi.h.t */ + {52,22,rxr,V,V,0}, /* stvi.w.t */ + {52,23,rxr,V,V,0}, /* stvi.l.t */ + {52,20,rxr,S,V,0}, /* stvi.b.t */ + {52,21,rxr,S,V,0}, /* stvi.h.t */ + {52,22,rxr,S,V,0}, /* stvi.w.t */ + {52,23,rxr,S,V,0}, /* stvi.l.t */ +}; +struct formstr e1_format6[] = { + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +struct formstr e1_format7[] = { + {84,20,r,V,0,0}, /* sum.b.t */ + {84,21,r,V,0,0}, /* sum.h.t */ + {84,22,r,V,0,0}, /* sum.w.t */ + {84,23,r,V,0,0}, /* sum.l.t */ + {85,1,r,V,0,0}, /* all.t */ + {86,1,r,V,0,0}, /* any.t */ + {87,1,r,V,0,0}, /* parity.t */ + {0,0,0,0,0,0}, + {88,20,r,V,0,0}, /* max.b.t */ + {88,21,r,V,0,0}, /* max.h.t */ + {88,22,r,V,0,0}, /* max.w.t */ + {88,23,r,V,0,0}, /* max.l.t */ + {89,20,r,V,0,0}, /* min.b.t */ + {89,21,r,V,0,0}, /* min.h.t */ + {89,22,r,V,0,0}, /* min.w.t */ + {89,23,r,V,0,0}, /* min.l.t */ + {84,18,r,V,0,0}, /* sum.s.t */ + {84,19,r,V,0,0}, /* sum.d.t */ + {90,18,r,V,0,0}, /* prod.s.t */ + {90,19,r,V,0,0}, /* prod.d.t */ + {88,18,r,V,0,0}, /* max.s.t */ + {88,19,r,V,0,0}, /* max.d.t */ + {89,18,r,V,0,0}, /* min.s.t */ + {89,19,r,V,0,0}, /* min.d.t */ + {90,20,r,V,0,0}, /* prod.b.t */ + {90,21,r,V,0,0}, /* prod.h.t */ + {90,22,r,V,0,0}, /* prod.w.t */ + {90,23,r,V,0,0}, /* prod.l.t */ + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, + {0,0,0,0,0,0}, +}; +char *lop[] = { + "mov", /* 0 */ + "merg", /* 1 */ + "mask", /* 2 */ + "mul", /* 3 */ + "div", /* 4 */ + "and", /* 5 */ + "or", /* 6 */ + "xor", /* 7 */ + "shf", /* 8 */ + "add", /* 9 */ + "sub", /* 10 */ + "exit", /* 11 */ + "jmp", /* 12 */ + "jmpi", /* 13 */ + "jmpa", /* 14 */ + "jmps", /* 15 */ + "tac", /* 16 */ + "ldea", /* 17 */ + "ld", /* 18 */ + "tas", /* 19 */ + "pshea", /* 20 */ + "st", /* 21 */ + "call", /* 22 */ + "calls", /* 23 */ + "callq", /* 24 */ + "pfork", /* 25 */ + "ste", /* 26 */ + "incr", /* 27 */ + "cvtw", /* 28 */ + "cvtb", /* 29 */ + "cvth", /* 30 */ + "cvts", /* 31 */ + "cvtd", /* 32 */ + "cvtl", /* 33 */ + "ldpa", /* 34 */ + "plc", /* 35 */ + "tzc", /* 36 */ + "eq", /* 37 */ + "leu", /* 38 */ + "ltu", /* 39 */ + "le", /* 40 */ + "lt", /* 41 */ + "not", /* 42 */ + "neg", /* 43 */ + "lop", /* 44 */ + "cprs", /* 45 */ + "nop", /* 46 */ + "br", /* 47 */ + "bri", /* 48 */ + "bra", /* 49 */ + "brs", /* 50 */ + "ldvi", /* 51 */ + "stvi", /* 52 */ + "ldsdr", /* 53 */ + "ldkdr", /* 54 */ + "ln", /* 55 */ + "patu", /* 56 */ + "pate", /* 57 */ + "pich", /* 58 */ + "plch", /* 59 */ + "idle", /* 60 */ + "rtnq", /* 61 */ + "cfork", /* 62 */ + "rtn", /* 63 */ + "wfork", /* 64 */ + "join", /* 65 */ + "rtnc", /* 66 */ + "exp", /* 67 */ + "sin", /* 68 */ + "cos", /* 69 */ + "psh", /* 70 */ + "pop", /* 71 */ + "eni", /* 72 */ + "dsi", /* 73 */ + "bkpt", /* 74 */ + "msync", /* 75 */ + "mski", /* 76 */ + "xmti", /* 77 */ + "tstvv", /* 78 */ + "diag", /* 79 */ + "pbkpt", /* 80 */ + "sqrt", /* 81 */ + "casr", /* 82 */ + "atan", /* 83 */ + "sum", /* 84 */ + "all", /* 85 */ + "any", /* 86 */ + "parity", /* 87 */ + "max", /* 88 */ + "min", /* 89 */ + "prod", /* 90 */ + "halt", /* 91 */ + "sysc", /* 92 */ + "trap", /* 93 */ + "tst", /* 94 */ + "lck", /* 95 */ + "ulk", /* 96 */ + "spawn", /* 97 */ + "ldcmr", /* 98 */ + "stcmr", /* 99 */ + "popr", /* 100 */ + "pshr", /* 101 */ + "rcvr", /* 102 */ + "matm", /* 103 */ + "sndr", /* 104 */ + "putr", /* 105 */ + "getr", /* 106 */ + "matr", /* 107 */ + "mat", /* 108 */ + "get", /* 109 */ + "rcv", /* 110 */ + "inc", /* 111 */ + "put", /* 112 */ + "snd", /* 113 */ + "enal", /* 114 */ + "enag", /* 115 */ + "frint", /* 116 */ + "xpnd", /* 117 */ + "ctrsl", /* 118 */ + "ctrsg", /* 119 */ + "stop", /* 120 */ +}; +char *rop[] = { + "", /* 0 */ + ".t", /* 1 */ + ".f", /* 2 */ + ".s", /* 3 */ + ".d", /* 4 */ + ".b", /* 5 */ + ".h", /* 6 */ + ".w", /* 7 */ + ".l", /* 8 */ + ".x", /* 9 */ + ".u", /* 10 */ + ".s.f", /* 11 */ + ".d.f", /* 12 */ + ".b.f", /* 13 */ + ".h.f", /* 14 */ + ".w.f", /* 15 */ + ".l.f", /* 16 */ + ".t.f", /* 17 */ + ".s.t", /* 18 */ + ".d.t", /* 19 */ + ".b.t", /* 20 */ + ".h.t", /* 21 */ + ".w.t", /* 22 */ + ".l.t", /* 23 */ + ".t.t", /* 24 */ +}; diff --git a/gdb/convex-pinsn.c b/gdb/convex-pinsn.c new file mode 100644 index 0000000..a283d29 --- /dev/null +++ b/gdb/convex-pinsn.c @@ -0,0 +1,314 @@ +/* Print Convex instructions for GDB, the GNU debugger. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" + +/* reg (fmt_field, inst_field) -- + the {first,second,third} operand of instruction as fmt_field = [ijk] + gets the value of the field from the [ijk] position of the instruction */ + +#define reg(a,b) ((char (*)[3])(op[fmt->a]))[inst.f0.b] + +/* lit (fmt_field) -- field [ijk] is a literal (PSW, VL, eg) */ + +#define lit(i) op[fmt->i] + +/* aj[j] -- name for A register j */ + +#define aj ((char (*)[3])(op[A])) + +union inst { + struct { + unsigned : 7; + unsigned i : 3; + unsigned j : 3; + unsigned k : 3; + unsigned : 16; + unsigned : 32; + } f0; + struct { + unsigned : 8; + unsigned indir : 1; + unsigned len : 1; + unsigned j : 3; + unsigned k : 3; + unsigned : 16; + unsigned : 32; + } f1; + unsigned char byte[8]; + unsigned short half[4]; + char signed_byte[8]; + short signed_half[4]; +}; + +struct opform { + int mask; /* opcode mask */ + int shift; /* opcode align */ + struct formstr *formstr[3]; /* ST, E0, E1 */ +}; + +struct formstr { + unsigned lop:8, rop:5; /* opcode */ + unsigned fmt:5; /* inst format */ + unsigned i:5, j:5, k:2; /* operand formats */ +}; + +#include "convex-opcode.h" + +unsigned char formdecode [] = { + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 9,9,9,9,9,9,9,9,9,9,9,9,9,9,9,9, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, + 3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, + 4,4,4,4,4,4,4,4,5,5,5,5,6,6,7,8, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, + 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, +}; + +struct opform opdecode[] = { + 0x7e00, 9, format0, e0_format0, e1_format0, + 0x3f00, 8, format1, e0_format1, e1_format1, + 0x1fc0, 6, format2, e0_format2, e1_format2, + 0x0fc0, 6, format3, e0_format3, e1_format3, + 0x0700, 8, format4, e0_format4, e1_format4, + 0x03c0, 6, format5, e0_format5, e1_format5, + 0x01f8, 3, format6, e0_format6, e1_format6, + 0x00f8, 3, format7, e0_format7, e1_format7, + 0x0000, 0, formatx, formatx, formatx, + 0x0f80, 7, formatx, formatx, formatx, + 0x0f80, 7, formatx, formatx, formatx, +}; + +/* Print the instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + union inst inst; + struct formstr *fmt; + register int format, op1, pfx; + int l; + + read_memory (memaddr, &inst, sizeof inst); + + /* Remove and note prefix, if present */ + + pfx = inst.half[0]; + if ((pfx & 0xfff0) == 0x7ef0) + { + pfx = ((pfx >> 3) & 1) + 1; + *(long long *) &inst = *(long long *) &inst.half[1]; + } + else pfx = 0; + + /* Split opcode into format.op1 and look up in appropriate table */ + + format = formdecode[inst.byte[0]]; + op1 = (inst.half[0] & opdecode[format].mask) >> opdecode[format].shift; + if (format == 9) + { + if (pfx) + fmt = formatx; + else if (inst.f1.j == 0) + fmt = &format1a[op1]; + else if (inst.f1.j == 1) + fmt = &format1b[op1]; + else + fmt = formatx; + } + else + fmt = &opdecode[format].formstr[pfx][op1]; + + /* Print it */ + + if (fmt->fmt == xxx) + { + /* noninstruction */ + fprintf (stream, "0x%04x", pfx ? pfx : inst.half[0]); + return 2; + } + + if (pfx) + pfx = 2; + + fprintf (stream, "%s%s%s", lop[fmt->lop], rop[fmt->rop], + &" "[strlen(lop[fmt->lop]) + strlen(rop[fmt->rop])]); + + switch (fmt->fmt) + { + case rrr: /* three register */ + fprintf (stream, "%s,%s,%s", reg(i,i), reg(j,j), reg(k,k)); + return pfx + 2; + + case rr: /* two register */ + fprintf (stream, "%s,%s", reg(i,j), reg(j,k)); + return pfx + 2; + + case rxr: /* two register, reversed i and j fields */ + fprintf (stream, "%s,%s", reg(i,k), reg(j,j)); + return pfx + 2; + + case r: /* one register */ + fprintf (stream, "%s", reg(i,k)); + return pfx + 2; + + case nops: /* no operands */ + return pfx + 2; + + case nr: /* short immediate, one register */ + fprintf (stream, "#%d,%s", inst.f0.j, reg(i,k)); + return pfx + 2; + + case pcrel: /* pc relative */ + print_address (memaddr + 2 * inst.signed_byte[1], stream); + return pfx + 2; + + case lr: /* literal, one register */ + fprintf (stream, "%s,%s", lit(i), reg(j,k)); + return pfx + 2; + + case rxl: /* one register, literal */ + fprintf (stream, "%s,%s", reg(i,k), lit(j)); + return pfx + 2; + + case rlr: /* register, literal, register */ + fprintf (stream, "%s,%s,%s", reg(i,j), lit(j), reg(k,k)); + return pfx + 2; + + case rrl: /* register, register, literal */ + fprintf (stream, "%s,%s,%s", reg(i,j), reg(j,k), lit(k)); + return pfx + 2; + + case iml: /* immediate, literal */ + if (inst.f1.len) + { + fprintf (stream, "#%#x,%s", + (inst.signed_half[1] << 16) + inst.half[2], lit(i)); + return pfx + 6; + } + else + { + fprintf (stream, "#%d,%s", inst.signed_half[1], lit(i)); + return pfx + 4; + } + + case imr: /* immediate, register */ + if (inst.f1.len) + { + fprintf (stream, "#%#x,%s", + (inst.signed_half[1] << 16) + inst.half[2], reg(i,k)); + return pfx + 6; + } + else + { + fprintf (stream, "#%d,%s", inst.signed_half[1], reg(i,k)); + return pfx + 4; + } + + case a1r: /* memory, register */ + l = print_effa (inst, stream); + fprintf (stream, ",%s", reg(i,k)); + return pfx + l; + + case a1l: /* memory, literal */ + l = print_effa (inst, stream); + fprintf (stream, ",%s", lit(i)); + return pfx + l; + + case a2r: /* register, memory */ + fprintf (stream, "%s,", reg(i,k)); + return pfx + print_effa (inst, stream); + + case a2l: /* literal, memory */ + fprintf (stream, "%s,", lit(i)); + return pfx + print_effa (inst, stream); + + case a3: /* memory */ + return pfx + print_effa (inst, stream); + + case a4: /* system call */ + l = 29; goto a4a5; + case a5: /* trap */ + l = 27; + a4a5: + if (inst.f1.len) + { + unsigned int m = (inst.signed_half[1] << 16) + inst.half[2]; + fprintf (stream, "#%d,#%d", m >> l, m & (-1 >> (32-l))); + return pfx + 6; + } + else + { + unsigned int m = inst.signed_half[1]; + fprintf (stream, "#%d,#%d", m >> l, m & (-1 >> (32-l))); + return pfx + 4; + } + } +} + + +/* print effective address @nnn(aj), return instruction length */ + +int print_effa (inst, stream) + union inst inst; + FILE *stream; +{ + int n, l; + + if (inst.f1.len) + { + n = (inst.signed_half[1] << 16) + inst.half[2]; + l = 6; + } + else + { + n = inst.signed_half[1]; + l = 4; + } + + if (inst.f1.indir) + printf ("@"); + + if (!inst.f1.j) + { + print_address (n, stream); + return l; + } + + fprintf (stream, (n & 0xf0000000) == 0x80000000 ? "%#x(%s)" : "%d(%s)", + n, aj[inst.f1.j]); + + return l; +} diff --git a/gdb/convex-tdep.c b/gdb/convex-tdep.c new file mode 100644 index 0000000..c206e1e --- /dev/null +++ b/gdb/convex-tdep.c @@ -0,0 +1,934 @@ +/* Convex stuff for GDB. + Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "command.h" +#include "symtab.h" +#include "value.h" +#include "frame.h" +#include "inferior.h" +#include "wait.h" + +#include <signal.h> +#include <fcntl.h> + +#include "gdbcore.h" +#include <sys/param.h> +#include <sys/dir.h> +#include <sys/user.h> +#include <sys/ioctl.h> +#include <sys/pcntl.h> +#include <sys/thread.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/mman.h> + +#include "gdbcmd.h" + +exec_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + int n; + struct stat st_exec; + + /* Eliminate all traces of old exec file. + Mark text segment as empty. */ + + if (execfile) + free (execfile); + execfile = 0; + data_start = 0; + data_end = 0; + text_start = 0; + text_end = 0; + exec_data_start = 0; + exec_data_end = 0; + if (execchan >= 0) + close (execchan); + execchan = -1; + + n_exec = 0; + + /* Now open and digest the file the user requested, if any. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0, + &execfile); + if (execchan < 0) + perror_with_name (filename); + + if (myread (execchan, &filehdr, sizeof filehdr) < 0) + perror_with_name (filename); + + if (! IS_SOFF_MAGIC (filehdr.h_magic)) + error ("%s: not an executable file.", filename); + + if (myread (execchan, &opthdr, filehdr.h_opthdr) <= 0) + perror_with_name (filename); + + /* Read through the section headers. + For text, data, etc, record an entry in the exec file map. + Record text_start and text_end. */ + + lseek (execchan, (long) filehdr.h_scnptr, 0); + + for (n = 0; n < filehdr.h_nscns; n++) + { + if (myread (execchan, &scnhdr, sizeof scnhdr) < 0) + perror_with_name (filename); + + if ((scnhdr.s_flags & S_TYPMASK) >= S_TEXT + && (scnhdr.s_flags & S_TYPMASK) <= S_COMON) + { + exec_map[n_exec].mem_addr = scnhdr.s_vaddr; + exec_map[n_exec].mem_end = scnhdr.s_vaddr + scnhdr.s_size; + exec_map[n_exec].file_addr = scnhdr.s_scnptr; + exec_map[n_exec].type = scnhdr.s_flags & S_TYPMASK; + n_exec++; + + if ((scnhdr.s_flags & S_TYPMASK) == S_TEXT) + { + text_start = scnhdr.s_vaddr; + text_end = scnhdr.s_vaddr + scnhdr.s_size; + } + } + } + + fstat (execchan, &st_exec); + exec_mtime = st_exec.st_mtime; + + validate_files (); + } + else if (from_tty) + printf_filtered ("No exec file now.\n"); + + /* Tell display code (if any) about the changed file name. */ + if (exec_file_display_hook) + (*exec_file_display_hook) (filename); +} + +/* Read data from SOFF exec or core file. + Return 0 on success, EIO if address out of bounds. */ + +int +xfer_core_file (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + register int i; + register int n; + register int val; + int xferchan; + char **xferfile; + int fileptr; + int returnval = 0; + + while (len > 0) + { + xferfile = 0; + xferchan = 0; + + /* Determine which file the next bunch of addresses reside in, + and where in the file. Set the file's read/write pointer + to point at the proper place for the desired address + and set xferfile and xferchan for the correct file. + If desired address is nonexistent, leave them zero. + i is set to the number of bytes that can be handled + along with the next address. */ + + i = len; + + for (n = 0; n < n_core; n++) + { + if (memaddr >= core_map[n].mem_addr && memaddr < core_map[n].mem_end + && (core_map[n].thread == -1 + || core_map[n].thread == inferior_thread)) + { + i = min (len, core_map[n].mem_end - memaddr); + fileptr = core_map[n].file_addr + memaddr - core_map[n].mem_addr; + if (core_map[n].file_addr) + { + xferfile = &corefile; + xferchan = corechan; + } + break; + } + else if (core_map[n].mem_addr >= memaddr + && core_map[n].mem_addr < memaddr + i) + i = core_map[n].mem_addr - memaddr; + } + + if (!xferfile) + for (n = 0; n < n_exec; n++) + { + if (memaddr >= exec_map[n].mem_addr + && memaddr < exec_map[n].mem_end) + { + i = min (len, exec_map[n].mem_end - memaddr); + fileptr = exec_map[n].file_addr + memaddr + - exec_map[n].mem_addr; + if (exec_map[n].file_addr) + { + xferfile = &execfile; + xferchan = execchan; + } + break; + } + else if (exec_map[n].mem_addr >= memaddr + && exec_map[n].mem_addr < memaddr + i) + i = exec_map[n].mem_addr - memaddr; + } + + /* Now we know which file to use. + Set up its pointer and transfer the data. */ + if (xferfile) + { + if (*xferfile == 0) + if (xferfile == &execfile) + error ("No program file to examine."); + else + error ("No core dump file or running program to examine."); + val = lseek (xferchan, fileptr, 0); + if (val < 0) + perror_with_name (*xferfile); + val = myread (xferchan, myaddr, i); + if (val < 0) + perror_with_name (*xferfile); + } + /* If this address is for nonexistent memory, + read zeros if reading, or do nothing if writing. */ + else + { + bzero (myaddr, i); + returnval = EIO; + } + + memaddr += i; + myaddr += i; + len -= i; + } + return returnval; +} + + +/* Here from info files command to print an address map. */ + +print_maps () +{ + struct pmap ptrs[200]; + int n; + + /* ID strings for core and executable file sections */ + + static char *idstr[] = + { + "0", "text", "data", "tdata", "bss", "tbss", + "common", "ttext", "ctx", "tctx", "10", "11", "12", + }; + + for (n = 0; n < n_core; n++) + { + core_map[n].which = 0; + ptrs[n] = core_map[n]; + } + for (n = 0; n < n_exec; n++) + { + exec_map[n].which = 1; + ptrs[n_core+n] = exec_map[n]; + } + + qsort (ptrs, n_core + n_exec, sizeof *ptrs, ptr_cmp); + + for (n = 0; n < n_core + n_exec; n++) + { + struct pmap *p = &ptrs[n]; + if (n > 0) + { + if (p->mem_addr < ptrs[n-1].mem_end) + p->mem_addr = ptrs[n-1].mem_end; + if (p->mem_addr >= p->mem_end) + continue; + } + printf_filtered ("%08x .. %08x %-6s %s\n", + p->mem_addr, p->mem_end, idstr[p->type], + p->which ? execfile : corefile); + } +} + +/* Compare routine to put file sections in order. + Sort into increasing order on address, and put core file sections + before exec file sections if both files contain the same addresses. */ + +static ptr_cmp (a, b) + struct pmap *a, *b; +{ + if (a->mem_addr != b->mem_addr) return a->mem_addr - b->mem_addr; + return a->which - b->which; +} + +/* Trapped internal variables are used to handle special registers. + A trapped i.v. calls a hook here every time it is dereferenced, + to provide a new value for the variable, and it calls a hook here + when a new value is assigned, to do something with the value. + + The vector registers are $vl, $vs, $vm, $vN, $VN (N in 0..7). + The communication registers are $cN, $CN (N in 0..63). + They not handled as regular registers because it's expensive to + read them, and their size varies, and they have too many names. */ + + +/* Return 1 if NAME is a trapped internal variable, else 0. */ + +int +is_trapped_internalvar (name) + char *name; +{ + if ((name[0] == 'c' || name[0] == 'C') + && name[1] >= '0' && name[1] <= '9' + && (name[2] == '\0' + || (name[2] >= '0' && name[2] <= '9' + && name[3] == '\0' && name[1] != '0')) + && atoi (&name[1]) < 64) return 1; + + if ((name[0] == 'v' || name[0] == 'V') + && (((name[1] & -8) == '0' && name[2] == '\0') + || !strcmp (name, "vl") + || !strcmp (name, "vs") + || !strcmp (name, "vm"))) + return 1; + else return 0; +} + +/* Return the value of trapped internal variable VAR */ + +value +value_of_trapped_internalvar (var) + struct internalvar *var; +{ + char *name = var->name; + value val; + struct type *type; + long len = *read_vector_register (VL_REGNUM); + if (len <= 0 || len > 128) len = 128; + + if (!strcmp (name, "vl")) + { + val = value_from_long (builtin_type_int, + (LONGEST) *read_vector_register_1 (VL_REGNUM)); + } + else if (!strcmp (name, "vs")) + { + val = value_from_long (builtin_type_int, + (LONGEST) *read_vector_register_1 (VS_REGNUM)); + } + else if (!strcmp (name, "vm")) + { + long vm[4]; + long i, *p; + bcopy (read_vector_register_1 (VM_REGNUM), vm, sizeof vm); + type = vector_type (builtin_type_int, len); + val = allocate_value (type); + p = (long *) VALUE_CONTENTS (val); + for (i = 0; i < len; i++) + *p++ = !! (vm[3 - (i >> 5)] & (1 << (i & 037))); + } + else if (name[0] == 'V') + { + type = vector_type (builtin_type_long_long, len); + val = allocate_value (type); + bcopy (read_vector_register_1 (name[1] - '0'), + VALUE_CONTENTS (val), TYPE_LENGTH (type)); + } + else if (name[0] == 'v') + { + long *p1, *p2; + type = vector_type (builtin_type_long, len); + val = allocate_value (type); + p1 = read_vector_register_1 (name[1] - '0'); + p2 = (long *) VALUE_CONTENTS (val); + while (--len >= 0) {p1++; *p2++ = *p1++;} + } + + else if (name[0] == 'c') + val = value_from_long (builtin_type_int, + read_comm_register (atoi (&name[1]))); + else if (name[0] == 'C') + val = value_from_long (builtin_type_long_long, + read_comm_register (atoi (&name[1]))); + + VALUE_LVAL (val) = lval_internalvar; + VALUE_INTERNALVAR (val) = var; + return val; +} + +/* Construct the type for a vector register's value -- + array[LENGTH] of ELEMENT_TYPE. */ + +static struct type * +vector_type (element_type, length) + struct type *element_type; + long length; +{ + struct type *type = (struct type *) xmalloc (sizeof (struct type)); + bzero (type, sizeof type); + TYPE_CODE (type) = TYPE_CODE_ARRAY; + TYPE_TARGET_TYPE (type) = element_type; + TYPE_LENGTH (type) = length * TYPE_LENGTH (TYPE_TARGET_TYPE (type)); + return type; +} + +/* Handle a new value assigned to a trapped internal variable */ + +void +set_trapped_internalvar (var, val, bitpos, bitsize, offset) + struct internalvar *var; + value val; + int bitpos, bitsize, offset; +{ + char *name = var->name; + long long newval = value_as_long (val); + + if (!strcmp (name, "vl")) + write_vector_register (VL_REGNUM, 0, newval); + else if (!strcmp (name, "vs")) + write_vector_register (VS_REGNUM, 0, newval); + else if (name[0] == 'c' || name[0] == 'C') + write_comm_register (atoi (&name[1]), newval); + else if (!strcmp (name, "vm")) + error ("can't assign to $vm"); + else + { + offset /= bitsize / 8; + write_vector_register (name[1] - '0', offset, newval); + } +} + +/* Print an integer value when no format was specified. gdb normally + prints these values in decimal, but the the leading 0x80000000 of + pointers produces intolerable 10-digit negative numbers. + If it looks like an address, print it in hex instead. */ + +decout (stream, type, val) + FILE *stream; + struct type *type; + LONGEST val; +{ + long lv = val; + + switch (output_radix) + { + case 0: + if ((lv == val || (unsigned) lv == val) + && ((lv & 0xf0000000) == 0x80000000 + || ((lv & 0xf0000000) == 0xf0000000 && lv < STACK_END_ADDR))) + { + fprintf_filtered (stream, "%#x", lv); + return; + } + + case 10: + fprintf_filtered (stream, TYPE_UNSIGNED (type) ? "%llu" : "%lld", val); + return; + + case 8: + if (TYPE_LENGTH (type) <= sizeof lv) + fprintf_filtered (stream, "%#o", lv); + else + fprintf_filtered (stream, "%#llo", val); + return; + + case 16: + if (TYPE_LENGTH (type) <= sizeof lv) + fprintf_filtered (stream, "%#x", lv); + else + fprintf_filtered (stream, "%#llx", val); + return; + } +} + +/* Change the default output radix to 10 or 16, or set it to 0 (heuristic). + This command is mostly obsolete now that the print command allows + formats to apply to aggregates, but is still handy occasionally. */ + +static void +set_base_command (arg) + char *arg; +{ + int new_radix; + + if (!arg) + output_radix = 0; + else + { + new_radix = atoi (arg); + if (new_radix != 10 && new_radix != 16 && new_radix != 8) + error ("base must be 8, 10 or 16, or null"); + else output_radix = new_radix; + } +} + +/* Turn pipelining on or off in the inferior. */ + +static void +set_pipelining_command (arg) + char *arg; +{ + if (!arg) + { + sequential = !sequential; + printf_filtered ("%s\n", sequential ? "off" : "on"); + } + else if (!strcmp (arg, "on")) + sequential = 0; + else if (!strcmp (arg, "off")) + sequential = 1; + else error ("valid args are `on', to allow instructions to overlap, or\n\ +`off', to prevent it and thereby pinpoint exceptions."); +} + +/* Enable, disable, or force parallel execution in the inferior. */ + +static void +set_parallel_command (arg) + char *arg; +{ + struct rlimit rl; + int prevparallel = parallel; + + if (!strncmp (arg, "fixed", strlen (arg))) + parallel = 2; + else if (!strcmp (arg, "on")) + parallel = 1; + else if (!strcmp (arg, "off")) + parallel = 0; + else error ("valid args are `on', to allow multiple threads, or\n\ +`fixed', to force multiple threads, or\n\ +`off', to run with one thread only."); + + if ((prevparallel == 0) != (parallel == 0) && inferior_pid) + printf_filtered ("will take effect at next run.\n"); + + getrlimit (RLIMIT_CONCUR, &rl); + rl.rlim_cur = parallel ? rl.rlim_max : 1; + setrlimit (RLIMIT_CONCUR, &rl); + + if (inferior_pid) + set_fixed_scheduling (inferior_pid, parallel == 2); +} + +/* Add a new name for an existing command. */ + +static void +alias_command (arg) + char *arg; +{ + static char *aliaserr = "usage is `alias NEW OLD', no args allowed"; + char *newname = arg; + struct cmd_list_element *new, *old; + + if (!arg) + error_no_arg ("newname oldname"); + + new = lookup_cmd (&arg, cmdlist, "", -1); + if (new && !strncmp (newname, new->name, strlen (new->name))) + { + newname = new->name; + if (!(*arg == '-' + || (*arg >= 'a' && *arg <= 'z') + || (*arg >= 'A' && *arg <= 'Z') + || (*arg >= '0' && *arg <= '9'))) + error (aliaserr); + } + else + { + arg = newname; + while (*arg == '-' + || (*arg >= 'a' && *arg <= 'z') + || (*arg >= 'A' && *arg <= 'Z') + || (*arg >= '0' && *arg <= '9')) + arg++; + if (*arg != ' ' && *arg != '\t') + error (aliaserr); + *arg = '\0'; + arg++; + } + + old = lookup_cmd (&arg, cmdlist, "", 0); + + if (*arg != '\0') + error (aliaserr); + + if (new && !strncmp (newname, new->name, strlen (new->name))) + { + char *tem; + if (new->class == (int) class_user || new->class == (int) class_alias) + tem = "Redefine command \"%s\"? "; + else + tem = "Really redefine built-in command \"%s\"? "; + if (!query (tem, new->name)) + error ("Command \"%s\" not redefined.", new->name); + } + + add_com (newname, class_alias, old->function, old->doc); +} + + + +/* Print the current thread number, and any threads with signals in the + queue. */ + +thread_info () +{ + struct threadpid *p; + + if (have_inferior_p ()) + { + ps.pi_buffer = (char *) &comm_registers; + ps.pi_nbytes = sizeof comm_registers; + ps.pi_offset = 0; + ps.pi_thread = inferior_thread; + ioctl (inferior_fd, PIXRDCREGS, &ps); + } + + printf_filtered ("Current thread %d stopped with signal %d.%d (%s).\n", + inferior_thread, stop_signal, stop_sigcode, + subsig_name (stop_signal, stop_sigcode)); + + for (p = signal_stack; p->pid; p--) + printf_filtered ("Thread %d stopped with signal %d.%d (%s).\n", + p->thread, p->signo, p->subsig, + subsig_name (p->signo, p->subsig)); + + if (iscrlbit (comm_registers.crctl.lbits.cc, 64+13)) + printf_filtered ("New thread start pc %#x\n", + (long) (comm_registers.crreg.pcpsw >> 32)); +} + +/* Return string describing a signal.subcode number */ + +static char * +subsig_name (signo, subcode) + int signo, subcode; +{ + static char *subsig4[] = { + "error exit", "privileged instruction", "unknown", + "unknown", "undefined opcode", + 0}; + static char *subsig5[] = {0, + "breakpoint", "single step", "fork trap", "exec trap", "pfork trap", + "join trap", "idle trap", "last thread", "wfork trap", + "process breakpoint", "trap instruction", + 0}; + static char *subsig8[] = {0, + "int overflow", "int divide check", "float overflow", + "float divide check", "float underflow", "reserved operand", + "sqrt error", "exp error", "ln error", "sin error", "cos error", + 0}; + static char *subsig10[] = {0, + "invalid inward ring address", "invalid outward ring call", + "invalid inward ring return", "invalid syscall gate", + "invalid rtn frame length", "invalid comm reg address", + "invalid trap gate", + 0}; + static char *subsig11[] = {0, + "read access denied", "write access denied", "execute access denied", + "segment descriptor fault", "page table fault", "data reference fault", + "i/o access denied", "levt pte invalid", + 0}; + + static char **subsig_list[] = + {0, 0, 0, 0, subsig4, subsig5, 0, 0, subsig8, 0, subsig10, subsig11, 0}; + + int i; + char *p = signo < NSIG ? sys_siglist[signo] : "unknown"; + + if (signo >= (sizeof subsig_list / sizeof *subsig_list) + || !subsig_list[signo]) + return p; + for (i = 1; subsig_list[signo][i]; i++) + if (i == subcode) + return subsig_list[signo][subcode]; + return p; +} + + +/* Print a compact display of thread status, essentially x/i $pc + for all active threads. */ + +static void +threadstat () +{ + int t; + + for (t = 0; t < n_threads; t++) + if (thread_state[t] == PI_TALIVE) + { + printf_filtered ("%d%c %08x%c %d.%d ", t, + (t == inferior_thread ? '*' : ' '), thread_pc[t], + (thread_is_in_kernel[t] ? '#' : ' '), + thread_signal[t], thread_sigcode[t]); + print_insn (thread_pc[t], stdout); + printf_filtered ("\n"); + } +} + +/* Change the current thread to ARG. */ + +set_thread_command (arg) + char *arg; +{ + int thread; + + if (!arg) + { + threadstat (); + return; + } + + thread = parse_and_eval_address (arg); + + if (thread < 0 || thread > n_threads || thread_state[thread] != PI_TALIVE) + error ("no such thread."); + + select_thread (thread); + + stop_pc = read_pc (); + flush_cached_frames (); + set_current_frame (create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + print_sel_frame (1); +} + +/* Here on CONT command; gdb's dispatch address is changed to come here. + Set global variable ALL_CONTINUE to tell resume() that it should + start up all threads, and that a thread switch will not blow gdb's + mind. */ + +static void +convex_cont_command (proc_count_exp, from_tty) + char *proc_count_exp; + int from_tty; +{ + all_continue = 1; + cont_command (proc_count_exp, from_tty); +} + +/* Here on 1CONT command. Resume only the current thread. */ + +one_cont_command (proc_count_exp, from_tty) + char *proc_count_exp; + int from_tty; +{ + cont_command (proc_count_exp, from_tty); +} + +/* Print the contents and lock bits of all communication registers, + or just register ARG if ARG is a communication register, + or the 3-word resource structure in memory at address ARG. */ + +comm_registers_info (arg) + char *arg; +{ + int i, regnum; + + if (arg) + { + if (sscanf (arg, "0x%x", ®num) == 1 + || sscanf (arg, "%d", ®num) == 1) + { + if (regnum > 0) + regnum &= ~0x8000; + } + else if (sscanf (arg, "$c%d", ®num) == 1) + ; + else if (sscanf (arg, "$C%d", ®num) == 1) + ; + else + regnum = parse_and_eval_address (arg); + + if (regnum >= 64) + error ("%s: invalid register name.", arg); + + /* if we got a (user) address, examine the resource struct there */ + + if (regnum < 0) + { + static int buf[3]; + read_memory (regnum, buf, sizeof buf); + printf_filtered ("%08x %08x%08x%s\n", regnum, buf[1], buf[2], + buf[0] & 0xff ? " locked" : ""); + return; + } + } + + ps.pi_buffer = (char *) &comm_registers; + ps.pi_nbytes = sizeof comm_registers; + ps.pi_offset = 0; + ps.pi_thread = inferior_thread; + ioctl (inferior_fd, PIXRDCREGS, &ps); + + for (i = 0; i < 64; i++) + if (!arg || i == regnum) + printf_filtered ("%2d 0x8%03x %016llx%s\n", i, i, + comm_registers.crreg.r4[i], + (iscrlbit (comm_registers.crctl.lbits.cc, i) + ? " locked" : "")); +} + +/* Print the psw */ + +static void +psw_info (arg) + char *arg; +{ + struct pswbit + { + int bit; + int pos; + char *text; + }; + + static struct pswbit pswbit[] = + { + { 0x80000000, -1, "A carry" }, + { 0x40000000, -1, "A integer overflow" }, + { 0x20000000, -1, "A zero divide" }, + { 0x10000000, -1, "Integer overflow enable" }, + { 0x08000000, -1, "Trace" }, + { 0x06000000, 25, "Frame length" }, + { 0x01000000, -1, "Sequential" }, + { 0x00800000, -1, "S carry" }, + { 0x00400000, -1, "S integer overflow" }, + { 0x00200000, -1, "S zero divide" }, + { 0x00100000, -1, "Zero divide enable" }, + { 0x00080000, -1, "Floating underflow" }, + { 0x00040000, -1, "Floating overflow" }, + { 0x00020000, -1, "Floating reserved operand" }, + { 0x00010000, -1, "Floating zero divide" }, + { 0x00008000, -1, "Floating error enable" }, + { 0x00004000, -1, "Floating underflow enable" }, + { 0x00002000, -1, "IEEE" }, + { 0x00001000, -1, "Sequential stores" }, + { 0x00000800, -1, "Intrinsic error" }, + { 0x00000400, -1, "Intrinsic error enable" }, + { 0x00000200, -1, "Trace thread creates" }, + { 0x00000100, -1, "Thread init trap" }, + { 0x000000e0, 5, "Reserved" }, + { 0x0000001f, 0, "Intrinsic error code" }, + {0, 0, 0}, + }; + + long psw; + struct pswbit *p; + + if (arg) + psw = parse_and_eval_address (arg); + else + psw = read_register (PS_REGNUM); + + for (p = pswbit; p->bit; p++) + { + if (p->pos < 0) + printf_filtered ("%08x %s %s\n", p->bit, + (psw & p->bit) ? "yes" : "no ", p->text); + else + printf_filtered ("%08x %3d %s\n", p->bit, + (psw & p->bit) >> p->pos, p->text); + } +} + +_initialize_convex_dep () +{ + add_com ("alias", class_support, alias_command, + "Add a new name for an existing command."); + + add_cmd ("base", class_vars, set_base_command, + "Change the integer output radix to 8, 10 or 16\n\ +or use just `set base' with no args to return to the ad-hoc default,\n\ +which is 16 for integers that look like addresses, 10 otherwise.", + &setlist); + + add_cmd ("pipeline", class_run, set_pipelining_command, + "Enable or disable overlapped execution of instructions.\n\ +With `set pipe off', exceptions are reported with\n\ +$pc pointing at the instruction after the faulting one.\n\ +The default is `set pipe on', which runs faster.", + &setlist); + + add_cmd ("parallel", class_run, set_parallel_command, + "Enable or disable multi-threaded execution of parallel code.\n\ +`set parallel off' means run the program on a single CPU.\n\ +`set parallel fixed' means run the program with all CPUs assigned to it.\n\ +`set parallel on' means run the program on any CPUs that are available.", + &setlist); + + add_com ("1cont", class_run, one_cont_command, + "Continue the program, activating only the current thread.\n\ +Args are the same as the `cont' command."); + + add_com ("thread", class_run, set_thread_command, + "Change the current thread, the one under scrutiny and control.\n\ +With no arg, show the active threads, the current one marked with *."); + + add_info ("threads", thread_info, + "List status of active threads."); + + add_info ("comm-registers", comm_registers_info, + "List communication registers and their contents.\n\ +A communication register name as argument means describe only that register.\n\ +An address as argument means describe the resource structure at that address.\n\ +`Locked' means that the register has been sent to but not yet received from."); + + add_info ("psw", psw_info, + "Display $ps, the processor status word, bit by bit.\n\ +An argument means display that value's interpretation as a psw."); + + add_cmd ("convex", no_class, 0, "Convex-specific commands.\n\ +32-bit registers $pc $ps $sp $ap $fp $a1-5 $s0-7 $v0-7 $vl $vs $vm $c0-63\n\ +64-bit registers $S0-7 $V0-7 $C0-63\n\ +\n\ +info threads display info on stopped threads waiting to signal\n\ +thread display list of active threads\n\ +thread N select thread N (its registers, stack, memory, etc.)\n\ +step, next, etc step selected thread only\n\ +1cont continue selected thread only\n\ +cont continue all threads\n\ +info comm-registers display contents of comm register(s) or a resource struct\n\ +info psw display processor status word $ps\n\ +set base N change integer radix used by `print' without a format\n\ +set pipeline off exceptions are precise, $pc points after the faulting insn\n\ +set pipeline on normal mode, $pc is somewhere ahead of faulting insn\n\ +set parallel off program runs on a single CPU\n\ +set parallel fixed all CPUs are assigned to the program\n\ +set parallel on normal mode, parallel execution on random available CPUs\n\ +", + &cmdlist); + +} diff --git a/gdb/convex-xdep.c b/gdb/convex-xdep.c new file mode 100644 index 0000000..f9f44a0 --- /dev/null +++ b/gdb/convex-xdep.c @@ -0,0 +1,983 @@ +/* Convex stuff for GDB. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "command.h" +#include "symtab.h" +#include "value.h" +#include "frame.h" +#include "inferior.h" +#include "wait.h" + +#include <signal.h> +#include <fcntl.h> +#include "gdbcore.h" + +#include <sys/param.h> +#include <sys/dir.h> +#include <sys/user.h> +#include <sys/ioctl.h> +#include <sys/pcntl.h> +#include <sys/thread.h> +#include <sys/proc.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/mman.h> + +#include <convex/vmparam.h> +#include <convex/filehdr.h> +#include <convex/opthdr.h> +#include <convex/scnhdr.h> +#include <convex/core.h> + +/* Per-thread data, read from the inferior at each stop and written + back at each resume. */ + +/* Number of active threads. + Tables are valid for thread numbers less than this. */ + +static int n_threads; + +#define MAXTHREADS 8 + +/* Thread state. The remaining data is valid only if this is PI_TALIVE. */ + +static int thread_state[MAXTHREADS]; + +/* Stop pc, signal, signal subcode */ + +static int thread_pc[MAXTHREADS]; +static int thread_signal[MAXTHREADS]; +static int thread_sigcode[MAXTHREADS]; + +/* Thread registers. + If thread is selected, the regs are in registers[] instead. */ + +static char thread_regs[MAXTHREADS][REGISTER_BYTES]; + +/* 1 if the top frame on the thread's stack was a context frame, + meaning that the kernel is up to something and we should not + touch the thread at all except to resume it. */ + +static char thread_is_in_kernel[MAXTHREADS]; + +/* The currently selected thread's number. */ + +static int inferior_thread; + +/* Inferior process's file handle and a process control block + to feed args to ioctl with. */ + +static int inferior_fd; +static struct pcntl ps; + +/* SOFF file headers for exec or core file. */ + +static FILEHDR filehdr; +static OPTHDR opthdr; +static SCNHDR scnhdr; + +/* Address maps constructed from section headers of exec and core files. + Defines process address -> file address translation. */ + +struct pmap +{ + long mem_addr; /* process start address */ + long mem_end; /* process end+1 address */ + long file_addr; /* file start address */ + long thread; /* -1 shared; 0,1,... thread-local */ + long type; /* S_TEXT S_DATA S_BSS S_TBSS etc */ + long which; /* used to sort map for info files */ +}; + +static int n_exec, n_core; +static struct pmap exec_map[100]; +static struct pmap core_map[100]; + +/* Offsets in the core file of core_context and core_tcontext blocks. */ + +static int context_offset; +static int tcontext_offset[MAXTHREADS]; + +/* Core file control blocks. */ + +static struct core_context_v70 c; +static struct core_tcontext_v70 tc; +static struct user u; +static thread_t th; +static proc_t pr; + +/* The registers of the currently selected thread. */ + +extern char registers[REGISTER_BYTES]; + +/* Vector and communication registers from core dump or from inferior. + These are read on demand, ie, not normally valid. */ + +static struct vecst vector_registers; +static struct creg_ctx comm_registers; + +/* Flag, set on a vanilla CONT command and cleared when the inferior + is continued. */ + +static int all_continue; + +/* Flag, set when the inferior is continued by a vanilla CONT command, + cleared if it is continued for any other purpose. */ + +static int thread_switch_ok; + +/* Stack of signals recieved from threads but not yet delivered to gdb. */ + +struct threadpid +{ + int pid; + int thread; + int signo; + int subsig; + int pc; +}; + +static struct threadpid signal_stack_bot[100]; +static struct threadpid *signal_stack = signal_stack_bot; + +/* How to detect empty stack -- bottom frame is all zero. */ + +#define signal_stack_is_empty() (signal_stack->pid == 0) + +/* Mode controlled by SET PIPE command, controls the psw SEQ bit + which forces each instruction to complete before the next one starts. */ + +static int sequential = 0; + +/* Mode controlled by the SET PARALLEL command. Values are: + 0 concurrency limit 1 thread, dynamic scheduling + 1 no concurrency limit, dynamic scheduling + 2 no concurrency limit, fixed scheduling */ + +static int parallel = 1; + +/* Mode controlled by SET BASE command, output radix for unformatted + integer typeout, as in argument lists, aggregates, and so on. + Zero means guess whether it's an address (hex) or not (decimal). */ + +static int output_radix = 0; + +/* Signal subcode at last thread stop. */ + +static int stop_sigcode; + +/* Hack, see wait() below. */ + +static int exec_trap_timer; + +#include "gdbcmd.h" + +/* Nonzero if we are debugging an attached outside process + rather than an inferior. */ + +extern int attach_flag; + + + +static struct type *vector_type (); +static long *read_vector_register (); +static long *read_vector_register_1 (); +static void write_vector_register (); +static REGISTER_TYPE read_comm_register (); +static void write_comm_register (); +static void convex_cont_command (); +static void thread_continue (); +static void select_thread (); +static void scan_stack (); +static void set_fixed_scheduling (); +static char *subsig_name (); +static void psw_info (); +static sig_noop (); +static ptr_cmp (); + +extern char *sys_siglist[]; + +/* Execute ptrace. Convex V7 replaced ptrace with pattach. + Allow ptrace (0) as a no-op. */ + +int +call_ptrace (request, pid, procaddr, buf) + int request, pid, procaddr, buf; +{ + if (request == 0) + return; + error ("no ptrace"); +} + +/* Replacement for system execle routine. + Convert it to an equivalent exect, which pattach insists on. */ + +execle (name, argv) + char *name, *argv; +{ + char ***envp = (char ***) &argv; + while (*envp++) ; + + signal (SIGTRAP, sig_noop); + exect (name, &argv, *envp); +} + +/* Stupid handler for stupid trace trap that otherwise causes + startup to stupidly hang. */ + +static sig_noop () +{} + +/* Read registers from inferior into registers[] array. + For convex, they are already there, read in when the inferior stops. */ + +void +fetch_inferior_registers (regno) + int regno; +{ +} + +/* Store our register values back into the inferior. + For Convex, do this only once, right before resuming inferior. */ + +store_inferior_registers (regno) + int regno; +{ +} + +/* Copy LEN bytes from inferior's memory starting at MEMADDR + to debugger memory starting at MYADDR. + On failure (cannot read from inferior, usually because address is out + of bounds) returns the value of errno. */ + +int +read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + errno = 0; + while (len > 0) + { + /* little-known undocumented max request size */ + int i = (len < 12288) ? len : 12288; + + lseek (inferior_fd, memaddr, 0); + read (inferior_fd, myaddr, i); + + memaddr += i; + myaddr += i; + len -= i; + } + if (errno) + bzero (myaddr, len); + return errno; +} + +/* Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. + Returns errno on failure (cannot write the inferior) */ + +int +write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + errno = 0; + lseek (inferior_fd, memaddr, 0); + write (inferior_fd, myaddr, len); + return errno; +} + +/* Here from create_inferior when the inferior process has been created + and started up. We must do a pattach to grab it for debugging. + + Also, intercept the CONT command by altering its dispatch address. */ + +create_inferior_hook (pid) + int pid; +{ + static char cont[] = "cont"; + static char cont1[] = "c"; + char *linep = cont; + char *linep1 = cont1; + char **line = &linep; + char **line1 = &linep1; + struct cmd_list_element *c; + + c = lookup_cmd (line, cmdlist, "", 0); + c->function = convex_cont_command; + c = lookup_cmd (line1, cmdlist, "", 0); + c->function = convex_cont_command; + + inferior_fd = pattach (pid, O_EXCL); + if (inferior_fd < 0) + perror_with_name ("pattach"); + inferior_thread = 0; + set_fixed_scheduling (pid, parallel == 2); +} + +/* Attach process PID for debugging. */ + +attach (pid) + int pid; +{ + int fd = pattach (pid, O_EXCL); + if (fd < 0) + perror_with_name ("pattach"); + attach_flag = 1; + /* wait for strange kernel reverberations to go away */ + sleep (1); + + setpgrp (pid, pid); + + inferior_fd = fd; + inferior_thread = 0; + return pid; +} + +/* Stop debugging the process whose number is PID + and continue it with signal number SIGNAL. + SIGNAL = 0 means just continue it. */ + +void +detach (signal) + int signal; +{ + signal_stack = signal_stack_bot; + thread_continue (-1, 0, signal); + ioctl (inferior_fd, PIXDETACH, &ps); + close (inferior_fd); + inferior_fd = 0; + attach_flag = 0; +} + +/* Kill off the inferior process. */ + +kill_inferior () +{ + if (inferior_pid == 0) + return; + ioctl (inferior_fd, PIXTERMINATE, 0); + wait (0); + target_mourn_inferior (); +} + +/* This is used when GDB is exiting. It gives less chance of error.*/ + +kill_inferior_fast () +{ + if (inferior_pid == 0) + return; + ioctl (inferior_fd, PIXTERMINATE, 0); + wait (0); +} + +/* Read vector register REG, and return a pointer to the value. */ + +static long * +read_vector_register (reg) + int reg; +{ + if (have_inferior_p ()) + { + errno = 0; + ps.pi_buffer = (char *) &vector_registers; + ps.pi_nbytes = sizeof vector_registers; + ps.pi_offset = 0; + ps.pi_thread = inferior_thread; + ioctl (inferior_fd, PIXRDVREGS, &ps); + if (errno) + bzero (&vector_registers, sizeof vector_registers); + } + else if (corechan >= 0) + { + lseek (corechan, tcontext_offset[inferior_thread], 0); + if (myread (corechan, &tc, sizeof tc) < 0) + perror_with_name (corefile); + lseek (corechan, tc.core_thread_p, 0); + if (myread (corechan, &th, sizeof th) < 0) + perror_with_name (corefile); + lseek (corechan, tc.core_vregs_p, 0); + if (myread (corechan, &vector_registers, 16*128) < 0) + perror_with_name (corefile); + vector_registers.vm[0] = th.t_vect_ctx.vc_vm[0]; + vector_registers.vm[1] = th.t_vect_ctx.vc_vm[1]; + vector_registers.vls = th.t_vect_ctx.vc_vls; + } + + return read_vector_register_1 (reg); +} + +/* Return a pointer to vector register REG, which must already have been + fetched from the inferior or core file. */ + +static long * +read_vector_register_1 (reg) + int reg; +{ + switch (reg) + { + case VM_REGNUM: + return (long *) vector_registers.vm; + case VS_REGNUM: + return (long *) &vector_registers.vls; + case VL_REGNUM: + return 1 + (long *) &vector_registers.vls; + default: + return (long *) &vector_registers.vr[reg]; + } +} + +/* Write vector register REG, element ELEMENT, new value VAL. + NB: must use read-modify-write on the entire vector state, + since pattach does not do offsetted writes correctly. */ + +static void +write_vector_register (reg, element, val) + int reg, element; + REGISTER_TYPE val; +{ + if (have_inferior_p ()) + { + errno = 0; + ps.pi_thread = inferior_thread; + ps.pi_offset = 0; + ps.pi_buffer = (char *) &vector_registers; + ps.pi_nbytes = sizeof vector_registers; + + ioctl (inferior_fd, PIXRDVREGS, &ps); + + switch (reg) + { + case VL_REGNUM: + vector_registers.vls = + (vector_registers.vls & 0xffffffff00000000LL) + + (unsigned long) val; + break; + + case VS_REGNUM: + vector_registers.vls = + (val << 32) + (unsigned long) vector_registers.vls; + break; + + default: + vector_registers.vr[reg].el[element] = val; + break; + } + + ioctl (inferior_fd, PIXWRVREGS, &ps); + + if (errno) + perror_with_name ("writing vector register"); + } +} + +/* Return the contents of communication register NUM. */ + +static REGISTER_TYPE +read_comm_register (num) + int num; +{ + if (have_inferior_p ()) + { + ps.pi_buffer = (char *) &comm_registers; + ps.pi_nbytes = sizeof comm_registers; + ps.pi_offset = 0; + ps.pi_thread = inferior_thread; + ioctl (inferior_fd, PIXRDCREGS, &ps); + } + return comm_registers.crreg.r4[num]; +} + +/* Store a new value VAL into communication register NUM. + NB: Must use read-modify-write on the whole comm register set + since pattach does not do offsetted writes correctly. */ + +static void +write_comm_register (num, val) + int num; + REGISTER_TYPE val; +{ + if (have_inferior_p ()) + { + ps.pi_buffer = (char *) &comm_registers; + ps.pi_nbytes = sizeof comm_registers; + ps.pi_offset = 0; + ps.pi_thread = inferior_thread; + ioctl (inferior_fd, PIXRDCREGS, &ps); + comm_registers.crreg.r4[num] = val; + ioctl (inferior_fd, PIXWRCREGS, &ps); + } +} + +/* Resume execution of the inferior process. + If STEP is nonzero, single-step it. + If SIGNAL is nonzero, give it that signal. */ + +void +resume (step, signal) + int step; + int signal; +{ + errno = 0; + if (step || signal) + thread_continue (inferior_thread, step, signal); + else + thread_continue (-1, 0, 0); +} + +/* Maybe resume some threads. + THREAD is which thread to resume, or -1 to resume them all. + STEP and SIGNAL are as in resume. + + Global variable ALL_CONTINUE is set when we are here to do a + `cont' command; otherwise we may be doing `finish' or a call or + something else that will not tolerate an automatic thread switch. + + If there are stopped threads waiting to deliver signals, and + ALL_CONTINUE, do not actually resume anything. gdb will do a wait + and see one of the stopped threads in the queue. */ + +static void +thread_continue (thread, step, signal) + int thread, step, signal; +{ + int n; + + /* If we are to continue all threads, but not for the CONTINUE command, + pay no attention and continue only the selected thread. */ + + if (thread < 0 && ! all_continue) + thread = inferior_thread; + + /* If we are not stepping, we have now executed the continue part + of a CONTINUE command. */ + + if (! step) + all_continue = 0; + + /* Allow wait() to switch threads if this is an all-out continue. */ + + thread_switch_ok = thread < 0; + + /* If there are threads queued up, don't resume. */ + + if (thread_switch_ok && ! signal_stack_is_empty ()) + return; + + /* OK, do it. */ + + for (n = 0; n < n_threads; n++) + if (thread_state[n] == PI_TALIVE) + { + select_thread (n); + + if ((thread < 0 || n == thread) && ! thread_is_in_kernel[n]) + { + /* Blam the trace bits in the stack's saved psws to match + the desired step mode. This is required so that + single-stepping a return doesn't restore a psw with a + clear trace bit and fly away, and conversely, + proceeding through a return in a routine that was + stepped into doesn't cause a phantom break by restoring + a psw with the trace bit set. */ + scan_stack (PSW_T_BIT, step); + scan_stack (PSW_S_BIT, sequential); + } + + ps.pi_buffer = registers; + ps.pi_nbytes = REGISTER_BYTES; + ps.pi_offset = 0; + ps.pi_thread = n; + if (! thread_is_in_kernel[n]) + if (ioctl (inferior_fd, PIXWRREGS, &ps)) + perror_with_name ("PIXWRREGS"); + + if (thread < 0 || n == thread) + { + ps.pi_pc = 1; + ps.pi_signo = signal; + if (ioctl (inferior_fd, step ? PIXSTEP : PIXCONTINUE, &ps) < 0) + perror_with_name ("PIXCONTINUE"); + } + } + + if (ioctl (inferior_fd, PIXRUN, &ps) < 0) + perror_with_name ("PIXRUN"); +} + +/* Replacement for system wait routine. + + The system wait returns with one or more threads stopped by + signals. Put stopped threads on a stack and return them one by + one, so that it appears that wait returns one thread at a time. + + Global variable THREAD_SWITCH_OK is set when gdb can tolerate wait + returning a new thread. If it is false, then only one thread is + running; we will do a real wait, the thread will do something, and + we will return that. */ + +pid_t +wait (w) + union wait *w; +{ + int pid; + + if (!w) + return wait3 (0, 0, 0); + + /* Do a real wait if we were told to, or if there are no queued threads. */ + + if (! thread_switch_ok || signal_stack_is_empty ()) + { + int thread; + + pid = wait3 (w, 0, 0); + + if (!WIFSTOPPED (*w) || pid != inferior_pid) + return pid; + + /* The inferior has done something and stopped. Read in all the + threads' registers, and queue up any signals that happened. */ + + if (ioctl (inferior_fd, PIXGETTHCOUNT, &ps) < 0) + perror_with_name ("PIXGETTHCOUNT"); + + n_threads = ps.pi_othdcnt; + for (thread = 0; thread < n_threads; thread++) + { + ps.pi_thread = thread; + if (ioctl (inferior_fd, PIXGETSUBCODE, &ps) < 0) + perror_with_name ("PIXGETSUBCODE"); + thread_state[thread] = ps.pi_otstate; + + if (ps.pi_otstate == PI_TALIVE) + { + select_thread (thread); + ps.pi_buffer = registers; + ps.pi_nbytes = REGISTER_BYTES; + ps.pi_offset = 0; + ps.pi_thread = thread; + if (ioctl (inferior_fd, PIXRDREGS, &ps) < 0) + perror_with_name ("PIXRDREGS"); + + registers_fetched (); + + thread_pc[thread] = read_pc (); + thread_signal[thread] = ps.pi_osigno; + thread_sigcode[thread] = ps.pi_osigcode; + + /* If the thread's stack has a context frame + on top, something fucked is going on. I do not + know what, but do I know this: the only thing you + can do with such a thread is continue it. */ + + thread_is_in_kernel[thread] = + ((read_register (PS_REGNUM) >> 25) & 3) == 0; + + /* Signals push an extended frame and then fault + with a ridiculous pc. Pop the frame. */ + + if (thread_pc[thread] > STACK_END_ADDR) + { + POP_FRAME; + if (is_break_pc (thread_pc[thread])) + thread_pc[thread] = read_pc () - 2; + else + thread_pc[thread] = read_pc (); + write_register (PC_REGNUM, thread_pc[thread]); + } + + if (ps.pi_osigno || ps.pi_osigcode) + { + signal_stack++; + signal_stack->pid = pid; + signal_stack->thread = thread; + signal_stack->signo = thread_signal[thread]; + signal_stack->subsig = thread_sigcode[thread]; + signal_stack->pc = thread_pc[thread]; + } + + /* The following hackery is caused by a unix 7.1 feature: + the inferior's fixed scheduling mode is cleared when + it execs the shell (since the shell is not a parallel + program). So, note the 5.4 trap we get when + the shell does its exec, then catch the 5.0 trap + that occurs when the debuggee starts, and set fixed + scheduling mode properly. */ + + if (ps.pi_osigno == 5 && ps.pi_osigcode == 4) + exec_trap_timer = 1; + else + exec_trap_timer--; + + if (ps.pi_osigno == 5 && exec_trap_timer == 0) + set_fixed_scheduling (pid, parallel == 2); + } + } + + if (signal_stack_is_empty ()) + error ("no active threads?!"); + } + + /* Select the thread that stopped, and return *w saying why. */ + + select_thread (signal_stack->thread); + + stop_signal = signal_stack->signo; + stop_sigcode = signal_stack->subsig; + + WSETSTOP (*w, signal_stack->signo); + w->w_thread = signal_stack->thread; + return (signal_stack--)->pid; +} + +/* Select thread THREAD -- its registers, stack, per-thread memory. + This is the only routine that may assign to inferior_thread + or thread_regs[]. */ + +static void +select_thread (thread) + int thread; +{ + if (thread == inferior_thread) + return; + + bcopy (registers, thread_regs[inferior_thread], REGISTER_BYTES); + ps.pi_thread = inferior_thread = thread; + if (have_inferior_p ()) + ioctl (inferior_fd, PISETRWTID, &ps); + bcopy (thread_regs[thread], registers, REGISTER_BYTES); +} + +/* Routine to set or clear a psw bit in the psw and also all psws + saved on the stack. Quits when we get to a frame in which the + saved psw is correct. */ + +static void +scan_stack (bit, val) + long bit, val; +{ + long ps = read_register (PS_REGNUM); + long fp; + if (val ? !(ps & bit) : (ps & bit)) + { + ps ^= bit; + write_register (PS_REGNUM, ps); + + fp = read_register (FP_REGNUM); + while (fp & 0x80000000) + { + ps = read_memory_integer (fp + 4, 4); + if (val ? (ps & bit) : !(ps & bit)) + break; + ps ^= bit; + write_memory (fp + 4, &ps, 4); + fp = read_memory_integer (fp + 8, 4); + } + } +} + +/* Set fixed scheduling (alliant mode) of process PID to ARG (0 or 1). */ + +static void +set_fixed_scheduling (pid, arg) + int arg; +{ + struct pattributes pattr; + getpattr (pid, &pattr); + pattr.pattr_pfixed = arg; + setpattr (pid, &pattr); +} + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int n; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + n_core = 0; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + + if (myread (corechan, &filehdr, sizeof filehdr) < 0) + perror_with_name (filename); + + if (!IS_CORE_SOFF_MAGIC (filehdr.h_magic)) + error ("%s: not a core file.\n", filename); + + if (myread (corechan, &opthdr, filehdr.h_opthdr) < 0) + perror_with_name (filename); + + /* Read through the section headers. + For text, data, etc, record an entry in the core file map. + For context and tcontext, record the file address of + the context blocks. */ + + lseek (corechan, (long) filehdr.h_scnptr, 0); + + n_threads = 0; + for (n = 0; n < filehdr.h_nscns; n++) + { + if (myread (corechan, &scnhdr, sizeof scnhdr) < 0) + perror_with_name (filename); + if ((scnhdr.s_flags & S_TYPMASK) >= S_TEXT + && (scnhdr.s_flags & S_TYPMASK) <= S_COMON) + { + core_map[n_core].mem_addr = scnhdr.s_vaddr; + core_map[n_core].mem_end = scnhdr.s_vaddr + scnhdr.s_size; + core_map[n_core].file_addr = scnhdr.s_scnptr; + core_map[n_core].type = scnhdr.s_flags & S_TYPMASK; + if (core_map[n_core].type != S_TBSS + && core_map[n_core].type != S_TDATA + && core_map[n_core].type != S_TTEXT) + core_map[n_core].thread = -1; + else if (n_core == 0 + || core_map[n_core-1].mem_addr != scnhdr.s_vaddr) + core_map[n_core].thread = 0; + else + core_map[n_core].thread = core_map[n_core-1].thread + 1; + n_core++; + } + else if ((scnhdr.s_flags & S_TYPMASK) == S_CONTEXT) + context_offset = scnhdr.s_scnptr; + else if ((scnhdr.s_flags & S_TYPMASK) == S_TCONTEXT) + tcontext_offset[n_threads++] = scnhdr.s_scnptr; + } + + /* Read the context block, struct user, struct proc, + and the comm regs. */ + + lseek (corechan, context_offset, 0); + if (myread (corechan, &c, sizeof c) < 0) + perror_with_name (filename); + lseek (corechan, c.core_user_p, 0); + if (myread (corechan, &u, sizeof u) < 0) + perror_with_name (filename); + lseek (corechan, c.core_proc_p, 0); + if (myread (corechan, &pr, sizeof pr) < 0) + perror_with_name (filename); + comm_registers = pr.p_creg; + + /* Core file apparently is really there. Make it really exist + for xfer_core_file so we can do read_memory on it. */ + + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + corefile = concat (current_directory, "/", filename); + + printf_filtered ("Program %s ", u.u_comm); + + /* Read the thread registers and fill in the thread_xxx[] data. */ + + for (n = 0; n < n_threads; n++) + { + select_thread (n); + + lseek (corechan, tcontext_offset[n], 0); + if (myread (corechan, &tc, sizeof tc) < 0) + perror_with_name (corefile); + lseek (corechan, tc.core_thread_p, 0); + if (myread (corechan, &th, sizeof th) < 0) + perror_with_name (corefile); + + lseek (corechan, tc.core_syscall_context_p, 0); + if (myread (corechan, registers, REGISTER_BYTES) < 0) + perror_with_name (corefile); + + thread_signal[n] = th.t_cursig; + thread_sigcode[n] = th.t_code; + thread_state[n] = th.t_state; + thread_pc[n] = read_pc (); + + if (thread_pc[n] > STACK_END_ADDR) + { + POP_FRAME; + if (is_break_pc (thread_pc[n])) + thread_pc[n] = read_pc () - 2; + else + thread_pc[n] = read_pc (); + write_register (PC_REGNUM, thread_pc[n]); + } + + printf_filtered ("thread %d received signal %d, %s\n", + n, thread_signal[n], + thread_signal[n] < NSIG + ? sys_siglist[thread_signal[n]] + : "(undocumented)"); + } + + /* Select an interesting thread -- also-rans died with SIGKILL, + so find one that didn't. */ + + for (n = 0; n < n_threads; n++) + if (thread_signal[n] != 0 && thread_signal[n] != SIGKILL) + { + select_thread (n); + stop_signal = thread_signal[n]; + stop_sigcode = thread_sigcode[n]; + break; + } + + core_aouthdr.a_magic = 0; + + flush_cached_frames (); + set_current_frame (create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + validate_files (); + + print_sel_frame (1); + } + else if (from_tty) + printf_filtered ("No core file now.\n"); +} diff --git a/gdb/core.c b/gdb/core.c new file mode 100644 index 0000000..2936e46 --- /dev/null +++ b/gdb/core.c @@ -0,0 +1,447 @@ +/* Work with core dump and executable files, for GDB. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <errno.h> +#include <signal.h> +#include "defs.h" +#include "param.h" +#include "frame.h" /* required by inferior.h */ +#include "inferior.h" +#include "symtab.h" +#include "command.h" +#include "bfd.h" +#include "target.h" +#include "gdbcore.h" + +extern int xfer_memory (); +extern void child_attach (), child_create_inferior (); + +extern int sys_nerr; +extern char *sys_errlist[]; +extern char *sys_siglist[]; + +extern char registers[]; + +/* Hook for `exec_file_command' command to call. */ + +void (*exec_file_display_hook) () = NULL; + +struct section_table *core_sections, *core_sections_end; + +/* Binary file diddling handle for the core file. */ + +bfd *core_bfd = NULL; + +/* Forward decl */ +extern struct target_ops core_ops; + + +/* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + +void +core_close (quitting) + int quitting; +{ + if (core_bfd) { + free (bfd_get_filename (core_bfd)); + bfd_close (core_bfd); + core_bfd = NULL; + } +} + +/* This routine opens and sets up the core file bfd */ + +void +core_open (filename, from_tty) + char *filename; + int from_tty; +{ + char *p; + int siggy; + struct cleanup *old_chain; + char *temp; + bfd *temp_bfd; + int ontop; + + if (!filename) + { + error (core_bfd? + "No core file specified. (Use `detach' to stop debugging a core file.)" + : "No core file specified."); + } + + filename = tilde_expand (filename); + if (filename[0] != '/') { + temp = concat (current_directory, "/", filename); + free (filename); + filename = temp; + } + + old_chain = make_cleanup (free, filename); + temp_bfd = bfd_openr (filename, NULL); + if (temp_bfd == NULL) + { + perror_with_name (filename); + } + + if (!bfd_check_format (temp_bfd, bfd_core)) + { + bfd_close (temp_bfd); + error ("\"%s\" does not appear to be a core dump", filename); + } + + /* Looks semi-reasonable. Toss the old core file and work on the new. */ + + discard_cleanups (old_chain); /* Don't free filename any more */ + unpush_target (&core_ops); + core_bfd = temp_bfd; + old_chain = make_cleanup (core_close, core_bfd); + + validate_files (); + + /* Find the data section */ + if (build_section_table (core_bfd, &core_sections, &core_sections_end)) + error ("Can't find sections in `%s': %s", bfd_get_filename(core_bfd), + bfd_errmsg (bfd_error)); + + ontop = !push_target (&core_ops); + + p = bfd_core_file_failing_command (core_bfd); + if (p) + printf ("Core file invoked as `%s'.\n", p); + + siggy = bfd_core_file_failing_signal (core_bfd); + if (siggy > 0) + printf ("Program terminated with signal %d, %s.\n", siggy, + siggy < NSIG ? sys_siglist[siggy] : "(undocumented)"); + + if (ontop) { + /* Fetch all registers from core file */ + target_fetch_registers (-1); + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + /* FIXME, handle shared library reading here. */ + print_sel_frame (0); /* Print the top frame and source line */ + } else { + printf ( +"Warning: you won't be able to access this core file until you terminate\n\ +your %s; do ``info files''\n", current_target->to_longname); + } + + discard_cleanups (old_chain); +} + +void +core_detach (args, from_tty) + char *args; + int from_tty; +{ + dont_repeat (); + if (args) + error ("Too many arguments"); + pop_target (); + if (from_tty) + printf ("No core file now.\n"); +} + +/* Backward compatability with old way of specifying core files. */ + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + if (!filename) + core_detach (filename, from_tty); + else + core_open (filename, from_tty); +} + + +/* Call this to specify the hook for exec_file_command to call back. + This is called from the x-window display code. */ + +void +specify_exec_file_hook (hook) + void (*hook) (); +{ + exec_file_display_hook = hook; +} + +/* The exec file must be closed before running an inferior. + If it is needed again after the inferior dies, it must + be reopened. */ + +void +close_exec_file () +{ +#ifdef FIXME + if (exec_bfd) + bfd_tempclose (exec_bfd); +#endif +} + +void +reopen_exec_file () +{ +#ifdef FIXME + if (exec_bfd) + bfd_reopen (exec_bfd); +#endif +} + +/* If we have both a core file and an exec file, + print a warning if they don't go together. + This should really check that the core file came + from that exec file, but I don't know how to do it. */ + +void +validate_files () +{ + if (exec_bfd && core_bfd) + { + if (core_file_matches_executable_p (core_bfd, exec_bfd)) + printf ("Warning: core file does not match specified executable file.\n"); + else if (bfd_get_mtime(exec_bfd) > bfd_get_mtime(core_bfd)) + printf ("Warning: exec file is newer than core file.\n"); + } +} + +/* Return the name of the executable file as a string. + ERR nonzero means get error if there is none specified; + otherwise return 0 in that case. */ + +char * +get_exec_file (err) + int err; +{ + if (exec_bfd) return bfd_get_filename(exec_bfd); + if (!err) return NULL; + + error ("No executable file specified.\n\ +Use the \"file\" or \"exec-file\" command."); + return NULL; +} + +static void +core_files_info () +{ + struct section_table *p; + + printf ("\tCore file `%s'.\n", bfd_get_filename(core_bfd)); + + for (p = core_sections; p < core_sections_end; p++) + printf("\tcore file from 0x%08x to 0x%08x is %s\n", + p->addr, p->endaddr, + bfd_section_name (core_bfd, p->sec_ptr)); +} + +void +memory_error (status, memaddr) + int status; + CORE_ADDR memaddr; +{ + + if (status == EIO) + { + /* Actually, address between memaddr and memaddr + len + was out of bounds. */ + error ("Cannot access memory: address 0x%x out of bounds.", memaddr); + } + else + { + if (status >= sys_nerr || status < 0) + error ("Error accessing memory address 0x%x: unknown error (%d).", + memaddr, status); + else + error ("Error accessing memory address 0x%x: %s.", + memaddr, sys_errlist[status]); + } +} + +/* Same as target_read_memory, but report an error if can't read. */ +void +read_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int status; + status = target_read_memory (memaddr, myaddr, len); + if (status != 0) + memory_error (status, memaddr); +} + +/* Same as target_write_memory, but report an error if can't write. */ +void +write_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int status; + + status = target_write_memory (memaddr, myaddr, len); + if (status != 0) + memory_error (status, memaddr); +} + +/* Read an integer from debugged memory, given address and number of bytes. */ + +long +read_memory_integer (memaddr, len) + CORE_ADDR memaddr; + int len; +{ + char cbuf; + short sbuf; + int ibuf; + long lbuf; + + if (len == sizeof (char)) + { + read_memory (memaddr, &cbuf, len); + return cbuf; + } + if (len == sizeof (short)) + { + read_memory (memaddr, (char *)&sbuf, len); + SWAP_TARGET_AND_HOST (&sbuf, sizeof (short)); + return sbuf; + } + if (len == sizeof (int)) + { + read_memory (memaddr, (char *)&ibuf, len); + SWAP_TARGET_AND_HOST (&ibuf, sizeof (int)); + return ibuf; + } + if (len == sizeof (lbuf)) + { + read_memory (memaddr, (char *)&lbuf, len); + SWAP_TARGET_AND_HOST (&lbuf, sizeof (lbuf)); + return lbuf; + } + error ("Cannot handle integers of %d bytes.", len); + return -1; /* for lint */ +} + +/* Read or write the core file. + + Args are address within core file, address within gdb address-space, + length, and a flag indicating whether to read or write. + + Result is a length: + + 0: We cannot handle this address and length. + > 0: We have handled N bytes starting at this address. + (If N == length, we did it all.) We might be able + to handle more bytes beyond this length, but no + promises. + < 0: We cannot handle this address, but if somebody + else handles (-N) bytes, we can start from there. + + The actual work is done by xfer_memory in exec.c, which we share + in common with exec_xfer_memory(). */ + +static int +core_xfer_memory (memaddr, myaddr, len, write) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; +{ + return xfer_memory (memaddr, myaddr, len, write, + core_bfd, core_sections, core_sections_end); +} + +/* Get the registers out of a core file. This is the machine- + independent part. Fetch_core_registers is the machine-dependent + part, typically implemented in the xm-file for each architecture. */ + +static int +get_core_registers (regno) + int regno; +{ + sec_ptr reg_sec; + unsigned size; + char *the_regs; + + reg_sec = bfd_get_section_by_name (core_bfd, ".reg"); + size = bfd_section_size (core_bfd, reg_sec); + the_regs = alloca (size); + if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, + (unsigned)0, size)) + { + fetch_core_registers (the_regs, size, 0); + } + else + { + fprintf (stderr, "Couldn't fetch registers from core file: %s\n", + bfd_errmsg (bfd_error)); + } + + /* Now do it again for the float registers, if they exist. */ + reg_sec = bfd_get_section_by_name (core_bfd, ".reg2"); + if (reg_sec) { + size = bfd_section_size (core_bfd, reg_sec); + the_regs = alloca (size); + if (bfd_get_section_contents (core_bfd, reg_sec, the_regs, + (unsigned)0, size)) + { + fetch_core_registers (the_regs, size, 2); + } + else + { + fprintf (stderr, "Couldn't fetch register set 2 from core file: %s\n", + bfd_errmsg (bfd_error)); + } + } + registers_fetched(); + return 0; /* FIXME, what result goes here? */ +} + +struct target_ops core_ops = { + "core", "Local core dump file", + core_open, core_close, + child_attach, core_detach, 0, 0, /* resume, wait */ + get_core_registers, + 0, 0, 0, 0, /* store_regs, prepare_to_store, conv_to, conv_from */ + core_xfer_memory, core_files_info, + 0, 0, /* core_insert_breakpoint, core_remove_breakpoint, */ + 0, 0, 0, 0, 0, /* terminal stuff */ + 0, 0, 0, 0, 0, /* kill, load, add_syms, call fn, lookup sym */ + child_create_inferior, 0, /* mourn_inferior */ + core_stratum, 0, /* next */ + 0, 1, 1, 1, 0, /* all mem, mem, stack, regs, exec */ + OPS_MAGIC, /* Always the last thing */ +}; + +void +_initialize_core() +{ + + add_com ("core-file", class_files, core_file_command, + "Use FILE as core dump for examining memory and registers.\n\ +No arg means have no core file. This command has been superseded by the\n\ +`target core' and `detach' commands."); + add_target (&core_ops); +} diff --git a/gdb/coredep.c b/gdb/coredep.c new file mode 100644 index 0000000..ea1c273 --- /dev/null +++ b/gdb/coredep.c @@ -0,0 +1,86 @@ +/* Extract registers from a "standard" core file, for GDB. + Copyright (C) 1988-1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* core.c is supposed to be the more machine-independent aspects of this; + this file is more machine-specific. */ + +#include "defs.h" +#include "param.h" +#include "gdbcore.h" + +/* Some of these are needed on various systems, perhaps, to expand + REGISTER_U_ADDR appropriately? */ +/* #include <sys/core.h> */ +#include <sys/param.h> +#include <sys/dir.h> +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/user.h> + + +/* Extract the register values out of the core file and store + them where `read_register' will find them. */ + +void +fetch_core_registers (core_reg_sect, core_reg_size) + char *core_reg_sect; + unsigned core_reg_size; +{ + register int regno; + register unsigned int addr; + int bad_reg = -1; + + for (regno = 0; regno < NUM_REGS; regno++) + { + addr = register_addr (regno, core_reg_size); + if (addr >= core_reg_size) { + if (bad_reg < 0) + bad_reg = regno; + } else { + supply_register (regno, core_reg_sect + addr); + } + } + if (bad_reg > 0) + { + error ("Register %s not found in core file.", reg_names[bad_reg]); + } +} + + +#ifdef REGISTER_U_ADDR + +/* Return the address in the core dump or inferior of register REGNO. + BLOCKEND is the address of the end of the user structure. */ + +unsigned int +register_addr (regno, blockend) + int regno; + int blockend; +{ + int addr; + + if (regno < 0 || regno >= NUM_REGS) + error ("Invalid register number %d.", regno); + + REGISTER_U_ADDR (addr, blockend, regno); + + return addr; +} + +#endif /* REGISTER_U_ADDR */ diff --git a/gdb/cplus-dem.c b/gdb/cplus-dem.c new file mode 100644 index 0000000..48109d8 --- /dev/null +++ b/gdb/cplus-dem.c @@ -0,0 +1,1001 @@ +/* Demangler for GNU C++ + Copyright (C) 1989 Free Software Foundation, Inc. + written by James Clark (jjc@jclark.uucp) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is for g++ 1.36.1 (November 6 version). It will probably + require changes for any other version. + + Modified for g++ 1.36.2 (November 18 version). */ + +/* This file exports one function + + char *cplus_demangle (const char *name, int mode) + + If NAME is a mangled function name produced by GNU C++, then + a pointer to a malloced string giving a C++ representation + of the name will be returned; otherwise NULL will be returned. + It is the caller's responsibility to free the string which + is returned. + + If MODE > 0, then ANSI qualifiers such as `const' and `void' are output. + Otherwise they are not. + If MODE >= 0, parameters are emitted; otherwise not. + + For example, + + cplus_demangle ("foo__1Ai", 0) => "A::foo(int)" + cplus_demangle ("foo__1Ai", 1) => "A::foo(int)" + cplus_demangle ("foo__1Ai", -1) => "A::foo" + + cplus_demangle ("foo__1Afe", 0) => "A::foo(float,...)" + cplus_demangle ("foo__1Afe", 1) => "A::foo(float,...)" + cplus_demangle ("foo__1Afe", -1) => "A::foo" + + This file imports xmalloc and xrealloc, which are like malloc and + realloc except that they generate a fatal error if there is no + available memory. */ + +/* define this if names don't start with _ */ +/* #define nounderscore 1 */ + +#include <stdio.h> +#include <ctype.h> + +#ifdef USG +#include <memory.h> +#include <string.h> +#else +#include <strings.h> +#define memcpy(s1, s2, n) bcopy ((s2), (s1), (n)) +#define memcmp(s1, s2, n) bcmp ((s2), (s1), (n)) +#define strchr index +#define strrchr rindex +#endif + +#ifndef __STDC__ +#define const +#endif + +#ifdef __STDC__ +extern char *cplus_demangle (const char *type, int mode); +#else +extern char *cplus_demangle (); +#endif + +#ifdef __STDC__ +extern char *xmalloc (int); +extern char *xrealloc (char *, int); +extern void free (char *); +#else +extern char *xmalloc (); +extern char *xrealloc (); +extern void free (); +#endif + +static char **typevec = 0; +static int ntypes = 0; +static int typevec_size = 0; + +static struct { + const char *in; + const char *out; +} optable[] = { + "new", " new", + "delete", " delete", + "ne", "!=", + "eq", "==", + "ge", ">=", + "gt", ">", + "le", "<=", + "lt", "<", + "plus", "+", + "minus", "-", + "mult", "*", + "convert", "+", /* unary + */ + "negate", "-", /* unary - */ + "trunc_mod", "%", + "trunc_div", "/", + "truth_andif", "&&", + "truth_orif", "||", + "truth_not", "!", + "postincrement", "++", + "postdecrement", "--", + "bit_ior", "|", + "bit_xor", "^", + "bit_and", "&", + "bit_not", "~", + "call", "()", + "cond", "?:", + "alshift", "<<", + "arshift", ">>", + "component", "->", + "indirect", "*", + "method_call", "->()", + "addr", "&", /* unary & */ + "array", "[]", + "nop", "", /* for operator= */ +}; + +/* Beware: these aren't '\0' terminated. */ + +typedef struct { + char *b; /* pointer to start of string */ + char *p; /* pointer after last character */ + char *e; /* pointer after end of allocated space */ +} string; + +#ifdef __STDC__ +static void string_need (string *s, int n); +static void string_delete (string *s); +static void string_init (string *s); +static void string_clear (string *s); +static int string_empty (string *s); +static void string_append (string *p, const char *s); +static void string_appends (string *p, string *s); +static void string_appendn (string *p, const char *s, int n); +static void string_prepend (string *p, const char *s); +#if 0 +static void string_prepends (string *p, string *s); +#endif +static void string_prependn (string *p, const char *s, int n); +static int get_count (const char **type, int *count); +static int do_args (const char **type, string *decl, int arg_mode); +static int do_type (const char **type, string *result, int arg_mode); +static int do_arg (const char **type, string *result, int arg_mode); +static void munge_function_name (string *name, int arg_mode); +static void remember_type (const char *type, int len); +#else +static void string_need (); +static void string_delete (); +static void string_init (); +static void string_clear (); +static int string_empty (); +static void string_append (); +static void string_appends (); +static void string_appendn (); +static void string_prepend (); +#if 0 +static void string_prepends (); +#endif +static void string_prependn (); +static int get_count (); +static int do_args (); +static int do_type (); +static int do_arg (); +static int do_args (); +static void munge_function_name (); +static void remember_type (); +#endif + +char * +cplus_demangle (type, arg_mode) + const char *type; + int arg_mode; +{ + string decl; + int n; + int success = 0; + int constructor = 0; + int const_flag = 0; + int i; + const char *p; +#ifndef LONGERNAMES + const char *premangle; +#endif + +# define print_ansi_qualifiers (arg_mode > 0) +# define print_arg_types (arg_mode >= 0) + + if (type == NULL || *type == '\0') + return NULL; +#ifndef nounderscore + if (*type++ != '_') + return NULL; +#endif + p = type; + while (*p != '\0' && !(*p == '_' && p[1] == '_')) + p++; + if (*p == '\0') + { + /* destructor */ + if (type[0] == '_' && type[1] == '$' && type[2] == '_') + { + int n = (strlen (type) - 3)*2 + 3 + 2 + 1; + char *tem = (char *) xmalloc (n); + strcpy (tem, type + 3); + strcat (tem, "::~"); + strcat (tem, type + 3); + strcat (tem, "()"); + return tem; + } + /* static data member */ + if (*type != '_' && (p = strchr (type, '$')) != NULL) + { + int n = strlen (type) + 2; + char *tem = (char *) xmalloc (n); + memcpy (tem, type, p - type); + strcpy (tem + (p - type), "::"); + strcpy (tem + (p - type) + 2, p + 1); + return tem; + } + /* virtual table "_vt$" */ + if (type[0] == '_' && type[1] == 'v' && type[2] == 't' && type[3] == '$') + { + int n = strlen (type + 4) + 14 + 1; + char *tem = (char *) xmalloc (n); + strcpy (tem, type + 4); + strcat (tem, " virtual table"); + return tem; + } + return NULL; + } + + string_init (&decl); + + if (p == type) + { + if (!isdigit (p[2])) + { + string_delete (&decl); + return NULL; + } + constructor = 1; + } + else + { + string_appendn (&decl, type, p - type); + munge_function_name (&decl, arg_mode); + } + p += 2; + +#ifndef LONGERNAMES + premangle = p; +#endif + switch (*p) + { + case 'C': + /* a const member function */ + if (!isdigit (p[1])) + { + string_delete (&decl); + return NULL; + } + p += 1; + const_flag = 1; + /* fall through */ + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do + { + n *= 10; + n += *p - '0'; + p += 1; + } + while (isdigit (*p)); + if (strlen (p) < n) + { + string_delete (&decl); + return NULL; + } + if (constructor) + { + string_appendn (&decl, p, n); + string_append (&decl, "::"); + string_appendn (&decl, p, n); + } + else + { + string_prepend (&decl, "::"); + string_prependn (&decl, p, n); + } + p += n; +#ifndef LONGERNAMES + remember_type (premangle, p - premangle); +#endif + success = do_args (&p, &decl, arg_mode); + if (const_flag && print_arg_types) + string_append (&decl, " const"); + break; + case 'F': + p += 1; + success = do_args (&p, &decl, arg_mode); + break; + } + + for (i = 0; i < ntypes; i++) + if (typevec[i] != NULL) + free (typevec[i]); + ntypes = 0; + if (typevec != NULL) + { + free ((char *)typevec); + typevec = NULL; + typevec_size = 0; + } + + if (success) + { + string_appendn (&decl, "", 1); + return decl.b; + } + else + { + string_delete (&decl); + return NULL; + } +} + +static int +get_count (type, count) + const char **type; + int *count; +{ + if (!isdigit (**type)) + return 0; + *count = **type - '0'; + *type += 1; + /* see flush_repeats in cplus-method.c */ + if (isdigit (**type)) + { + const char *p = *type; + int n = *count; + do + { + n *= 10; + n += *p - '0'; + p += 1; + } + while (isdigit (*p)); + if (*p == '_') + { + *type = p + 1; + *count = n; + } + } + return 1; +} + +/* result will be initialised here; it will be freed on failure */ + +static int +do_type (type, result, arg_mode) + const char **type; + string *result; + int arg_mode; +{ + int n; + int done; + int non_empty = 0; + int success; + string decl; + const char *remembered_type; + + string_init (&decl); + string_init (result); + + done = 0; + success = 1; + while (success && !done) + { + int member; + switch (**type) + { + case 'P': + *type += 1; + string_prepend (&decl, "*"); + break; + + case 'R': + *type += 1; + string_prepend (&decl, "&"); + break; + + case 'T': + *type += 1; + if (!get_count (type, &n) || n >= ntypes) + success = 0; + else + { + remembered_type = typevec[n]; + type = &remembered_type; + } + break; + + case 'F': + *type += 1; + if (!string_empty (&decl) && decl.b[0] == '*') + { + string_prepend (&decl, "("); + string_append (&decl, ")"); + } + if (!do_args (type, &decl, arg_mode) || **type != '_') + success = 0; + else + *type += 1; + break; + + case 'M': + case 'O': + { + int constp = 0; + int volatilep = 0; + + member = **type == 'M'; + *type += 1; + if (!isdigit (**type)) + { + success = 0; + break; + } + n = 0; + do + { + n *= 10; + n += **type - '0'; + *type += 1; + } + while (isdigit (**type)); + if (strlen (*type) < n) + { + success = 0; + break; + } + string_append (&decl, ")"); + string_prepend (&decl, "::"); + string_prependn (&decl, *type, n); + string_prepend (&decl, "("); + *type += n; + if (member) + { + if (**type == 'C') + { + *type += 1; + constp = 1; + } + if (**type == 'V') + { + *type += 1; + volatilep = 1; + } + if (*(*type)++ != 'F') + { + success = 0; + break; + } + } + if ((member && !do_args (type, &decl, arg_mode)) || **type != '_') + { + success = 0; + break; + } + *type += 1; + if (! print_ansi_qualifiers) + break; + if (constp) + { + if (non_empty) + string_append (&decl, " "); + else + non_empty = 1; + string_append (&decl, "const"); + } + if (volatilep) + { + if (non_empty) + string_append (&decl, " "); + else + non_empty = 1; + string_append (&decl, "volatile"); + } + break; + } + + case 'C': + if ((*type)[1] == 'P') + { + *type += 1; + if (print_ansi_qualifiers) + { + if (!string_empty (&decl)) + string_prepend (&decl, " "); + string_prepend (&decl, "const"); + } + break; + } + + /* fall through */ + default: + done = 1; + break; + } + } + + done = 0; + non_empty = 0; + while (success && !done) + { + switch (**type) + { + case 'C': + *type += 1; + if (print_ansi_qualifiers) + { + if (non_empty) + string_append (result, " "); + else + non_empty = 1; + string_append (result, "const"); + } + break; + case 'U': + *type += 1; + if (non_empty) + string_append (result, " "); + else + non_empty = 1; + string_append (result, "unsigned"); + break; + case 'V': + *type += 1; + if (print_ansi_qualifiers) + { + if (non_empty) + string_append (result, " "); + else + non_empty = 1; + string_append (result, "volatile"); + } + break; + default: + done = 1; + break; + } + } + + if (success) + switch (**type) + { + case '\0': + case '_': + break; + case 'v': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "void"); + break; + case 'x': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "long long"); + break; + case 'l': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "long"); + break; + case 'i': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "int"); + break; + case 's': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "short"); + break; + case 'c': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "char"); + break; + case 'r': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "long double"); + break; + case 'd': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "double"); + break; + case 'f': + *type += 1; + if (non_empty) + string_append (result, " "); + string_append (result, "float"); + break; + case 'G': + *type += 1; + if (!isdigit (**type)) + { + success = 0; + break; + } + /* fall through */ + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + n = 0; + do + { + n *= 10; + n += **type - '0'; + *type += 1; + } + while (isdigit (**type)); + if (strlen (*type) < n) + { + success = 0; + break; + } + if (non_empty) + string_append (result, " "); + string_appendn (result, *type, n); + *type += n; + break; + default: + success = 0; + break; + } + + if (success) + { + if (!string_empty (&decl)) + { + string_append (result, " "); + string_appends (result, &decl); + } + string_delete (&decl); + return 1; + } + else + { + string_delete (&decl); + string_delete (result); + return 0; + } +} + +/* `result' will be initialised in do_type; it will be freed on failure */ + +static int +do_arg (type, result, arg_mode) + const char **type; + string *result; + int arg_mode; +{ + const char *start = *type; + + if (!do_type (type, result, arg_mode)) + return 0; + remember_type (start, *type - start); + return 1; +} + +static void +remember_type (start, len) + const char *start; + int len; +{ + char *tem; + + if (ntypes >= typevec_size) + { + if (typevec_size == 0) + { + typevec_size = 3; + typevec = (char **) xmalloc (sizeof (char*)*typevec_size); + } + else + { + typevec_size *= 2; + typevec = (char **) xrealloc ((char *)typevec, sizeof (char*)*typevec_size); + } + } + tem = (char *) xmalloc (len + 1); + memcpy (tem, start, len); + tem[len] = '\0'; + typevec[ntypes++] = tem; +} + +/* `decl' must be already initialised, usually non-empty; + it won't be freed on failure */ + +static int +do_args (type, decl, arg_mode) + const char **type; + string *decl; + int arg_mode; +{ + string arg; + int need_comma = 0; + + if (print_arg_types) + string_append (decl, "("); + + while (**type != '_' && **type != '\0' && **type != 'e' && **type != 'v') + { + if (**type == 'N') + { + int r; + int t; + *type += 1; + if (!get_count (type, &r) || !get_count (type, &t) || t >= ntypes) + return 0; + while (--r >= 0) + { + const char *tem = typevec[t]; + if (need_comma && print_arg_types) + string_append (decl, ", "); + if (!do_arg (&tem, &arg, arg_mode)) + return 0; + if (print_arg_types) + string_appends (decl, &arg); + string_delete (&arg); + need_comma = 1; + } + } + else + { + if (need_comma & print_arg_types) + string_append (decl, ", "); + if (!do_arg (type, &arg, arg_mode)) + return 0; + if (print_arg_types) + string_appends (decl, &arg); + string_delete (&arg); + need_comma = 1; + } + } + + if (**type == 'v') + *type += 1; + else if (**type == 'e') + { + *type += 1; + if (print_arg_types) + { + if (need_comma) + string_append (decl, ","); + string_append (decl, "..."); + } + } + + if (print_arg_types) + string_append (decl, ")"); + return 1; +} + +static void +munge_function_name (name, arg_mode) + string *name; + int arg_mode; +{ + if (!string_empty (name) && name->p - name->b >= 3 + && name->b[0] == 'o' && name->b[1] == 'p' && name->b[2] == '$') + { + int i; + /* see if it's an assignment expression */ + if (name->p - name->b >= 10 /* op$assign_ */ + && memcmp (name->b + 3, "assign_", 7) == 0) + { + for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) + { + int len = name->p - name->b - 10; + if (strlen (optable[i].in) == len + && memcmp (optable[i].in, name->b + 10, len) == 0) + { + string_clear (name); + string_append (name, "operator"); + string_append (name, optable[i].out); + string_append (name, "="); + return; + } + } + } + else + { + for (i = 0; i < sizeof (optable)/sizeof (optable[0]); i++) + { + int len = name->p - name->b - 3; + if (strlen (optable[i].in) == len + && memcmp (optable[i].in, name->b + 3, len) == 0) + { + string_clear (name); + string_append (name, "operator"); + string_append (name, optable[i].out); + return; + } + } + } + return; + } + else if (!string_empty (name) && name->p - name->b >= 5 + && memcmp (name->b, "type$", 5) == 0) + { + /* type conversion operator */ + string type; + const char *tem = name->b + 5; + if (do_type (&tem, &type, arg_mode)) + { + string_clear (name); + string_append (name, "operator "); + string_appends (name, &type); + string_delete (&type); + return; + } + } +} + +/* a mini string-handling package */ + +static void +string_need (s, n) + string *s; + int n; +{ + if (s->b == NULL) + { + if (n < 32) + n = 32; + s->p = s->b = (char *) xmalloc (n); + s->e = s->b + n; + } + else if (s->e - s->p < n) + { + int tem = s->p - s->b; + n += tem; + n *= 2; + s->b = (char *) xrealloc (s->b, n); + s->p = s->b + tem; + s->e = s->b + n; + } +} + +static void +string_delete (s) + string *s; +{ + if (s->b != NULL) + { + free (s->b); + s->b = s->e = s->p = NULL; + } +} + +static void +string_init (s) + string *s; +{ + s->b = s->p = s->e = NULL; +} + +static void +string_clear (s) + string *s; +{ + s->p = s->b; +} + +static int +string_empty (s) + string *s; +{ + return s->b == s->p; +} + +static void +string_append (p, s) + string *p; + const char *s; +{ + int n; + if (s == NULL || *s == '\0') + return; + n = strlen (s); + string_need (p, n); + memcpy (p->p, s, n); + p->p += n; +} + +static void +string_appends (p, s) + string *p, *s; +{ + int n; + if (s->b == s->p) + return; + n = s->p - s->b; + string_need (p, n); + memcpy (p->p, s->b, n); + p->p += n; +} + +static void +string_appendn (p, s, n) + string *p; + const char *s; + int n; +{ + if (n == 0) + return; + string_need (p, n); + memcpy (p->p, s, n); + p->p += n; +} + +static void +string_prepend (p, s) + string *p; + const char *s; +{ + if (s == NULL || *s == '\0') + return; + string_prependn (p, s, strlen (s)); +} + +#if 0 +static void +string_prepends (p, s) + string *p, *s; +{ + if (s->b == s->p) + return; + string_prependn (p, s->b, s->p - s->b); +} +#endif + +static void +string_prependn (p, s, n) + string *p; + const char *s; + int n; +{ + char *q; + + if (n == 0) + return; + string_need (p, n); + for (q = p->p - 1; q >= p->b; q--) + q[n] = q[0]; + memcpy (p->b, s, n); + p->p += n; +} diff --git a/gdb/createtags b/gdb/createtags new file mode 100755 index 0000000..6f02ff2 --- /dev/null +++ b/gdb/createtags @@ -0,0 +1,20 @@ +#!/bin/sh +# +# Here we check to see if we are compiling in a directory that contains +# symlinks to the source files instead of the actual files. If this is so, +# we setup the TAGS entries to point to the actual source directory. +# +filelist="" +if test "`find main.c -type l -print `" != "" ; then + prefix=`ls -l main.c | awk '{print $11}' | sed 's;main.c$;;'` +else + prefix="" +fi + +# Replace .o at end of filename with .c +for i in $@ ; do + file=`echo $i-x- | sed -e 's/\.o-x-/\.c-x-/' | sed -e 's/-x-//'` + filelist="$filelist $prefix$file" +done + +etags $filelist diff --git a/gdb/depend b/gdb/depend new file mode 100755 index 0000000..c78aa66 --- /dev/null +++ b/gdb/depend @@ -0,0 +1,195 @@ +altos-xdep.o : altos-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +am29k-pinsn.o : am29k-pinsn.c defs.h target.h am29k-opcode.h +am29k-tdep.o : am29k-tdep.c defs.h gdbcore.h $(INCLUDE_DIR)/bfd.h frame.h \ + param.h tm.h config.status param-no-tm.h xm.h config.status value.h symtab.h inferior.h breakpoint.h +arm-pinsn.o : arm-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + arm-opcode.h +arm-tdep.o : arm-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h arm-opcode.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +arm-xdep.o : arm-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h arm-opcode.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +blockframe.o : blockframe.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + frame.h gdbcore.h $(INCLUDE_DIR)/bfd.h value.h target.h +breakpoint.o : breakpoint.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + frame.h breakpoint.h value.h expression.h gdbcore.h $(INCLUDE_DIR)/bfd.h \ + gdbcmd.h command.h inferior.h target.h +coffread.o : coffread.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + breakpoint.h value.h $(INCLUDE_DIR)/bfd.h $(BFD_DIR)/libcoff.h symfile.h +command.o : command.c defs.h command.h symtab.h value.h +convex-pinsn.o : convex-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + symtab.h convex-opcode.h +convex-tdep.o : convex-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + command.h symtab.h value.h frame.h inferior.h breakpoint.h \ + $(INCLUDE_DIR)/wait.h gdbcore.h $(INCLUDE_DIR)/bfd.h gdbcmd.h +convex-xdep.o : convex-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + command.h symtab.h value.h frame.h inferior.h breakpoint.h \ + $(INCLUDE_DIR)/wait.h gdbcore.h $(INCLUDE_DIR)/bfd.h gdbcmd.h +core.o : core.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h inferior.h \ + breakpoint.h value.h symtab.h command.h $(INCLUDE_DIR)/bfd.h target.h \ + gdbcore.h +coredep.o : coredep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +cplus-dem.o : cplus-dem.c +dbxread.o : dbxread.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + $(INCLUDE_DIR)/a.out.gnu.h $(INCLUDE_DIR)/target.h $(INCLUDE_DIR)/reloc.h \ + $(INCLUDE_DIR)/stab.gnu.h $(INCLUDE_DIR)/stab.def symtab.h breakpoint.h value.h \ + command.h target.h gdbcore.h $(INCLUDE_DIR)/bfd.h $(BFD_DIR)/liba.out.h \ + symfile.h +environ.o : environ.c environ.h +eval.o : eval.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h value.h \ + expression.h target.h +exec.o : exec.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h inferior.h \ + breakpoint.h value.h symtab.h target.h gdbcore.h $(INCLUDE_DIR)/bfd.h +expprint.o : expprint.c defs.h symtab.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + expression.h value.h +findvar.o : findvar.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + frame.h value.h gdbcore.h $(INCLUDE_DIR)/bfd.h inferior.h breakpoint.h \ + target.h +gould-pinsn.o : gould-pinsn.c gdbcore.h $(INCLUDE_DIR)/bfd.h defs.h param.h \ + tm.h config.status param-no-tm.h xm.h config.status symtab.h frame.h np1-opcode.h +gould-xdep.o : gould-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +hp300hpux-xdep.o : hp300hpux-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + frame.h inferior.h breakpoint.h value.h symtab.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +i386-pinsn.o : i386-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + frame.h inferior.h breakpoint.h value.h gdbcore.h $(INCLUDE_DIR)/bfd.h +i386-tdep.o : i386-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +i386-xdep.o : i386-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +i960-pinsn.o : i960-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h +i960-tdep.o : i960-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + value.h frame.h signame.h ieee-float.h +ieee-float.o : ieee-float.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + ieee-float.h +infcmd.o : infcmd.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h frame.h \ + inferior.h breakpoint.h value.h environ.h gdbcmd.h command.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h target.h +inflow.o : inflow.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h command.h signals.h terminal.h \ + target.h +infptrace.o : infptrace.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h target.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +infrun.o : infrun.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h frame.h \ + inferior.h breakpoint.h value.h $(INCLUDE_DIR)/wait.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h signame.h command.h terminal.h target.h +inftarg.o : inftarg.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h target.h $(INCLUDE_DIR)/wait.h \ + gdbcore.h $(INCLUDE_DIR)/bfd.h ieee-float.h +m68k-pinsn.o : m68k-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + m68k-opcode.h gdbcore.h $(INCLUDE_DIR)/bfd.h +m68k-tdep.o : m68k-tdep.c defs.h ieee-float.h +main.o : main.c defs.h gdbcmd.h command.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + symtab.h inferior.h breakpoint.h value.h frame.h signals.h target.h +mem-break.o : mem-break.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status +mips-pinsn.o : mips-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + mips-opcode.h +mips-tdep.o : mips-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcmd.h command.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +mips-xdep.o : mips-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +mipsread.o : mipsread.c param.h tm.h config.status param-no-tm.h xm.h config.status obstack.h defs.h \ + symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h symfile.h $(INCLUDE_DIR)/intel-coff.h +news-xdep.o : news-xdep.c +Onindy.o : ${srcdir}/nindy-share/Onindy.c ${srcdir}/nindy-share/ttycntl.h \ + ${srcdir}/nindy-share/block_io.h $(INCLUDE_DIR)/wait.h ${srcdir}/nindy-share/env.h \ + /usr/include/string.h +nindy.o : ${srcdir}/nindy-share/nindy.c ${srcdir}/nindy-share/ttycntl.h ${srcdir}/nindy-share/block_io.h \ + $(INCLUDE_DIR)/wait.h ${srcdir}/nindy-share/env.h /usr/include/string.h +ttybreak.o : ${srcdir}/nindy-share/ttybreak.c ${srcdir}/nindy-share/ttycntl.h +ttyflush.o : ${srcdir}/nindy-share/ttyflush.c ${srcdir}/nindy-share/ttycntl.h +nindy-tdep.o : nindy-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + frame.h +ns32k-pinsn.o : ns32k-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + symtab.h ns32k-opcode.h gdbcore.h $(INCLUDE_DIR)/bfd.h +printcmd.o : printcmd.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + symtab.h value.h expression.h gdbcore.h $(INCLUDE_DIR)/bfd.h gdbcmd.h \ + command.h target.h +pyr-pinsn.o : pyr-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + pyr-opcode.h gdbcore.h $(INCLUDE_DIR)/bfd.h +pyr-tdep.o : pyr-tdep.c +pyr-xdep.o : pyr-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +remote-eb.o : remote-eb.c defs.h tm-29k.h param-no-tm.h xm.h config.status inferior.h \ + breakpoint.h value.h symtab.h frame.h param.h $(INCLUDE_DIR)/wait.h \ + terminal.h target.h +remote-nindy.o : remote-nindy.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + frame.h inferior.h breakpoint.h value.h symtab.h target.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h command.h ieee-float.h $(INCLUDE_DIR)/wait.h \ + ${srcdir}/nindy-share/ttycntl.h ${srcdir}/nindy-share/demux.h ${srcdir}/nindy-share/env.h \ + ${srcdir}/nindy-share/stop.h +remote-vx.o : remote-vx.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h $(INCLUDE_DIR)/wait.h target.h \ + gdbcore.h $(INCLUDE_DIR)/bfd.h command.h symfile.h ${srcdir}/vx-share/xdr_ptrace.h \ + ${srcdir}/vx-share/xdr_regs.h ${srcdir}/vx-share/reg.h ${srcdir}/vx-share/xdr_ld.h \ + ${srcdir}/vx-share/xdr_rdb.h ${srcdir}/vx-share/dbgRpcLib.h +remote.o : remote.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h target.h $(INCLUDE_DIR)/wait.h \ + terminal.h +signame.o : signame.c signame.h +solib.o : solib.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h command.h +source.o : source.c defs.h symtab.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + command.h frame.h gdbcore.h $(INCLUDE_DIR)/bfd.h +sparc-pinsn.o : sparc-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + symtab.h sparc-opcode.h gdbcore.h $(INCLUDE_DIR)/bfd.h /usr/include/string.h \ + target.h +sparc-tdep.o : sparc-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h obstack.h signame.h target.h \ + ieee-float.h gdbcore.h $(INCLUDE_DIR)/bfd.h +sparc-xdep.o : sparc-xdep.c defs.h tm-sparc.h param-no-tm.h xm.h config.status inferior.h \ + breakpoint.h value.h symtab.h frame.h param.h target.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +stack.o : stack.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h frame.h \ + gdbcmd.h command.h value.h gdbcore.h $(INCLUDE_DIR)/bfd.h target.h \ + breakpoint.h +sun3-xdep.o : sun3-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status inferior.h \ + breakpoint.h value.h symtab.h frame.h gdbcore.h $(INCLUDE_DIR)/bfd.h +sun386-xdep.o : sun386-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + frame.h inferior.h breakpoint.h value.h symtab.h signame.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +symfile.o : symfile.c defs.h symtab.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + gdbcore.h $(INCLUDE_DIR)/bfd.h frame.h target.h value.h symfile.h gdbcmd.h \ + command.h breakpoint.h +symmetry-tdep.o : symmetry-tdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + frame.h inferior.h breakpoint.h value.h symtab.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +symmetry-xdep.o : symmetry-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + frame.h inferior.h breakpoint.h value.h symtab.h gdbcore.h \ + $(INCLUDE_DIR)/bfd.h +symmisc.o : symmisc.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + breakpoint.h value.h command.h +symtab.o : symtab.c defs.h symtab.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + gdbcore.h $(INCLUDE_DIR)/bfd.h frame.h target.h value.h symfile.h gdbcmd.h \ + command.h +target.o : target.c defs.h target.h gdbcmd.h command.h symtab.h inferior.h \ + breakpoint.h value.h frame.h param.h tm.h config.status param-no-tm.h xm.h config.status \ + $(INCLUDE_DIR)/bfd.h symfile.h +tdesc.o : tdesc.c +umax-xdep.o : umax-xdep.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status frame.h \ + inferior.h breakpoint.h value.h symtab.h gdbcore.h $(INCLUDE_DIR)/bfd.h +utils.o : utils.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status signals.h gdbcmd.h \ + command.h terminal.h $(INCLUDE_DIR)/bfd.h target.h +valarith.o : valarith.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status value.h \ + symtab.h expression.h target.h +valops.o : valops.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h value.h \ + frame.h inferior.h breakpoint.h gdbcore.h $(INCLUDE_DIR)/bfd.h target.h +valprint.o : valprint.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + value.h gdbcore.h $(INCLUDE_DIR)/bfd.h gdbcmd.h command.h target.h obstack.h +values.o : values.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h value.h \ + gdbcore.h $(INCLUDE_DIR)/bfd.h frame.h command.h +vax-pinsn.o : vax-pinsn.c defs.h param.h tm.h config.status param-no-tm.h xm.h config.status symtab.h \ + vax-opcode.h +xdr_ld.o : ${srcdir}/vx-share/xdr_ld.c ${srcdir}/vx-share/vxWorks.h ${srcdir}/vx-share/vxTypes.h \ + /usr/include/rpc/rpc.h ${srcdir}/vx-share/xdr_ld.h +xdr_ptrace.o : ${srcdir}/vx-share/xdr_ptrace.c +xdr_rdb.o : ${srcdir}/vx-share/xdr_rdb.c ${srcdir}/vx-share/vxWorks.h ${srcdir}/vx-share/vxTypes.h \ + ${srcdir}/vx-share/xdr_rdb.h +xdr_regs.o : ${srcdir}/vx-share/xdr_regs.c diff --git a/gdb/expread.tab.c b/gdb/expread.tab.c new file mode 100755 index 0000000..86fbd0f --- /dev/null +++ b/gdb/expread.tab.c @@ -0,0 +1,2657 @@ + +/* A Bison parser, made from ../expread.y */ + +#define INT 258 +#define CHAR 259 +#define UINT 260 +#define FLOAT 261 +#define STRING 262 +#define NAME 263 +#define BLOCKNAME 264 +#define TYPENAME 265 +#define NAME_OR_INT 266 +#define NAME_OR_UINT 267 +#define STRUCT 268 +#define UNION 269 +#define ENUM 270 +#define SIZEOF 271 +#define UNSIGNED 272 +#define COLONCOLON 273 +#define ERROR 274 +#define SIGNED 275 +#define LONG 276 +#define SHORT 277 +#define INT_KEYWORD 278 +#define LAST 279 +#define REGNAME 280 +#define VARIABLE 281 +#define ASSIGN_MODIFY 282 +#define THIS 283 +#define ABOVE_COMMA 284 +#define OR 285 +#define AND 286 +#define EQUAL 287 +#define NOTEQUAL 288 +#define LEQ 289 +#define GEQ 290 +#define LSH 291 +#define RSH 292 +#define UNARY 293 +#define INCREMENT 294 +#define DECREMENT 295 +#define ARROW 296 + +#line 29 "../expread.y" + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "frame.h" +#include "expression.h" +#include "value.h" +#include "command.h" + +static struct expression *expout; +static int expout_size; +static int expout_ptr; + +static int yylex (); +static void yyerror (); +static void write_exp_elt (); +static void write_exp_elt_opcode (); +static void write_exp_elt_sym (); +static void write_exp_elt_longcst (); +static void write_exp_elt_dblcst (); +static void write_exp_elt_type (); +static void write_exp_elt_intern (); +static void write_exp_string (); +static void start_arglist (); +static int end_arglist (); +static void free_funcalls (); +static char *copy_name (); +static int parse_number (); + +/* If this is nonzero, this block is used as the lexical context + for symbol names. */ + +static struct block *expression_context_block; + +/* The innermost context required by the stack and register variables + we've encountered so far. */ +struct block *innermost_block; + +/* The block in which the most recently discovered symbol was found. */ +struct block *block_found; + +/* Number of arguments seen so far in innermost function call. */ +static int arglist_len; + +/* Data structure for saving values of arglist_len + for function calls whose arguments contain other function calls. */ + +struct funcall + { + struct funcall *next; + int arglist_len; + }; + +struct funcall *funcall_chain; + +/* This kind of datum is used to represent the name + of a symbol token. */ + +struct stoken + { + char *ptr; + int length; + }; + +struct ttype + { + struct stoken stoken; + struct type *type; + }; + +struct symtoken + { + struct stoken stoken; + struct symbol *sym; + int is_a_field_of_this; + }; + +/* For parsing of complicated types. + An array should be preceded in the list by the size of the array. */ +enum type_pieces + {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function}; +static enum type_pieces *type_stack; +static int type_stack_depth, type_stack_size; + +static void push_type (); +static enum type_pieces pop_type (); + +/* Allow debugging of parsing. */ +#define YYDEBUG 1 + +#line 125 "../expread.y" +typedef union + { + LONGEST lval; + unsigned LONGEST ulval; + double dval; + struct symbol *sym; + struct type *tval; + struct stoken sval; + struct ttype tsym; + struct symtoken ssym; + int voidval; + struct block *bval; + enum exp_opcode opcode; + struct internalvar *ivar; + + struct type **tvec; + int *ivec; + } YYSTYPE; + +#ifndef YYLTYPE +typedef + struct yyltype + { + int timestamp; + int first_line; + int first_column; + int last_line; + int last_column; + char *text; + } + yyltype; + +#define YYLTYPE yyltype +#endif + +#include <stdio.h> + +#ifndef __STDC__ +#define const +#endif + + + +#define YYFINAL 189 +#define YYFLAG -32768 +#define YYNTBASE 66 + +#define YYTRANSLATE(x) ((unsigned)(x) <= 296 ? yytranslate[x] : 84) + +static const char yytranslate[] = { 0, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 59, 2, 2, 2, 51, 37, 2, 58, + 62, 49, 47, 29, 48, 56, 50, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 65, 2, 40, + 31, 41, 32, 46, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 57, 2, 61, 36, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 63, 35, 64, 60, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 1, 2, 3, 4, 5, + 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, + 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, + 26, 27, 28, 30, 33, 34, 38, 39, 42, 43, + 44, 45, 52, 53, 54, 55 +}; + +static const short yyrline[] = { 0, + 218, 222, 223, 228, 231, 234, 238, 242, 246, 250, + 254, 258, 262, 266, 272, 276, 282, 286, 290, 294, + 300, 303, 307, 311, 317, 323, 329, 333, 337, 341, + 345, 349, 353, 357, 361, 365, 369, 373, 377, 381, + 385, 389, 393, 397, 401, 405, 409, 413, 419, 429, + 442, 454, 467, 474, 481, 484, 490, 496, 502, 509, + 516, 523, 540, 550, 562, 575, 621, 695, 696, 731, + 733, 735, 738, 740, 745, 751, 753, 757, 759, 763, + 767, 768, 770, 772, 775, 782, 784, 786, 788, 790, + 792, 794, 796, 798, 801, 804, 807, 809, 811, 813, + 817, 818, 824, 830, 839, 844, 851, 852, 853, 854, + 855, 858, 859, 860, 861 +}; + +static const char * const yytname[] = { 0, +"error","$illegal.","INT","CHAR","UINT","FLOAT","STRING","NAME","BLOCKNAME","TYPENAME", +"NAME_OR_INT","NAME_OR_UINT","STRUCT","UNION","ENUM","SIZEOF","UNSIGNED","COLONCOLON","ERROR","SIGNED", +"LONG","SHORT","INT_KEYWORD","LAST","REGNAME","VARIABLE","ASSIGN_MODIFY","THIS","','","ABOVE_COMMA", +"'='","'?'","OR","AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'", +"'>'","LEQ","GEQ","LSH","RSH","'@'","'+'","'-'","'*'","'/'", +"'%'","UNARY","INCREMENT","DECREMENT","ARROW","'.'","'['","'('","'!'","'~'", +"']'","')'","'{'","'}'","':'","start" +}; + +static const short yyr1[] = { 0, + 66, 67, 67, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 69, 68, + 70, 70, 70, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 68, 68, 68, 68, 68, 68, 68, 68, 68, + 68, 71, 71, 72, 72, 72, 72, 73, 73, 74, + 74, 74, 75, 75, 75, 75, 75, 76, 76, 77, + 78, 78, 78, 78, 78, 79, 79, 79, 79, 79, + 79, 79, 79, 79, 79, 79, 79, 79, 79, 79, + 80, 80, 80, 80, 81, 81, 82, 82, 82, 82, + 82, 83, 83, 83, 83 +}; + +static const short yyr2[] = { 0, + 1, 1, 3, 2, 2, 2, 2, 2, 2, 2, + 2, 2, 2, 3, 4, 3, 4, 4, 0, 5, + 0, 1, 3, 4, 4, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, + 3, 3, 3, 3, 3, 5, 3, 3, 1, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 4, 1, + 1, 1, 3, 3, 3, 2, 1, 1, 2, 1, + 2, 1, 3, 2, 1, 2, 1, 2, 3, 2, + 1, 3, 6, 8, 9, 1, 1, 1, 1, 2, + 3, 2, 3, 2, 2, 2, 2, 1, 2, 1, + 1, 1, 1, 1, 1, 3, 1, 1, 1, 1, + 1, 1, 1, 1, 1 +}; + +static const short yydefact[] = { 0, + 49, 53, 51, 54, 60, 112, 113, 86, 50, 52, + 0, 0, 0, 0, 98, 0, 100, 88, 89, 87, + 56, 57, 58, 61, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 1, 2, 0, 55, 0, 67, 107, + 108, 109, 110, 111, 94, 95, 96, 0, 13, 101, + 103, 104, 102, 97, 66, 103, 104, 99, 90, 92, + 5, 6, 4, 9, 10, 0, 81, 0, 68, 7, + 8, 0, 68, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 11, 12, 0, 0, + 0, 19, 0, 0, 0, 91, 93, 26, 0, 0, + 0, 70, 0, 0, 69, 72, 75, 77, 0, 0, + 3, 48, 47, 0, 45, 44, 43, 42, 41, 35, + 36, 39, 40, 37, 38, 33, 34, 27, 31, 32, + 28, 29, 30, 0, 14, 0, 16, 0, 21, 64, + 65, 59, 0, 25, 82, 71, 0, 78, 80, 0, + 0, 74, 76, 24, 0, 15, 17, 18, 22, 0, + 0, 79, 73, 46, 0, 20, 0, 23, 83, 0, + 84, 105, 0, 0, 85, 106, 0, 0, 0 +}; + +static const short yydefgoto[] = { 187, + 66, 35, 149, 170, 36, 37, 67, 115, 116, 117, + 118, 68, 38, 54, 183, 151, 39 +}; + +static const short yypact[] = { 159, +-32768,-32768,-32768,-32768,-32768,-32768, -13,-32768,-32768,-32768, + 21, 21, 21, 220, 121, 21, 124, -15, 3,-32768, +-32768,-32768,-32768,-32768, 159, 159, 159, 159, 159, 159, + 159, 159, 272, 80, 306, 32,-32768, 99,-32768,-32768, +-32768,-32768,-32768,-32768,-32768,-32768,-32768, 159, 508,-32768, + 100, 101,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768, + 508, 508, 508, 508, 508, -4,-32768, -52, 79, 508, + 508, -55, 92, 159, 159, 159, 159, 159, 159, 159, + 159, 159, 159, 159, 159, 159, 159, 159, 159, 159, + 159, 159, 159, 159, 159, 159,-32768,-32768, 90, 104, + 159,-32768, 21, 21, -35,-32768,-32768,-32768, 272, 159, + 110, 157, 25, 209,-32768, 30,-32768,-32768, 159, 84, + 306, 306, 306, 271, 358, 382, 405, 427, 448, 467, + 467, 144, 144, 144, 144, 480, 480, 492, 502, 502, + 508, 508, 508, 159,-32768, 159,-32768, 66, 159, 111, +-32768, 31, 122, 508,-32768,-32768, 94,-32768,-32768, 95, + 98,-32768,-32768, 508, 159, 508, 508,-32768, 306, 63, + 107,-32768,-32768, 333, 159,-32768, 116, 306, 128, 239, +-32768, 145, 64, 272,-32768, 145, 204, 205,-32768 +}; + +static const short yypgoto[] = {-32768, + 2, -14,-32768,-32768,-32768,-32768,-32768, -8,-32768, 93, + 105, -32, -26, 193,-32768, 8,-32768 +}; + + +#define YYLAST 566 + + +static const short yytable[] = { 49, + 72, 34, 109, 69, -62, 109, 73, 59, 119, 110, + 61, 62, 63, 64, 65, 105, 70, 71, 45, 46, + 47, 69, 109, 55, 74, 60, 152, 157, 40, 41, + 42, 43, 44, 1, 2, 3, 4, 5, 6, 7, + 8, 9, 10, 11, 12, 13, 14, 15, 16, 103, + 17, 18, 19, 20, 21, 22, 23, 108, 24, 121, + 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, + 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, + 142, 143, 153, 28, 29, 158, 113, 161, 30, 31, + 32, 175, 184, 33, 74, 154, 111, 40, 41, 42, + 43, 44, 148, 156, 164, 160, 145, 147, 74, 120, + 150, 40, 41, 42, 43, 44, 104, 40, 41, 42, + 43, 44, 106, 107, 176, 185, 168, 112, -63, 166, + 50, 167, 155, 50, 169, 113, 114, 154, 144, 171, + 112, 51, 52, 53, 56, 57, 53, 182, 113, 114, + 174, 186, 146, 73, 172, 177, 173, 73, 155, 159, + 178, 1, 2, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 179, 17, 18, + 19, 20, 21, 22, 23, 180, 24, 89, 90, 91, + 92, 93, 94, 95, 96, 25, 97, 98, 99, 100, + 101, 102, 109, 188, 189, 112, 26, 27, 162, 58, + 0, 28, 29, 113, 114, 0, 30, 31, 32, 0, + 163, 33, 1, 2, 3, 4, 5, 6, 7, 8, + 9, 10, 11, 12, 13, 14, 15, 16, 0, 17, + 18, 19, 20, 21, 22, 23, 0, 24, 8, 0, + 0, 11, 12, 13, 0, 15, 25, 112, 17, 18, + 19, 20, 0, 0, 0, 113, 114, 26, 27, 0, + 159, 0, 28, 29, 0, 0, 0, 48, 31, 32, + 0, 8, 33, 0, 11, 12, 13, 0, 15, 0, + 0, 17, 18, 19, 20, 0, 0, 75, 0, 0, + 181, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 0, 97, 98, 99, 100, 101, 102, 0, + 0, 0, 75, 0, 0, 165, 76, 77, 78, 79, + 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, + 90, 91, 92, 93, 94, 95, 96, 0, 97, 98, + 99, 100, 101, 102, 77, 78, 79, 80, 81, 82, + 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, + 93, 94, 95, 96, 0, 97, 98, 99, 100, 101, + 102, 79, 80, 81, 82, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 0, + 97, 98, 99, 100, 101, 102, 80, 81, 82, 83, + 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, + 94, 95, 96, 0, 97, 98, 99, 100, 101, 102, + 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, + 91, 92, 93, 94, 95, 96, 0, 97, 98, 99, + 100, 101, 102, 82, 83, 84, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 0, 97, + 98, 99, 100, 101, 102, 83, 84, 85, 86, 87, + 88, 89, 90, 91, 92, 93, 94, 95, 96, 0, + 97, 98, 99, 100, 101, 102, 85, 86, 87, 88, + 89, 90, 91, 92, 93, 94, 95, 96, 0, 97, + 98, 99, 100, 101, 102, 91, 92, 93, 94, 95, + 96, 0, 97, 98, 99, 100, 101, 102, 92, 93, + 94, 95, 96, 0, 97, 98, 99, 100, 101, 102, + 94, 95, 96, 0, 97, 98, 99, 100, 101, 102, + 97, 98, 99, 100, 101, 102 +}; + +static const short yycheck[] = { 14, + 33, 0, 58, 30, 18, 58, 33, 23, 64, 62, + 25, 26, 27, 28, 29, 48, 31, 32, 11, 12, + 13, 48, 58, 16, 29, 23, 62, 3, 8, 9, + 10, 11, 12, 3, 4, 5, 6, 7, 8, 9, + 10, 11, 12, 13, 14, 15, 16, 17, 18, 18, + 20, 21, 22, 23, 24, 25, 26, 62, 28, 74, + 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, + 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, + 95, 96, 109, 53, 54, 61, 57, 58, 58, 59, + 60, 29, 29, 63, 29, 110, 18, 8, 9, 10, + 11, 12, 101, 112, 119, 114, 99, 100, 29, 18, + 103, 8, 9, 10, 11, 12, 18, 8, 9, 10, + 11, 12, 23, 23, 62, 62, 61, 49, 18, 144, + 10, 146, 49, 10, 149, 57, 58, 152, 49, 18, + 49, 21, 22, 23, 21, 22, 23, 180, 57, 58, + 165, 184, 49, 180, 61, 49, 62, 184, 49, 62, + 175, 3, 4, 5, 6, 7, 8, 9, 10, 11, + 12, 13, 14, 15, 16, 17, 18, 62, 20, 21, + 22, 23, 24, 25, 26, 58, 28, 44, 45, 46, + 47, 48, 49, 50, 51, 37, 53, 54, 55, 56, + 57, 58, 58, 0, 0, 49, 48, 49, 116, 17, + -1, 53, 54, 57, 58, -1, 58, 59, 60, -1, + 116, 63, 3, 4, 5, 6, 7, 8, 9, 10, + 11, 12, 13, 14, 15, 16, 17, 18, -1, 20, + 21, 22, 23, 24, 25, 26, -1, 28, 10, -1, + -1, 13, 14, 15, -1, 17, 37, 49, 20, 21, + 22, 23, -1, -1, -1, 57, 58, 48, 49, -1, + 62, -1, 53, 54, -1, -1, -1, 58, 59, 60, + -1, 10, 63, -1, 13, 14, 15, -1, 17, -1, + -1, 20, 21, 22, 23, -1, -1, 27, -1, -1, + 62, 31, 32, 33, 34, 35, 36, 37, 38, 39, + 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, + 50, 51, -1, 53, 54, 55, 56, 57, 58, -1, + -1, -1, 27, -1, -1, 65, 31, 32, 33, 34, + 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, + 45, 46, 47, 48, 49, 50, 51, -1, 53, 54, + 55, 56, 57, 58, 32, 33, 34, 35, 36, 37, + 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, + 48, 49, 50, 51, -1, 53, 54, 55, 56, 57, + 58, 34, 35, 36, 37, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, + 53, 54, 55, 56, 57, 58, 35, 36, 37, 38, + 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, -1, 53, 54, 55, 56, 57, 58, + 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, + 46, 47, 48, 49, 50, 51, -1, 53, 54, 55, + 56, 57, 58, 37, 38, 39, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, -1, 53, + 54, 55, 56, 57, 58, 38, 39, 40, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, + 53, 54, 55, 56, 57, 58, 40, 41, 42, 43, + 44, 45, 46, 47, 48, 49, 50, 51, -1, 53, + 54, 55, 56, 57, 58, 46, 47, 48, 49, 50, + 51, -1, 53, 54, 55, 56, 57, 58, 47, 48, + 49, 50, 51, -1, 53, 54, 55, 56, 57, 58, + 49, 50, 51, -1, 53, 54, 55, 56, 57, 58, + 53, 54, 55, 56, 57, 58 +}; +#define YYPURE 1 + +/* -*-C-*- Note some compilers choke on comments on `#line' lines. */ +#line 3 "bison.simple" + +/* Skeleton output parser for bison, + Copyright (C) 1984 Bob Corbett and Richard Stallman + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) +#include <alloca.h> +#endif + +/* This is the parser code that is written into each bison parser + when the %semantic_parser declaration is not specified in the grammar. + It was written by Richard Stallman by simplifying the hairy parser + used when %semantic_parser is specified. */ + +/* Note: there must be only one dollar sign in this file. + It is replaced by the list of actions, each action + as one case of the switch. */ + +#define yyerrok (yyerrstatus = 0) +#define yyclearin (yychar = YYEMPTY) +#define YYEMPTY -2 +#define YYEOF 0 +#define YYFAIL goto yyerrlab; +#define YYACCEPT return(0) +#define YYABORT return(1) +#define YYERROR goto yyerrlab + +#define YYTERROR 1 +#define YYERRCODE 256 + +#ifndef YYIMPURE +#define YYLEX yylex() +#endif + +#ifndef YYPURE +#define YYLEX yylex(&yylval, &yylloc) +#endif + +/* If nonreentrant, generate the variables here */ + +#ifndef YYIMPURE + +int yychar; /* the lookahead symbol */ +YYSTYPE yylval; /* the semantic value of the */ + /* lookahead symbol */ + +YYLTYPE yylloc; /* location data for the lookahead */ + /* symbol */ + +int yynerrs; /* number of parse errors so far */ +#endif /* YYIMPURE */ + +#if YYDEBUG != 0 +int yydebug; /* nonzero means print parse trace */ +/* Since this is uninitialized, it does not stop multiple parsers + from coexisting. */ +#endif + +/* YYMAXDEPTH indicates the initial size of the parser's stacks */ + +#ifndef YYMAXDEPTH +#define YYMAXDEPTH 200 +#endif + +/* YYMAXLIMIT is the maximum size the stacks can grow to + (effective only if the built-in stack extension method is used). */ + +#ifndef YYMAXLIMIT +#define YYMAXLIMIT 10000 +#endif + + +#line 90 "bison.simple" +int +yyparse() +{ + register int yystate; + register int yyn; + register short *yyssp; + register YYSTYPE *yyvsp; + YYLTYPE *yylsp; + int yyerrstatus; /* number of tokens to shift before error messages enabled */ + int yychar1; /* lookahead token as an internal (translated) token number */ + + short yyssa[YYMAXDEPTH]; /* the state stack */ + YYSTYPE yyvsa[YYMAXDEPTH]; /* the semantic value stack */ + YYLTYPE yylsa[YYMAXDEPTH]; /* the location stack */ + + short *yyss = yyssa; /* refer to the stacks thru separate pointers */ + YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */ + YYLTYPE *yyls = yylsa; + + int yymaxdepth = YYMAXDEPTH; + +#ifndef YYPURE + int yychar; + YYSTYPE yylval; + YYLTYPE yylloc; + int yynerrs; +#endif + + YYSTYPE yyval; /* the variable used to return */ + /* semantic values from the action */ + /* routines */ + + int yylen; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Starting parse\n"); +#endif + + yystate = 0; + yyerrstatus = 0; + yynerrs = 0; + yychar = YYEMPTY; /* Cause a token to be read. */ + + /* Initialize stack pointers. + Waste one element of value and location stack + so that they stay on the same level as the state stack. */ + + yyssp = yyss - 1; + yyvsp = yyvs; + yylsp = yyls; + +/* Push a new state, which is found in yystate . */ +/* In all cases, when you get here, the value and location stacks + have just been pushed. so pushing a state here evens the stacks. */ +yynewstate: + + *++yyssp = yystate; + + if (yyssp >= yyss + yymaxdepth - 1) + { + /* Give user a chance to reallocate the stack */ + /* Use copies of these so that the &'s don't force the real ones into memory. */ + YYSTYPE *yyvs1 = yyvs; + YYLTYPE *yyls1 = yyls; + short *yyss1 = yyss; + + /* Get the current used size of the three stacks, in elements. */ + int size = yyssp - yyss + 1; + +#ifdef yyoverflow + /* Each stack pointer address is followed by the size of + the data in use in that stack, in bytes. */ + yyoverflow("parser stack overflow", + &yyss1, size * sizeof (*yyssp), + &yyvs1, size * sizeof (*yyvsp), + &yyls1, size * sizeof (*yylsp), + &yymaxdepth); + + yyss = yyss1; yyvs = yyvs1; yyls = yyls1; +#else /* no yyoverflow */ + /* Extend the stack our own way. */ + if (yymaxdepth >= YYMAXLIMIT) + yyerror("parser stack overflow"); + yymaxdepth *= 2; + if (yymaxdepth > YYMAXLIMIT) + yymaxdepth = YYMAXLIMIT; + yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp)); + bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp)); + yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp)); + bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp)); +#ifdef YYLSP_NEEDED + yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp)); + bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp)); +#endif +#endif /* no yyoverflow */ + + yyssp = yyss + size - 1; + yyvsp = yyvs + size - 1; +#ifdef YYLSP_NEEDED + yylsp = yyls + size - 1; +#endif + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Stack size increased to %d\n", yymaxdepth); +#endif + + if (yyssp >= yyss + yymaxdepth - 1) + YYABORT; + } + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Entering state %d\n", yystate); +#endif + +/* Do appropriate processing given the current state. */ +/* Read a lookahead token if we need one and don't already have one. */ +yyresume: + + /* First try to decide what to do without reference to lookahead token. */ + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yydefault; + + /* Not known => get a lookahead token if don't already have one. */ + + /* yychar is either YYEMPTY or YYEOF + or a valid token in external form. */ + + if (yychar == YYEMPTY) + { +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Reading a token: "); +#endif + yychar = YYLEX; + } + + /* Convert token to internal form (in yychar1) for indexing tables with */ + + if (yychar <= 0) /* This means end of input. */ + { + yychar1 = 0; + yychar = YYEOF; /* Don't call YYLEX any more */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Now at end of input.\n"); +#endif + } + else + { + yychar1 = YYTRANSLATE(yychar); + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]); +#endif + } + + yyn += yychar1; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1) + goto yydefault; + + yyn = yytable[yyn]; + + /* yyn is what to do for this token type in this state. + Negative => reduce, -yyn is rule number. + Positive => shift, yyn is new state. + New state is final state => don't bother to shift, + just return success. + 0, or most negative number => error. */ + + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrlab; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrlab; + + if (yyn == YYFINAL) + YYACCEPT; + + /* Shift the lookahead token. */ + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]); +#endif + + /* Discard the token being shifted unless it is eof. */ + if (yychar != YYEOF) + yychar = YYEMPTY; + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + /* count tokens shifted since error; after three, turn off error status. */ + if (yyerrstatus) yyerrstatus--; + + yystate = yyn; + goto yynewstate; + +/* Do the default action for the current state. */ +yydefault: + + yyn = yydefact[yystate]; + if (yyn == 0) + goto yyerrlab; + +/* Do a reduction. yyn is the number of a rule to reduce with. */ +yyreduce: + yylen = yyr2[yyn]; + yyval = yyvsp[1-yylen]; /* implement default value of the action */ + +#if YYDEBUG != 0 + if (yydebug) + { + if (yylen == 1) + fprintf (stderr, "Reducing 1 value via line %d, ", + yyrline[yyn]); + else + fprintf (stderr, "Reducing %d values via line %d, ", + yylen, yyrline[yyn]); + } +#endif + + + switch (yyn) { + +case 3: +#line 224 "../expread.y" +{ write_exp_elt_opcode (BINOP_COMMA); ; + break;} +case 4: +#line 229 "../expread.y" +{ write_exp_elt_opcode (UNOP_IND); ; + break;} +case 5: +#line 232 "../expread.y" +{ write_exp_elt_opcode (UNOP_ADDR); ; + break;} +case 6: +#line 235 "../expread.y" +{ write_exp_elt_opcode (UNOP_NEG); ; + break;} +case 7: +#line 239 "../expread.y" +{ write_exp_elt_opcode (UNOP_ZEROP); ; + break;} +case 8: +#line 243 "../expread.y" +{ write_exp_elt_opcode (UNOP_LOGNOT); ; + break;} +case 9: +#line 247 "../expread.y" +{ write_exp_elt_opcode (UNOP_PREINCREMENT); ; + break;} +case 10: +#line 251 "../expread.y" +{ write_exp_elt_opcode (UNOP_PREDECREMENT); ; + break;} +case 11: +#line 255 "../expread.y" +{ write_exp_elt_opcode (UNOP_POSTINCREMENT); ; + break;} +case 12: +#line 259 "../expread.y" +{ write_exp_elt_opcode (UNOP_POSTDECREMENT); ; + break;} +case 13: +#line 263 "../expread.y" +{ write_exp_elt_opcode (UNOP_SIZEOF); ; + break;} +case 14: +#line 267 "../expread.y" +{ write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string (yyvsp[0].sval); + write_exp_elt_opcode (STRUCTOP_PTR); ; + break;} +case 15: +#line 273 "../expread.y" +{ write_exp_elt_opcode (STRUCTOP_MPTR); ; + break;} +case 16: +#line 277 "../expread.y" +{ write_exp_elt_opcode (STRUCTOP_STRUCT); + write_exp_string (yyvsp[0].sval); + write_exp_elt_opcode (STRUCTOP_STRUCT); ; + break;} +case 17: +#line 283 "../expread.y" +{ write_exp_elt_opcode (STRUCTOP_MEMBER); ; + break;} +case 18: +#line 287 "../expread.y" +{ write_exp_elt_opcode (BINOP_SUBSCRIPT); ; + break;} +case 19: +#line 293 "../expread.y" +{ start_arglist (); ; + break;} +case 20: +#line 295 "../expread.y" +{ write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_longcst ((LONGEST) end_arglist ()); + write_exp_elt_opcode (OP_FUNCALL); ; + break;} +case 22: +#line 304 "../expread.y" +{ arglist_len = 1; ; + break;} +case 23: +#line 308 "../expread.y" +{ arglist_len++; ; + break;} +case 24: +#line 312 "../expread.y" +{ write_exp_elt_opcode (UNOP_MEMVAL); + write_exp_elt_type (yyvsp[-2].tval); + write_exp_elt_opcode (UNOP_MEMVAL); ; + break;} +case 25: +#line 318 "../expread.y" +{ write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_type (yyvsp[-2].tval); + write_exp_elt_opcode (UNOP_CAST); ; + break;} +case 26: +#line 324 "../expread.y" +{ ; + break;} +case 27: +#line 330 "../expread.y" +{ write_exp_elt_opcode (BINOP_REPEAT); ; + break;} +case 28: +#line 334 "../expread.y" +{ write_exp_elt_opcode (BINOP_MUL); ; + break;} +case 29: +#line 338 "../expread.y" +{ write_exp_elt_opcode (BINOP_DIV); ; + break;} +case 30: +#line 342 "../expread.y" +{ write_exp_elt_opcode (BINOP_REM); ; + break;} +case 31: +#line 346 "../expread.y" +{ write_exp_elt_opcode (BINOP_ADD); ; + break;} +case 32: +#line 350 "../expread.y" +{ write_exp_elt_opcode (BINOP_SUB); ; + break;} +case 33: +#line 354 "../expread.y" +{ write_exp_elt_opcode (BINOP_LSH); ; + break;} +case 34: +#line 358 "../expread.y" +{ write_exp_elt_opcode (BINOP_RSH); ; + break;} +case 35: +#line 362 "../expread.y" +{ write_exp_elt_opcode (BINOP_EQUAL); ; + break;} +case 36: +#line 366 "../expread.y" +{ write_exp_elt_opcode (BINOP_NOTEQUAL); ; + break;} +case 37: +#line 370 "../expread.y" +{ write_exp_elt_opcode (BINOP_LEQ); ; + break;} +case 38: +#line 374 "../expread.y" +{ write_exp_elt_opcode (BINOP_GEQ); ; + break;} +case 39: +#line 378 "../expread.y" +{ write_exp_elt_opcode (BINOP_LESS); ; + break;} +case 40: +#line 382 "../expread.y" +{ write_exp_elt_opcode (BINOP_GTR); ; + break;} +case 41: +#line 386 "../expread.y" +{ write_exp_elt_opcode (BINOP_LOGAND); ; + break;} +case 42: +#line 390 "../expread.y" +{ write_exp_elt_opcode (BINOP_LOGXOR); ; + break;} +case 43: +#line 394 "../expread.y" +{ write_exp_elt_opcode (BINOP_LOGIOR); ; + break;} +case 44: +#line 398 "../expread.y" +{ write_exp_elt_opcode (BINOP_AND); ; + break;} +case 45: +#line 402 "../expread.y" +{ write_exp_elt_opcode (BINOP_OR); ; + break;} +case 46: +#line 406 "../expread.y" +{ write_exp_elt_opcode (TERNOP_COND); ; + break;} +case 47: +#line 410 "../expread.y" +{ write_exp_elt_opcode (BINOP_ASSIGN); ; + break;} +case 48: +#line 414 "../expread.y" +{ write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); + write_exp_elt_opcode (yyvsp[-1].opcode); + write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); ; + break;} +case 49: +#line 420 "../expread.y" +{ write_exp_elt_opcode (OP_LONG); + if (yyvsp[0].lval == (int) yyvsp[0].lval || yyvsp[0].lval == (unsigned int) yyvsp[0].lval) + write_exp_elt_type (builtin_type_int); + else + write_exp_elt_type (BUILTIN_TYPE_LONGEST); + write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); + write_exp_elt_opcode (OP_LONG); ; + break;} +case 50: +#line 430 "../expread.y" +{ YYSTYPE val; + parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + if (val.lval == (int) val.lval || + val.lval == (unsigned int) val.lval) + write_exp_elt_type (builtin_type_int); + else + write_exp_elt_type (BUILTIN_TYPE_LONGEST); + write_exp_elt_longcst (val.lval); + write_exp_elt_opcode (OP_LONG); ; + break;} +case 51: +#line 443 "../expread.y" +{ + write_exp_elt_opcode (OP_LONG); + if (yyvsp[0].ulval == (unsigned int) yyvsp[0].ulval) + write_exp_elt_type (builtin_type_unsigned_int); + else + write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); + write_exp_elt_longcst ((LONGEST) yyvsp[0].ulval); + write_exp_elt_opcode (OP_LONG); + ; + break;} +case 52: +#line 455 "../expread.y" +{ YYSTYPE val; + parse_number (yyvsp[0].ssym.stoken.ptr, yyvsp[0].ssym.stoken.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + if (val.ulval == (unsigned int) val.ulval) + write_exp_elt_type (builtin_type_unsigned_int); + else + write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); + write_exp_elt_longcst ((LONGEST)val.ulval); + write_exp_elt_opcode (OP_LONG); + ; + break;} +case 53: +#line 468 "../expread.y" +{ write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_char); + write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); + write_exp_elt_opcode (OP_LONG); ; + break;} +case 54: +#line 475 "../expread.y" +{ write_exp_elt_opcode (OP_DOUBLE); + write_exp_elt_type (builtin_type_double); + write_exp_elt_dblcst (yyvsp[0].dval); + write_exp_elt_opcode (OP_DOUBLE); ; + break;} +case 56: +#line 485 "../expread.y" +{ write_exp_elt_opcode (OP_LAST); + write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); + write_exp_elt_opcode (OP_LAST); ; + break;} +case 57: +#line 491 "../expread.y" +{ write_exp_elt_opcode (OP_REGISTER); + write_exp_elt_longcst ((LONGEST) yyvsp[0].lval); + write_exp_elt_opcode (OP_REGISTER); ; + break;} +case 58: +#line 497 "../expread.y" +{ write_exp_elt_opcode (OP_INTERNALVAR); + write_exp_elt_intern (yyvsp[0].ivar); + write_exp_elt_opcode (OP_INTERNALVAR); ; + break;} +case 59: +#line 503 "../expread.y" +{ write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) TYPE_LENGTH (yyvsp[-1].tval)); + write_exp_elt_opcode (OP_LONG); ; + break;} +case 60: +#line 510 "../expread.y" +{ write_exp_elt_opcode (OP_STRING); + write_exp_string (yyvsp[0].sval); + write_exp_elt_opcode (OP_STRING); ; + break;} +case 61: +#line 517 "../expread.y" +{ write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); ; + break;} +case 62: +#line 524 "../expread.y" +{ + if (yyvsp[0].ssym.sym != 0) + yyval.bval = SYMBOL_BLOCK_VALUE (yyvsp[0].ssym.sym); + else + { + struct symtab *tem = + lookup_symtab (copy_name (yyvsp[0].ssym.stoken)); + if (tem) + yyval.bval = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1); + else + error ("No file or function \"%s\".", + copy_name (yyvsp[0].ssym.stoken)); + } + ; + break;} +case 63: +#line 541 "../expread.y" +{ struct symbol *tem + = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, + VAR_NAMESPACE, 0, NULL); + if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) + error ("No function \"%s\" in specified context.", + copy_name (yyvsp[0].sval)); + yyval.bval = SYMBOL_BLOCK_VALUE (tem); ; + break;} +case 64: +#line 551 "../expread.y" +{ struct symbol *sym; + sym = lookup_symbol (copy_name (yyvsp[0].sval), yyvsp[-2].bval, + VAR_NAMESPACE, 0, NULL); + if (sym == 0) + error ("No symbol \"%s\" in specified context.", + copy_name (yyvsp[0].sval)); + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); ; + break;} +case 65: +#line 563 "../expread.y" +{ + struct type *type = yyvsp[-2].tval; + if (TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + error ("`%s' is not defined as an aggregate type.", + TYPE_NAME (type)); + + write_exp_elt_opcode (OP_SCOPE); + write_exp_elt_type (type); + write_exp_string (yyvsp[0].sval); + write_exp_elt_opcode (OP_SCOPE); + ; + break;} +case 66: +#line 576 "../expread.y" +{ + char *name = copy_name (yyvsp[0].sval); + struct symbol *sym; + int i; + + sym = + lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); + if (sym) + { + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + break; + } + for (i = 0; i < misc_function_count; i++) + if (!strcmp (misc_function_vector[i].name, name)) + break; + + if (i < misc_function_count) + { + enum misc_function_type mft = + misc_function_vector[i].type; + + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (UNOP_MEMVAL); + if (mft == mf_data || mft == mf_bss) + write_exp_elt_type (builtin_type_int); + else if (mft == mf_text) + write_exp_elt_type (lookup_function_type (builtin_type_int)); + else + write_exp_elt_type (builtin_type_char); + write_exp_elt_opcode (UNOP_MEMVAL); + } + else + if (symtab_list == 0 + && partial_symtab_list == 0) + error ("No symbol table is loaded. Use the \"file\" command."); + else + error ("No symbol \"%s\" in current context.", name); + ; + break;} +case 67: +#line 622 "../expread.y" +{ struct symbol *sym = yyvsp[0].ssym.sym; + + if (sym) + { + switch (sym->class) + { + case LOC_REGISTER: + case LOC_ARG: + case LOC_LOCAL: + case LOC_LOCAL_ARG: + if (innermost_block == 0 || + contained_in (block_found, + innermost_block)) + innermost_block = block_found; + } + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + } + else if (yyvsp[0].ssym.is_a_field_of_this) + { + /* C++: it hangs off of `this'. Must + not inadvertently convert from a method call + to data ref. */ + if (innermost_block == 0 || + contained_in (block_found, innermost_block)) + innermost_block = block_found; + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string (yyvsp[0].ssym.stoken); + write_exp_elt_opcode (STRUCTOP_PTR); + } + else + { + register int i; + register char *arg = copy_name (yyvsp[0].ssym.stoken); + + /* FIXME, this search is linear! At least + optimize the strcmp with a 1-char cmp... */ + for (i = 0; i < misc_function_count; i++) + if (!strcmp (misc_function_vector[i].name, arg)) + break; + + if (i < misc_function_count) + { + enum misc_function_type mft = + misc_function_vector[i].type; + + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (UNOP_MEMVAL); + if (mft == mf_data || mft == mf_bss) + write_exp_elt_type (builtin_type_int); + else if (mft == mf_text) + write_exp_elt_type (lookup_function_type (builtin_type_int)); + else + write_exp_elt_type (builtin_type_char); + write_exp_elt_opcode (UNOP_MEMVAL); + } + else if (symtab_list == 0 + && partial_symtab_list == 0) + error ("No symbol table is loaded. Use the \"file\" command."); + else + error ("No symbol \"%s\" in current context.", + copy_name (yyvsp[0].ssym.stoken)); + } + ; + break;} +case 69: +#line 697 "../expread.y" +{ + /* This is where the interesting stuff happens. */ + int done = 0; + int array_size; + struct type *follow_type = yyvsp[-1].tval; + + while (!done) + switch (pop_type ()) + { + case tp_end: + done = 1; + break; + case tp_pointer: + follow_type = lookup_pointer_type (follow_type); + break; + case tp_reference: + follow_type = lookup_reference_type (follow_type); + break; + case tp_array: + array_size = (int) pop_type (); + if (array_size != -1) + follow_type = create_array_type (follow_type, + array_size); + else + follow_type = lookup_pointer_type (follow_type); + break; + case tp_function: + follow_type = lookup_function_type (follow_type); + break; + } + yyval.tval = follow_type; + ; + break;} +case 70: +#line 732 "../expread.y" +{ push_type (tp_pointer); yyval.voidval = 0; ; + break;} +case 71: +#line 734 "../expread.y" +{ push_type (tp_pointer); yyval.voidval = yyvsp[0].voidval; ; + break;} +case 73: +#line 739 "../expread.y" +{ yyval.voidval = yyvsp[-1].voidval; ; + break;} +case 74: +#line 741 "../expread.y" +{ + push_type ((enum type_pieces) yyvsp[0].lval); + push_type (tp_array); + ; + break;} +case 75: +#line 746 "../expread.y" +{ + push_type ((enum type_pieces) yyvsp[0].lval); + push_type (tp_array); + yyval.voidval = 0; + ; + break;} +case 76: +#line 752 "../expread.y" +{ push_type (tp_function); ; + break;} +case 77: +#line 754 "../expread.y" +{ push_type (tp_function); ; + break;} +case 78: +#line 758 "../expread.y" +{ yyval.lval = -1; ; + break;} +case 79: +#line 760 "../expread.y" +{ yyval.lval = yyvsp[-1].lval; ; + break;} +case 80: +#line 764 "../expread.y" +{ yyval.voidval = 0; ; + break;} +case 82: +#line 769 "../expread.y" +{ yyval.tval = lookup_member_type (builtin_type_int, yyvsp[-2].tval); ; + break;} +case 83: +#line 771 "../expread.y" +{ yyval.tval = lookup_member_type (yyvsp[-5].tval, yyvsp[-3].tval); ; + break;} +case 84: +#line 773 "../expread.y" +{ yyval.tval = lookup_member_type + (lookup_function_type (yyvsp[-7].tval), yyvsp[-5].tval); ; + break;} +case 85: +#line 776 "../expread.y" +{ yyval.tval = lookup_member_type + (lookup_function_type (yyvsp[-8].tval), yyvsp[-6].tval); + free (yyvsp[-1].tvec); ; + break;} +case 86: +#line 783 "../expread.y" +{ yyval.tval = yyvsp[0].tsym.type; ; + break;} +case 87: +#line 785 "../expread.y" +{ yyval.tval = builtin_type_int; ; + break;} +case 88: +#line 787 "../expread.y" +{ yyval.tval = builtin_type_long; ; + break;} +case 89: +#line 789 "../expread.y" +{ yyval.tval = builtin_type_short; ; + break;} +case 90: +#line 791 "../expread.y" +{ yyval.tval = builtin_type_long; ; + break;} +case 91: +#line 793 "../expread.y" +{ yyval.tval = builtin_type_unsigned_long; ; + break;} +case 92: +#line 795 "../expread.y" +{ yyval.tval = builtin_type_short; ; + break;} +case 93: +#line 797 "../expread.y" +{ yyval.tval = builtin_type_unsigned_short; ; + break;} +case 94: +#line 799 "../expread.y" +{ yyval.tval = lookup_struct (copy_name (yyvsp[0].sval), + expression_context_block); ; + break;} +case 95: +#line 802 "../expread.y" +{ yyval.tval = lookup_union (copy_name (yyvsp[0].sval), + expression_context_block); ; + break;} +case 96: +#line 805 "../expread.y" +{ yyval.tval = lookup_enum (copy_name (yyvsp[0].sval), + expression_context_block); ; + break;} +case 97: +#line 808 "../expread.y" +{ yyval.tval = lookup_unsigned_typename (TYPE_NAME(yyvsp[0].tsym.type)); ; + break;} +case 98: +#line 810 "../expread.y" +{ yyval.tval = builtin_type_unsigned_int; ; + break;} +case 99: +#line 812 "../expread.y" +{ yyval.tval = yyvsp[0].tsym.type; ; + break;} +case 100: +#line 814 "../expread.y" +{ yyval.tval = builtin_type_int; ; + break;} +case 102: +#line 819 "../expread.y" +{ + yyval.tsym.stoken.ptr = "int"; + yyval.tsym.stoken.length = 3; + yyval.tsym.type = builtin_type_int; + ; + break;} +case 103: +#line 825 "../expread.y" +{ + yyval.tsym.stoken.ptr = "long"; + yyval.tsym.stoken.length = 4; + yyval.tsym.type = builtin_type_long; + ; + break;} +case 104: +#line 831 "../expread.y" +{ + yyval.tsym.stoken.ptr = "short"; + yyval.tsym.stoken.length = 5; + yyval.tsym.type = builtin_type_short; + ; + break;} +case 105: +#line 840 "../expread.y" +{ yyval.tvec = (struct type **)xmalloc (sizeof (struct type *) * 2); + yyval.tvec[0] = (struct type *)0; + yyval.tvec[1] = yyvsp[0].tval; + ; + break;} +case 106: +#line 845 "../expread.y" +{ int len = sizeof (struct type *) * ++(yyvsp[-2].ivec[0]); + yyval.tvec = (struct type **)xrealloc (yyvsp[-2].tvec, len); + yyval.tvec[yyval.ivec[0]] = yyvsp[0].tval; + ; + break;} +case 107: +#line 851 "../expread.y" +{ yyval.sval = yyvsp[0].ssym.stoken; ; + break;} +case 108: +#line 852 "../expread.y" +{ yyval.sval = yyvsp[0].ssym.stoken; ; + break;} +case 109: +#line 853 "../expread.y" +{ yyval.sval = yyvsp[0].tsym.stoken; ; + break;} +case 110: +#line 854 "../expread.y" +{ yyval.sval = yyvsp[0].ssym.stoken; ; + break;} +case 111: +#line 855 "../expread.y" +{ yyval.sval = yyvsp[0].ssym.stoken; ; + break;} +} + /* the action file gets copied in in place of this dollarsign */ +#line 327 "bison.simple" + + yyvsp -= yylen; + yyssp -= yylen; +#ifdef YYLSP_NEEDED + yylsp -= yylen; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + + *++yyvsp = yyval; + +#ifdef YYLSP_NEEDED + yylsp++; + if (yylen == 0) + { + yylsp->first_line = yylloc.first_line; + yylsp->first_column = yylloc.first_column; + yylsp->last_line = (yylsp-1)->last_line; + yylsp->last_column = (yylsp-1)->last_column; + yylsp->text = 0; + } + else + { + yylsp->last_line = (yylsp+yylen-1)->last_line; + yylsp->last_column = (yylsp+yylen-1)->last_column; + } +#endif + + /* Now "shift" the result of the reduction. + Determine what state that goes to, + based on the state we popped back to + and the rule number reduced by. */ + + yyn = yyr1[yyn]; + + yystate = yypgoto[yyn - YYNTBASE] + *yyssp; + if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp) + yystate = yytable[yystate]; + else + yystate = yydefgoto[yyn - YYNTBASE]; + + goto yynewstate; + +yyerrlab: /* here on detecting error */ + + if (! yyerrstatus) + /* If not already recovering from an error, report this error. */ + { + ++yynerrs; + yyerror("parse error"); + } + + if (yyerrstatus == 3) + { + /* if just tried and failed to reuse lookahead token after an error, discard it. */ + + /* return failure if at end of input */ + if (yychar == YYEOF) + YYABORT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]); +#endif + + yychar = YYEMPTY; + } + + /* Else will try to reuse lookahead token + after shifting the error token. */ + + yyerrstatus = 3; /* Each real token shifted decrements this */ + + goto yyerrhandle; + +yyerrdefault: /* current state does not do anything special for the error token. */ + +#if 0 + /* This is wrong; only states that explicitly want error tokens + should shift them. */ + yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/ + if (yyn) goto yydefault; +#endif + +yyerrpop: /* pop the current state because it cannot handle the error token */ + + if (yyssp == yyss) YYABORT; + yyvsp--; + yystate = *--yyssp; +#ifdef YYLSP_NEEDED + yylsp--; +#endif + +#if YYDEBUG != 0 + if (yydebug) + { + short *ssp1 = yyss - 1; + fprintf (stderr, "Error: state stack now"); + while (ssp1 != yyssp) + fprintf (stderr, " %d", *++ssp1); + fprintf (stderr, "\n"); + } +#endif + +yyerrhandle: + + yyn = yypact[yystate]; + if (yyn == YYFLAG) + goto yyerrdefault; + + yyn += YYTERROR; + if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR) + goto yyerrdefault; + + yyn = yytable[yyn]; + if (yyn < 0) + { + if (yyn == YYFLAG) + goto yyerrpop; + yyn = -yyn; + goto yyreduce; + } + else if (yyn == 0) + goto yyerrpop; + + if (yyn == YYFINAL) + YYACCEPT; + +#if YYDEBUG != 0 + if (yydebug) + fprintf(stderr, "Shifting error token, "); +#endif + + *++yyvsp = yylval; +#ifdef YYLSP_NEEDED + *++yylsp = yylloc; +#endif + + yystate = yyn; + goto yynewstate; +} +#line 864 "../expread.y" + + +/* Begin counting arguments for a function call, + saving the data about any containing call. */ + +static void +start_arglist () +{ + register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall)); + + new->next = funcall_chain; + new->arglist_len = arglist_len; + arglist_len = 0; + funcall_chain = new; +} + +/* Return the number of arguments in a function call just terminated, + and restore the data for the containing function call. */ + +static int +end_arglist () +{ + register int val = arglist_len; + register struct funcall *call = funcall_chain; + funcall_chain = call->next; + arglist_len = call->arglist_len; + free (call); + return val; +} + +/* Free everything in the funcall chain. + Used when there is an error inside parsing. */ + +static void +free_funcalls () +{ + register struct funcall *call, *next; + + for (call = funcall_chain; call; call = next) + { + next = call->next; + free (call); + } +} + +/* This page contains the functions for adding data to the struct expression + being constructed. */ + +/* Add one element to the end of the expression. */ + +/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into + a register through here */ + +static void +write_exp_elt (expelt) + union exp_element expelt; +{ + if (expout_ptr >= expout_size) + { + expout_size *= 2; + expout = (struct expression *) xrealloc (expout, + sizeof (struct expression) + + expout_size * sizeof (union exp_element)); + } + expout->elts[expout_ptr++] = expelt; +} + +static void +write_exp_elt_opcode (expelt) + enum exp_opcode expelt; +{ + union exp_element tmp; + + tmp.opcode = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_sym (expelt) + struct symbol *expelt; +{ + union exp_element tmp; + + tmp.symbol = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_longcst (expelt) + LONGEST expelt; +{ + union exp_element tmp; + + tmp.longconst = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_dblcst (expelt) + double expelt; +{ + union exp_element tmp; + + tmp.doubleconst = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_type (expelt) + struct type *expelt; +{ + union exp_element tmp; + + tmp.type = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_intern (expelt) + struct internalvar *expelt; +{ + union exp_element tmp; + + tmp.internalvar = expelt; + + write_exp_elt (tmp); +} + +/* Add a string constant to the end of the expression. + Follow it by its length in bytes, as a separate exp_element. */ + +static void +write_exp_string (str) + struct stoken str; +{ + register int len = str.length; + register int lenelt + = (len + sizeof (union exp_element)) / sizeof (union exp_element); + + expout_ptr += lenelt; + + if (expout_ptr >= expout_size) + { + expout_size = max (expout_size * 2, expout_ptr + 10); + expout = (struct expression *) + xrealloc (expout, (sizeof (struct expression) + + (expout_size * sizeof (union exp_element)))); + } + bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len); + ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0; + write_exp_elt_longcst ((LONGEST) len); +} + +/* During parsing of a C expression, the pointer to the next character + is in this variable. */ + +static char *lexptr; + +/* Tokens that refer to names do so with explicit pointer and length, + so they can share the storage that lexptr is parsing. + + When it is necessary to pass a name to a function that expects + a null-terminated string, the substring is copied out + into a block of storage that namecopy points to. + + namecopy is allocated once, guaranteed big enough, for each parsing. */ + +static char *namecopy; + +/* Current depth in parentheses within the expression. */ + +static int paren_depth; + +/* Nonzero means stop parsing on first comma (if not within parentheses). */ + +static int comma_terminates; + +/* Take care of parsing a number (anything that starts with a digit). + Set yylval and return the token type; update lexptr. + LEN is the number of characters in it. */ + +/*** Needs some error checking for the float case ***/ + +static int +parse_number (p, len, parsed_float, putithere) + register char *p; + register int len; + int parsed_float; + YYSTYPE *putithere; +{ + register LONGEST n = 0; + register int i; + register int c; + register int base = input_radix; + int unsigned_p = 0; + + extern double atof (); + + if (parsed_float) + { + /* It's a float since it contains a point or an exponent. */ + putithere->dval = atof (p); + return FLOAT; + } + + /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ + if (p[0] == '0') + switch (p[1]) + { + case 'x': + case 'X': + if (len >= 3) + { + p += 2; + base = 16; + len -= 2; + } + break; + + case 't': + case 'T': + case 'd': + case 'D': + if (len >= 3) + { + p += 2; + base = 10; + len -= 2; + } + break; + + default: + base = 8; + break; + } + + while (len-- > 0) + { + c = *p++; + if (c >= 'A' && c <= 'Z') + c += 'a' - 'A'; + if (c != 'l' && c != 'u') + n *= base; + if (c >= '0' && c <= '9') + n += i = c - '0'; + else + { + if (base > 10 && c >= 'a' && c <= 'f') + n += i = c - 'a' + 10; + else if (len == 0 && c == 'l') + ; + else if (len == 0 && c == 'u') + unsigned_p = 1; + else + return ERROR; /* Char not a digit */ + } + if (i >= base) + return ERROR; /* Invalid digit in this base */ + } + + if (unsigned_p) + { + putithere->ulval = n; + return UINT; + } + else + { + putithere->lval = n; + return INT; + } +} + +struct token +{ + char *operator; + int token; + enum exp_opcode opcode; +}; + +static struct token tokentab3[] = + { + {">>=", ASSIGN_MODIFY, BINOP_RSH}, + {"<<=", ASSIGN_MODIFY, BINOP_LSH} + }; + +static struct token tokentab2[] = + { + {"+=", ASSIGN_MODIFY, BINOP_ADD}, + {"-=", ASSIGN_MODIFY, BINOP_SUB}, + {"*=", ASSIGN_MODIFY, BINOP_MUL}, + {"/=", ASSIGN_MODIFY, BINOP_DIV}, + {"%=", ASSIGN_MODIFY, BINOP_REM}, + {"|=", ASSIGN_MODIFY, BINOP_LOGIOR}, + {"&=", ASSIGN_MODIFY, BINOP_LOGAND}, + {"^=", ASSIGN_MODIFY, BINOP_LOGXOR}, + {"++", INCREMENT, BINOP_END}, + {"--", DECREMENT, BINOP_END}, + {"->", ARROW, BINOP_END}, + {"&&", AND, BINOP_END}, + {"||", OR, BINOP_END}, + {"::", COLONCOLON, BINOP_END}, + {"<<", LSH, BINOP_END}, + {">>", RSH, BINOP_END}, + {"==", EQUAL, BINOP_END}, + {"!=", NOTEQUAL, BINOP_END}, + {"<=", LEQ, BINOP_END}, + {">=", GEQ, BINOP_END} + }; + +/* assign machine-independent names to certain registers + * (unless overridden by the REGISTER_NAMES table) + */ +struct std_regs { + char *name; + int regnum; +} std_regs[] = { +#ifdef PC_REGNUM + { "pc", PC_REGNUM }, +#endif +#ifdef FP_REGNUM + { "fp", FP_REGNUM }, +#endif +#ifdef SP_REGNUM + { "sp", SP_REGNUM }, +#endif +#ifdef PS_REGNUM + { "ps", PS_REGNUM }, +#endif +}; + +#define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0]) + +/* Read one token, getting characters through lexptr. */ + +static int +yylex () +{ + register int c; + register int namelen; + register unsigned i; + register char *tokstart; + + retry: + + tokstart = lexptr; + /* See if it is a special token of length 3. */ + for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) + if (!strncmp (tokstart, tokentab3[i].operator, 3)) + { + lexptr += 3; + yylval.opcode = tokentab3[i].opcode; + return tokentab3[i].token; + } + + /* See if it is a special token of length 2. */ + for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) + if (!strncmp (tokstart, tokentab2[i].operator, 2)) + { + lexptr += 2; + yylval.opcode = tokentab2[i].opcode; + return tokentab2[i].token; + } + + switch (c = *tokstart) + { + case 0: + return 0; + + case ' ': + case '\t': + case '\n': + lexptr++; + goto retry; + + case '\'': + lexptr++; + c = *lexptr++; + if (c == '\\') + c = parse_escape (&lexptr); + yylval.lval = c; + c = *lexptr++; + if (c != '\'') + error ("Invalid character constant."); + return CHAR; + + case '(': + paren_depth++; + lexptr++; + return c; + + case ')': + if (paren_depth == 0) + return 0; + paren_depth--; + lexptr++; + return c; + + case ',': + if (comma_terminates && paren_depth == 0) + return 0; + lexptr++; + return c; + + case '.': + /* Might be a floating point number. */ + if (lexptr[1] < '0' || lexptr[1] > '9') + goto symbol; /* Nope, must be a symbol. */ + /* FALL THRU into number case. */ + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + /* It's a number. */ + int got_dot = 0, got_e = 0, toktype; + register char *p = tokstart; + int hex = input_radix > 10; + + if (c == '0' && (p[1] == 'x' || p[1] == 'X')) + { + p += 2; + hex = 1; + } + else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) + { + p += 2; + hex = 0; + } + + for (;; ++p) + { + if (!hex && !got_e && (*p == 'e' || *p == 'E')) + got_dot = got_e = 1; + else if (!hex && !got_dot && *p == '.') + got_dot = 1; + else if (got_e && (p[-1] == 'e' || p[-1] == 'E') + && (*p == '-' || *p == '+')) + /* This is the sign of the exponent, not the end of the + number. */ + continue; + /* We will take any letters or digits. parse_number will + complain if past the radix, or if L or U are not final. */ + else if ((*p < '0' || *p > '9') + && ((*p < 'a' || *p > 'z') + && (*p < 'A' || *p > 'Z'))) + break; + } + toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); + if (toktype == ERROR) + { + char *err_copy = (char *) alloca (p - tokstart + 1); + + bcopy (tokstart, err_copy, p - tokstart); + err_copy[p - tokstart] = 0; + error ("Invalid number \"%s\".", err_copy); + } + lexptr = p; + return toktype; + } + + case '+': + case '-': + case '*': + case '/': + case '%': + case '|': + case '&': + case '^': + case '~': + case '!': + case '@': + case '<': + case '>': + case '[': + case ']': + case '?': + case ':': + case '=': + case '{': + case '}': + symbol: + lexptr++; + return c; + + case '"': + for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++) + if (c == '\\') + { + c = tokstart[++namelen]; + if (c >= '0' && c <= '9') + { + c = tokstart[++namelen]; + if (c >= '0' && c <= '9') + c = tokstart[++namelen]; + } + } + yylval.sval.ptr = tokstart + 1; + yylval.sval.length = namelen - 1; + lexptr += namelen + 1; + return STRING; + } + + if (!(c == '_' || c == '$' + || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) + /* We must have come across a bad character (e.g. ';'). */ + error ("Invalid character '%c' in expression.", c); + + /* It's a name. See how long it is. */ + namelen = 0; + for (c = tokstart[namelen]; + (c == '_' || c == '$' || (c >= '0' && c <= '9') + || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); + c = tokstart[++namelen]) + ; + + /* The token "if" terminates the expression and is NOT + removed from the input stream. */ + if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') + { + return 0; + } + + lexptr += namelen; + + /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1) + and $$digits (equivalent to $<-digits> if you could type that). + Make token type LAST, and put the number (the digits) in yylval. */ + + if (*tokstart == '$') + { + register int negate = 0; + c = 1; + /* Double dollar means negate the number and add -1 as well. + Thus $$ alone means -1. */ + if (namelen >= 2 && tokstart[1] == '$') + { + negate = 1; + c = 2; + } + if (c == namelen) + { + /* Just dollars (one or two) */ + yylval.lval = - negate; + return LAST; + } + /* Is the rest of the token digits? */ + for (; c < namelen; c++) + if (!(tokstart[c] >= '0' && tokstart[c] <= '9')) + break; + if (c == namelen) + { + yylval.lval = atoi (tokstart + 1 + negate); + if (negate) + yylval.lval = - yylval.lval; + return LAST; + } + } + + /* Handle tokens that refer to machine registers: + $ followed by a register name. */ + + if (*tokstart == '$') { + for (c = 0; c < NUM_REGS; c++) + if (namelen - 1 == strlen (reg_names[c]) + && !strncmp (tokstart + 1, reg_names[c], namelen - 1)) + { + yylval.lval = c; + return REGNAME; + } + for (c = 0; c < NUM_STD_REGS; c++) + if (namelen - 1 == strlen (std_regs[c].name) + && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1)) + { + yylval.lval = std_regs[c].regnum; + return REGNAME; + } + } + /* Catch specific keywords. Should be done with a data structure. */ + switch (namelen) + { + case 8: + if (!strncmp (tokstart, "unsigned", 8)) + return UNSIGNED; + break; + case 6: + if (!strncmp (tokstart, "struct", 6)) + return STRUCT; + if (!strncmp (tokstart, "signed", 6)) + return SIGNED; + if (!strncmp (tokstart, "sizeof", 6)) + return SIZEOF; + break; + case 5: + if (!strncmp (tokstart, "union", 5)) + return UNION; + if (!strncmp (tokstart, "short", 5)) + return SHORT; + break; + case 4: + if (!strncmp (tokstart, "enum", 4)) + return ENUM; + if (!strncmp (tokstart, "long", 4)) + return LONG; + if (!strncmp (tokstart, "this", 4)) + { + static const char this_name[] = + { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' }; + + if (lookup_symbol (this_name, expression_context_block, + VAR_NAMESPACE, 0, NULL)) + return THIS; + } + break; + case 3: + if (!strncmp (tokstart, "int", 3)) + return INT_KEYWORD; + break; + default: + break; + } + + yylval.sval.ptr = tokstart; + yylval.sval.length = namelen; + + /* Any other names starting in $ are debugger internal variables. */ + + if (*tokstart == '$') + { + yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1); + return VARIABLE; + } + + /* Use token-type BLOCKNAME for symbols that happen to be defined as + functions or symtabs. If this is not so, then ... + Use token-type TYPENAME for symbols that happen to be defined + currently as names of types; NAME for other symbols. + The caller is not constrained to care about the distinction. */ + { + char *tmp = copy_name (yylval.sval); + struct symbol *sym; + int is_a_field_of_this = 0; + int hextype; + + sym = lookup_symbol (tmp, expression_context_block, + VAR_NAMESPACE, &is_a_field_of_this, NULL); + if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) || + lookup_partial_symtab (tmp)) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return BLOCKNAME; + } + if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + { + yylval.tsym.type = SYMBOL_TYPE (sym); + return TYPENAME; + } + if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0) + return TYPENAME; + + /* Input names that aren't symbols but ARE valid hex numbers, + when the input radix permits them, can be names or numbers + depending on the parse. Note we support radixes > 16 here. */ + if (!sym && + ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || + (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) + { + YYSTYPE newlval; /* Its value is ignored. */ + hextype = parse_number (tokstart, namelen, 0, &newlval); + if (hextype == INT) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME_OR_INT; + } + if (hextype == UINT) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME_OR_UINT; + } + } + + /* Any other kind of symbol */ + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME; + } +} + +static void +yyerror (msg) + char *msg; +{ + error ("Invalid syntax in expression."); +} + +/* Return a null-terminated temporary copy of the name + of a string token. */ + +static char * +copy_name (token) + struct stoken token; +{ + bcopy (token.ptr, namecopy, token.length); + namecopy[token.length] = 0; + return namecopy; +} + +/* Reverse an expression from suffix form (in which it is constructed) + to prefix form (in which we can conveniently print or execute it). */ + +static void prefixify_subexp (); + +static void +prefixify_expression (expr) + register struct expression *expr; +{ + register int len = sizeof (struct expression) + + expr->nelts * sizeof (union exp_element); + register struct expression *temp; + register int inpos = expr->nelts, outpos = 0; + + temp = (struct expression *) alloca (len); + + /* Copy the original expression into temp. */ + bcopy (expr, temp, len); + + prefixify_subexp (temp, expr, inpos, outpos); +} + +/* Return the number of exp_elements in the subexpression of EXPR + whose last exp_element is at index ENDPOS - 1 in EXPR. */ + +static int +length_of_subexp (expr, endpos) + register struct expression *expr; + register int endpos; +{ + register int oplen = 1; + register int args = 0; + register int i; + + if (endpos < 0) + error ("?error in length_of_subexp"); + + i = (int) expr->elts[endpos - 1].opcode; + + switch (i) + { + /* C++ */ + case OP_SCOPE: + oplen = 4 + ((expr->elts[endpos - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case OP_LONG: + case OP_DOUBLE: + oplen = 4; + break; + + case OP_VAR_VALUE: + case OP_LAST: + case OP_REGISTER: + case OP_INTERNALVAR: + oplen = 3; + break; + + case OP_FUNCALL: + oplen = 3; + args = 1 + expr->elts[endpos - 2].longconst; + break; + + case UNOP_CAST: + case UNOP_MEMVAL: + oplen = 3; + args = 1; + break; + + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + args = 1; + case OP_STRING: + oplen = 3 + ((expr->elts[endpos - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case TERNOP_COND: + args = 3; + break; + + case BINOP_ASSIGN_MODIFY: + oplen = 3; + args = 2; + break; + + /* C++ */ + case OP_THIS: + oplen = 2; + break; + + default: + args = 1 + (i < (int) BINOP_END); + } + + while (args > 0) + { + oplen += length_of_subexp (expr, endpos - oplen); + args--; + } + + return oplen; +} + +/* Copy the subexpression ending just before index INEND in INEXPR + into OUTEXPR, starting at index OUTBEG. + In the process, convert it from suffix to prefix form. */ + +static void +prefixify_subexp (inexpr, outexpr, inend, outbeg) + register struct expression *inexpr; + struct expression *outexpr; + register int inend; + int outbeg; +{ + register int oplen = 1; + register int args = 0; + register int i; + int *arglens; + enum exp_opcode opcode; + + /* Compute how long the last operation is (in OPLEN), + and also how many preceding subexpressions serve as + arguments for it (in ARGS). */ + + opcode = inexpr->elts[inend - 1].opcode; + switch (opcode) + { + /* C++ */ + case OP_SCOPE: + oplen = 4 + ((inexpr->elts[inend - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case OP_LONG: + case OP_DOUBLE: + oplen = 4; + break; + + case OP_VAR_VALUE: + case OP_LAST: + case OP_REGISTER: + case OP_INTERNALVAR: + oplen = 3; + break; + + case OP_FUNCALL: + oplen = 3; + args = 1 + inexpr->elts[inend - 2].longconst; + break; + + case UNOP_CAST: + case UNOP_MEMVAL: + oplen = 3; + args = 1; + break; + + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + args = 1; + case OP_STRING: + oplen = 3 + ((inexpr->elts[inend - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + + break; + + case TERNOP_COND: + args = 3; + break; + + case BINOP_ASSIGN_MODIFY: + oplen = 3; + args = 2; + break; + + /* C++ */ + case OP_THIS: + oplen = 2; + break; + + default: + args = 1 + ((int) opcode < (int) BINOP_END); + } + + /* Copy the final operator itself, from the end of the input + to the beginning of the output. */ + inend -= oplen; + bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg], + oplen * sizeof (union exp_element)); + outbeg += oplen; + + /* Find the lengths of the arg subexpressions. */ + arglens = (int *) alloca (args * sizeof (int)); + for (i = args - 1; i >= 0; i--) + { + oplen = length_of_subexp (inexpr, inend); + arglens[i] = oplen; + inend -= oplen; + } + + /* Now copy each subexpression, preserving the order of + the subexpressions, but prefixifying each one. + In this loop, inend starts at the beginning of + the expression this level is working on + and marches forward over the arguments. + outbeg does similarly in the output. */ + for (i = 0; i < args; i++) + { + oplen = arglens[i]; + inend += oplen; + prefixify_subexp (inexpr, outexpr, inend, outbeg); + outbeg += oplen; + } +} + +/* This page contains the two entry points to this file. */ + +/* Read a C expression from the string *STRINGPTR points to, + parse it, and return a pointer to a struct expression that we malloc. + Use block BLOCK as the lexical context for variable names; + if BLOCK is zero, use the block of the selected stack frame. + Meanwhile, advance *STRINGPTR to point after the expression, + at the first nonwhite character that is not part of the expression + (possibly a null character). + + If COMMA is nonzero, stop if a comma is reached. */ + +struct expression * +parse_c_1 (stringptr, block, comma) + char **stringptr; + struct block *block; + int comma; +{ + struct cleanup *old_chain; + + lexptr = *stringptr; + + paren_depth = 0; + type_stack_depth = 0; + + comma_terminates = comma; + + if (lexptr == 0 || *lexptr == 0) + error_no_arg ("expression to compute"); + + old_chain = make_cleanup (free_funcalls, 0); + funcall_chain = 0; + + expression_context_block = block ? block : get_selected_block (); + + namecopy = (char *) alloca (strlen (lexptr) + 1); + expout_size = 10; + expout_ptr = 0; + expout = (struct expression *) + xmalloc (sizeof (struct expression) + + expout_size * sizeof (union exp_element)); + make_cleanup (free_current_contents, &expout); + if (yyparse ()) + yyerror (NULL); + discard_cleanups (old_chain); + expout->nelts = expout_ptr; + expout = (struct expression *) + xrealloc (expout, + sizeof (struct expression) + + expout_ptr * sizeof (union exp_element)); + prefixify_expression (expout); + *stringptr = lexptr; + return expout; +} + +/* Parse STRING as an expression, and complain if this fails + to use up all of the contents of STRING. */ + +struct expression * +parse_c_expression (string) + char *string; +{ + register struct expression *exp; + exp = parse_c_1 (&string, 0, 0); + if (*string) + error ("Junk after end of expression."); + return exp; +} + +static void +push_type (tp) + enum type_pieces tp; +{ + if (type_stack_depth == type_stack_size) + { + type_stack_size *= 2; + type_stack = (enum type_pieces *) + xrealloc (type_stack, type_stack_size * sizeof (enum type_pieces)); + } + type_stack[type_stack_depth++] = tp; +} + +static enum type_pieces +pop_type () +{ + if (type_stack_depth) + return type_stack[--type_stack_depth]; + return tp_end; +} + +void +_initialize_expread () +{ + type_stack_size = 80; + type_stack_depth = 0; + type_stack = (enum type_pieces *) + xmalloc (type_stack_size * sizeof (enum type_pieces)); +} diff --git a/gdb/expread.y b/gdb/expread.y new file mode 100755 index 0000000..3b19750 --- /dev/null +++ b/gdb/expread.y @@ -0,0 +1,1902 @@ +/* Parse C expressions for GDB. + Copyright (C) 1986, 1989, 1990, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Parse a C expression from text in a string, + and return the result as a struct expression pointer. + That structure contains arithmetic operations in reverse polish, + with constants represented by operations that are followed by special data. + See expression.h for the details of the format. + What is important here is that it can be built up sequentially + during the process of parsing; the lower levels of the tree always + come first in the result. */ + +%{ +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "frame.h" +#include "expression.h" +#include "value.h" +#include "command.h" + +static struct expression *expout; +static int expout_size; +static int expout_ptr; + +static int yylex (); +static void yyerror (); +static void write_exp_elt (); +static void write_exp_elt_opcode (); +static void write_exp_elt_sym (); +static void write_exp_elt_longcst (); +static void write_exp_elt_dblcst (); +static void write_exp_elt_type (); +static void write_exp_elt_intern (); +static void write_exp_string (); +static void start_arglist (); +static int end_arglist (); +static void free_funcalls (); +static char *copy_name (); +static int parse_number (); + +/* If this is nonzero, this block is used as the lexical context + for symbol names. */ + +static struct block *expression_context_block; + +/* The innermost context required by the stack and register variables + we've encountered so far. */ +struct block *innermost_block; + +/* The block in which the most recently discovered symbol was found. */ +struct block *block_found; + +/* Number of arguments seen so far in innermost function call. */ +static int arglist_len; + +/* Data structure for saving values of arglist_len + for function calls whose arguments contain other function calls. */ + +struct funcall + { + struct funcall *next; + int arglist_len; + }; + +struct funcall *funcall_chain; + +/* This kind of datum is used to represent the name + of a symbol token. */ + +struct stoken + { + char *ptr; + int length; + }; + +struct ttype + { + struct stoken stoken; + struct type *type; + }; + +struct symtoken + { + struct stoken stoken; + struct symbol *sym; + int is_a_field_of_this; + }; + +/* For parsing of complicated types. + An array should be preceded in the list by the size of the array. */ +enum type_pieces + {tp_end = -1, tp_pointer, tp_reference, tp_array, tp_function}; +static enum type_pieces *type_stack; +static int type_stack_depth, type_stack_size; + +static void push_type (); +static enum type_pieces pop_type (); + +/* Allow debugging of parsing. */ +#define YYDEBUG 1 +%} + +/* Although the yacc "value" of an expression is not used, + since the result is stored in the structure being created, + other node types do have values. */ + +%union + { + LONGEST lval; + unsigned LONGEST ulval; + double dval; + struct symbol *sym; + struct type *tval; + struct stoken sval; + struct ttype tsym; + struct symtoken ssym; + int voidval; + struct block *bval; + enum exp_opcode opcode; + struct internalvar *ivar; + + struct type **tvec; + int *ivec; + } + +%type <voidval> exp exp1 start variable +%type <tval> type typebase +%type <tvec> nonempty_typelist +%type <bval> block + +/* Fancy type parsing. */ +%type <voidval> func_mod direct_abs_decl abs_decl +%type <tval> ptype +%type <lval> array_mod + +%token <lval> INT CHAR +%token <ulval> UINT +%token <dval> FLOAT + +/* Both NAME and TYPENAME tokens represent symbols in the input, + and both convey their data as strings. + But a TYPENAME is a string that happens to be defined as a typedef + or builtin type name (such as int or char) + and a NAME is any other symbol. + + Contexts where this distinction is not important can use the + nonterminal "name", which matches either NAME or TYPENAME. */ + +%token <sval> STRING +%token <ssym> NAME BLOCKNAME +%token <tsym> TYPENAME +%type <sval> name +%type <ssym> name_not_typename +%type <tsym> typename + +/* A NAME_OR_INT is a symbol which is not known in the symbol table, + but which would parse as a valid number in the current input radix. + E.g. "c" when input_radix==16. Depending on the parse, it will be + turned into a name or into a number. NAME_OR_UINT ditto. */ + +%token <ssym> NAME_OR_INT NAME_OR_UINT + +%token STRUCT UNION ENUM SIZEOF UNSIGNED COLONCOLON +%token ERROR + +/* Special type cases, put in to allow the parser to distinguish different + legal basetypes. */ +%token SIGNED LONG SHORT INT_KEYWORD + +%token <lval> LAST REGNAME + +%token <ivar> VARIABLE + +%token <opcode> ASSIGN_MODIFY + +/* C++ */ +%token THIS + +%left ',' +%left ABOVE_COMMA +%right '=' ASSIGN_MODIFY +%right '?' +%left OR +%left AND +%left '|' +%left '^' +%left '&' +%left EQUAL NOTEQUAL +%left '<' '>' LEQ GEQ +%left LSH RSH +%left '@' +%left '+' '-' +%left '*' '/' '%' +%right UNARY INCREMENT DECREMENT +%right ARROW '.' '[' '(' +%left COLONCOLON + +%% + +start : exp1 + ; + +/* Expressions, including the comma operator. */ +exp1 : exp + | exp1 ',' exp + { write_exp_elt_opcode (BINOP_COMMA); } + ; + +/* Expressions, not including the comma operator. */ +exp : '*' exp %prec UNARY + { write_exp_elt_opcode (UNOP_IND); } + +exp : '&' exp %prec UNARY + { write_exp_elt_opcode (UNOP_ADDR); } + +exp : '-' exp %prec UNARY + { write_exp_elt_opcode (UNOP_NEG); } + ; + +exp : '!' exp %prec UNARY + { write_exp_elt_opcode (UNOP_ZEROP); } + ; + +exp : '~' exp %prec UNARY + { write_exp_elt_opcode (UNOP_LOGNOT); } + ; + +exp : INCREMENT exp %prec UNARY + { write_exp_elt_opcode (UNOP_PREINCREMENT); } + ; + +exp : DECREMENT exp %prec UNARY + { write_exp_elt_opcode (UNOP_PREDECREMENT); } + ; + +exp : exp INCREMENT %prec UNARY + { write_exp_elt_opcode (UNOP_POSTINCREMENT); } + ; + +exp : exp DECREMENT %prec UNARY + { write_exp_elt_opcode (UNOP_POSTDECREMENT); } + ; + +exp : SIZEOF exp %prec UNARY + { write_exp_elt_opcode (UNOP_SIZEOF); } + ; + +exp : exp ARROW name + { write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string ($3); + write_exp_elt_opcode (STRUCTOP_PTR); } + ; + +exp : exp ARROW '*' exp + { write_exp_elt_opcode (STRUCTOP_MPTR); } + ; + +exp : exp '.' name + { write_exp_elt_opcode (STRUCTOP_STRUCT); + write_exp_string ($3); + write_exp_elt_opcode (STRUCTOP_STRUCT); } + ; + +exp : exp '.' '*' exp + { write_exp_elt_opcode (STRUCTOP_MEMBER); } + ; + +exp : exp '[' exp1 ']' + { write_exp_elt_opcode (BINOP_SUBSCRIPT); } + ; + +exp : exp '(' + /* This is to save the value of arglist_len + being accumulated by an outer function call. */ + { start_arglist (); } + arglist ')' %prec ARROW + { write_exp_elt_opcode (OP_FUNCALL); + write_exp_elt_longcst ((LONGEST) end_arglist ()); + write_exp_elt_opcode (OP_FUNCALL); } + ; + +arglist : + ; + +arglist : exp + { arglist_len = 1; } + ; + +arglist : arglist ',' exp %prec ABOVE_COMMA + { arglist_len++; } + ; + +exp : '{' type '}' exp %prec UNARY + { write_exp_elt_opcode (UNOP_MEMVAL); + write_exp_elt_type ($2); + write_exp_elt_opcode (UNOP_MEMVAL); } + ; + +exp : '(' type ')' exp %prec UNARY + { write_exp_elt_opcode (UNOP_CAST); + write_exp_elt_type ($2); + write_exp_elt_opcode (UNOP_CAST); } + ; + +exp : '(' exp1 ')' + { } + ; + +/* Binary operators in order of decreasing precedence. */ + +exp : exp '@' exp + { write_exp_elt_opcode (BINOP_REPEAT); } + ; + +exp : exp '*' exp + { write_exp_elt_opcode (BINOP_MUL); } + ; + +exp : exp '/' exp + { write_exp_elt_opcode (BINOP_DIV); } + ; + +exp : exp '%' exp + { write_exp_elt_opcode (BINOP_REM); } + ; + +exp : exp '+' exp + { write_exp_elt_opcode (BINOP_ADD); } + ; + +exp : exp '-' exp + { write_exp_elt_opcode (BINOP_SUB); } + ; + +exp : exp LSH exp + { write_exp_elt_opcode (BINOP_LSH); } + ; + +exp : exp RSH exp + { write_exp_elt_opcode (BINOP_RSH); } + ; + +exp : exp EQUAL exp + { write_exp_elt_opcode (BINOP_EQUAL); } + ; + +exp : exp NOTEQUAL exp + { write_exp_elt_opcode (BINOP_NOTEQUAL); } + ; + +exp : exp LEQ exp + { write_exp_elt_opcode (BINOP_LEQ); } + ; + +exp : exp GEQ exp + { write_exp_elt_opcode (BINOP_GEQ); } + ; + +exp : exp '<' exp + { write_exp_elt_opcode (BINOP_LESS); } + ; + +exp : exp '>' exp + { write_exp_elt_opcode (BINOP_GTR); } + ; + +exp : exp '&' exp + { write_exp_elt_opcode (BINOP_LOGAND); } + ; + +exp : exp '^' exp + { write_exp_elt_opcode (BINOP_LOGXOR); } + ; + +exp : exp '|' exp + { write_exp_elt_opcode (BINOP_LOGIOR); } + ; + +exp : exp AND exp + { write_exp_elt_opcode (BINOP_AND); } + ; + +exp : exp OR exp + { write_exp_elt_opcode (BINOP_OR); } + ; + +exp : exp '?' exp ':' exp %prec '?' + { write_exp_elt_opcode (TERNOP_COND); } + ; + +exp : exp '=' exp + { write_exp_elt_opcode (BINOP_ASSIGN); } + ; + +exp : exp ASSIGN_MODIFY exp + { write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); + write_exp_elt_opcode ($2); + write_exp_elt_opcode (BINOP_ASSIGN_MODIFY); } + ; + +exp : INT + { write_exp_elt_opcode (OP_LONG); + if ($1 == (int) $1 || $1 == (unsigned int) $1) + write_exp_elt_type (builtin_type_int); + else + write_exp_elt_type (BUILTIN_TYPE_LONGEST); + write_exp_elt_longcst ((LONGEST) $1); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : NAME_OR_INT + { YYSTYPE val; + parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + if (val.lval == (int) val.lval || + val.lval == (unsigned int) val.lval) + write_exp_elt_type (builtin_type_int); + else + write_exp_elt_type (BUILTIN_TYPE_LONGEST); + write_exp_elt_longcst (val.lval); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : UINT + { + write_exp_elt_opcode (OP_LONG); + if ($1 == (unsigned int) $1) + write_exp_elt_type (builtin_type_unsigned_int); + else + write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); + write_exp_elt_longcst ((LONGEST) $1); + write_exp_elt_opcode (OP_LONG); + } + ; + +exp : NAME_OR_UINT + { YYSTYPE val; + parse_number ($1.stoken.ptr, $1.stoken.length, 0, &val); + write_exp_elt_opcode (OP_LONG); + if (val.ulval == (unsigned int) val.ulval) + write_exp_elt_type (builtin_type_unsigned_int); + else + write_exp_elt_type (BUILTIN_TYPE_UNSIGNED_LONGEST); + write_exp_elt_longcst ((LONGEST)val.ulval); + write_exp_elt_opcode (OP_LONG); + } + ; + +exp : CHAR + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_char); + write_exp_elt_longcst ((LONGEST) $1); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : FLOAT + { write_exp_elt_opcode (OP_DOUBLE); + write_exp_elt_type (builtin_type_double); + write_exp_elt_dblcst ($1); + write_exp_elt_opcode (OP_DOUBLE); } + ; + +exp : variable + ; + +exp : LAST + { write_exp_elt_opcode (OP_LAST); + write_exp_elt_longcst ((LONGEST) $1); + write_exp_elt_opcode (OP_LAST); } + ; + +exp : REGNAME + { write_exp_elt_opcode (OP_REGISTER); + write_exp_elt_longcst ((LONGEST) $1); + write_exp_elt_opcode (OP_REGISTER); } + ; + +exp : VARIABLE + { write_exp_elt_opcode (OP_INTERNALVAR); + write_exp_elt_intern ($1); + write_exp_elt_opcode (OP_INTERNALVAR); } + ; + +exp : SIZEOF '(' type ')' %prec UNARY + { write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) TYPE_LENGTH ($3)); + write_exp_elt_opcode (OP_LONG); } + ; + +exp : STRING + { write_exp_elt_opcode (OP_STRING); + write_exp_string ($1); + write_exp_elt_opcode (OP_STRING); } + ; + +/* C++. */ +exp : THIS + { write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); } + ; + +/* end of C++. */ + +block : BLOCKNAME + { + if ($1.sym != 0) + $$ = SYMBOL_BLOCK_VALUE ($1.sym); + else + { + struct symtab *tem = + lookup_symtab (copy_name ($1.stoken)); + if (tem) + $$ = BLOCKVECTOR_BLOCK (BLOCKVECTOR (tem), 1); + else + error ("No file or function \"%s\".", + copy_name ($1.stoken)); + } + } + ; + +block : block COLONCOLON name + { struct symbol *tem + = lookup_symbol (copy_name ($3), $1, + VAR_NAMESPACE, 0, NULL); + if (!tem || SYMBOL_CLASS (tem) != LOC_BLOCK) + error ("No function \"%s\" in specified context.", + copy_name ($3)); + $$ = SYMBOL_BLOCK_VALUE (tem); } + ; + +variable: block COLONCOLON name + { struct symbol *sym; + sym = lookup_symbol (copy_name ($3), $1, + VAR_NAMESPACE, 0, NULL); + if (sym == 0) + error ("No symbol \"%s\" in specified context.", + copy_name ($3)); + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); } + ; + +variable: typebase COLONCOLON name + { + struct type *type = $1; + if (TYPE_CODE (type) != TYPE_CODE_STRUCT + && TYPE_CODE (type) != TYPE_CODE_UNION) + error ("`%s' is not defined as an aggregate type.", + TYPE_NAME (type)); + + write_exp_elt_opcode (OP_SCOPE); + write_exp_elt_type (type); + write_exp_string ($3); + write_exp_elt_opcode (OP_SCOPE); + } + | COLONCOLON name + { + char *name = copy_name ($2); + struct symbol *sym; + int i; + + sym = + lookup_symbol (name, 0, VAR_NAMESPACE, 0, NULL); + if (sym) + { + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + break; + } + for (i = 0; i < misc_function_count; i++) + if (!strcmp (misc_function_vector[i].name, name)) + break; + + if (i < misc_function_count) + { + enum misc_function_type mft = + misc_function_vector[i].type; + + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (UNOP_MEMVAL); + if (mft == mf_data || mft == mf_bss) + write_exp_elt_type (builtin_type_int); + else if (mft == mf_text) + write_exp_elt_type (lookup_function_type (builtin_type_int)); + else + write_exp_elt_type (builtin_type_char); + write_exp_elt_opcode (UNOP_MEMVAL); + } + else + if (symtab_list == 0 + && partial_symtab_list == 0) + error ("No symbol table is loaded. Use the \"file\" command."); + else + error ("No symbol \"%s\" in current context.", name); + } + ; + +variable: name_not_typename + { struct symbol *sym = $1.sym; + + if (sym) + { + switch (sym->class) + { + case LOC_REGISTER: + case LOC_ARG: + case LOC_LOCAL: + case LOC_LOCAL_ARG: + if (innermost_block == 0 || + contained_in (block_found, + innermost_block)) + innermost_block = block_found; + } + write_exp_elt_opcode (OP_VAR_VALUE); + write_exp_elt_sym (sym); + write_exp_elt_opcode (OP_VAR_VALUE); + } + else if ($1.is_a_field_of_this) + { + /* C++: it hangs off of `this'. Must + not inadvertently convert from a method call + to data ref. */ + if (innermost_block == 0 || + contained_in (block_found, innermost_block)) + innermost_block = block_found; + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (OP_THIS); + write_exp_elt_opcode (STRUCTOP_PTR); + write_exp_string ($1.stoken); + write_exp_elt_opcode (STRUCTOP_PTR); + } + else + { + register int i; + register char *arg = copy_name ($1.stoken); + + /* FIXME, this search is linear! At least + optimize the strcmp with a 1-char cmp... */ + for (i = 0; i < misc_function_count; i++) + if (!strcmp (misc_function_vector[i].name, arg)) + break; + + if (i < misc_function_count) + { + enum misc_function_type mft = + misc_function_vector[i].type; + + write_exp_elt_opcode (OP_LONG); + write_exp_elt_type (builtin_type_int); + write_exp_elt_longcst ((LONGEST) misc_function_vector[i].address); + write_exp_elt_opcode (OP_LONG); + write_exp_elt_opcode (UNOP_MEMVAL); + if (mft == mf_data || mft == mf_bss) + write_exp_elt_type (builtin_type_int); + else if (mft == mf_text) + write_exp_elt_type (lookup_function_type (builtin_type_int)); + else + write_exp_elt_type (builtin_type_char); + write_exp_elt_opcode (UNOP_MEMVAL); + } + else if (symtab_list == 0 + && partial_symtab_list == 0) + error ("No symbol table is loaded. Use the \"file\" command."); + else + error ("No symbol \"%s\" in current context.", + copy_name ($1.stoken)); + } + } + ; + + +ptype : typebase + | typebase abs_decl + { + /* This is where the interesting stuff happens. */ + int done = 0; + int array_size; + struct type *follow_type = $1; + + while (!done) + switch (pop_type ()) + { + case tp_end: + done = 1; + break; + case tp_pointer: + follow_type = lookup_pointer_type (follow_type); + break; + case tp_reference: + follow_type = lookup_reference_type (follow_type); + break; + case tp_array: + array_size = (int) pop_type (); + if (array_size != -1) + follow_type = create_array_type (follow_type, + array_size); + else + follow_type = lookup_pointer_type (follow_type); + break; + case tp_function: + follow_type = lookup_function_type (follow_type); + break; + } + $$ = follow_type; + } + ; + +abs_decl: '*' + { push_type (tp_pointer); $$ = 0; } + | '*' abs_decl + { push_type (tp_pointer); $$ = $2; } + | direct_abs_decl + ; + +direct_abs_decl: '(' abs_decl ')' + { $$ = $2; } + | direct_abs_decl array_mod + { + push_type ((enum type_pieces) $2); + push_type (tp_array); + } + | array_mod + { + push_type ((enum type_pieces) $1); + push_type (tp_array); + $$ = 0; + } + | direct_abs_decl func_mod + { push_type (tp_function); } + | func_mod + { push_type (tp_function); } + ; + +array_mod: '[' ']' + { $$ = -1; } + | '[' INT ']' + { $$ = $2; } + ; + +func_mod: '(' ')' + { $$ = 0; } + ; + +type : ptype + | typebase COLONCOLON '*' + { $$ = lookup_member_type (builtin_type_int, $1); } + | type '(' typebase COLONCOLON '*' ')' + { $$ = lookup_member_type ($1, $3); } + | type '(' typebase COLONCOLON '*' ')' '(' ')' + { $$ = lookup_member_type + (lookup_function_type ($1), $3); } + | type '(' typebase COLONCOLON '*' ')' '(' nonempty_typelist ')' + { $$ = lookup_member_type + (lookup_function_type ($1), $3); + free ($8); } + ; + +typebase + : TYPENAME + { $$ = $1.type; } + | INT_KEYWORD + { $$ = builtin_type_int; } + | LONG + { $$ = builtin_type_long; } + | SHORT + { $$ = builtin_type_short; } + | LONG INT_KEYWORD + { $$ = builtin_type_long; } + | UNSIGNED LONG INT_KEYWORD + { $$ = builtin_type_unsigned_long; } + | SHORT INT_KEYWORD + { $$ = builtin_type_short; } + | UNSIGNED SHORT INT_KEYWORD + { $$ = builtin_type_unsigned_short; } + | STRUCT name + { $$ = lookup_struct (copy_name ($2), + expression_context_block); } + | UNION name + { $$ = lookup_union (copy_name ($2), + expression_context_block); } + | ENUM name + { $$ = lookup_enum (copy_name ($2), + expression_context_block); } + | UNSIGNED typename + { $$ = lookup_unsigned_typename (TYPE_NAME($2.type)); } + | UNSIGNED + { $$ = builtin_type_unsigned_int; } + | SIGNED typename + { $$ = $2.type; } + | SIGNED + { $$ = builtin_type_int; } + ; + +typename: TYPENAME + | INT_KEYWORD + { + $$.stoken.ptr = "int"; + $$.stoken.length = 3; + $$.type = builtin_type_int; + } + | LONG + { + $$.stoken.ptr = "long"; + $$.stoken.length = 4; + $$.type = builtin_type_long; + } + | SHORT + { + $$.stoken.ptr = "short"; + $$.stoken.length = 5; + $$.type = builtin_type_short; + } + ; + +nonempty_typelist + : type + { $$ = (struct type **)xmalloc (sizeof (struct type *) * 2); + $$[0] = (struct type *)0; + $$[1] = $1; + } + | nonempty_typelist ',' type + { int len = sizeof (struct type *) * ++($<ivec>1[0]); + $$ = (struct type **)xrealloc ($1, len); + $$[$<ivec>$[0]] = $3; + } + ; + +name : NAME { $$ = $1.stoken; } + | BLOCKNAME { $$ = $1.stoken; } + | TYPENAME { $$ = $1.stoken; } + | NAME_OR_INT { $$ = $1.stoken; } + | NAME_OR_UINT { $$ = $1.stoken; } + ; + +name_not_typename : NAME + | BLOCKNAME + | NAME_OR_INT + | NAME_OR_UINT + ; + +%% + +/* Begin counting arguments for a function call, + saving the data about any containing call. */ + +static void +start_arglist () +{ + register struct funcall *new = (struct funcall *) xmalloc (sizeof (struct funcall)); + + new->next = funcall_chain; + new->arglist_len = arglist_len; + arglist_len = 0; + funcall_chain = new; +} + +/* Return the number of arguments in a function call just terminated, + and restore the data for the containing function call. */ + +static int +end_arglist () +{ + register int val = arglist_len; + register struct funcall *call = funcall_chain; + funcall_chain = call->next; + arglist_len = call->arglist_len; + free (call); + return val; +} + +/* Free everything in the funcall chain. + Used when there is an error inside parsing. */ + +static void +free_funcalls () +{ + register struct funcall *call, *next; + + for (call = funcall_chain; call; call = next) + { + next = call->next; + free (call); + } +} + +/* This page contains the functions for adding data to the struct expression + being constructed. */ + +/* Add one element to the end of the expression. */ + +/* To avoid a bug in the Sun 4 compiler, we pass things that can fit into + a register through here */ + +static void +write_exp_elt (expelt) + union exp_element expelt; +{ + if (expout_ptr >= expout_size) + { + expout_size *= 2; + expout = (struct expression *) xrealloc (expout, + sizeof (struct expression) + + expout_size * sizeof (union exp_element)); + } + expout->elts[expout_ptr++] = expelt; +} + +static void +write_exp_elt_opcode (expelt) + enum exp_opcode expelt; +{ + union exp_element tmp; + + tmp.opcode = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_sym (expelt) + struct symbol *expelt; +{ + union exp_element tmp; + + tmp.symbol = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_longcst (expelt) + LONGEST expelt; +{ + union exp_element tmp; + + tmp.longconst = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_dblcst (expelt) + double expelt; +{ + union exp_element tmp; + + tmp.doubleconst = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_type (expelt) + struct type *expelt; +{ + union exp_element tmp; + + tmp.type = expelt; + + write_exp_elt (tmp); +} + +static void +write_exp_elt_intern (expelt) + struct internalvar *expelt; +{ + union exp_element tmp; + + tmp.internalvar = expelt; + + write_exp_elt (tmp); +} + +/* Add a string constant to the end of the expression. + Follow it by its length in bytes, as a separate exp_element. */ + +static void +write_exp_string (str) + struct stoken str; +{ + register int len = str.length; + register int lenelt + = (len + sizeof (union exp_element)) / sizeof (union exp_element); + + expout_ptr += lenelt; + + if (expout_ptr >= expout_size) + { + expout_size = max (expout_size * 2, expout_ptr + 10); + expout = (struct expression *) + xrealloc (expout, (sizeof (struct expression) + + (expout_size * sizeof (union exp_element)))); + } + bcopy (str.ptr, (char *) &expout->elts[expout_ptr - lenelt], len); + ((char *) &expout->elts[expout_ptr - lenelt])[len] = 0; + write_exp_elt_longcst ((LONGEST) len); +} + +/* During parsing of a C expression, the pointer to the next character + is in this variable. */ + +static char *lexptr; + +/* Tokens that refer to names do so with explicit pointer and length, + so they can share the storage that lexptr is parsing. + + When it is necessary to pass a name to a function that expects + a null-terminated string, the substring is copied out + into a block of storage that namecopy points to. + + namecopy is allocated once, guaranteed big enough, for each parsing. */ + +static char *namecopy; + +/* Current depth in parentheses within the expression. */ + +static int paren_depth; + +/* Nonzero means stop parsing on first comma (if not within parentheses). */ + +static int comma_terminates; + +/* Take care of parsing a number (anything that starts with a digit). + Set yylval and return the token type; update lexptr. + LEN is the number of characters in it. */ + +/*** Needs some error checking for the float case ***/ + +static int +parse_number (p, len, parsed_float, putithere) + register char *p; + register int len; + int parsed_float; + YYSTYPE *putithere; +{ + register LONGEST n = 0; + register int i; + register int c; + register int base = input_radix; + int unsigned_p = 0; + + extern double atof (); + + if (parsed_float) + { + /* It's a float since it contains a point or an exponent. */ + putithere->dval = atof (p); + return FLOAT; + } + + /* Handle base-switching prefixes 0x, 0t, 0d, 0 */ + if (p[0] == '0') + switch (p[1]) + { + case 'x': + case 'X': + if (len >= 3) + { + p += 2; + base = 16; + len -= 2; + } + break; + + case 't': + case 'T': + case 'd': + case 'D': + if (len >= 3) + { + p += 2; + base = 10; + len -= 2; + } + break; + + default: + base = 8; + break; + } + + while (len-- > 0) + { + c = *p++; + if (c >= 'A' && c <= 'Z') + c += 'a' - 'A'; + if (c != 'l' && c != 'u') + n *= base; + if (c >= '0' && c <= '9') + n += i = c - '0'; + else + { + if (base > 10 && c >= 'a' && c <= 'f') + n += i = c - 'a' + 10; + else if (len == 0 && c == 'l') + ; + else if (len == 0 && c == 'u') + unsigned_p = 1; + else + return ERROR; /* Char not a digit */ + } + if (i >= base) + return ERROR; /* Invalid digit in this base */ + } + + if (unsigned_p) + { + putithere->ulval = n; + return UINT; + } + else + { + putithere->lval = n; + return INT; + } +} + +struct token +{ + char *operator; + int token; + enum exp_opcode opcode; +}; + +static struct token tokentab3[] = + { + {">>=", ASSIGN_MODIFY, BINOP_RSH}, + {"<<=", ASSIGN_MODIFY, BINOP_LSH} + }; + +static struct token tokentab2[] = + { + {"+=", ASSIGN_MODIFY, BINOP_ADD}, + {"-=", ASSIGN_MODIFY, BINOP_SUB}, + {"*=", ASSIGN_MODIFY, BINOP_MUL}, + {"/=", ASSIGN_MODIFY, BINOP_DIV}, + {"%=", ASSIGN_MODIFY, BINOP_REM}, + {"|=", ASSIGN_MODIFY, BINOP_LOGIOR}, + {"&=", ASSIGN_MODIFY, BINOP_LOGAND}, + {"^=", ASSIGN_MODIFY, BINOP_LOGXOR}, + {"++", INCREMENT, BINOP_END}, + {"--", DECREMENT, BINOP_END}, + {"->", ARROW, BINOP_END}, + {"&&", AND, BINOP_END}, + {"||", OR, BINOP_END}, + {"::", COLONCOLON, BINOP_END}, + {"<<", LSH, BINOP_END}, + {">>", RSH, BINOP_END}, + {"==", EQUAL, BINOP_END}, + {"!=", NOTEQUAL, BINOP_END}, + {"<=", LEQ, BINOP_END}, + {">=", GEQ, BINOP_END} + }; + +/* assign machine-independent names to certain registers + * (unless overridden by the REGISTER_NAMES table) + */ +struct std_regs { + char *name; + int regnum; +} std_regs[] = { +#ifdef PC_REGNUM + { "pc", PC_REGNUM }, +#endif +#ifdef FP_REGNUM + { "fp", FP_REGNUM }, +#endif +#ifdef SP_REGNUM + { "sp", SP_REGNUM }, +#endif +#ifdef PS_REGNUM + { "ps", PS_REGNUM }, +#endif +}; + +#define NUM_STD_REGS (sizeof std_regs / sizeof std_regs[0]) + +/* Read one token, getting characters through lexptr. */ + +static int +yylex () +{ + register int c; + register int namelen; + register unsigned i; + register char *tokstart; + + retry: + + tokstart = lexptr; + /* See if it is a special token of length 3. */ + for (i = 0; i < sizeof tokentab3 / sizeof tokentab3[0]; i++) + if (!strncmp (tokstart, tokentab3[i].operator, 3)) + { + lexptr += 3; + yylval.opcode = tokentab3[i].opcode; + return tokentab3[i].token; + } + + /* See if it is a special token of length 2. */ + for (i = 0; i < sizeof tokentab2 / sizeof tokentab2[0]; i++) + if (!strncmp (tokstart, tokentab2[i].operator, 2)) + { + lexptr += 2; + yylval.opcode = tokentab2[i].opcode; + return tokentab2[i].token; + } + + switch (c = *tokstart) + { + case 0: + return 0; + + case ' ': + case '\t': + case '\n': + lexptr++; + goto retry; + + case '\'': + lexptr++; + c = *lexptr++; + if (c == '\\') + c = parse_escape (&lexptr); + yylval.lval = c; + c = *lexptr++; + if (c != '\'') + error ("Invalid character constant."); + return CHAR; + + case '(': + paren_depth++; + lexptr++; + return c; + + case ')': + if (paren_depth == 0) + return 0; + paren_depth--; + lexptr++; + return c; + + case ',': + if (comma_terminates && paren_depth == 0) + return 0; + lexptr++; + return c; + + case '.': + /* Might be a floating point number. */ + if (lexptr[1] < '0' || lexptr[1] > '9') + goto symbol; /* Nope, must be a symbol. */ + /* FALL THRU into number case. */ + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + { + /* It's a number. */ + int got_dot = 0, got_e = 0, toktype; + register char *p = tokstart; + int hex = input_radix > 10; + + if (c == '0' && (p[1] == 'x' || p[1] == 'X')) + { + p += 2; + hex = 1; + } + else if (c == '0' && (p[1]=='t' || p[1]=='T' || p[1]=='d' || p[1]=='D')) + { + p += 2; + hex = 0; + } + + for (;; ++p) + { + if (!hex && !got_e && (*p == 'e' || *p == 'E')) + got_dot = got_e = 1; + else if (!hex && !got_dot && *p == '.') + got_dot = 1; + else if (got_e && (p[-1] == 'e' || p[-1] == 'E') + && (*p == '-' || *p == '+')) + /* This is the sign of the exponent, not the end of the + number. */ + continue; + /* We will take any letters or digits. parse_number will + complain if past the radix, or if L or U are not final. */ + else if ((*p < '0' || *p > '9') + && ((*p < 'a' || *p > 'z') + && (*p < 'A' || *p > 'Z'))) + break; + } + toktype = parse_number (tokstart, p - tokstart, got_dot|got_e, &yylval); + if (toktype == ERROR) + { + char *err_copy = (char *) alloca (p - tokstart + 1); + + bcopy (tokstart, err_copy, p - tokstart); + err_copy[p - tokstart] = 0; + error ("Invalid number \"%s\".", err_copy); + } + lexptr = p; + return toktype; + } + + case '+': + case '-': + case '*': + case '/': + case '%': + case '|': + case '&': + case '^': + case '~': + case '!': + case '@': + case '<': + case '>': + case '[': + case ']': + case '?': + case ':': + case '=': + case '{': + case '}': + symbol: + lexptr++; + return c; + + case '"': + for (namelen = 1; (c = tokstart[namelen]) != '"'; namelen++) + if (c == '\\') + { + c = tokstart[++namelen]; + if (c >= '0' && c <= '9') + { + c = tokstart[++namelen]; + if (c >= '0' && c <= '9') + c = tokstart[++namelen]; + } + } + yylval.sval.ptr = tokstart + 1; + yylval.sval.length = namelen - 1; + lexptr += namelen + 1; + return STRING; + } + + if (!(c == '_' || c == '$' + || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))) + /* We must have come across a bad character (e.g. ';'). */ + error ("Invalid character '%c' in expression.", c); + + /* It's a name. See how long it is. */ + namelen = 0; + for (c = tokstart[namelen]; + (c == '_' || c == '$' || (c >= '0' && c <= '9') + || (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z')); + c = tokstart[++namelen]) + ; + + /* The token "if" terminates the expression and is NOT + removed from the input stream. */ + if (namelen == 2 && tokstart[0] == 'i' && tokstart[1] == 'f') + { + return 0; + } + + lexptr += namelen; + + /* Handle the tokens $digits; also $ (short for $0) and $$ (short for $$1) + and $$digits (equivalent to $<-digits> if you could type that). + Make token type LAST, and put the number (the digits) in yylval. */ + + if (*tokstart == '$') + { + register int negate = 0; + c = 1; + /* Double dollar means negate the number and add -1 as well. + Thus $$ alone means -1. */ + if (namelen >= 2 && tokstart[1] == '$') + { + negate = 1; + c = 2; + } + if (c == namelen) + { + /* Just dollars (one or two) */ + yylval.lval = - negate; + return LAST; + } + /* Is the rest of the token digits? */ + for (; c < namelen; c++) + if (!(tokstart[c] >= '0' && tokstart[c] <= '9')) + break; + if (c == namelen) + { + yylval.lval = atoi (tokstart + 1 + negate); + if (negate) + yylval.lval = - yylval.lval; + return LAST; + } + } + + /* Handle tokens that refer to machine registers: + $ followed by a register name. */ + + if (*tokstart == '$') { + for (c = 0; c < NUM_REGS; c++) + if (namelen - 1 == strlen (reg_names[c]) + && !strncmp (tokstart + 1, reg_names[c], namelen - 1)) + { + yylval.lval = c; + return REGNAME; + } + for (c = 0; c < NUM_STD_REGS; c++) + if (namelen - 1 == strlen (std_regs[c].name) + && !strncmp (tokstart + 1, std_regs[c].name, namelen - 1)) + { + yylval.lval = std_regs[c].regnum; + return REGNAME; + } + } + /* Catch specific keywords. Should be done with a data structure. */ + switch (namelen) + { + case 8: + if (!strncmp (tokstart, "unsigned", 8)) + return UNSIGNED; + break; + case 6: + if (!strncmp (tokstart, "struct", 6)) + return STRUCT; + if (!strncmp (tokstart, "signed", 6)) + return SIGNED; + if (!strncmp (tokstart, "sizeof", 6)) + return SIZEOF; + break; + case 5: + if (!strncmp (tokstart, "union", 5)) + return UNION; + if (!strncmp (tokstart, "short", 5)) + return SHORT; + break; + case 4: + if (!strncmp (tokstart, "enum", 4)) + return ENUM; + if (!strncmp (tokstart, "long", 4)) + return LONG; + if (!strncmp (tokstart, "this", 4)) + { + static const char this_name[] = + { CPLUS_MARKER, 't', 'h', 'i', 's', '\0' }; + + if (lookup_symbol (this_name, expression_context_block, + VAR_NAMESPACE, 0, NULL)) + return THIS; + } + break; + case 3: + if (!strncmp (tokstart, "int", 3)) + return INT_KEYWORD; + break; + default: + break; + } + + yylval.sval.ptr = tokstart; + yylval.sval.length = namelen; + + /* Any other names starting in $ are debugger internal variables. */ + + if (*tokstart == '$') + { + yylval.ivar = lookup_internalvar (copy_name (yylval.sval) + 1); + return VARIABLE; + } + + /* Use token-type BLOCKNAME for symbols that happen to be defined as + functions or symtabs. If this is not so, then ... + Use token-type TYPENAME for symbols that happen to be defined + currently as names of types; NAME for other symbols. + The caller is not constrained to care about the distinction. */ + { + char *tmp = copy_name (yylval.sval); + struct symbol *sym; + int is_a_field_of_this = 0; + int hextype; + + sym = lookup_symbol (tmp, expression_context_block, + VAR_NAMESPACE, &is_a_field_of_this, NULL); + if ((sym && SYMBOL_CLASS (sym) == LOC_BLOCK) || + lookup_partial_symtab (tmp)) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return BLOCKNAME; + } + if (sym && SYMBOL_CLASS (sym) == LOC_TYPEDEF) + { + yylval.tsym.type = SYMBOL_TYPE (sym); + return TYPENAME; + } + if ((yylval.tsym.type = lookup_primitive_typename (tmp)) != 0) + return TYPENAME; + + /* Input names that aren't symbols but ARE valid hex numbers, + when the input radix permits them, can be names or numbers + depending on the parse. Note we support radixes > 16 here. */ + if (!sym && + ((tokstart[0] >= 'a' && tokstart[0] < 'a' + input_radix - 10) || + (tokstart[0] >= 'A' && tokstart[0] < 'A' + input_radix - 10))) + { + YYSTYPE newlval; /* Its value is ignored. */ + hextype = parse_number (tokstart, namelen, 0, &newlval); + if (hextype == INT) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME_OR_INT; + } + if (hextype == UINT) + { + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME_OR_UINT; + } + } + + /* Any other kind of symbol */ + yylval.ssym.sym = sym; + yylval.ssym.is_a_field_of_this = is_a_field_of_this; + return NAME; + } +} + +static void +yyerror (msg) + char *msg; +{ + error ("Invalid syntax in expression."); +} + +/* Return a null-terminated temporary copy of the name + of a string token. */ + +static char * +copy_name (token) + struct stoken token; +{ + bcopy (token.ptr, namecopy, token.length); + namecopy[token.length] = 0; + return namecopy; +} + +/* Reverse an expression from suffix form (in which it is constructed) + to prefix form (in which we can conveniently print or execute it). */ + +static void prefixify_subexp (); + +static void +prefixify_expression (expr) + register struct expression *expr; +{ + register int len = sizeof (struct expression) + + expr->nelts * sizeof (union exp_element); + register struct expression *temp; + register int inpos = expr->nelts, outpos = 0; + + temp = (struct expression *) alloca (len); + + /* Copy the original expression into temp. */ + bcopy (expr, temp, len); + + prefixify_subexp (temp, expr, inpos, outpos); +} + +/* Return the number of exp_elements in the subexpression of EXPR + whose last exp_element is at index ENDPOS - 1 in EXPR. */ + +static int +length_of_subexp (expr, endpos) + register struct expression *expr; + register int endpos; +{ + register int oplen = 1; + register int args = 0; + register int i; + + if (endpos < 0) + error ("?error in length_of_subexp"); + + i = (int) expr->elts[endpos - 1].opcode; + + switch (i) + { + /* C++ */ + case OP_SCOPE: + oplen = 4 + ((expr->elts[endpos - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case OP_LONG: + case OP_DOUBLE: + oplen = 4; + break; + + case OP_VAR_VALUE: + case OP_LAST: + case OP_REGISTER: + case OP_INTERNALVAR: + oplen = 3; + break; + + case OP_FUNCALL: + oplen = 3; + args = 1 + expr->elts[endpos - 2].longconst; + break; + + case UNOP_CAST: + case UNOP_MEMVAL: + oplen = 3; + args = 1; + break; + + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + args = 1; + case OP_STRING: + oplen = 3 + ((expr->elts[endpos - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case TERNOP_COND: + args = 3; + break; + + case BINOP_ASSIGN_MODIFY: + oplen = 3; + args = 2; + break; + + /* C++ */ + case OP_THIS: + oplen = 2; + break; + + default: + args = 1 + (i < (int) BINOP_END); + } + + while (args > 0) + { + oplen += length_of_subexp (expr, endpos - oplen); + args--; + } + + return oplen; +} + +/* Copy the subexpression ending just before index INEND in INEXPR + into OUTEXPR, starting at index OUTBEG. + In the process, convert it from suffix to prefix form. */ + +static void +prefixify_subexp (inexpr, outexpr, inend, outbeg) + register struct expression *inexpr; + struct expression *outexpr; + register int inend; + int outbeg; +{ + register int oplen = 1; + register int args = 0; + register int i; + int *arglens; + enum exp_opcode opcode; + + /* Compute how long the last operation is (in OPLEN), + and also how many preceding subexpressions serve as + arguments for it (in ARGS). */ + + opcode = inexpr->elts[inend - 1].opcode; + switch (opcode) + { + /* C++ */ + case OP_SCOPE: + oplen = 4 + ((inexpr->elts[inend - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + break; + + case OP_LONG: + case OP_DOUBLE: + oplen = 4; + break; + + case OP_VAR_VALUE: + case OP_LAST: + case OP_REGISTER: + case OP_INTERNALVAR: + oplen = 3; + break; + + case OP_FUNCALL: + oplen = 3; + args = 1 + inexpr->elts[inend - 2].longconst; + break; + + case UNOP_CAST: + case UNOP_MEMVAL: + oplen = 3; + args = 1; + break; + + case STRUCTOP_STRUCT: + case STRUCTOP_PTR: + args = 1; + case OP_STRING: + oplen = 3 + ((inexpr->elts[inend - 2].longconst + + sizeof (union exp_element)) + / sizeof (union exp_element)); + + break; + + case TERNOP_COND: + args = 3; + break; + + case BINOP_ASSIGN_MODIFY: + oplen = 3; + args = 2; + break; + + /* C++ */ + case OP_THIS: + oplen = 2; + break; + + default: + args = 1 + ((int) opcode < (int) BINOP_END); + } + + /* Copy the final operator itself, from the end of the input + to the beginning of the output. */ + inend -= oplen; + bcopy (&inexpr->elts[inend], &outexpr->elts[outbeg], + oplen * sizeof (union exp_element)); + outbeg += oplen; + + /* Find the lengths of the arg subexpressions. */ + arglens = (int *) alloca (args * sizeof (int)); + for (i = args - 1; i >= 0; i--) + { + oplen = length_of_subexp (inexpr, inend); + arglens[i] = oplen; + inend -= oplen; + } + + /* Now copy each subexpression, preserving the order of + the subexpressions, but prefixifying each one. + In this loop, inend starts at the beginning of + the expression this level is working on + and marches forward over the arguments. + outbeg does similarly in the output. */ + for (i = 0; i < args; i++) + { + oplen = arglens[i]; + inend += oplen; + prefixify_subexp (inexpr, outexpr, inend, outbeg); + outbeg += oplen; + } +} + +/* This page contains the two entry points to this file. */ + +/* Read a C expression from the string *STRINGPTR points to, + parse it, and return a pointer to a struct expression that we malloc. + Use block BLOCK as the lexical context for variable names; + if BLOCK is zero, use the block of the selected stack frame. + Meanwhile, advance *STRINGPTR to point after the expression, + at the first nonwhite character that is not part of the expression + (possibly a null character). + + If COMMA is nonzero, stop if a comma is reached. */ + +struct expression * +parse_c_1 (stringptr, block, comma) + char **stringptr; + struct block *block; + int comma; +{ + struct cleanup *old_chain; + + lexptr = *stringptr; + + paren_depth = 0; + type_stack_depth = 0; + + comma_terminates = comma; + + if (lexptr == 0 || *lexptr == 0) + error_no_arg ("expression to compute"); + + old_chain = make_cleanup (free_funcalls, 0); + funcall_chain = 0; + + expression_context_block = block ? block : get_selected_block (); + + namecopy = (char *) alloca (strlen (lexptr) + 1); + expout_size = 10; + expout_ptr = 0; + expout = (struct expression *) + xmalloc (sizeof (struct expression) + + expout_size * sizeof (union exp_element)); + make_cleanup (free_current_contents, &expout); + if (yyparse ()) + yyerror (NULL); + discard_cleanups (old_chain); + expout->nelts = expout_ptr; + expout = (struct expression *) + xrealloc (expout, + sizeof (struct expression) + + expout_ptr * sizeof (union exp_element)); + prefixify_expression (expout); + *stringptr = lexptr; + return expout; +} + +/* Parse STRING as an expression, and complain if this fails + to use up all of the contents of STRING. */ + +struct expression * +parse_c_expression (string) + char *string; +{ + register struct expression *exp; + exp = parse_c_1 (&string, 0, 0); + if (*string) + error ("Junk after end of expression."); + return exp; +} + +static void +push_type (tp) + enum type_pieces tp; +{ + if (type_stack_depth == type_stack_size) + { + type_stack_size *= 2; + type_stack = (enum type_pieces *) + xrealloc (type_stack, type_stack_size * sizeof (enum type_pieces)); + } + type_stack[type_stack_depth++] = tp; +} + +static enum type_pieces +pop_type () +{ + if (type_stack_depth) + return type_stack[--type_stack_depth]; + return tp_end; +} + +void +_initialize_expread () +{ + type_stack_size = 80; + type_stack_depth = 0; + type_stack = (enum type_pieces *) + xmalloc (type_stack_size * sizeof (enum type_pieces)); +} diff --git a/gdb/getpagesize.h b/gdb/getpagesize.h new file mode 100755 index 0000000..32adae6 --- /dev/null +++ b/gdb/getpagesize.h @@ -0,0 +1,25 @@ +#ifdef BSD +#ifndef BSD4_1 +#define HAVE_GETPAGESIZE +#endif +#endif + +#ifndef HAVE_GETPAGESIZE + +#include <sys/param.h> + +#ifdef EXEC_PAGESIZE +#define getpagesize() EXEC_PAGESIZE +#else +#ifdef NBPG +#define getpagesize() NBPG * CLSIZE +#ifndef CLSIZE +#define CLSIZE 1 +#endif /* no CLSIZE */ +#else /* no NBPG */ +#define getpagesize() NBPC +#endif /* no NBPG */ +#endif /* no EXEC_PAGESIZE */ + +#endif /* not HAVE_GETPAGESIZE */ + diff --git a/gdb/gmalloc.c b/gdb/gmalloc.c new file mode 100755 index 0000000..0468551 --- /dev/null +++ b/gdb/gmalloc.c @@ -0,0 +1,1116 @@ + +/* gmalloc.c - THIS FILE IS AUTOMAGICALLY GENERATED SO DON'T EDIT IT. */ + +/* Single-file skeleton for GNU malloc. + Copyright 1989 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#define __ONEFILE + +/* DO NOT DELETE THIS LINE -- ansidecl.h INSERTED HERE. */ +/* Copyright (C) 1989 Free Software Foundation, Inc. +This file is part of the GNU C Library. + +The GNU C Library is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +The GNU C Library is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with the GNU C Library; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* ANSI and traditional C compatibility macros + + ANSI C is assumed if __STDC__ is #defined. + + Macros + PTR - Generic pointer type + LONG_DOUBLE - `long double' type + CONST - `const' keyword + VOLATILE - `volatile' keyword + SIGNED - `signed' keyword + PTRCONST - Generic const pointer (void *const) + + EXFUN(name, prototype) - declare external function NAME + with prototype PROTOTYPE + DEFUN(name, arglist, args) - define function NAME with + args ARGLIST of types in ARGS + DEFUN_VOID(name) - define function NAME with no args + AND - argument separator for ARGS + NOARGS - null arglist + DOTS - `...' in args + + For example: + extern int EXFUN(printf, (CONST char *format DOTS)); + int DEFUN(fprintf, (stream, format), + FILE *stream AND CONST char *format DOTS) { ... } + void DEFUN_VOID(abort) { ... } +*/ + +#ifndef _ANSIDECL_H + +#define _ANSIDECL_H 1 + + +/* Every source file includes this file, + so they will all get the switch for lint. */ +/* LINTLIBRARY */ + + +#ifdef __STDC__ + +#define PTR void * +#define PTRCONST void *CONST +#define LONG_DOUBLE long double + +#define AND , +#define NOARGS void +#define CONST const +#define VOLATILE volatile +#define SIGNED signed +#define DOTS , ... + +#define EXFUN(name, proto) name proto +#define DEFUN(name, arglist, args) name(args) +#define DEFUN_VOID(name) name(NOARGS) + +#else /* Not ANSI C. */ + +#define PTR char * +#define PTRCONST PTR +#define LONG_DOUBLE double + +#define AND ; +#define NOARGS +#define CONST +#define VOLATILE +#define SIGNED +#define DOTS + +#define EXFUN(name, proto) name() +#define DEFUN(name, arglist, args) name arglist args; +#define DEFUN_VOID(name) name() + +#endif /* ANSI C. */ + + +#endif /* ansidecl.h */ + +#ifdef __STDC__ +#include <limits.h> +#else +/* DO NOT DELETE THIS LINE -- limits.h INSERTED HERE. */ +/* Number of bits in a `char'. */ +#define CHAR_BIT 8 + +/* No multibyte characters supported yet. */ +#define MB_LEN_MAX 1 + +/* Minimum and maximum values a `signed char' can hold. */ +#define SCHAR_MIN -128 +#define SCHAR_MAX 127 + +/* Maximum value an `unsigned char' can hold. (Minimum is 0). */ +#define UCHAR_MAX 255U + +/* Minimum and maximum values a `char' can hold. */ +#ifdef __CHAR_UNSIGNED__ +#define CHAR_MIN 0 +#define CHAR_MAX 255U +#else +#define CHAR_MIN -128 +#define CHAR_MAX 127 +#endif + +/* Minimum and maximum values a `signed short int' can hold. */ +#define SHRT_MIN -32768 +#define SHRT_MAX 32767 + +/* Maximum value an `unsigned short int' can hold. (Minimum is 0). */ +#define USHRT_MAX 65535U + +/* Minimum and maximum values a `signed int' can hold. */ +#define INT_MIN -2147483648 +#define INT_MAX 2147483647 + +/* Maximum value an `unsigned int' can hold. (Minimum is 0). */ +#define UINT_MAX 4294967295U + +/* Minimum and maximum values a `signed long int' can hold. + (Same as `int'). */ +#define LONG_MIN (-LONG_MAX-1) +#define LONG_MAX 2147483647 + +/* Maximum value an `unsigned long int' can hold. (Minimum is 0). */ +#define ULONG_MAX 4294967295U +#endif + +#ifdef __STDC__ +#include <stddef.h> +#else +/* DO NOT DELETE THIS LINE -- stddef.h INSERTED HERE. */ +#ifndef _STDDEF_H +#define _STDDEF_H + +/* Signed type of difference of two pointers. */ + +typedef long ptrdiff_t; + +/* Unsigned type of `sizeof' something. */ + +#ifndef _SIZE_T /* in case <sys/types.h> has defined it. */ +#define _SIZE_T +typedef unsigned long size_t; +#endif /* _SIZE_T */ + +/* A null pointer constant. */ + +#undef NULL /* in case <stdio.h> has defined it. */ +#define NULL 0 + +/* Offset of member MEMBER in a struct of type TYPE. */ + +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) + +#endif /* _STDDEF_H */ +#endif + +/* DO NOT DELETE THIS LINE -- stdlib.h INSERTED HERE. */ +/* Fake stdlib.h supplying the stuff needed by malloc. */ + +#ifndef __ONEFILE +#include <stddef.h> +#endif + +extern void EXFUN(abort, (void)); +extern void EXFUN(free, (PTR)); +extern PTR EXFUN(malloc, (size_t)); +extern PTR EXFUN(realloc, (PTR, size_t)); + +/* DO NOT DELETE THIS LINE -- string.h INSERTED HERE. */ +/* Fake string.h supplying stuff used by malloc. */ +#ifndef __ONEFILE +#include <stddef.h> +#endif + +extern PTR EXFUN(memcpy, (PTR, PTR, size_t)); +extern PTR EXFUN(memset, (PTR, int, size_t)); +#define memmove memcpy + +#define _MALLOC_INTERNAL +/* DO NOT DELETE THIS LINE -- malloc.h INSERTED HERE. */ +/* Declarations for `malloc' and friends. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef _MALLOC_H + +#define _MALLOC_H 1 + +#ifndef __ONEFILE +#define __need_NULL +#define __need_size_t +#define __need_ptrdiff_t +#include <stddef.h> +#endif + +#ifdef _MALLOC_INTERNAL + +#ifndef __ONEFILE +#include <limits.h> +#endif + +/* The allocator divides the heap into blocks of fixed size; large + requests receive one or more whole blocks, and small requests + receive a fragment of a block. Fragment sizes are powers of two, + and all fragments of a block are the same size. When all the + fragments in a block have been freed, the block itself is freed. */ +#define INT_BIT (CHAR_BIT * sizeof(int)) +#define BLOCKLOG (INT_BIT > 16 ? 12 : 9) +#define BLOCKSIZE (1 << BLOCKLOG) +#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) + +/* Determine the amount of memory spanned by the initial heap table + (not an absolute limit). */ +#define HEAP (INT_BIT > 16 ? 4194304 : 65536) + +/* Number of contiguous free blocks allowed to build up at the end of + memory before they will be returned to the system. */ +#define FINAL_FREE_BLOCKS 8 + +/* Where to start searching the free list when looking for new memory. + The two possible values are 0 and _heapindex. Starting at 0 seems + to reduce total memory usage, while starting at _heapindex seems to + run faster. */ +#define MALLOC_SEARCH_START _heapindex + +/* Data structure giving per-block information. */ +typedef union + { + /* Heap information for a busy block. */ + struct + { + /* Zero for a large block, or positive giving the + logarithm to the base two of the fragment size. */ + int type; + union + { + struct + { + size_t nfree; /* Free fragments in a fragmented block. */ + size_t first; /* First free fragment of the block. */ + } frag; + /* Size (in blocks) of a large cluster. */ + size_t size; + } info; + } busy; + /* Heap information for a free block (that may be the first of + a free cluster). */ + struct + { + size_t size; /* Size (in blocks) of a free cluster. */ + size_t next; /* Index of next free cluster. */ + size_t prev; /* Index of previous free cluster. */ + } free; + } malloc_info; + +/* Pointer to first block of the heap. */ +extern char *_heapbase; + +/* Table indexed by block number giving per-block information. */ +extern malloc_info *_heapinfo; + +/* Address to block number and vice versa. */ +#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) +#define ADDRESS(B) ((PTR) (((B) - 1) * BLOCKSIZE + _heapbase)) + +/* Current search index for the heap table. */ +extern size_t _heapindex; + +/* Limit of valid info table indices. */ +extern size_t _heaplimit; + +/* Doubly linked lists of free fragments. */ +struct list + { + struct list *next; + struct list *prev; + }; + +/* Free list headers for each fragment size. */ +extern struct list _fraghead[]; + +/* Instrumentation. */ +extern size_t _chunks_used; +extern size_t _bytes_used; +extern size_t _chunks_free; +extern size_t _bytes_free; + +/* Internal version of free() used in morecore(). */ +extern void EXFUN(__free, (PTR __ptr)); + +#endif /* _MALLOC_INTERNAL. */ + +/* Underlying allocation function; successive calls should + return contiguous pieces of memory. */ +extern PTR EXFUN((*__morecore), (ptrdiff_t __size)); + +/* Default value of previous. */ +extern PTR EXFUN(__default_morecore, (ptrdiff_t __size)); + +/* Flag whether malloc has been called. */ +extern int __malloc_initialized; + +/* Hooks for debugging versions. */ +extern void EXFUN((*__free_hook), (PTR __ptr)); +extern PTR EXFUN((*__malloc_hook), (size_t __size)); +extern PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size)); + +/* Activate a standard collection of debugging hooks. */ +extern void EXFUN(mcheck, (void EXFUN((*func), (void)))); + +/* Statistics available to the user. */ +struct mstats + { + size_t bytes_total; /* Total size of the heap. */ + size_t chunks_used; /* Chunks allocated by the user. */ + size_t bytes_used; /* Byte total of user-allocated chunks. */ + size_t chunks_free; /* Chunks in the free list. */ + size_t bytes_free; /* Byte total of chunks in the free list. */ + }; + +/* Pick up the current statistics. */ +extern struct mstats EXFUN(mstats, (NOARGS)); + +#endif /* malloc.h */ + +/* DO NOT DELETE THIS LINE -- free.c INSERTED HERE. */ +/* Free a block of memory allocated by `malloc'. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef __ONEFILE +#include "ansidecl.h" +#include <stddef.h> +#include <stdlib.h> + +#define _MALLOC_INTERNAL +#include "malloc.h" +#endif /* __ONEFILE */ + +/* Debugging hook for free. */ +void EXFUN((*__free_hook), (PTR __ptr)); + +/* Return memory to the heap. Like free() but don't call a __free_hook + if there is one. */ +void +DEFUN(__free, (ptr), PTR ptr) +{ + int type; + size_t block, blocks; + register size_t i; + struct list *prev, *next; + + block = BLOCK(ptr); + + type = _heapinfo[block].busy.type; + switch (type) + { + case 0: + /* Get as many statistics as early as we can. */ + --_chunks_used; + _bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE; + _bytes_free += _heapinfo[block].busy.info.size * BLOCKSIZE; + + /* Find the free cluster previous to this one in the free list. + Start searching at the last block referenced; this may benefit + programs with locality of allocation. */ + i = _heapindex; + if (i > block) + while (i > block) + i = _heapinfo[i].free.prev; + else + { + do + i = _heapinfo[i].free.next; + while (i > 0 && i < block); + i = _heapinfo[i].free.prev; + } + + /* Determine how to link this block into the free list. */ + if (block == i + _heapinfo[i].free.size) + { + /* Coalesce this block with its predecessor. */ + _heapinfo[i].free.size += _heapinfo[block].busy.info.size; + block = i; + } + else + { + /* Really link this block back into the free list. */ + _heapinfo[block].free.size = _heapinfo[block].busy.info.size; + _heapinfo[block].free.next = _heapinfo[i].free.next; + _heapinfo[block].free.prev = i; + _heapinfo[i].free.next = block; + _heapinfo[_heapinfo[block].free.next].free.prev = block; + ++_chunks_free; + } + + /* Now that the block is linked in, see if we can coalesce it + with its successor (by deleting its successor from the list + and adding in its size). */ + if (block + _heapinfo[block].free.size == _heapinfo[block].free.next) + { + _heapinfo[block].free.size + += _heapinfo[_heapinfo[block].free.next].free.size; + _heapinfo[block].free.next + = _heapinfo[_heapinfo[block].free.next].free.next; + _heapinfo[_heapinfo[block].free.next].free.prev = block; + --_chunks_free; + } + + /* Now see if we can return stuff to the system. */ + blocks = _heapinfo[block].free.size; + if (blocks >= FINAL_FREE_BLOCKS && block + blocks == _heaplimit + && (*__morecore)(0) == ADDRESS(block + blocks)) + { + register size_t bytes = blocks * BLOCKSIZE; + _heaplimit -= blocks; + (*__morecore)(- bytes); + _heapinfo[_heapinfo[block].free.prev].free.next + = _heapinfo[block].free.next; + _heapinfo[_heapinfo[block].free.next].free.prev + = _heapinfo[block].free.prev; + block = _heapinfo[block].free.prev; + --_chunks_free; + _bytes_free -= bytes; + } + + /* Set the next search to begin at this block. */ + _heapindex = block; + break; + + default: + /* Do some of the statistics. */ + --_chunks_used; + _bytes_used -= 1 << type; + ++_chunks_free; + _bytes_free += 1 << type; + + /* Get the address of the first free fragment in this block. */ + prev = (struct list *) ((char *) ADDRESS(block) + + (_heapinfo[block].busy.info.frag.first << type)); + + if (_heapinfo[block].busy.info.frag.nfree == (BLOCKSIZE >> type) - 1) + { + /* If all fragments of this block are free, remove them + from the fragment list and free the whole block. */ + next = prev; + for (i = 1; i < BLOCKSIZE >> type; ++i) + next = next->next; + prev->prev->next = next; + if (next != NULL) + next->prev = prev->prev; + _heapinfo[block].busy.type = 0; + _heapinfo[block].busy.info.size = 1; + + /* Keep the statistics accurate. */ + ++_chunks_used; + _bytes_used += BLOCKSIZE; + _chunks_free -= BLOCKSIZE >> type; + _bytes_free -= BLOCKSIZE; + + free(ADDRESS(block)); + } + else if (_heapinfo[block].busy.info.frag.nfree != 0) + { + /* If some fragments of this block are free, link this + fragment into the fragment list after the first free + fragment of this block. */ + next = (struct list *) ptr; + next->next = prev->next; + next->prev = prev; + prev->next = next; + if (next->next != NULL) + next->next->prev = next; + ++_heapinfo[block].busy.info.frag.nfree; + } + else + { + /* No fragments of this block are free, so link this + fragment into the fragment list and announce that + it is the first free fragment of this block. */ + prev = (struct list *) ptr; + _heapinfo[block].busy.info.frag.nfree = 1; + _heapinfo[block].busy.info.frag.first = (unsigned int) + (((char *) ptr - (char *) NULL) % BLOCKSIZE >> type); + prev->next = _fraghead[type].next; + prev->prev = &_fraghead[type]; + prev->prev->next = prev; + if (prev->next != NULL) + prev->next->prev = prev; + } + break; + } +} + +/* Return memory to the heap. */ +void +DEFUN(free, (ptr), PTR ptr) +{ + if (ptr == NULL) + return; + + if (__free_hook != NULL) + (*__free_hook)(ptr); + else + __free (ptr); +} + +/* DO NOT DELETE THIS LINE -- malloc.c INSERTED HERE. */ +/* Memory allocator `malloc'. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef __ONEFILE +#include "ansidecl.h" +#include <stddef.h> +#include <stdlib.h> +#include <string.h> + +#define _MALLOC_INTERNAL +#include "malloc.h" +#endif /* __ONEFILE */ + +/* How to really get more memory. */ +PTR EXFUN((*__morecore), (ptrdiff_t __size)) = __default_morecore; + +/* Debugging hook for `malloc'. */ +PTR EXFUN((*__malloc_hook), (size_t __size)); + +/* Pointer to the base of the first block. */ +char *_heapbase; + +/* Block information table. Allocated with align/__free (not malloc/free). */ +malloc_info *_heapinfo; + +/* Number of info entries. */ +static size_t heapsize; + +/* Search index in the info table. */ +size_t _heapindex; + +/* Limit of valid info table indices. */ +size_t _heaplimit; + +/* Free lists for each fragment size. */ +struct list _fraghead[BLOCKLOG]; + +/* Instrumentation. */ +size_t _chunks_used; +size_t _bytes_used; +size_t _chunks_free; +size_t _bytes_free; + +/* Are you experienced? */ +int __malloc_initialized; + +/* Aligned allocation. */ +static PTR +DEFUN(align, (size), size_t size) +{ + PTR result; + unsigned int adj; + + result = (*__morecore)(size); + adj = (unsigned int) ((char *) result - (char *) NULL) % BLOCKSIZE; + if (adj != 0) + { + adj = BLOCKSIZE - adj; + (void) (*__morecore)(adj); + result = (char *) result + adj; + } + return result; +} + +/* Set everything up and remember that we have. */ +static int +DEFUN_VOID(initialize) +{ + heapsize = HEAP / BLOCKSIZE; + _heapinfo = (malloc_info *) align(heapsize * sizeof(malloc_info)); + if (_heapinfo == NULL) + return 0; + memset(_heapinfo, 0, heapsize * sizeof(malloc_info)); + _heapinfo[0].free.size = 0; + _heapinfo[0].free.next = _heapinfo[0].free.prev = 0; + _heapindex = 0; + _heapbase = (char *) _heapinfo; + __malloc_initialized = 1; + return 1; +} + +/* Get neatly aligned memory, initializing or + growing the heap info table as necessary. */ +static PTR +DEFUN(morecore, (size), size_t size) +{ + PTR result; + malloc_info *newinfo, *oldinfo; + size_t newsize; + + result = align(size); + if (result == NULL) + return NULL; + + /* Check if we need to grow the info table. */ + if (BLOCK((char *) result + size) > heapsize) + { + newsize = heapsize; + while (BLOCK((char *) result + size) > newsize) + newsize *= 2; + newinfo = (malloc_info *) align(newsize * sizeof(malloc_info)); + if (newinfo == NULL) + { + (*__morecore)(- size); + return NULL; + } + memset(newinfo, 0, newsize * sizeof(malloc_info)); + memcpy(newinfo, _heapinfo, heapsize * sizeof(malloc_info)); + oldinfo = _heapinfo; + newinfo[BLOCK(oldinfo)].busy.type = 0; + newinfo[BLOCK(oldinfo)].busy.info.size + = BLOCKIFY(heapsize * sizeof(malloc_info)); + _heapinfo = newinfo; + __free(oldinfo); + heapsize = newsize; + } + + _heaplimit = BLOCK((char *) result + size); + return result; +} + +/* Allocate memory from the heap. */ +PTR +DEFUN(malloc, (size), size_t size) +{ + PTR result; + size_t block, blocks, lastblocks, start; + register size_t i; + struct list *next; + + if (size == 0) + return NULL; + + if (__malloc_hook != NULL) + return (*__malloc_hook)(size); + + if (!__malloc_initialized) + if (!initialize()) + return NULL; + + if (size < sizeof(struct list)) + size = sizeof(struct list); + + /* Determine the allocation policy based on the request size. */ + if (size <= BLOCKSIZE / 2) + { + /* Small allocation to receive a fragment of a block. + Determine the logarithm to base two of the fragment size. */ + register size_t log = 1; + --size; + while ((size /= 2) != 0) + ++log; + + /* Look in the fragment lists for a + free fragment of the desired size. */ + next = _fraghead[log].next; + if (next != NULL) + { + /* There are free fragments of this size. + Pop a fragment out of the fragment list and return it. + Update the block's nfree and first counters. */ + result = (PTR) next; + next->prev->next = next->next; + if (next->next != NULL) + next->next->prev = next->prev; + block = BLOCK(result); + if (--_heapinfo[block].busy.info.frag.nfree != 0) + _heapinfo[block].busy.info.frag.first = (unsigned int) + (((char *) next->next - (char *) NULL) % BLOCKSIZE) >> log; + + /* Update the statistics. */ + ++_chunks_used; + _bytes_used += 1 << log; + --_chunks_free; + _bytes_free -= 1 << log; + } + else + { + /* No free fragments of the desired size, so get a new block + and break it into fragments, returning the first. */ + result = malloc(BLOCKSIZE); + if (result == NULL) + return NULL; + + /* Link all fragments but the first into the free list. */ + for (i = 1; i < BLOCKSIZE >> log; ++i) + { + next = (struct list *) ((char *) result + (i << log)); + next->next = _fraghead[log].next; + next->prev = &_fraghead[log]; + next->prev->next = next; + if (next->next != NULL) + next->next->prev = next; + } + + /* Initialize the nfree and first counters for this block. */ + block = BLOCK(result); + _heapinfo[block].busy.type = log; + _heapinfo[block].busy.info.frag.nfree = i - 1; + _heapinfo[block].busy.info.frag.first = i - 1; + + _chunks_free += (BLOCKSIZE >> log) - 1; + _bytes_free += BLOCKSIZE - (1 << log); + } + } + else + { + /* Large allocation to receive one or more blocks. + Search the free list in a circle starting at the last place visited. + If we loop completely around without finding a large enough + space we will have to get more memory from the system. */ + blocks = BLOCKIFY(size); + start = block = MALLOC_SEARCH_START; + while (_heapinfo[block].free.size < blocks) + { + block = _heapinfo[block].free.next; + if (block == start) + { + /* Need to get more from the system. Check to see if + the new core will be contiguous with the final free + block; if so we don't need to get as much. */ + block = _heapinfo[0].free.prev; + lastblocks = _heapinfo[block].free.size; + if (_heaplimit != 0 && block + lastblocks == _heaplimit && + (*__morecore)(0) == ADDRESS(block + lastblocks) && + (morecore((blocks - lastblocks) * BLOCKSIZE)) != NULL) + { + _heapinfo[block].free.size = blocks; + _bytes_free += (blocks - lastblocks) * BLOCKSIZE; + continue; + } + result = morecore(blocks * BLOCKSIZE); + if (result == NULL) + return NULL; + block = BLOCK(result); + _heapinfo[block].busy.type = 0; + _heapinfo[block].busy.info.size = blocks; + ++_chunks_used; + _bytes_used += blocks * BLOCKSIZE; + return result; + } + } + + /* At this point we have found a suitable free list entry. + Figure out how to remove what we need from the list. */ + result = ADDRESS(block); + if (_heapinfo[block].free.size > blocks) + { + /* The block we found has a bit left over, + so relink the tail end back into the free list. */ + _heapinfo[block + blocks].free.size + = _heapinfo[block].free.size - blocks; + _heapinfo[block + blocks].free.next + = _heapinfo[block].free.next; + _heapinfo[block + blocks].free.prev + = _heapinfo[block].free.prev; + _heapinfo[_heapinfo[block].free.prev].free.next + = _heapinfo[_heapinfo[block].free.next].free.prev + = _heapindex = block + blocks; + } + else + { + /* The block exactly matches our requirements, + so just remove it from the list. */ + _heapinfo[_heapinfo[block].free.next].free.prev + = _heapinfo[block].free.prev; + _heapinfo[_heapinfo[block].free.prev].free.next + = _heapindex = _heapinfo[block].free.next; + --_chunks_free; + } + + _heapinfo[block].busy.type = 0; + _heapinfo[block].busy.info.size = blocks; + ++_chunks_used; + _bytes_used += blocks * BLOCKSIZE; + _bytes_free -= blocks * BLOCKSIZE; + } + + return result; +} + +/* DO NOT DELETE THIS LINE -- realloc.c INSERTED HERE. */ +/* Change the size of a block allocated by `malloc'. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef __ONEFILE +#include "ansidecl.h" +#include <stdlib.h> +#include <string.h> + +#define _MALLOC_INTERNAL +#include "malloc.h" +#endif /* __ONEFILE */ + +#define MIN(A, B) ((A) < (B) ? (A) : (B)) + +/* Debugging hook for realloc. */ +PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size)); + +/* Resize the given region to the new size, returning a pointer + to the (possibly moved) region. This is optimized for speed; + some benchmarks seem to indicate that greater compactness is + achieved by unconditionally allocating and copying to a + new region. This module has incestuous knowledge of the + internals of both free and malloc. */ +PTR +DEFUN(realloc, (ptr, size), PTR ptr AND size_t size) +{ + PTR result; + int type; + size_t block, blocks, oldlimit; + + if (size == 0) + { + free(ptr); + return NULL; + } + else if (ptr == NULL) + return malloc(size); + + if (__realloc_hook != NULL) + return (*__realloc_hook)(ptr, size); + + block = BLOCK(ptr); + + type = _heapinfo[block].busy.type; + switch (type) + { + case 0: + /* Maybe reallocate a large block to a small fragment. */ + if (size <= BLOCKSIZE / 2) + { + result = malloc(size); + if (result != NULL) + { + memcpy(result, ptr, size); + free(ptr); + return result; + } + } + + /* The new size is a large allocation as well; + see if we can hold it in place. */ + blocks = BLOCKIFY(size); + if (blocks < _heapinfo[block].busy.info.size) + { + /* The new size is smaller; return + excess memory to the free list. */ + _heapinfo[block + blocks].busy.type = 0; + _heapinfo[block + blocks].busy.info.size + = _heapinfo[block].busy.info.size - blocks; + _heapinfo[block].busy.info.size = blocks; + free(ADDRESS(block + blocks)); + result = ptr; + } + else if (blocks == _heapinfo[block].busy.info.size) + /* No size change necessary. */ + result = ptr; + else + { + /* Won't fit, so allocate a new region that will. + Free the old region first in case there is sufficient + adjacent free space to grow without moving. */ + blocks = _heapinfo[block].busy.info.size; + /* Prevent free from actually returning memory to the system. */ + oldlimit = _heaplimit; + _heaplimit = 0; + free(ptr); + _heaplimit = oldlimit; + result = malloc(size); + if (result == NULL) + { + (void) malloc(blocks * BLOCKSIZE); + return NULL; + } + if (ptr != result) + memmove(result, ptr, blocks * BLOCKSIZE); + } + break; + + default: + /* Old size is a fragment; type is logarithm + to base two of the fragment size. */ + if (size > 1 << (type - 1) && size <= 1 << type) + /* The new size is the same kind of fragment. */ + result = ptr; + else + { + /* The new size is different; allocate a new space, + and copy the lesser of the new size and the old. */ + result = malloc(size); + if (result == NULL) + return NULL; + memcpy(result, ptr, MIN(size, 1 << type)); + free(ptr); + } + break; + } + + return result; +} + +/* DO NOT DELETE THIS LINE -- unix.c INSERTED HERE. */ +/* unix.c - get more memory with a UNIX system call. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef __ONEFILE +#include "ansidecl.h" +#include <stddef.h> + +#define _MALLOC_INTERNAL +#include "malloc.h" +#endif /* __ONEFILE */ + +extern PTR EXFUN(sbrk, (ptrdiff_t size)); + +PTR +DEFUN(__default_morecore, (size), ptrdiff_t size) +{ + PTR result; + + result = sbrk(size); + if (result == (PTR) -1) + return NULL; + return result; +} + +#define __getpagesize getpagesize +/* DO NOT DELETE THIS LINE -- valloc.c INSERTED HERE. */ +/* Allocate memory on a page boundary. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef __ONEFILE +#include "ansidecl.h" +#include <stdlib.h> +#endif /* __ONEFILE */ + +extern size_t EXFUN(__getpagesize, (NOARGS)); + +static size_t pagesize; + +PTR +DEFUN(valloc, (size), size_t size) +{ + PTR result; + unsigned int adj; + + if (pagesize == 0) + pagesize = __getpagesize(); + + result = malloc(size + pagesize); + if (result == NULL) + return NULL; + adj = (unsigned int) ((char *) result - (char *) NULL) % pagesize; + if (adj != 0) + result = (char *) result + pagesize - adj; + return result; +} diff --git a/gdb/gmalloc.h b/gdb/gmalloc.h new file mode 100755 index 0000000..8718e80 --- /dev/null +++ b/gdb/gmalloc.h @@ -0,0 +1,161 @@ +/* Declarations for `malloc' and friends. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#ifndef _MALLOC_H + +#define _MALLOC_H 1 + +#ifndef __ONEFILE +#define __need_NULL +#define __need_size_t +#define __need_ptrdiff_t +#include <stddef.h> +#endif + +#ifdef _MALLOC_INTERNAL + +#ifndef __ONEFILE +#include <limits.h> +#endif + +/* The allocator divides the heap into blocks of fixed size; large + requests receive one or more whole blocks, and small requests + receive a fragment of a block. Fragment sizes are powers of two, + and all fragments of a block are the same size. When all the + fragments in a block have been freed, the block itself is freed. */ +#define INT_BIT (CHAR_BIT * sizeof(int)) +#define BLOCKLOG (INT_BIT > 16 ? 12 : 9) +#define BLOCKSIZE (1 << BLOCKLOG) +#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) + +/* Determine the amount of memory spanned by the initial heap table + (not an absolute limit). */ +#define HEAP (INT_BIT > 16 ? 4194304 : 65536) + +/* Number of contiguous free blocks allowed to build up at the end of + memory before they will be returned to the system. */ +#define FINAL_FREE_BLOCKS 8 + +/* Where to start searching the free list when looking for new memory. + The two possible values are 0 and _heapindex. Starting at 0 seems + to reduce total memory usage, while starting at _heapindex seems to + run faster. */ +#define MALLOC_SEARCH_START _heapindex + +/* Data structure giving per-block information. */ +typedef union + { + /* Heap information for a busy block. */ + struct + { + /* Zero for a large block, or positive giving the + logarithm to the base two of the fragment size. */ + int type; + union + { + struct + { + size_t nfree; /* Free fragments in a fragmented block. */ + size_t first; /* First free fragment of the block. */ + } frag; + /* Size (in blocks) of a large cluster. */ + size_t size; + } info; + } busy; + /* Heap information for a free block (that may be the first of + a free cluster). */ + struct + { + size_t size; /* Size (in blocks) of a free cluster. */ + size_t next; /* Index of next free cluster. */ + size_t prev; /* Index of previous free cluster. */ + } free; + } malloc_info; + +/* Pointer to first block of the heap. */ +extern char *_heapbase; + +/* Table indexed by block number giving per-block information. */ +extern malloc_info *_heapinfo; + +/* Address to block number and vice versa. */ +#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) +#define ADDRESS(B) ((PTR) (((B) - 1) * BLOCKSIZE + _heapbase)) + +/* Current search index for the heap table. */ +extern size_t _heapindex; + +/* Limit of valid info table indices. */ +extern size_t _heaplimit; + +/* Doubly linked lists of free fragments. */ +struct list + { + struct list *next; + struct list *prev; + }; + +/* Free list headers for each fragment size. */ +extern struct list _fraghead[]; + +/* Instrumentation. */ +extern size_t _chunks_used; +extern size_t _bytes_used; +extern size_t _chunks_free; +extern size_t _bytes_free; + +/* Internal version of free() used in morecore(). */ +extern void EXFUN(__free, (PTR __ptr)); + +#endif /* _MALLOC_INTERNAL. */ + +/* Underlying allocation function; successive calls should + return contiguous pieces of memory. */ +extern PTR EXFUN((*__morecore), (ptrdiff_t __size)); + +/* Default value of previous. */ +extern PTR EXFUN(__default_morecore, (ptrdiff_t __size)); + +/* Flag whether malloc has been called. */ +extern int __malloc_initialized; + +/* Hooks for debugging versions. */ +extern void EXFUN((*__free_hook), (PTR __ptr)); +extern PTR EXFUN((*__malloc_hook), (size_t __size)); +extern PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size)); + +/* Activate a standard collection of debugging hooks. */ +extern void EXFUN(mcheck, (void EXFUN((*func), (void)))); + +/* Statistics available to the user. */ +struct mstats + { + size_t bytes_total; /* Total size of the heap. */ + size_t chunks_used; /* Chunks allocated by the user. */ + size_t bytes_used; /* Byte total of user-allocated chunks. */ + size_t chunks_free; /* Chunks in the free list. */ + size_t bytes_free; /* Byte total of chunks in the free list. */ + }; + +/* Pick up the current statistics. */ +extern struct mstats EXFUN(mstats, (NOARGS)); + +#endif /* malloc.h */ diff --git a/gdb/gould-pinsn.c b/gdb/gould-pinsn.c new file mode 100644 index 0000000..b655f26 --- /dev/null +++ b/gdb/gould-pinsn.c @@ -0,0 +1,294 @@ +/* Print GOULD RISC instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "gdbcore.h" + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "frame.h" +#if defined GOULD_PN +#include "pn-opcode.h" +#else +#include "np1-opcode.h" +#endif + +/* GOULD RISC instructions are never longer than this many bytes. */ +#define MAXLEN 4 + +/* Number of elements in the opcode table. */ +#define NOPCODES (sizeof gld_opcodes / sizeof gld_opcodes[0]) + + +/* Print the GOULD instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i; + register char *d; + register int bestmask; + unsigned best; + int temp, index, bestlen; + + read_memory (memaddr, buffer, MAXLEN); + + bestmask = 0; + index = -1; + best = 0xffffffff; + for (i = 0; i < NOPCODES; i++) + { + register unsigned int opcode = gld_opcodes[i].opcode; + register unsigned int mask = gld_opcodes[i].mask; + register unsigned int len = gld_opcodes[i].length; + register unsigned int test; + + /* Get possible opcode bytes into integer */ + test = buffer[0] << 24; + test |= buffer[1] << 16; + test |= buffer[2] << 8; + test |= buffer[3]; + + /* Mask with opcode and see if match */ + if ((opcode & mask) == (test & mask)) + { + /* See if second or third match */ + if (index >= 0) + { + /* Take new one if it looks good */ + if (bestlen == MAXLEN && len == MAXLEN) + { + /* See if lower bits matched */ + if (((bestmask & 3) == 0) && + ((mask & 3) != 0)) + { + bestmask = mask; + bestlen = len; + best = test; + index = i; + } + } + } + else + { + /* First match, save it */ + bestmask = mask; + bestlen = len; + best = test; + index = i; + } + } + } + + /* Handle undefined instructions. */ + if (index < 0) + { + fprintf (stream, "undefined 0%o",(buffer[0]<<8)+buffer[1]); + return 2; + } + + /* Print instruction name */ + fprintf (stream, "%-12s", gld_opcodes[index].name); + + /* Adjust if short instruction */ + if (gld_opcodes[index].length < 4) + { + best >>= 16; + i = 0; + } + else + { + i = 16; + } + + /* Dump out instruction arguments */ + for (d = gld_opcodes[index].args; *d; ++d) + { + switch (*d) + { + case 'f': + fprintf (stream, "%d", (best >> (7 + i)) & 7); + break; + case 'r': + fprintf (stream, "r%d", (best >> (7 + i)) & 7); + break; + case 'R': + fprintf (stream, "r%d", (best >> (4 + i)) & 7); + break; + case 'b': + fprintf (stream, "b%d", (best >> (7 + i)) & 7); + break; + case 'B': + fprintf (stream, "b%d", (best >> (4 + i)) & 7); + break; + case 'v': + fprintf (stream, "b%d", (best >> (7 + i)) & 7); + break; + case 'V': + fprintf (stream, "b%d", (best >> (4 + i)) & 7); + break; + case 'X': + temp = (best >> 20) & 7; + if (temp) + fprintf (stream, "r%d", temp); + else + putc ('0', stream); + break; + case 'A': + temp = (best >> 16) & 7; + if (temp) + fprintf (stream, "(b%d)", temp); + break; + case 'S': + fprintf (stream, "#%d", best & 0x1f); + break; + case 'I': + fprintf (stream, "#%x", best & 0xffff); + break; + case 'O': + fprintf (stream, "%x", best & 0xffff); + break; + case 'h': + fprintf (stream, "%d", best & 0xfffe); + break; + case 'd': + fprintf (stream, "%d", best & 0xfffc); + break; + case 'T': + fprintf (stream, "%d", (best >> 8) & 0xff); + break; + case 'N': + fprintf (stream, "%d", best & 0xff); + break; + default: + putc (*d, stream); + break; + } + } + + /* Return length of instruction */ + return (gld_opcodes[index].length); +} + +/* + * Find the number of arguments to a function. + */ +findarg(frame) + struct frame_info *frame; +{ + register struct symbol *func; + register unsigned pc; + +#ifdef notdef + /* find starting address of frame function */ + pc = get_pc_function_start (frame->pc); + + /* find function symbol info */ + func = find_pc_function (pc); + + /* call blockframe code to look for match */ + if (func != NULL) + return (func->value.block->nsyms / sizeof(int)); +#endif + + return (-1); +} + +/* + * In the case of the NPL, the frame's norminal address is Br2 and the + * previous routines frame is up the stack X bytes. Finding out what + * 'X' is can be tricky. + * + * 1.) stored in the code function header xA(Br1). + * 2.) must be careful of recurssion. + */ +FRAME_ADDR +findframe(thisframe) + FRAME thisframe; +{ + register FRAME_ADDR pointer; + FRAME_ADDR framechain(); +#if 0 + struct frame_info *frame; + + /* Setup toplevel frame structure */ + frame->pc = read_pc(); + frame->next_frame = 0; + frame->frame = read_register (SP_REGNUM); /* Br2 */ + + /* Search for this frame (start at current Br2) */ + do + { + pointer = framechain(frame); + frame->next_frame = frame->frame; + frame->frame = pointer; + frame->pc = FRAME_SAVED_PC(frame); + } + while (frame->next_frame != thisframe); +#endif + + pointer = framechain (thisframe); + + /* stop gap for now, end at __base3 */ + if (thisframe->pc == 0) + return 0; + + return pointer; +} + +/* + * Gdb front-end and internal framechain routine. + * Go back up stack one level. Tricky... + */ +FRAME_ADDR +framechain(frame) + register struct frame_info *frame; +{ + register CORE_ADDR func, prevsp; + register unsigned value; + + /* Get real function start address from internal frame address */ + func = get_pc_function_start(frame->pc); + + /* If no stack given, read register Br1 "(sp)" */ + if (!frame->frame) + prevsp = read_register (SP_REGNUM); + else + prevsp = frame->frame; + + /* Check function header, case #2 */ + value = read_memory_integer (func, 4); + if (value) + { + /* 32bit call push value stored in function header */ + prevsp += value; + } + else + { + /* read half-word from suabr at start of function */ + prevsp += read_memory_integer (func + 10, 2); + } + + return (prevsp); +} diff --git a/gdb/gould-xdep.c b/gdb/gould-xdep.c new file mode 100644 index 0000000..c3aec0d --- /dev/null +++ b/gdb/gould-xdep.c @@ -0,0 +1,132 @@ +/* Low level interface to ptrace, for GDB when running under Unix. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/user.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#include "gdbcore.h" + +#include <sys/file.h> +#include <sys/stat.h> + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct user u; + int reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name (filename); + data_start = exec_data_start; + + data_end = data_start + NBPG * u.u_dsize; + stack_start = stack_end - NBPG * u.u_ssize; + data_offset = NBPG * UPAGES; + stack_offset = NBPG * (UPAGES + u.u_dsize); + reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR; + + /* I don't know where to find this info. + So, for now, mark it as not available. */ + core_aouthdr.a_magic = 0; + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = lseek (corechan, register_addr (regno, reg_offset), 0); + if (val < 0) + perror_with_name (filename); + + val = myread (corechan, buf, sizeof buf); + if (val < 0) + perror_with_name (filename); + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} diff --git a/gdb/hp300hpux-xdep.c b/gdb/hp300hpux-xdep.c new file mode 100755 index 0000000..f7f1cf0 --- /dev/null +++ b/gdb/hp300hpux-xdep.c @@ -0,0 +1,230 @@ +/* HP/UX interface for HP 300's, for GDB when running under Unix. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +/* Defining this means some system include files define some extra stuff. */ +#define WOPR +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/user.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#include <sys/ptrace.h> +#include <sys/reg.h> +#include <sys/trap.h> + +#include "gdbcore.h" + +#include <sys/file.h> +#include <sys/stat.h> + +#define INFERIOR_AR0(u) \ + ((ptrace \ + (PT_RUAREA, inferior_pid, ((char *) &u.u_ar0 - (char *) &u), 0)) \ + - KERNEL_U_ADDR) + +static void +fetch_inferior_register (regno, regaddr) + register int regno; + register unsigned int regaddr; +{ +#ifndef HPUX_VERSION_5 + if (regno == PS_REGNUM) + { + union { int i; short s[2]; } ps_val; + int regval; + + ps_val.i = (ptrace (PT_RUAREA, inferior_pid, regaddr, 0)); + regval = ps_val.s[0]; + supply_register (regno, ®val); + } + else +#endif /* not HPUX_VERSION_5 */ + { + char buf[MAX_REGISTER_RAW_SIZE]; + register int i; + + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + { + *(int *) &buf[i] = ptrace (PT_RUAREA, inferior_pid, regaddr, 0); + regaddr += sizeof (int); + } + supply_register (regno, buf); + } + return; +} + +static void +store_inferior_register_1 (regno, regaddr, value) + int regno; + unsigned int regaddr; + int value; +{ + errno = 0; + ptrace (PT_WUAREA, inferior_pid, regaddr, value); +#if 0 + /* HP-UX randomly sets errno to non-zero for regno == 25. + However, the value is correctly written, so ignore errno. */ + if (errno != 0) + { + char string_buf[64]; + + sprintf (string_buf, "writing register number %d", regno); + perror_with_name (string_buf); + } +#endif + return; +} + +static void +store_inferior_register (regno, regaddr) + register int regno; + register unsigned int regaddr; +{ +#ifndef HPUX_VERSION_5 + if (regno == PS_REGNUM) + { + union { int i; short s[2]; } ps_val; + + ps_val.i = (ptrace (PT_RUAREA, inferior_pid, regaddr, 0)); + ps_val.s[0] = (read_register (regno)); + store_inferior_register_1 (regno, regaddr, ps_val.i); + } + else +#endif /* not HPUX_VERSION_5 */ + { + char buf[MAX_REGISTER_RAW_SIZE]; + register int i; + extern char registers[]; + + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + { + store_inferior_register_1 + (regno, regaddr, + (*(int *) ®isters[(REGISTER_BYTE (regno)) + i])); + regaddr += sizeof (int); + } + } + return; +} + +void +fetch_inferior_registers (regno) + int regno; +{ + struct user u; + register int regno; + register unsigned int ar0_offset; + + ar0_offset = (INFERIOR_AR0 (u)); + if (regno == -1) + { + for (regno = 0; (regno < FP0_REGNUM); regno++) + fetch_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); + for (; (regno < NUM_REGS); regno++) + fetch_inferior_register (regno, (FP_REGISTER_ADDR (u, regno))); + } + else + fetch_inferior_register (regno, + (regno < FP0_REGNUM + ? REGISTER_ADDR (ar0_offset, regno) + : FP_REGISTER_ADDR (u, regno))); +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + register int regno; +{ + struct user u; + register unsigned int ar0_offset; + extern char registers[]; + + if (regno >= FP0_REGNUM) + { + store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno))); + return; + } + + ar0_offset = (INFERIOR_AR0 (u)); + if (regno >= 0) + { + store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); + return; + } + + for (regno = 0; (regno < FP0_REGNUM); regno++) + store_inferior_register (regno, (REGISTER_ADDR (ar0_offset, regno))); + for (; (regno < NUM_REGS); regno++) + store_inferior_register (regno, (FP_REGISTER_ADDR (u, regno))); + return; +} + + +/* Take the register values out of a core file and store + them where `read_register' will find them. */ + +#ifdef HPUX_VERSION_5 +#define e_PS e_regs[PS] +#define e_PC e_regs[PC] +#endif /* HPUX_VERSION_5 */ + +void +fetch_core_registers (core_reg_sect, core_reg_size, which) + char *core_reg_sect; + int core_reg_size; + int which; +{ + int val, regno; + struct user u; + struct exception_stack *pes = (struct exception_stack *) core_reg_sect; +#define es (*pes) + char *buf; + + if (which == 0) { + if (core_reg_size < + ((char *) &es.e_offset - (char *) &es.e_regs[R0])) + error ("Not enough registers in core file"); + for (regno = 0; (regno < PS_REGNUM); regno++) + supply_register (regno, &es.e_regs[regno + R0]); + val = es.e_PS; + supply_register (regno++, &val); + supply_register (regno++, &es.e_PC); + + } else if (which == 2) { + + /* FIXME: This may not work if the float regs and control regs are + discontinuous. */ + for (regno = FP0_REGNUM, buf = core_reg_sect; + (regno < NUM_REGS); + buf += REGISTER_RAW_SIZE (regno), regno++) + { + supply_register (regno, buf); + } + } +} diff --git a/gdb/i386-pinsn.c b/gdb/i386-pinsn.c new file mode 100644 index 0000000..50cf14b --- /dev/null +++ b/gdb/i386-pinsn.c @@ -0,0 +1,1834 @@ +/* Print i386 instructions for GDB, the GNU debugger. + Copyright (C) 1988, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * 80386 instruction printer by Pace Willisson (pace@prep.ai.mit.edu) + * July 1988 + */ + +/* + * The main tables describing the instructions is essentially a copy + * of the "Opcode Map" chapter (Appendix A) of the Intel 80386 + * Programmers Manual. Usually, there is a capital letter, followed + * by a small letter. The capital letter tell the addressing mode, + * and the small letter tells about the operand size. Refer to + * the Intel manual for details. + */ + +#include <stdio.h> +#include <ctype.h> + +#define Eb OP_E, b_mode +#define indirEb OP_indirE, b_mode +#define Gb OP_G, b_mode +#define Ev OP_E, v_mode +#define indirEv OP_indirE, v_mode +#define Ew OP_E, w_mode +#define Ma OP_E, v_mode +#define M OP_E, 0 +#define Mp OP_E, 0 /* ? */ +#define Gv OP_G, v_mode +#define Gw OP_G, w_mode +#define Rw OP_rm, w_mode +#define Rd OP_rm, d_mode +#define Ib OP_I, b_mode +#define sIb OP_sI, b_mode /* sign extened byte */ +#define Iv OP_I, v_mode +#define Iw OP_I, w_mode +#define Jb OP_J, b_mode +#define Jv OP_J, v_mode +#define ONE OP_ONE, 0 +#define Cd OP_C, d_mode +#define Dd OP_D, d_mode +#define Td OP_T, d_mode + +#define eAX OP_REG, eAX_reg +#define eBX OP_REG, eBX_reg +#define eCX OP_REG, eCX_reg +#define eDX OP_REG, eDX_reg +#define eSP OP_REG, eSP_reg +#define eBP OP_REG, eBP_reg +#define eSI OP_REG, eSI_reg +#define eDI OP_REG, eDI_reg +#define AL OP_REG, al_reg +#define CL OP_REG, cl_reg +#define DL OP_REG, dl_reg +#define BL OP_REG, bl_reg +#define AH OP_REG, ah_reg +#define CH OP_REG, ch_reg +#define DH OP_REG, dh_reg +#define BH OP_REG, bh_reg +#define AX OP_REG, ax_reg +#define DX OP_REG, dx_reg +#define indirDX OP_REG, indir_dx_reg + +#define Sw OP_SEG, w_mode +#define Ap OP_DIR, lptr +#define Av OP_DIR, v_mode +#define Ob OP_OFF, b_mode +#define Ov OP_OFF, v_mode +#define Xb OP_DSSI, b_mode +#define Xv OP_DSSI, v_mode +#define Yb OP_ESDI, b_mode +#define Yv OP_ESDI, v_mode + +#define es OP_REG, es_reg +#define ss OP_REG, ss_reg +#define cs OP_REG, cs_reg +#define ds OP_REG, ds_reg +#define fs OP_REG, fs_reg +#define gs OP_REG, gs_reg + +int OP_E(), OP_indirE(), OP_G(), OP_I(), OP_sI(), OP_REG(); +int OP_J(), OP_SEG(); +int OP_DIR(), OP_OFF(), OP_DSSI(), OP_ESDI(), OP_ONE(), OP_C(); +int OP_D(), OP_T(), OP_rm(); + + +#define b_mode 1 +#define v_mode 2 +#define w_mode 3 +#define d_mode 4 + +#define es_reg 100 +#define cs_reg 101 +#define ss_reg 102 +#define ds_reg 103 +#define fs_reg 104 +#define gs_reg 105 +#define eAX_reg 107 +#define eCX_reg 108 +#define eDX_reg 109 +#define eBX_reg 110 +#define eSP_reg 111 +#define eBP_reg 112 +#define eSI_reg 113 +#define eDI_reg 114 + +#define lptr 115 + +#define al_reg 116 +#define cl_reg 117 +#define dl_reg 118 +#define bl_reg 119 +#define ah_reg 120 +#define ch_reg 121 +#define dh_reg 122 +#define bh_reg 123 + +#define ax_reg 124 +#define cx_reg 125 +#define dx_reg 126 +#define bx_reg 127 +#define sp_reg 128 +#define bp_reg 129 +#define si_reg 130 +#define di_reg 131 + +#define indir_dx_reg 150 + +#define GRP1b NULL, NULL, 0 +#define GRP1S NULL, NULL, 1 +#define GRP1Ss NULL, NULL, 2 +#define GRP2b NULL, NULL, 3 +#define GRP2S NULL, NULL, 4 +#define GRP2b_one NULL, NULL, 5 +#define GRP2S_one NULL, NULL, 6 +#define GRP2b_cl NULL, NULL, 7 +#define GRP2S_cl NULL, NULL, 8 +#define GRP3b NULL, NULL, 9 +#define GRP3S NULL, NULL, 10 +#define GRP4 NULL, NULL, 11 +#define GRP5 NULL, NULL, 12 +#define GRP6 NULL, NULL, 13 +#define GRP7 NULL, NULL, 14 +#define GRP8 NULL, NULL, 15 + +#define FLOATCODE 50 +#define FLOAT NULL, NULL, FLOATCODE + +struct dis386 { + char *name; + int (*op1)(); + int bytemode1; + int (*op2)(); + int bytemode2; + int (*op3)(); + int bytemode3; +}; + +struct dis386 dis386[] = { + /* 00 */ + { "addb", Eb, Gb }, + { "addS", Ev, Gv }, + { "addb", Gb, Eb }, + { "addS", Gv, Ev }, + { "addb", AL, Ib }, + { "addS", eAX, Iv }, + { "pushl", es }, + { "popl", es }, + /* 08 */ + { "orb", Eb, Gb }, + { "orS", Ev, Gv }, + { "orb", Gb, Eb }, + { "orS", Gv, Ev }, + { "orb", AL, Ib }, + { "orS", eAX, Iv }, + { "pushl", cs }, + { "(bad)" }, /* 0x0f extended opcode escape */ + /* 10 */ + { "adcb", Eb, Gb }, + { "adcS", Ev, Gv }, + { "adcb", Gb, Eb }, + { "adcS", Gv, Ev }, + { "adcb", AL, Ib }, + { "adcS", eAX, Iv }, + { "pushl", ss }, + { "popl", ss }, + /* 18 */ + { "sbbb", Eb, Gb }, + { "sbbS", Ev, Gv }, + { "sbbb", Gb, Eb }, + { "sbbS", Gv, Ev }, + { "sbbb", AL, Ib }, + { "sbbS", eAX, Iv }, + { "pushl", ds }, + { "popl", ds }, + /* 20 */ + { "andb", Eb, Gb }, + { "andS", Ev, Gv }, + { "andb", Gb, Eb }, + { "andS", Gv, Ev }, + { "andb", AL, Ib }, + { "andS", eAX, Iv }, + { "(bad)" }, /* SEG ES prefix */ + { "daa" }, + /* 28 */ + { "subb", Eb, Gb }, + { "subS", Ev, Gv }, + { "subb", Gb, Eb }, + { "subS", Gv, Ev }, + { "subb", AL, Ib }, + { "subS", eAX, Iv }, + { "(bad)" }, /* SEG CS prefix */ + { "das" }, + /* 30 */ + { "xorb", Eb, Gb }, + { "xorS", Ev, Gv }, + { "xorb", Gb, Eb }, + { "xorS", Gv, Ev }, + { "xorb", AL, Ib }, + { "xorS", eAX, Iv }, + { "(bad)" }, /* SEG SS prefix */ + { "aaa" }, + /* 38 */ + { "cmpb", Eb, Gb }, + { "cmpS", Ev, Gv }, + { "cmpb", Gb, Eb }, + { "cmpS", Gv, Ev }, + { "cmpb", AL, Ib }, + { "cmpS", eAX, Iv }, + { "(bad)" }, /* SEG DS prefix */ + { "aas" }, + /* 40 */ + { "incS", eAX }, + { "incS", eCX }, + { "incS", eDX }, + { "incS", eBX }, + { "incS", eSP }, + { "incS", eBP }, + { "incS", eSI }, + { "incS", eDI }, + /* 48 */ + { "decS", eAX }, + { "decS", eCX }, + { "decS", eDX }, + { "decS", eBX }, + { "decS", eSP }, + { "decS", eBP }, + { "decS", eSI }, + { "decS", eDI }, + /* 50 */ + { "pushS", eAX }, + { "pushS", eCX }, + { "pushS", eDX }, + { "pushS", eBX }, + { "pushS", eSP }, + { "pushS", eBP }, + { "pushS", eSI }, + { "pushS", eDI }, + /* 58 */ + { "popS", eAX }, + { "popS", eCX }, + { "popS", eDX }, + { "popS", eBX }, + { "popS", eSP }, + { "popS", eBP }, + { "popS", eSI }, + { "popS", eDI }, + /* 60 */ + { "pusha" }, + { "popa" }, + { "boundS", Gv, Ma }, + { "arpl", Ew, Gw }, + { "(bad)" }, /* seg fs */ + { "(bad)" }, /* seg gs */ + { "(bad)" }, /* op size prefix */ + { "(bad)" }, /* adr size prefix */ + /* 68 */ + { "pushS", Iv }, /* 386 book wrong */ + { "imulS", Gv, Ev, Iv }, + { "pushl", sIb }, /* push of byte really pushes 4 bytes */ + { "imulS", Gv, Ev, Ib }, + { "insb", Yb, indirDX }, + { "insS", Yv, indirDX }, + { "outsb", indirDX, Xb }, + { "outsS", indirDX, Xv }, + /* 70 */ + { "jo", Jb }, + { "jno", Jb }, + { "jb", Jb }, + { "jae", Jb }, + { "je", Jb }, + { "jne", Jb }, + { "jbe", Jb }, + { "ja", Jb }, + /* 78 */ + { "js", Jb }, + { "jns", Jb }, + { "jp", Jb }, + { "jnp", Jb }, + { "jl", Jb }, + { "jnl", Jb }, + { "jle", Jb }, + { "jg", Jb }, + /* 80 */ + { GRP1b }, + { GRP1S }, + { "(bad)" }, + { GRP1Ss }, + { "testb", Eb, Gb }, + { "testS", Ev, Gv }, + { "xchgb", Eb, Gb }, + { "xchgS", Ev, Gv }, + /* 88 */ + { "movb", Eb, Gb }, + { "movS", Ev, Gv }, + { "movb", Gb, Eb }, + { "movS", Gv, Ev }, + { "movw", Ew, Sw }, + { "leaS", Gv, M }, + { "movw", Sw, Ew }, + { "popS", Ev }, + /* 90 */ + { "nop" }, + { "xchgS", eCX, eAX }, + { "xchgS", eDX, eAX }, + { "xchgS", eBX, eAX }, + { "xchgS", eSP, eAX }, + { "xchgS", eBP, eAX }, + { "xchgS", eSI, eAX }, + { "xchgS", eDI, eAX }, + /* 98 */ + { "cwtl" }, + { "cltd" }, + { "lcall", Ap }, + { "(bad)" }, /* fwait */ + { "pushf" }, + { "popf" }, + { "sahf" }, + { "lahf" }, + /* a0 */ + { "movb", AL, Ob }, + { "movS", eAX, Ov }, + { "movb", Ob, AL }, + { "movS", Ov, eAX }, + { "movsb", Yb, Xb }, + { "movsS", Yv, Xv }, + { "cmpsb", Yb, Xb }, + { "cmpsS", Yv, Xv }, + /* a8 */ + { "testb", AL, Ib }, + { "testS", eAX, Iv }, + { "stosb", Yb, AL }, + { "stosS", Yv, eAX }, + { "lodsb", AL, Xb }, + { "lodsS", eAX, Xv }, + { "scasb", AL, Xb }, + { "scasS", eAX, Xv }, + /* b0 */ + { "movb", AL, Ib }, + { "movb", CL, Ib }, + { "movb", DL, Ib }, + { "movb", BL, Ib }, + { "movb", AH, Ib }, + { "movb", CH, Ib }, + { "movb", DH, Ib }, + { "movb", BH, Ib }, + /* b8 */ + { "movS", eAX, Iv }, + { "movS", eCX, Iv }, + { "movS", eDX, Iv }, + { "movS", eBX, Iv }, + { "movS", eSP, Iv }, + { "movS", eBP, Iv }, + { "movS", eSI, Iv }, + { "movS", eDI, Iv }, + /* c0 */ + { GRP2b }, + { GRP2S }, + { "ret", Iw }, + { "ret" }, + { "lesS", Gv, Mp }, + { "ldsS", Gv, Mp }, + { "movb", Eb, Ib }, + { "movS", Ev, Iv }, + /* c8 */ + { "enter", Iw, Ib }, + { "leave" }, + { "lret", Iw }, + { "lret" }, + { "int3" }, + { "int", Ib }, + { "into" }, + { "iret" }, + /* d0 */ + { GRP2b_one }, + { GRP2S_one }, + { GRP2b_cl }, + { GRP2S_cl }, + { "aam", Ib }, + { "aad", Ib }, + { "(bad)" }, + { "xlat" }, + /* d8 */ + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + { FLOAT }, + /* e0 */ + { "loopne", Jb }, + { "loope", Jb }, + { "loop", Jb }, + { "jCcxz", Jb }, + { "inb", AL, Ib }, + { "inS", eAX, Ib }, + { "outb", Ib, AL }, + { "outS", Ib, eAX }, + /* e8 */ + { "call", Av }, + { "jmp", Jv }, + { "ljmp", Ap }, + { "jmp", Jb }, + { "inb", AL, indirDX }, + { "inS", eAX, indirDX }, + { "outb", indirDX, AL }, + { "outS", indirDX, eAX }, + /* f0 */ + { "(bad)" }, /* lock prefix */ + { "(bad)" }, + { "(bad)" }, /* repne */ + { "(bad)" }, /* repz */ + { "hlt" }, + { "cmc" }, + { GRP3b }, + { GRP3S }, + /* f8 */ + { "clc" }, + { "stc" }, + { "cli" }, + { "sti" }, + { "cld" }, + { "std" }, + { GRP4 }, + { GRP5 }, +}; + +struct dis386 dis386_twobyte[] = { + /* 00 */ + { GRP6 }, + { GRP7 }, + { "larS", Gv, Ew }, + { "lslS", Gv, Ew }, + { "(bad)" }, + { "(bad)" }, + { "clts" }, + { "(bad)" }, + /* 08 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 10 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 18 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 20 */ + /* these are all backward in appendix A of the intel book */ + { "movl", Rd, Cd }, + { "movl", Rd, Dd }, + { "movl", Cd, Rd }, + { "movl", Dd, Rd }, + { "movl", Rd, Td }, + { "(bad)" }, + { "movl", Td, Rd }, + { "(bad)" }, + /* 28 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 30 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 38 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 40 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 48 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 50 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 58 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 60 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 68 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 70 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 78 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* 80 */ + { "jo", Jv }, + { "jno", Jv }, + { "jb", Jv }, + { "jae", Jv }, + { "je", Jv }, + { "jne", Jv }, + { "jbe", Jv }, + { "ja", Jv }, + /* 88 */ + { "js", Jv }, + { "jns", Jv }, + { "jp", Jv }, + { "jnp", Jv }, + { "jl", Jv }, + { "jge", Jv }, + { "jle", Jv }, + { "jg", Jv }, + /* 90 */ + { "seto", Eb }, + { "setno", Eb }, + { "setb", Eb }, + { "setae", Eb }, + { "sete", Eb }, + { "setne", Eb }, + { "setbe", Eb }, + { "seta", Eb }, + /* 98 */ + { "sets", Eb }, + { "setns", Eb }, + { "setp", Eb }, + { "setnp", Eb }, + { "setl", Eb }, + { "setge", Eb }, + { "setle", Eb }, + { "setg", Eb }, + /* a0 */ + { "pushl", fs }, + { "popl", fs }, + { "(bad)" }, + { "btS", Ev, Gv }, + { "shldS", Ev, Gv, Ib }, + { "shldS", Ev, Gv, CL }, + { "(bad)" }, + { "(bad)" }, + /* a8 */ + { "pushl", gs }, + { "popl", gs }, + { "(bad)" }, + { "btsS", Ev, Gv }, + { "shrdS", Ev, Gv, Ib }, + { "shrdS", Ev, Gv, CL }, + { "(bad)" }, + { "imulS", Gv, Ev }, + /* b0 */ + { "(bad)" }, + { "(bad)" }, + { "lssS", Gv, Mp }, /* 386 lists only Mp */ + { "btrS", Ev, Gv }, + { "lfsS", Gv, Mp }, /* 386 lists only Mp */ + { "lgsS", Gv, Mp }, /* 386 lists only Mp */ + { "movzbS", Gv, Eb }, + { "movzwS", Gv, Ew }, + /* b8 */ + { "(bad)" }, + { "(bad)" }, + { GRP8 }, + { "btcS", Ev, Gv }, + { "bsfS", Gv, Ev }, + { "bsrS", Gv, Ev }, + { "movsbS", Gv, Eb }, + { "movswS", Gv, Ew }, + /* c0 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* c8 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* d0 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* d8 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* e0 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* e8 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* f0 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + /* f8 */ + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, + { "(bad)" }, { "(bad)" }, { "(bad)" }, { "(bad)" }, +}; + +static char obuf[100]; +static char *obufp; +static char scratchbuf[100]; +static unsigned char *start_codep; +static unsigned char *codep; +static int mod; +static int rm; +static int reg; +static void oappend (); + +static char *names32[]={ + "%eax","%ecx","%edx","%ebx", "%esp","%ebp","%esi","%edi", +}; +static char *names16[] = { + "%ax","%cx","%dx","%bx","%sp","%bp","%si","%di", +}; +static char *names8[] = { + "%al","%cl","%dl","%bl","%ah","%ch","%dh","%bh", +}; +static char *names_seg[] = { + "%es","%cs","%ss","%ds","%fs","%gs","%?","%?", +}; + +struct dis386 grps[][8] = { + /* GRP1b */ + { + { "addb", Eb, Ib }, + { "orb", Eb, Ib }, + { "adcb", Eb, Ib }, + { "sbbb", Eb, Ib }, + { "andb", Eb, Ib }, + { "subb", Eb, Ib }, + { "xorb", Eb, Ib }, + { "cmpb", Eb, Ib } + }, + /* GRP1S */ + { + { "addS", Ev, Iv }, + { "orS", Ev, Iv }, + { "adcS", Ev, Iv }, + { "sbbS", Ev, Iv }, + { "andS", Ev, Iv }, + { "subS", Ev, Iv }, + { "xorS", Ev, Iv }, + { "cmpS", Ev, Iv } + }, + /* GRP1Ss */ + { + { "addS", Ev, sIb }, + { "orS", Ev, sIb }, + { "adcS", Ev, sIb }, + { "sbbS", Ev, sIb }, + { "andS", Ev, sIb }, + { "subS", Ev, sIb }, + { "xorS", Ev, sIb }, + { "cmpS", Ev, sIb } + }, + /* GRP2b */ + { + { "rolb", Eb, Ib }, + { "rorb", Eb, Ib }, + { "rclb", Eb, Ib }, + { "rcrb", Eb, Ib }, + { "shlb", Eb, Ib }, + { "shrb", Eb, Ib }, + { "(bad)" }, + { "sarb", Eb, Ib }, + }, + /* GRP2S */ + { + { "rolS", Ev, Ib }, + { "rorS", Ev, Ib }, + { "rclS", Ev, Ib }, + { "rcrS", Ev, Ib }, + { "shlS", Ev, Ib }, + { "shrS", Ev, Ib }, + { "(bad)" }, + { "sarS", Ev, Ib }, + }, + /* GRP2b_one */ + { + { "rolb", Eb }, + { "rorb", Eb }, + { "rclb", Eb }, + { "rcrb", Eb }, + { "shlb", Eb }, + { "shrb", Eb }, + { "(bad)" }, + { "sarb", Eb }, + }, + /* GRP2S_one */ + { + { "rolS", Ev }, + { "rorS", Ev }, + { "rclS", Ev }, + { "rcrS", Ev }, + { "shlS", Ev }, + { "shrS", Ev }, + { "(bad)" }, + { "sarS", Ev }, + }, + /* GRP2b_cl */ + { + { "rolb", Eb, CL }, + { "rorb", Eb, CL }, + { "rclb", Eb, CL }, + { "rcrb", Eb, CL }, + { "shlb", Eb, CL }, + { "shrb", Eb, CL }, + { "(bad)" }, + { "sarb", Eb, CL }, + }, + /* GRP2S_cl */ + { + { "rolS", Ev, CL }, + { "rorS", Ev, CL }, + { "rclS", Ev, CL }, + { "rcrS", Ev, CL }, + { "shlS", Ev, CL }, + { "shrS", Ev, CL }, + { "(bad)" }, + { "sarS", Ev, CL } + }, + /* GRP3b */ + { + { "testb", Eb, Ib }, + { "(bad)", Eb }, + { "notb", Eb }, + { "negb", Eb }, + { "mulb", AL, Eb }, + { "imulb", AL, Eb }, + { "divb", AL, Eb }, + { "idivb", AL, Eb } + }, + /* GRP3S */ + { + { "testS", Ev, Iv }, + { "(bad)" }, + { "notS", Ev }, + { "negS", Ev }, + { "mulS", eAX, Ev }, + { "imulS", eAX, Ev }, + { "divS", eAX, Ev }, + { "idivS", eAX, Ev }, + }, + /* GRP4 */ + { + { "incb", Eb }, + { "decb", Eb }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + }, + /* GRP5 */ + { + { "incS", Ev }, + { "decS", Ev }, + { "call", indirEv }, + { "lcall", indirEv }, + { "jmp", indirEv }, + { "ljmp", indirEv }, + { "pushS", Ev }, + { "(bad)" }, + }, + /* GRP6 */ + { + { "sldt", Ew }, + { "str", Ew }, + { "lldt", Ew }, + { "ltr", Ew }, + { "verr", Ew }, + { "verw", Ew }, + { "(bad)" }, + { "(bad)" } + }, + /* GRP7 */ + { + { "sgdt", Ew }, + { "sidt", Ew }, + { "lgdt", Ew }, + { "lidt", Ew }, + { "smsw", Ew }, + { "(bad)" }, + { "lmsw", Ew }, + { "(bad)" }, + }, + /* GRP8 */ + { + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "btS", Ev, Ib }, + { "btsS", Ev, Ib }, + { "btrS", Ev, Ib }, + { "btcS", Ev, Ib }, + } +}; + +#define PREFIX_REPZ 1 +#define PREFIX_REPNZ 2 +#define PREFIX_LOCK 4 +#define PREFIX_CS 8 +#define PREFIX_SS 0x10 +#define PREFIX_DS 0x20 +#define PREFIX_ES 0x40 +#define PREFIX_FS 0x80 +#define PREFIX_GS 0x100 +#define PREFIX_DATA 0x200 +#define PREFIX_ADR 0x400 +#define PREFIX_FWAIT 0x800 + +static int prefixes; + +ckprefix () +{ + prefixes = 0; + while (1) + { + switch (*codep) + { + case 0xf3: + prefixes |= PREFIX_REPZ; + break; + case 0xf2: + prefixes |= PREFIX_REPNZ; + break; + case 0xf0: + prefixes |= PREFIX_LOCK; + break; + case 0x2e: + prefixes |= PREFIX_CS; + break; + case 0x36: + prefixes |= PREFIX_SS; + break; + case 0x3e: + prefixes |= PREFIX_DS; + break; + case 0x26: + prefixes |= PREFIX_ES; + break; + case 0x64: + prefixes |= PREFIX_FS; + break; + case 0x65: + prefixes |= PREFIX_GS; + break; + case 0x66: + prefixes |= PREFIX_DATA; + break; + case 0x67: + prefixes |= PREFIX_ADR; + break; + case 0x9b: + prefixes |= PREFIX_FWAIT; + break; + default: + return; + } + codep++; + } +} + +static int dflag; +static int aflag; + +static char op1out[100], op2out[100], op3out[100]; +static int op_address[3], op_ad, op_index[3]; +static int start_pc; +extern void fputs_filtered (); + +/* + * disassemble the first instruction in 'inbuf'. You have to make + * sure all of the bytes of the instruction are filled in. + * On the 386's of 1988, the maximum length of an instruction is 15 bytes. + * (see topic "Redundant prefixes" in the "Differences from 8086" + * section of the "Virtual 8086 Mode" chapter.) + * 'pc' should be the address of this instruction, it will + * be used to print the target address if this is a relative jump or call + * 'outbuf' gets filled in with the disassembled instruction. it should + * be long enough to hold the longest disassembled instruction. + * 100 bytes is certainly enough, unless symbol printing is added later + * The function returns the length of this instruction in bytes. + */ +i386dis (pc, inbuf, stream) + int pc; + unsigned char *inbuf; + FILE *stream; +{ + struct dis386 *dp; + char *p; + int i; + int enter_instruction; + char *first, *second, *third; + int needcomma; + + obuf[0] = 0; + op1out[0] = 0; + op2out[0] = 0; + op3out[0] = 0; + + op_index[0] = op_index[1] = op_index[2] = -1; + + start_pc = pc; + start_codep = inbuf; + codep = inbuf; + + ckprefix (); + + if (*codep == 0xc8) + enter_instruction = 1; + else + enter_instruction = 0; + + obufp = obuf; + + if (prefixes & PREFIX_REPZ) + oappend ("repz "); + if (prefixes & PREFIX_REPNZ) + oappend ("repnz "); + if (prefixes & PREFIX_LOCK) + oappend ("lock "); + + if ((prefixes & PREFIX_FWAIT) + && ((*codep < 0xd8) || (*codep > 0xdf))) + { + /* fwait not followed by floating point instruction */ + fputs_filtered ("fwait", stream); + return (1); + } + + /* these would be initialized to 0 if disassembling for 8086 or 286 */ + dflag = 1; + aflag = 1; + + if (prefixes & PREFIX_DATA) + dflag ^= 1; + + if (prefixes & PREFIX_ADR) + { + aflag ^= 1; + oappend ("addr16 "); + } + + if (*codep == 0x0f) + dp = &dis386_twobyte[*++codep]; + else + dp = &dis386[*codep]; + codep++; + mod = (*codep >> 6) & 3; + reg = (*codep >> 3) & 7; + rm = *codep & 7; + + if (dp->name == NULL && dp->bytemode1 == FLOATCODE) + { + dofloat (); + } + else + { + if (dp->name == NULL) + dp = &grps[dp->bytemode1][reg]; + + putop (dp->name); + + obufp = op1out; + op_ad = 2; + if (dp->op1) + (*dp->op1)(dp->bytemode1); + + obufp = op2out; + op_ad = 1; + if (dp->op2) + (*dp->op2)(dp->bytemode2); + + obufp = op3out; + op_ad = 0; + if (dp->op3) + (*dp->op3)(dp->bytemode3); + } + + obufp = obuf + strlen (obuf); + for (i = strlen (obuf); i < 6; i++) + oappend (" "); + oappend (" "); + fputs_filtered (obuf, stream); + + /* enter instruction is printed with operands in the + * same order as the intel book; everything else + * is printed in reverse order + */ + if (enter_instruction) + { + first = op1out; + second = op2out; + third = op3out; + op_ad = op_index[0]; + op_index[0] = op_index[2]; + op_index[2] = op_ad; + } + else + { + first = op3out; + second = op2out; + third = op1out; + } + needcomma = 0; + if (*first) + { + if (op_index[0] != -1) + print_address (op_address[op_index[0]], stream); + else + fputs_filtered (first, stream); + needcomma = 1; + } + if (*second) + { + if (needcomma) + fputs_filtered (",", stream); + if (op_index[1] != -1) + print_address (op_address[op_index[1]], stream); + else + fputs_filtered (second, stream); + needcomma = 1; + } + if (*third) + { + if (needcomma) + fputs_filtered (",", stream); + if (op_index[2] != -1) + print_address (op_address[op_index[2]], stream); + else + fputs_filtered (third, stream); + } + return (codep - inbuf); +} + +char *float_mem[] = { + /* d8 */ + "fadds", + "fmuls", + "fcoms", + "fcomps", + "fsubs", + "fsubrs", + "fdivs", + "fdivrs", + /* d9 */ + "flds", + "(bad)", + "fsts", + "fstps", + "fldenv", + "fldcw", + "fNstenv", + "fNstcw", + /* da */ + "fiaddl", + "fimull", + "ficoml", + "ficompl", + "fisubl", + "fisubrl", + "fidivl", + "fidivrl", + /* db */ + "fildl", + "(bad)", + "fistl", + "fistpl", + "(bad)", + "fldt", + "(bad)", + "fstpt", + /* dc */ + "faddl", + "fmull", + "fcoml", + "fcompl", + "fsubl", + "fsubrl", + "fdivl", + "fdivrl", + /* dd */ + "fldl", + "(bad)", + "fstl", + "fstpl", + "frstor", + "(bad)", + "fNsave", + "fNstsw", + /* de */ + "fiadd", + "fimul", + "ficom", + "ficomp", + "fisub", + "fisubr", + "fidiv", + "fidivr", + /* df */ + "fild", + "(bad)", + "fist", + "fistp", + "fbld", + "fildll", + "fbstp", + "fistpll", +}; + +#define ST OP_ST, 0 +#define STi OP_STi, 0 +int OP_ST(), OP_STi(); + +#define FGRPd9_2 NULL, NULL, 0 +#define FGRPd9_4 NULL, NULL, 1 +#define FGRPd9_5 NULL, NULL, 2 +#define FGRPd9_6 NULL, NULL, 3 +#define FGRPd9_7 NULL, NULL, 4 +#define FGRPda_5 NULL, NULL, 5 +#define FGRPdb_4 NULL, NULL, 6 +#define FGRPde_3 NULL, NULL, 7 +#define FGRPdf_4 NULL, NULL, 8 + +struct dis386 float_reg[][8] = { + /* d8 */ + { + { "fadd", ST, STi }, + { "fmul", ST, STi }, + { "fcom", STi }, + { "fcomp", STi }, + { "fsub", ST, STi }, + { "fsubr", ST, STi }, + { "fdiv", ST, STi }, + { "fdivr", ST, STi }, + }, + /* d9 */ + { + { "fld", STi }, + { "fxch", STi }, + { FGRPd9_2 }, + { "(bad)" }, + { FGRPd9_4 }, + { FGRPd9_5 }, + { FGRPd9_6 }, + { FGRPd9_7 }, + }, + /* da */ + { + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { FGRPda_5 }, + { "(bad)" }, + { "(bad)" }, + }, + /* db */ + { + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { FGRPdb_4 }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + }, + /* dc */ + { + { "fadd", STi, ST }, + { "fmul", STi, ST }, + { "(bad)" }, + { "(bad)" }, + { "fsub", STi, ST }, + { "fsubr", STi, ST }, + { "fdiv", STi, ST }, + { "fdivr", STi, ST }, + }, + /* dd */ + { + { "ffree", STi }, + { "(bad)" }, + { "fst", STi }, + { "fstp", STi }, + { "fucom", STi }, + { "fucomp", STi }, + { "(bad)" }, + { "(bad)" }, + }, + /* de */ + { + { "faddp", STi, ST }, + { "fmulp", STi, ST }, + { "(bad)" }, + { FGRPde_3 }, + { "fsubp", STi, ST }, + { "fsubrp", STi, ST }, + { "fdivp", STi, ST }, + { "fdivrp", STi, ST }, + }, + /* df */ + { + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + { FGRPdf_4 }, + { "(bad)" }, + { "(bad)" }, + { "(bad)" }, + }, +}; + + +char *fgrps[][8] = { + /* d9_2 0 */ + { + "fnop","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* d9_4 1 */ + { + "fchs","fabs","(bad)","(bad)","ftst","fxam","(bad)","(bad)", + }, + + /* d9_5 2 */ + { + "fld1","fldl2t","fldl2e","fldpi","fldlg2","fldln2","fldz","(bad)", + }, + + /* d9_6 3 */ + { + "f2xm1","fyl2x","fptan","fpatan","fxtract","fprem1","fdecstp","fincstp", + }, + + /* d9_7 4 */ + { + "fprem","fyl2xp1","fsqrt","fsincos","frndint","fscale","fsin","fcos", + }, + + /* da_5 5 */ + { + "(bad)","fucompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* db_4 6 */ + { + "feni(287 only)","fdisi(287 only)","fNclex","fNinit", + "fNsetpm(287 only)","(bad)","(bad)","(bad)", + }, + + /* de_3 7 */ + { + "(bad)","fcompp","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, + + /* df_4 8 */ + { + "fNstsw","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)","(bad)", + }, +}; + + +dofloat () +{ + struct dis386 *dp; + unsigned char floatop; + + floatop = codep[-1]; + + if (mod != 3) + { + putop (float_mem[(floatop - 0xd8) * 8 + reg]); + obufp = op1out; + OP_E (v_mode); + return; + } + codep++; + + dp = &float_reg[floatop - 0xd8][reg]; + if (dp->name == NULL) + { + putop (fgrps[dp->bytemode1][rm]); + /* instruction fnstsw is only one with strange arg */ + if (floatop == 0xdf && *codep == 0xe0) + strcpy (op1out, "%eax"); + } + else + { + putop (dp->name); + obufp = op1out; + if (dp->op1) + (*dp->op1)(dp->bytemode1); + obufp = op2out; + if (dp->op2) + (*dp->op2)(dp->bytemode2); + } +} + +/* ARGSUSED */ +OP_ST (ignore) +{ + oappend ("%st"); +} + +/* ARGSUSED */ +OP_STi (ignore) +{ + sprintf (scratchbuf, "%%st(%d)", rm); + oappend (scratchbuf); +} + + +/* capital letters in template are macros */ +putop (template) + char *template; +{ + char *p; + + for (p = template; *p; p++) + { + switch (*p) + { + default: + *obufp++ = *p; + break; + case 'C': /* For jcxz/jecxz */ + if (aflag == 0) + *obufp++ = 'e'; + break; + case 'N': + if ((prefixes & PREFIX_FWAIT) == 0) + *obufp++ = 'n'; + break; + case 'S': + /* operand size flag */ + if (dflag) + *obufp++ = 'l'; + else + *obufp++ = 'w'; + break; + } + } + *obufp = 0; +} + +static void +oappend (s) +char *s; +{ + strcpy (obufp, s); + obufp += strlen (s); + *obufp = 0; +} + +append_prefix () +{ + if (prefixes & PREFIX_CS) + oappend ("%cs:"); + if (prefixes & PREFIX_DS) + oappend ("%ds:"); + if (prefixes & PREFIX_SS) + oappend ("%ss:"); + if (prefixes & PREFIX_ES) + oappend ("%es:"); + if (prefixes & PREFIX_FS) + oappend ("%fs:"); + if (prefixes & PREFIX_GS) + oappend ("%gs:"); +} + +OP_indirE (bytemode) +{ + oappend ("*"); + OP_E (bytemode); +} + +OP_E (bytemode) +{ + int disp; + int havesib; + int didoutput = 0; + int base; + int index; + int scale; + int havebase; + + /* skip mod/rm byte */ + codep++; + + havesib = 0; + havebase = 0; + disp = 0; + + if (mod == 3) + { + switch (bytemode) + { + case b_mode: + oappend (names8[rm]); + break; + case w_mode: + oappend (names16[rm]); + break; + case v_mode: + if (dflag) + oappend (names32[rm]); + else + oappend (names16[rm]); + break; + default: + oappend ("<bad dis table>"); + break; + } + return; + } + + append_prefix (); + if (rm == 4) + { + havesib = 1; + havebase = 1; + scale = (*codep >> 6) & 3; + index = (*codep >> 3) & 7; + base = *codep & 7; + codep++; + } + + switch (mod) + { + case 0: + switch (rm) + { + case 4: + /* implies havesib and havebase */ + if (base == 5) { + havebase = 0; + disp = get32 (); + } + break; + case 5: + disp = get32 (); + break; + default: + havebase = 1; + base = rm; + break; + } + break; + case 1: + disp = *(char *)codep++; + if (rm != 4) + { + havebase = 1; + base = rm; + } + break; + case 2: + disp = get32 (); + if (rm != 4) + { + havebase = 1; + base = rm; + } + break; + } + + if (mod != 0 || rm == 5 || (havesib && base == 5)) + { + sprintf (scratchbuf, "%d", disp); + oappend (scratchbuf); + } + + if (havebase || havesib) + { + oappend ("("); + if (havebase) + oappend (names32[base]); + if (havesib) + { + if (index != 4) + { + sprintf (scratchbuf, ",%s", names32[index]); + oappend (scratchbuf); + } + sprintf (scratchbuf, ",%d", 1 << scale); + oappend (scratchbuf); + } + oappend (")"); + } +} + +OP_G (bytemode) +{ + switch (bytemode) + { + case b_mode: + oappend (names8[reg]); + break; + case w_mode: + oappend (names16[reg]); + break; + case d_mode: + oappend (names32[reg]); + break; + case v_mode: + if (dflag) + oappend (names32[reg]); + else + oappend (names16[reg]); + break; + default: + oappend ("<internal disassembler error>"); + break; + } +} + +get32 () +{ + int x = 0; + + x = *codep++ & 0xff; + x |= (*codep++ & 0xff) << 8; + x |= (*codep++ & 0xff) << 16; + x |= (*codep++ & 0xff) << 24; + return (x); +} + +get16 () +{ + int x = 0; + + x = *codep++ & 0xff; + x |= (*codep++ & 0xff) << 8; + return (x); +} + +set_op (op) +int op; +{ + op_index[op_ad] = op_ad; + op_address[op_ad] = op; +} + +OP_REG (code) +{ + char *s; + + switch (code) + { + case indir_dx_reg: s = "(%dx)"; break; + case ax_reg: case cx_reg: case dx_reg: case bx_reg: + case sp_reg: case bp_reg: case si_reg: case di_reg: + s = names16[code - ax_reg]; + break; + case es_reg: case ss_reg: case cs_reg: + case ds_reg: case fs_reg: case gs_reg: + s = names_seg[code - es_reg]; + break; + case al_reg: case ah_reg: case cl_reg: case ch_reg: + case dl_reg: case dh_reg: case bl_reg: case bh_reg: + s = names8[code - al_reg]; + break; + case eAX_reg: case eCX_reg: case eDX_reg: case eBX_reg: + case eSP_reg: case eBP_reg: case eSI_reg: case eDI_reg: + if (dflag) + s = names32[code - eAX_reg]; + else + s = names16[code - eAX_reg]; + break; + default: + s = "<internal disassembler error>"; + break; + } + oappend (s); +} + +OP_I (bytemode) +{ + int op; + + switch (bytemode) + { + case b_mode: + op = *codep++ & 0xff; + break; + case v_mode: + if (dflag) + op = get32 (); + else + op = get16 (); + break; + case w_mode: + op = get16 (); + break; + default: + oappend ("<internal disassembler error>"); + return; + } + sprintf (scratchbuf, "$0x%x", op); + oappend (scratchbuf); +} + +OP_sI (bytemode) +{ + int op; + + switch (bytemode) + { + case b_mode: + op = *(char *)codep++; + break; + case v_mode: + if (dflag) + op = get32 (); + else + op = (short)get16(); + break; + case w_mode: + op = (short)get16 (); + break; + default: + oappend ("<internal disassembler error>"); + return; + } + sprintf (scratchbuf, "$0x%x", op); + oappend (scratchbuf); +} + +OP_J (bytemode) +{ + int disp; + int mask = -1; + + switch (bytemode) + { + case b_mode: + disp = *(char *)codep++; + break; + case v_mode: + if (dflag) + disp = get32 (); + else + { + disp = (short)get16 (); + /* for some reason, a data16 prefix on a jump instruction + means that the pc is masked to 16 bits after the + displacement is added! */ + mask = 0xffff; + } + break; + default: + oappend ("<internal disassembler error>"); + return; + } + disp = (start_pc + codep - start_codep + disp) & mask; + set_op (disp); + sprintf (scratchbuf, "0x%x", disp); + oappend (scratchbuf); +} + +/* ARGSUSED */ +OP_SEG (dummy) +{ + static char *sreg[] = { + "%es","%cs","%ss","%ds","%fs","%gs","%?","%?", + }; + + oappend (sreg[reg]); +} + +OP_DIR (size) +{ + int seg, offset; + + switch (size) + { + case lptr: + if (aflag) + { + offset = get32 (); + seg = get16 (); + } + else + { + offset = get16 (); + seg = get16 (); + } + sprintf (scratchbuf, "0x%x,0x%x", seg, offset); + oappend (scratchbuf); + break; + case v_mode: + if (aflag) + offset = get32 (); + else + offset = (short)get16 (); + + offset = start_pc + codep - start_codep + offset; + set_op (offset); + sprintf (scratchbuf, "0x%x", offset); + oappend (scratchbuf); + break; + default: + oappend ("<internal disassembler error>"); + break; + } +} + +/* ARGSUSED */ +OP_OFF (bytemode) +{ + int off; + + if (aflag) + off = get32 (); + else + off = get16 (); + + sprintf (scratchbuf, "0x%x", off); + oappend (scratchbuf); +} + +/* ARGSUSED */ +OP_ESDI (dummy) +{ + oappend ("%es:("); + oappend (aflag ? "%edi" : "%di"); + oappend (")"); +} + +/* ARGSUSED */ +OP_DSSI (dummy) +{ + oappend ("%ds:("); + oappend (aflag ? "%esi" : "%si"); + oappend (")"); +} + +/* ARGSUSED */ +OP_ONE (dummy) +{ + oappend ("1"); +} + +/* ARGSUSED */ +OP_C (dummy) +{ + codep++; /* skip mod/rm */ + sprintf (scratchbuf, "%%cr%d", reg); + oappend (scratchbuf); +} + +/* ARGSUSED */ +OP_D (dummy) +{ + codep++; /* skip mod/rm */ + sprintf (scratchbuf, "%%db%d", reg); + oappend (scratchbuf); +} + +/* ARGSUSED */ +OP_T (dummy) +{ + codep++; /* skip mod/rm */ + sprintf (scratchbuf, "%%tr%d", reg); + oappend (scratchbuf); +} + +OP_rm (bytemode) +{ + switch (bytemode) + { + case d_mode: + oappend (names32[rm]); + break; + case w_mode: + oappend (names16[rm]); + break; + } +} + +/* GDB interface */ +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "frame.h" +#include "inferior.h" +#include "gdbcore.h" + +#define MAXLEN 20 +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + + read_memory (memaddr, buffer, MAXLEN); + + return (i386dis ((int)memaddr, buffer, stream)); +} + diff --git a/gdb/i386-xdep.c b/gdb/i386-xdep.c new file mode 100644 index 0000000..dddf22d --- /dev/null +++ b/gdb/i386-xdep.c @@ -0,0 +1,357 @@ +/* Intel 386 stuff. + Copyright (C) 1988, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "gdbcore.h" + +#ifdef USG +#include <sys/types.h> +#endif + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/user.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#include <sys/file.h> +#include <sys/stat.h> + +#include <sys/reg.h> + +/* this table must line up with REGISTER_NAMES in m-i386.h */ +/* symbols like 'EAX' come from <sys/reg.h> */ +static int regmap[] = +{ + EAX, ECX, EDX, EBX, + UESP, EBP, ESI, EDI, + EIP, EFL, CS, SS, + DS, ES, FS, GS, +}; + +/* blockend is the value of u.u_ar0, and points to the + * place where GS is stored + */ +i386_register_u_addr (blockend, regnum) +{ +#if 0 + /* this will be needed if fp registers are reinstated */ + /* for now, you can look at them with 'info float' + * sys5 wont let you change them with ptrace anyway + */ + if (regnum >= FP0_REGNUM && regnum <= FP7_REGNUM) + { + int ubase, fpstate; + struct user u; + ubase = blockend + 4 * (SS + 1) - KSTKSZ; + fpstate = ubase + ((char *)&u.u_fpstate - (char *)&u); + return (fpstate + 0x1c + 10 * (regnum - FP0_REGNUM)); + } + else +#endif + return (blockend + 4 * regmap[regnum]); + +} + +/* This is broken for cross debugging. Possible solutions are: + +1. Don't worry about whether the thing compiles for cross-debugging. +Go ahead and call them from i386-tdep.c. +1a. Same thing but use some macros in xm-i386.h so that gdb will +compile for cross-debugging but just give an error (or some such behavior) +when you attempt to convert floats. + +2. Write a portable (in the sense of running on any machine; it would +always be for i387 floating-point formats) extended<->double converter +(which just deals with the values as arrays of char). + +3. Assume the host machine has *some* IEEE chip. However, IEEE does +not standardize formats for extended floats (387 is 10 bytes, 68881 is +12 bytes), so this won't work. */ + +i387_to_double (from, to) + char *from; + char *to; +{ + long *lp; + /* push extended mode on 387 stack, then pop in double mode + * + * first, set exception masks so no error is generated - + * number will be rounded to inf or 0, if necessary + */ + asm ("pushl %eax"); /* grab a stack slot */ + asm ("fstcw (%esp)"); /* get 387 control word */ + asm ("movl (%esp),%eax"); /* save old value */ + asm ("orl $0x3f,%eax"); /* mask all exceptions */ + asm ("pushl %eax"); + asm ("fldcw (%esp)"); /* load new value into 387 */ + + asm ("movl 8(%ebp),%eax"); + asm ("fldt (%eax)"); /* push extended number on 387 stack */ + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpl (%eax)"); /* pop double */ + asm ("fwait"); + + asm ("popl %eax"); /* flush modified control word */ + asm ("fnclex"); /* clear exceptions */ + asm ("fldcw (%esp)"); /* restore original control word */ + asm ("popl %eax"); /* flush saved copy */ +} + +double_to_i387 (from, to) + char *from; + char *to; +{ + /* push double mode on 387 stack, then pop in extended mode + * no errors are possible because every 64-bit pattern + * can be converted to an extended + */ + asm ("movl 8(%ebp),%eax"); + asm ("fldl (%eax)"); + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpt (%eax)"); + asm ("fwait"); +} + +struct env387 +{ + unsigned short control; + unsigned short r0; + unsigned short status; + unsigned short r1; + unsigned short tag; + unsigned short r2; + unsigned long eip; + unsigned short code_seg; + unsigned short opcode; + unsigned long operand; + unsigned short operand_seg; + unsigned short r3; + unsigned char regs[8][10]; +}; + +static +print_387_control_word (control) +unsigned short control; +{ + printf ("control 0x%04x: ", control); + printf ("compute to "); + switch ((control >> 8) & 3) + { + case 0: printf ("24 bits; "); break; + case 1: printf ("(bad); "); break; + case 2: printf ("53 bits; "); break; + case 3: printf ("64 bits; "); break; + } + printf ("round "); + switch ((control >> 10) & 3) + { + case 0: printf ("NEAREST; "); break; + case 1: printf ("DOWN; "); break; + case 2: printf ("UP; "); break; + case 3: printf ("CHOP; "); break; + } + if (control & 0x3f) + { + printf ("mask:"); + if (control & 0x0001) printf (" INVALID"); + if (control & 0x0002) printf (" DENORM"); + if (control & 0x0004) printf (" DIVZ"); + if (control & 0x0008) printf (" OVERF"); + if (control & 0x0010) printf (" UNDERF"); + if (control & 0x0020) printf (" LOS"); + printf (";"); + } + printf ("\n"); + if (control & 0xe080) printf ("warning: reserved bits on 0x%x\n", + control & 0xe080); +} + +static +print_387_status_word (status) + unsigned short status; +{ + printf ("status 0x%04x: ", status); + if (status & 0xff) + { + printf ("exceptions:"); + if (status & 0x0001) printf (" INVALID"); + if (status & 0x0002) printf (" DENORM"); + if (status & 0x0004) printf (" DIVZ"); + if (status & 0x0008) printf (" OVERF"); + if (status & 0x0010) printf (" UNDERF"); + if (status & 0x0020) printf (" LOS"); + if (status & 0x0040) printf (" FPSTACK"); + printf ("; "); + } + printf ("flags: %d%d%d%d; ", + (status & 0x4000) != 0, + (status & 0x0400) != 0, + (status & 0x0200) != 0, + (status & 0x0100) != 0); + + printf ("top %d\n", (status >> 11) & 7); +} + +static +print_387_status (status, ep) + unsigned short status; + struct env387 *ep; +{ + int i; + int bothstatus; + int top; + int fpreg; + unsigned char *p; + + bothstatus = ((status != 0) && (ep->status != 0)); + if (status != 0) + { + if (bothstatus) + printf ("u: "); + print_387_status_word (status); + } + + if (ep->status != 0) + { + if (bothstatus) + printf ("e: "); + print_387_status_word (ep->status); + } + + print_387_control_word (ep->control); + printf ("last exception: "); + printf ("opcode 0x%x; ", ep->opcode); + printf ("pc 0x%x:0x%x; ", ep->code_seg, ep->eip); + printf ("operand 0x%x:0x%x\n", ep->operand_seg, ep->operand); + + top = (ep->status >> 11) & 7; + + printf ("regno tag msb lsb value\n"); + for (fpreg = 7; fpreg >= 0; fpreg--) + { + double val; + + printf ("%s %d: ", fpreg == top ? "=>" : " ", fpreg); + + switch ((ep->tag >> (fpreg * 2)) & 3) + { + case 0: printf ("valid "); break; + case 1: printf ("zero "); break; + case 2: printf ("trap "); break; + case 3: printf ("empty "); break; + } + for (i = 9; i >= 0; i--) + printf ("%02x", ep->regs[fpreg][i]); + + i387_to_double (ep->regs[fpreg], (char *)&val); + printf (" %g\n", val); + } + if (ep->r0) + printf ("warning: reserved0 is 0x%x\n", ep->r0); + if (ep->r1) + printf ("warning: reserved1 is 0x%x\n", ep->r1); + if (ep->r2) + printf ("warning: reserved2 is 0x%x\n", ep->r2); + if (ep->r3) + printf ("warning: reserved3 is 0x%x\n", ep->r3); +} + +#ifndef U_FPSTATE +#define U_FPSTATE(u) u.u_fpstate +#endif + +i386_float_info () +{ + struct user u; /* just for address computations */ + int i; + /* fpstate defined in <sys/user.h> */ + struct fpstate *fpstatep; + char buf[sizeof (struct fpstate) + 2 * sizeof (int)]; + unsigned int uaddr; + char fpvalid; + unsigned int rounded_addr; + unsigned int rounded_size; + extern int corechan; + int skip; + + uaddr = (char *)&u.u_fpvalid - (char *)&u; + if (have_inferior_p()) + { + unsigned int data; + unsigned int mask; + + rounded_addr = uaddr & -sizeof (int); + data = ptrace (3, inferior_pid, rounded_addr, 0); + mask = 0xff << ((uaddr - rounded_addr) * 8); + + fpvalid = ((data & mask) != 0); + } + else + { + if (lseek (corechan, uaddr, 0) < 0) + perror ("seek on core file"); + if (myread (corechan, &fpvalid, 1) < 0) + perror ("read on core file"); + + } + + if (fpvalid == 0) + { + printf ("no floating point status saved\n"); + return; + } + + uaddr = (char *)&U_FPSTATE(u) - (char *)&u; + if (have_inferior_p ()) + { + int *ip; + + rounded_addr = uaddr & -sizeof (int); + rounded_size = (((uaddr + sizeof (struct fpstate)) - uaddr) + + sizeof (int) - 1) / sizeof (int); + skip = uaddr - rounded_addr; + + ip = (int *)buf; + for (i = 0; i < rounded_size; i++) + { + *ip++ = ptrace (3, inferior_pid, rounded_addr, 0); + rounded_addr += sizeof (int); + } + } + else + { + if (lseek (corechan, uaddr, 0) < 0) + perror_with_name ("seek on core file"); + if (myread (corechan, buf, sizeof (struct fpstate)) < 0) + perror_with_name ("read from core file"); + skip = 0; + } + + fpstatep = (struct fpstate *)(buf + skip); + print_387_status (fpstatep->status, (struct env387 *)fpstatep->state); +} + diff --git a/gdb/i960-pinsn.c b/gdb/i960-pinsn.c new file mode 100644 index 0000000..ea3fa64 --- /dev/null +++ b/gdb/i960-pinsn.c @@ -0,0 +1,847 @@ +/* Disassemble i80960 instructions. + */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +extern char *reg_names[]; + +static FILE *stream; /* Output goes here */ +static void print_addr(); +static void ctrl(); +static void cobr(); +static void reg(); +static int mem(); +static void ea(); +static void dstop(); +static void regop(); +static void invalid(); +static int pinsn(); +static void put_abs(); + + +/* Print the i960 instruction at address 'memaddr' in debugged memory, + on stream 's'. Returns length of the instruction, in bytes. */ +int +print_insn( memaddr, s ) + CORE_ADDR memaddr; + FILE *s; +{ + unsigned int word1, word2; + + stream = s; + word1 = read_memory_integer( memaddr, 4 ); + word2 = read_memory_integer( memaddr+4, 4 ); + return pinsn( memaddr, word1, word2 ); +} + + +/* Read the i960 instruction at 'memaddr' and return the address of + the next instruction after that, or 0 if 'memaddr' is not the + address of a valid instruction. The first word of the instruction + is stored at 'pword1', and the second word, if any, is stored at + 'pword2'. */ + +CORE_ADDR +next_insn (memaddr, pword1, pword2) + unsigned long *pword1, *pword2; + CORE_ADDR memaddr; +{ + int len; + unsigned long buf[2]; + + /* Read the two (potential) words of the instruction at once, + to eliminate the overhead of two calls to read_memory (). + TODO: read more instructions at once and cache them. */ + + read_memory (memaddr, buf, sizeof (buf)); + *pword1 = buf[0]; + SWAP_TARGET_AND_HOST (pword1, sizeof (long)); + *pword2 = buf[1]; + SWAP_TARGET_AND_HOST (pword2, sizeof (long)); + + /* Divide instruction set into classes based on high 4 bits of opcode*/ + + switch ((*pword1 >> 28) & 0xf) + { + case 0x0: + case 0x1: /* ctrl */ + + case 0x2: + case 0x3: /* cobr */ + + case 0x5: + case 0x6: + case 0x7: /* reg */ + len = 4; + break; + + case 0x8: + case 0x9: + case 0xa: + case 0xb: + case 0xc: + len = mem (memaddr, *pword1, *pword2, 1); + break; + + default: /* invalid instruction */ + len = 0; + break; + } + + if (len) + return memaddr + len; + else + return 0; +} + +#define IN_GDB + +/***************************************************************************** + * All code below this point should be identical with that of + * the disassembler in gdmp960. + *****************************************************************************/ + +struct tabent { + char *name; + char numops; +}; + +static int +pinsn( memaddr, word1, word2 ) + unsigned long memaddr; + unsigned long word1, word2; +{ + int instr_len; + + instr_len = 4; + put_abs( word1, word2 ); + + /* Divide instruction set into classes based on high 4 bits of opcode*/ + + switch ( (word1 >> 28) & 0xf ){ + case 0x0: + case 0x1: + ctrl( memaddr, word1, word2 ); + break; + case 0x2: + case 0x3: + cobr( memaddr, word1, word2 ); + break; + case 0x5: + case 0x6: + case 0x7: + reg( word1 ); + break; + case 0x8: + case 0x9: + case 0xa: + case 0xb: + case 0xc: + instr_len = mem( memaddr, word1, word2, 0 ); + break; + default: + /* invalid instruction, print as data word */ + invalid( word1 ); + break; + } + return instr_len; +} + +/****************************************/ +/* CTRL format */ +/****************************************/ +static void +ctrl( memaddr, word1, word2 ) + unsigned long memaddr; + unsigned long word1, word2; +{ + int i; + static struct tabent ctrl_tab[] = { + NULL, 0, /* 0x00 */ + NULL, 0, /* 0x01 */ + NULL, 0, /* 0x02 */ + NULL, 0, /* 0x03 */ + NULL, 0, /* 0x04 */ + NULL, 0, /* 0x05 */ + NULL, 0, /* 0x06 */ + NULL, 0, /* 0x07 */ + "b", 1, /* 0x08 */ + "call", 1, /* 0x09 */ + "ret", 0, /* 0x0a */ + "bal", 1, /* 0x0b */ + NULL, 0, /* 0x0c */ + NULL, 0, /* 0x0d */ + NULL, 0, /* 0x0e */ + NULL, 0, /* 0x0f */ + "bno", 1, /* 0x10 */ + "bg", 1, /* 0x11 */ + "be", 1, /* 0x12 */ + "bge", 1, /* 0x13 */ + "bl", 1, /* 0x14 */ + "bne", 1, /* 0x15 */ + "ble", 1, /* 0x16 */ + "bo", 1, /* 0x17 */ + "faultno", 0, /* 0x18 */ + "faultg", 0, /* 0x19 */ + "faulte", 0, /* 0x1a */ + "faultge", 0, /* 0x1b */ + "faultl", 0, /* 0x1c */ + "faultne", 0, /* 0x1d */ + "faultle", 0, /* 0x1e */ + "faulto", 0, /* 0x1f */ + }; + + i = (word1 >> 24) & 0xff; + if ( (ctrl_tab[i].name == NULL) || ((word1 & 1) != 0) ){ + invalid( word1 ); + return; + } + + fputs( ctrl_tab[i].name, stream ); + if ( word1 & 2 ){ /* Predicts branch not taken */ + fputs( ".f", stream ); + } + + if ( ctrl_tab[i].numops == 1 ){ + /* EXTRACT DISPLACEMENT AND CONVERT TO ADDRESS */ + word1 &= 0x00ffffff; + if ( word1 & 0x00800000 ){ /* Sign bit is set */ + word1 |= (-1 & ~0xffffff); /* Sign extend */ + } + putc( '\t', stream ); + print_addr( word1 + memaddr ); + } +} + +/****************************************/ +/* COBR format */ +/****************************************/ +static void +cobr( memaddr, word1, word2 ) + unsigned long memaddr; + unsigned long word1, word2; +{ + int src1; + int src2; + int i; + + static struct tabent cobr_tab[] = { + "testno", 1, /* 0x20 */ + "testg", 1, /* 0x21 */ + "teste", 1, /* 0x22 */ + "testge", 1, /* 0x23 */ + "testl", 1, /* 0x24 */ + "testne", 1, /* 0x25 */ + "testle", 1, /* 0x26 */ + "testo", 1, /* 0x27 */ + NULL, 0, /* 0x28 */ + NULL, 0, /* 0x29 */ + NULL, 0, /* 0x2a */ + NULL, 0, /* 0x2b */ + NULL, 0, /* 0x2c */ + NULL, 0, /* 0x2d */ + NULL, 0, /* 0x2e */ + NULL, 0, /* 0x2f */ + "bbc", 3, /* 0x30 */ + "cmpobg", 3, /* 0x31 */ + "cmpobe", 3, /* 0x32 */ + "cmpobge", 3, /* 0x33 */ + "cmpobl", 3, /* 0x34 */ + "cmpobne", 3, /* 0x35 */ + "cmpoble", 3, /* 0x36 */ + "bbs", 3, /* 0x37 */ + "cmpibno", 3, /* 0x38 */ + "cmpibg", 3, /* 0x39 */ + "cmpibe", 3, /* 0x3a */ + "cmpibge", 3, /* 0x3b */ + "cmpibl", 3, /* 0x3c */ + "cmpibne", 3, /* 0x3d */ + "cmpible", 3, /* 0x3e */ + "cmpibo", 3, /* 0x3f */ + }; + + i = ((word1 >> 24) & 0xff) - 0x20; + if ( cobr_tab[i].name == NULL ){ + invalid( word1 ); + return; + } + + fputs( cobr_tab[i].name, stream ); + if ( word1 & 2 ){ /* Predicts branch not taken */ + fputs( ".f", stream ); + } + putc( '\t', stream ); + + src1 = (word1 >> 19) & 0x1f; + src2 = (word1 >> 14) & 0x1f; + + if ( word1 & 0x02000 ){ /* M1 is 1 */ + fprintf( stream, "%d", src1 ); + } else { /* M1 is 0 */ + fputs( reg_names[src1], stream ); + } + + if ( cobr_tab[i].numops > 1 ){ + if ( word1 & 1 ){ /* S2 is 1 */ + fprintf( stream, ",sf%d,", src2 ); + } else { /* S1 is 0 */ + fprintf( stream, ",%s,", reg_names[src2] ); + } + + /* Extract displacement and convert to address + */ + word1 &= 0x00001ffc; + if ( word1 & 0x00001000 ){ /* Negative displacement */ + word1 |= (-1 & ~0x1fff); /* Sign extend */ + } + print_addr( memaddr + word1 ); + } +} + +/****************************************/ +/* MEM format */ +/****************************************/ +static int /* returns instruction length: 4 or 8 */ +mem( memaddr, word1, word2, noprint ) + unsigned long memaddr; + unsigned long word1, word2; + int noprint; /* If TRUE, return instruction length, but + don't output any text. */ +{ + int i, j; + int len; + int mode; + int offset; + char *reg1, *reg2, *reg3; + + /* This lookup table is too sparse to make it worth typing in, but not + * so large as to make a sparse array necessary. We allocate the + * table at runtime, initialize all entries to empty, and copy the + * real ones in from an initialization table. + * + * NOTE: In this table, the meaning of 'numops' is: + * 1: single operand + * 2: 2 operands, load instruction + * -2: 2 operands, store instruction + */ + static struct tabent *mem_tab = NULL; + static struct { int opcode; char *name; char numops; } mem_init[] = { +#define MEM_MIN 0x80 + 0x80, "ldob", 2, + 0x82, "stob", -2, + 0x84, "bx", 1, + 0x85, "balx", 2, + 0x86, "callx", 1, + 0x88, "ldos", 2, + 0x8a, "stos", -2, + 0x8c, "lda", 2, + 0x90, "ld", 2, + 0x92, "st", -2, + 0x98, "ldl", 2, + 0x9a, "stl", -2, + 0xa0, "ldt", 2, + 0xa2, "stt", -2, + 0xb0, "ldq", 2, + 0xb2, "stq", -2, + 0xc0, "ldib", 2, + 0xc2, "stib", -2, + 0xc8, "ldis", 2, + 0xca, "stis", -2, +#define MEM_MAX 0xca +#define MEM_SIZ ((MEM_MAX-MEM_MIN+1) * sizeof(struct tabent)) + 0, NULL, 0 + }; + + if ( mem_tab == NULL ){ + mem_tab = (struct tabent *) xmalloc( MEM_SIZ ); + bzero( mem_tab, MEM_SIZ ); + for ( i = 0; mem_init[i].opcode != 0; i++ ){ + j = mem_init[i].opcode - MEM_MIN; + mem_tab[j].name = mem_init[i].name; + mem_tab[j].numops = mem_init[i].numops; + } + } + + i = ((word1 >> 24) & 0xff) - MEM_MIN; + mode = (word1 >> 10) & 0xf; + + if ( (mem_tab[i].name != NULL) /* Valid instruction */ + && ((mode == 5) || (mode >=12)) ){ /* With 32-bit displacement */ + len = 8; + } else { + len = 4; + } + + if ( noprint ){ + return len; + } + + if ( (mem_tab[i].name == NULL) || (mode == 6) ){ + invalid( word1 ); + return len; + } + + fprintf( stream, "%s\t", mem_tab[i].name ); + + reg1 = reg_names[ (word1 >> 19) & 0x1f ]; /* MEMB only */ + reg2 = reg_names[ (word1 >> 14) & 0x1f ]; + reg3 = reg_names[ word1 & 0x1f ]; /* MEMB only */ + offset = word1 & 0xfff; /* MEMA only */ + + switch ( mem_tab[i].numops ){ + + case 2: /* LOAD INSTRUCTION */ + if ( mode & 4 ){ /* MEMB FORMAT */ + ea( memaddr, mode, reg2, reg3, word1, word2 ); + fprintf( stream, ",%s", reg1 ); + } else { /* MEMA FORMAT */ + fprintf( stream, "0x%x", offset ); + if (mode & 8) { + fprintf( stream, "(%s)", reg2 ); + } + fprintf( stream, ",%s", reg1 ); + } + break; + + case -2: /* STORE INSTRUCTION */ + if ( mode & 4 ){ /* MEMB FORMAT */ + fprintf( stream, "%s,", reg1 ); + ea( memaddr, mode, reg2, reg3, word1, word2 ); + } else { /* MEMA FORMAT */ + fprintf( stream, "%s,0x%x", reg1, offset ); + if (mode & 8) { + fprintf( stream, "(%s)", reg2 ); + } + } + break; + + case 1: /* BX/CALLX INSTRUCTION */ + if ( mode & 4 ){ /* MEMB FORMAT */ + ea( memaddr, mode, reg2, reg3, word1, word2 ); + } else { /* MEMA FORMAT */ + fprintf( stream, "0x%x", offset ); + if (mode & 8) { + fprintf( stream, "(%s)", reg2 ); + } + } + break; + } + + return len; +} + +/****************************************/ +/* REG format */ +/****************************************/ +static void +reg( word1 ) + unsigned long word1; +{ + int i, j; + int opcode; + int fp; + int m1, m2, m3; + int s1, s2; + int src, src2, dst; + char *mnemp; + + /* This lookup table is too sparse to make it worth typing in, but not + * so large as to make a sparse array necessary. We allocate the + * table at runtime, initialize all entries to empty, and copy the + * real ones in from an initialization table. + * + * NOTE: In this table, the meaning of 'numops' is: + * 1: single operand, which is NOT a destination. + * -1: single operand, which IS a destination. + * 2: 2 operands, the 2nd of which is NOT a destination. + * -2: 2 operands, the 2nd of which IS a destination. + * 3: 3 operands + * + * If an opcode mnemonic begins with "F", it is a floating-point + * opcode (the "F" is not printed). + */ + + static struct tabent *reg_tab = NULL; + static struct { int opcode; char *name; char numops; } reg_init[] = { +#define REG_MIN 0x580 + 0x580, "notbit", 3, + 0x581, "and", 3, + 0x582, "andnot", 3, + 0x583, "setbit", 3, + 0x584, "notand", 3, + 0x586, "xor", 3, + 0x587, "or", 3, + 0x588, "nor", 3, + 0x589, "xnor", 3, + 0x58a, "not", -2, + 0x58b, "ornot", 3, + 0x58c, "clrbit", 3, + 0x58d, "notor", 3, + 0x58e, "nand", 3, + 0x58f, "alterbit", 3, + 0x590, "addo", 3, + 0x591, "addi", 3, + 0x592, "subo", 3, + 0x593, "subi", 3, + 0x598, "shro", 3, + 0x59a, "shrdi", 3, + 0x59b, "shri", 3, + 0x59c, "shlo", 3, + 0x59d, "rotate", 3, + 0x59e, "shli", 3, + 0x5a0, "cmpo", 2, + 0x5a1, "cmpi", 2, + 0x5a2, "concmpo", 2, + 0x5a3, "concmpi", 2, + 0x5a4, "cmpinco", 3, + 0x5a5, "cmpinci", 3, + 0x5a6, "cmpdeco", 3, + 0x5a7, "cmpdeci", 3, + 0x5ac, "scanbyte", 2, + 0x5ae, "chkbit", 2, + 0x5b0, "addc", 3, + 0x5b2, "subc", 3, + 0x5cc, "mov", -2, + 0x5d8, "eshro", 3, + 0x5dc, "movl", -2, + 0x5ec, "movt", -2, + 0x5fc, "movq", -2, + 0x600, "synmov", 2, + 0x601, "synmovl", 2, + 0x602, "synmovq", 2, + 0x603, "cmpstr", 3, + 0x604, "movqstr", 3, + 0x605, "movstr", 3, + 0x610, "atmod", 3, + 0x612, "atadd", 3, + 0x613, "inspacc", -2, + 0x614, "ldphy", -2, + 0x615, "synld", -2, + 0x617, "fill", 3, + 0x630, "sdma", 3, + 0x631, "udma", 0, + 0x640, "spanbit", -2, + 0x641, "scanbit", -2, + 0x642, "daddc", 3, + 0x643, "dsubc", 3, + 0x644, "dmovt", -2, + 0x645, "modac", 3, + 0x646, "condrec", -2, + 0x650, "modify", 3, + 0x651, "extract", 3, + 0x654, "modtc", 3, + 0x655, "modpc", 3, + 0x656, "receive", -2, + 0x659, "sysctl", 3, + 0x660, "calls", 1, + 0x662, "send", 3, + 0x663, "sendserv", 1, + 0x664, "resumprcs", 1, + 0x665, "schedprcs", 1, + 0x666, "saveprcs", 0, + 0x668, "condwait", 1, + 0x669, "wait", 1, + 0x66a, "signal", 1, + 0x66b, "mark", 0, + 0x66c, "fmark", 0, + 0x66d, "flushreg", 0, + 0x66f, "syncf", 0, + 0x670, "emul", 3, + 0x671, "ediv", 3, + 0x673, "ldtime", -1, + 0x674, "Fcvtir", -2, + 0x675, "Fcvtilr", -2, + 0x676, "Fscalerl", 3, + 0x677, "Fscaler", 3, + 0x680, "Fatanr", 3, + 0x681, "Flogepr", 3, + 0x682, "Flogr", 3, + 0x683, "Fremr", 3, + 0x684, "Fcmpor", 2, + 0x685, "Fcmpr", 2, + 0x688, "Fsqrtr", -2, + 0x689, "Fexpr", -2, + 0x68a, "Flogbnr", -2, + 0x68b, "Froundr", -2, + 0x68c, "Fsinr", -2, + 0x68d, "Fcosr", -2, + 0x68e, "Ftanr", -2, + 0x68f, "Fclassr", 1, + 0x690, "Fatanrl", 3, + 0x691, "Flogeprl", 3, + 0x692, "Flogrl", 3, + 0x693, "Fremrl", 3, + 0x694, "Fcmporl", 2, + 0x695, "Fcmprl", 2, + 0x698, "Fsqrtrl", -2, + 0x699, "Fexprl", -2, + 0x69a, "Flogbnrl", -2, + 0x69b, "Froundrl", -2, + 0x69c, "Fsinrl", -2, + 0x69d, "Fcosrl", -2, + 0x69e, "Ftanrl", -2, + 0x69f, "Fclassrl", 1, + 0x6c0, "Fcvtri", -2, + 0x6c1, "Fcvtril", -2, + 0x6c2, "Fcvtzri", -2, + 0x6c3, "Fcvtzril", -2, + 0x6c9, "Fmovr", -2, + 0x6d9, "Fmovrl", -2, + 0x6e1, "Fmovre", -2, + 0x6e2, "Fcpysre", 3, + 0x6e3, "Fcpyrsre", 3, + 0x701, "mulo", 3, + 0x708, "remo", 3, + 0x70b, "divo", 3, + 0x741, "muli", 3, + 0x748, "remi", 3, + 0x749, "modi", 3, + 0x74b, "divi", 3, + 0x78b, "Fdivr", 3, + 0x78c, "Fmulr", 3, + 0x78d, "Fsubr", 3, + 0x78f, "Faddr", 3, + 0x79b, "Fdivrl", 3, + 0x79c, "Fmulrl", 3, + 0x79d, "Fsubrl", 3, + 0x79f, "Faddrl", 3, +#define REG_MAX 0x79f +#define REG_SIZ ((REG_MAX-REG_MIN+1) * sizeof(struct tabent)) + 0, NULL, 0 + }; + + if ( reg_tab == NULL ){ + reg_tab = (struct tabent *) xmalloc( REG_SIZ ); + bzero( reg_tab, REG_SIZ ); + for ( i = 0; reg_init[i].opcode != 0; i++ ){ + j = reg_init[i].opcode - REG_MIN; + reg_tab[j].name = reg_init[i].name; + reg_tab[j].numops = reg_init[i].numops; + } + } + + opcode = ((word1 >> 20) & 0xff0) | ((word1 >> 7) & 0xf); + i = opcode - REG_MIN; + + if ( (opcode<REG_MIN) || (opcode>REG_MAX) || (reg_tab[i].name==NULL) ){ + invalid( word1 ); + return; + } + + mnemp = reg_tab[i].name; + if ( *mnemp == 'F' ){ + fp = 1; + mnemp++; + } else { + fp = 0; + } + + fputs( mnemp, stream ); + + s1 = (word1 >> 5) & 1; + s2 = (word1 >> 6) & 1; + m1 = (word1 >> 11) & 1; + m2 = (word1 >> 12) & 1; + m3 = (word1 >> 13) & 1; + src = word1 & 0x1f; + src2 = (word1 >> 14) & 0x1f; + dst = (word1 >> 19) & 0x1f; + + if ( reg_tab[i].numops != 0 ){ + putc( '\t', stream ); + + switch ( reg_tab[i].numops ){ + case 1: + regop( m1, s1, src, fp ); + break; + case -1: + dstop( m3, dst, fp ); + break; + case 2: + regop( m1, s1, src, fp ); + putc( ',', stream ); + regop( m2, s2, src2, fp ); + break; + case -2: + regop( m1, s1, src, fp ); + putc( ',', stream ); + dstop( m3, dst, fp ); + break; + case 3: + regop( m1, s1, src, fp ); + putc( ',', stream ); + regop( m2, s2, src2, fp ); + putc( ',', stream ); + dstop( m3, dst, fp ); + break; + } + } +} + + +/* + * Print out effective address for memb instructions. + */ +static void +ea( memaddr, mode, reg2, reg3, word1, word2 ) + unsigned long memaddr; + int mode; + char *reg2, *reg3; + unsigned int word2; +{ + int scale; + static int scale_tab[] = { 1, 2, 4, 8, 16 }; + + scale = (word1 >> 7) & 0x07; + if ( (scale > 4) || ((word1 >> 5) & 0x03 != 0) ){ + invalid( word1 ); + return; + } + scale = scale_tab[scale]; + + switch (mode) { + case 4: /* (reg) */ + fprintf( stream, "(%s)", reg2 ); + break; + case 5: /* displ+8(ip) */ + print_addr( word2+8+memaddr ); + break; + case 7: /* (reg)[index*scale] */ + if (scale == 1) { + fprintf( stream, "(%s)[%s]", reg2, reg3 ); + } else { + fprintf( stream, "(%s)[%s*%d]",reg2,reg3,scale); + } + break; + case 12: /* displacement */ + print_addr( word2 ); + break; + case 13: /* displ(reg) */ + print_addr( word2 ); + fprintf( stream, "(%s)", reg2 ); + break; + case 14: /* displ[index*scale] */ + print_addr( word2 ); + if (scale == 1) { + fprintf( stream, "[%s]", reg3 ); + } else { + fprintf( stream, "[%s*%d]", reg3, scale ); + } + break; + case 15: /* displ(reg)[index*scale] */ + print_addr( word2 ); + if (scale == 1) { + fprintf( stream, "(%s)[%s]", reg2, reg3 ); + } else { + fprintf( stream, "(%s)[%s*%d]",reg2,reg3,scale ); + } + break; + default: + invalid( word1 ); + return; + } +} + + +/************************************************/ +/* Register Instruction Operand */ +/************************************************/ +static void +regop( mode, spec, reg, fp ) + int mode, spec, reg, fp; +{ + if ( fp ){ /* FLOATING POINT INSTRUCTION */ + if ( mode == 1 ){ /* FP operand */ + switch ( reg ){ + case 0: fputs( "fp0", stream ); break; + case 1: fputs( "fp1", stream ); break; + case 2: fputs( "fp2", stream ); break; + case 3: fputs( "fp3", stream ); break; + case 16: fputs( "0f0.0", stream ); break; + case 22: fputs( "0f1.0", stream ); break; + default: putc( '?', stream ); break; + } + } else { /* Non-FP register */ + fputs( reg_names[reg], stream ); + } + } else { /* NOT FLOATING POINT */ + if ( mode == 1 ){ /* Literal */ + fprintf( stream, "%d", reg ); + } else { /* Register */ + if ( spec == 0 ){ + fputs( reg_names[reg], stream ); + } else { + fprintf( stream, "sf%d", reg ); + } + } + } +} + +/************************************************/ +/* Register Instruction Destination Operand */ +/************************************************/ +static void +dstop( mode, reg, fp ) + int mode, reg, fp; +{ + /* 'dst' operand can't be a literal. On non-FP instructions, register + * mode is assumed and "m3" acts as if were "s3"; on FP-instructions, + * sf registers are not allowed so m3 acts normally. + */ + if ( fp ){ + regop( mode, 0, reg, fp ); + } else { + regop( 0, mode, reg, fp ); + } +} + + +static void +invalid( word1 ) + int word1; +{ + fprintf( stream, ".word\t0x%08x", word1 ); +} + +static void +print_addr(a) +{ + fprintf( stream, "0x%x", a ); +} + +static void +put_abs( word1, word2 ) + unsigned long word1, word2; +{ +#ifdef IN_GDB + return; +#else + int len; + + switch ( (word1 >> 28) & 0xf ){ + case 0x8: + case 0x9: + case 0xa: + case 0xb: + case 0xc: + /* MEM format instruction */ + len = mem( 0, word1, word2, 1 ); + break; + default: + len = 4; + break; + } + + if ( len == 8 ){ + fprintf( stream, "%08x %08x\t", word1, word2 ); + } else { + fprintf( stream, "%08x \t", word1 ); + } +; + +#endif +} diff --git a/gdb/i960-tdep.c b/gdb/i960-tdep.c new file mode 100644 index 0000000..a82328a --- /dev/null +++ b/gdb/i960-tdep.c @@ -0,0 +1,646 @@ +/* Target-machine dependent code for the Intel 960 + Copyright (C) 1991 Free Software Foundation, Inc. + Contributed by Intel Corporation. + examine_prologue and other parts contributed by Wind River Systems. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Miscellaneous i80960-dependent routines. + Most are called from macros defined in "tm-i960.h". */ + +#include <stdio.h> +#include <signal.h> +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "value.h" +#include "frame.h" +#include "signame.h" +#include "ieee-float.h" + +/* Structure of i960 extended floating point format. */ + +const struct ext_format ext_format_i960 [] = { +/* tot sbyte smask expbyte manbyte */ + { 12, 9, 0x80, 9,8, 4,0 }, /* i960 */ +}; + +/* gdb960 is always running on a non-960 host. Check its characteristics. + This routine must be called as part of gdb initialization. */ + +static void +check_host() +{ + int i; + + static struct typestruct { + int hostsize; /* Size of type on host */ + int i960size; /* Size of type on i960 */ + char *typename; /* Name of type, for error msg */ + } types[] = { + { sizeof(short), 2, "short" }, + { sizeof(int), 4, "int" }, + { sizeof(long), 4, "long" }, + { sizeof(float), 4, "float" }, + { sizeof(double), 8, "double" }, + { sizeof(char *), 4, "pointer" }, + }; +#define TYPELEN (sizeof(types) / sizeof(struct typestruct)) + + /* Make sure that host type sizes are same as i960 + */ + for ( i = 0; i < TYPELEN; i++ ){ + if ( types[i].hostsize != types[i].i960size ){ + printf("sizeof(%s) != %d: PROCEED AT YOUR OWN RISK!\n", + types[i].typename, types[i].i960size ); + } + + } +} + +/* Examine an i960 function prologue, recording the addresses at which + registers are saved explicitly by the prologue code, and returning + the address of the first instruction after the prologue (but not + after the instruction at address LIMIT, as explained below). + + LIMIT places an upper bound on addresses of the instructions to be + examined. If the prologue code scan reaches LIMIT, the scan is + aborted and LIMIT is returned. This is used, when examining the + prologue for the current frame, to keep examine_prologue () from + claiming that a given register has been saved when in fact the + instruction that saves it has not yet been executed. LIMIT is used + at other times to stop the scan when we hit code after the true + function prologue (e.g. for the first source line) which might + otherwise be mistaken for function prologue. + + The format of the function prologue matched by this routine is + derived from examination of the source to gcc960 1.21, particularly + the routine i960_function_prologue (). A "regular expression" for + the function prologue is given below: + + (lda LRn, g14 + mov g14, g[0-7] + (mov 0, g14) | (lda 0, g14))? + + (mov[qtl]? g[0-15], r[4-15])* + ((addo [1-31], sp, sp) | (lda n(sp), sp))? + (st[qtl]? g[0-15], n(fp))* + + (cmpobne 0, g14, LFn + mov sp, g14 + lda 0x30(sp), sp + LFn: stq g0, (g14) + stq g4, 0x10(g14) + stq g8, 0x20(g14))? + + (st g14, n(fp))? + (mov g13,r[4-15])? +*/ + +/* Macros for extracting fields from i960 instructions. */ + +#define BITMASK(pos, width) (((0x1 << (width)) - 1) << (pos)) +#define EXTRACT_FIELD(val, pos, width) ((val) >> (pos) & BITMASK (0, width)) + +#define REG_SRC1(insn) EXTRACT_FIELD (insn, 0, 5) +#define REG_SRC2(insn) EXTRACT_FIELD (insn, 14, 5) +#define REG_SRCDST(insn) EXTRACT_FIELD (insn, 19, 5) +#define MEM_SRCDST(insn) EXTRACT_FIELD (insn, 19, 5) +#define MEMA_OFFSET(insn) EXTRACT_FIELD (insn, 0, 12) + +/* Fetch the instruction at ADDR, returning 0 if ADDR is beyond LIM or + is not the address of a valid instruction, the address of the next + instruction beyond ADDR otherwise. *PWORD1 receives the first word + of the instruction, and (for two-word instructions), *PWORD2 receives + the second. */ + +#define NEXT_PROLOGUE_INSN(addr, lim, pword1, pword2) \ + (((addr) < (lim)) ? next_insn (addr, pword1, pword2) : 0) + +static CORE_ADDR +examine_prologue (ip, limit, frame_addr, fsr) + register CORE_ADDR ip; + register CORE_ADDR limit; + FRAME_ADDR frame_addr; + struct frame_saved_regs *fsr; +{ + register CORE_ADDR next_ip; + register int src, dst; + register unsigned int *pcode; + unsigned int insn1, insn2; + int size; + int within_leaf_prologue; + CORE_ADDR save_addr; + static unsigned int varargs_prologue_code [] = + { + 0x3507a00c, /* cmpobne 0x0, g14, LFn */ + 0x5cf01601, /* mov sp, g14 */ + 0x8c086030, /* lda 0x30(sp), sp */ + 0xb2879000, /* LFn: stq g0, (g14) */ + 0xb2a7a010, /* stq g4, 0x10(g14) */ + 0xb2c7a020 /* stq g8, 0x20(g14) */ + }; + + /* Accept a leaf procedure prologue code fragment if present. + Note that ip might point to either the leaf or non-leaf + entry point; we look for the non-leaf entry point first: */ + + within_leaf_prologue = 0; + if ((next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2)) + && ((insn1 & 0xfffff000) == 0x8cf00000 /* lda LRx, g14 (MEMA) */ + || (insn1 & 0xfffffc60) == 0x8cf03000)) /* lda LRx, g14 (MEMB) */ + { + within_leaf_prologue = 1; + next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2); + } + + /* Now look for the prologue code at a leaf entry point: */ + + if (next_ip + && (insn1 & 0xff87ffff) == 0x5c80161e /* mov g14, gx */ + && REG_SRCDST (insn1) <= G0_REGNUM + 7) + { + within_leaf_prologue = 1; + if ((next_ip = NEXT_PROLOGUE_INSN (next_ip, limit, &insn1, &insn2)) + && (insn1 == 0x8cf00000 /* lda 0, g14 */ + || insn1 == 0x5cf01e00)) /* mov 0, g14 */ + { + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + within_leaf_prologue = 0; + } + } + + /* If something that looks like the beginning of a leaf prologue + has been seen, but the remainder of the prologue is missing, bail. + We don't know what we've got. */ + + if (within_leaf_prologue) + return (ip); + + /* Accept zero or more instances of "mov[qtl]? gx, ry", where y >= 4. + This may cause us to mistake the moving of a register + parameter to a local register for the saving of a callee-saved + register, but that can't be helped, since with the + "-fcall-saved" flag, any register can be made callee-saved. */ + + while (next_ip + && (insn1 & 0xfc802fb0) == 0x5c000610 + && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4)) + { + src = REG_SRC1 (insn1); + size = EXTRACT_FIELD (insn1, 24, 2) + 1; + save_addr = frame_addr + ((dst - R0_REGNUM) * 4); + while (size--) + { + fsr->regs[src++] = save_addr; + save_addr += 4; + } + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept an optional "addo n, sp, sp" or "lda n(sp), sp". */ + + if (next_ip && + ((insn1 & 0xffffffe0) == 0x59084800 /* addo n, sp, sp */ + || (insn1 & 0xfffff000) == 0x8c086000 /* lda n(sp), sp (MEMA) */ + || (insn1 & 0xfffffc60) == 0x8c087400)) /* lda n(sp), sp (MEMB) */ + { + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept zero or more instances of "st[qtl]? gx, n(fp)". + This may cause us to mistake the copying of a register + parameter to the frame for the saving of a callee-saved + register, but that can't be helped, since with the + "-fcall-saved" flag, any register can be made callee-saved. + We can, however, refuse to accept a save of register g14, + since that is matched explicitly below. */ + + while (next_ip && + ((insn1 & 0xf787f000) == 0x9287e000 /* stl? gx, n(fp) (MEMA) */ + || (insn1 & 0xf787fc60) == 0x9287f400 /* stl? gx, n(fp) (MEMB) */ + || (insn1 & 0xef87f000) == 0xa287e000 /* st[tq] gx, n(fp) (MEMA) */ + || (insn1 & 0xef87fc60) == 0xa287f400) /* st[tq] gx, n(fp) (MEMB) */ + && ((src = MEM_SRCDST (insn1)) != G14_REGNUM)) + { + save_addr = frame_addr + ((insn1 & BITMASK (12, 1)) + ? insn2 : MEMA_OFFSET (insn1)); + size = (insn1 & BITMASK (29, 1)) ? ((insn1 & BITMASK (28, 1)) ? 4 : 3) + : ((insn1 & BITMASK (27, 1)) ? 2 : 1); + while (size--) + { + fsr->regs[src++] = save_addr; + save_addr += 4; + } + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept the varargs prologue code if present. */ + + size = sizeof (varargs_prologue_code) / sizeof (int); + pcode = varargs_prologue_code; + while (size-- && next_ip && *pcode++ == insn1) + { + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept an optional "st g14, n(fp)". */ + + if (next_ip && + ((insn1 & 0xfffff000) == 0x92f7e000 /* st g14, n(fp) (MEMA) */ + || (insn1 & 0xfffffc60) == 0x92f7f400)) /* st g14, n(fp) (MEMB) */ + { + fsr->regs[G14_REGNUM] = frame_addr + ((insn1 & BITMASK (12, 1)) + ? insn2 : MEMA_OFFSET (insn1)); + ip = next_ip; + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); + } + + /* Accept zero or one instance of "mov g13, ry", where y >= 4. + This is saving the address where a struct should be returned. */ + + if (next_ip + && (insn1 & 0xff802fbf) == 0x5c00061d + && (dst = REG_SRCDST (insn1)) >= (R0_REGNUM + 4)) + { + save_addr = frame_addr + ((dst - R0_REGNUM) * 4); + fsr->regs[G0_REGNUM+13] = save_addr; + ip = next_ip; +#if 0 /* We'll need this once there is a subsequent instruction examined. */ + next_ip = NEXT_PROLOGUE_INSN (ip, limit, &insn1, &insn2); +#endif + } + + return (ip); +} + +/* Given an ip value corresponding to the start of a function, + return the ip of the first instruction after the function + prologue. */ + +CORE_ADDR +skip_prologue (ip) + CORE_ADDR (ip); +{ + struct frame_saved_regs saved_regs_dummy; + struct symtab_and_line sal; + CORE_ADDR limit; + + sal = find_pc_line (ip, 0); + limit = (sal.end) ? sal.end : 0xffffffff; + + return (examine_prologue (ip, limit, (FRAME_ADDR) 0, &saved_regs_dummy)); +} + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. + + We cache the result of doing this in the frame_cache_obstack, since + it is fairly expensive. */ + +void +frame_find_saved_regs (fi, fsr) + struct frame_info *fi; + struct frame_saved_regs *fsr; +{ + register CORE_ADDR next_addr; + register CORE_ADDR *saved_regs; + register int regnum; + register struct frame_saved_regs *cache_fsr; + extern struct obstack frame_cache_obstack; + CORE_ADDR ip; + struct symtab_and_line sal; + CORE_ADDR limit; + + if (!fi->fsr) + { + cache_fsr = (struct frame_saved_regs *) + obstack_alloc (&frame_cache_obstack, + sizeof (struct frame_saved_regs)); + bzero (cache_fsr, sizeof (struct frame_saved_regs)); + fi->fsr = cache_fsr; + + /* Find the start and end of the function prologue. If the PC + is in the function prologue, we only consider the part that + has executed already. */ + + ip = get_pc_function_start (fi->pc); + sal = find_pc_line (ip, 0); + limit = (sal.end && sal.end < fi->pc) ? sal.end: fi->pc; + + examine_prologue (ip, limit, fi->frame, cache_fsr); + + /* Record the addresses at which the local registers are saved. + Strictly speaking, we should only do this for non-leaf procedures, + but no one will ever look at these values if it is a leaf procedure, + since local registers are always caller-saved. */ + + next_addr = (CORE_ADDR) fi->frame; + saved_regs = cache_fsr->regs; + for (regnum = R0_REGNUM; regnum <= R15_REGNUM; regnum++) + { + *saved_regs++ = next_addr; + next_addr += 4; + } + + cache_fsr->regs[FP_REGNUM] = cache_fsr->regs[PFP_REGNUM]; + } + + *fsr = *fi->fsr; + + /* Fetch the value of the sp from memory every time, since it + is conceivable that it has changed since the cache was flushed. + This unfortunately undoes much of the savings from caching the + saved register values. I suggest adding an argument to + get_frame_saved_regs () specifying the register number we're + interested in (or -1 for all registers). This would be passed + through to FRAME_FIND_SAVED_REGS (), permitting more efficient + computation of saved register addresses (e.g., on the i960, + we don't have to examine the prologue to find local registers). + -- markf@wrs.com + FIXME, we don't need to refetch this, since the cache is cleared + every time the child process is restarted. If GDB itself + modifies SP, it has to clear the cache by hand (does it?). -gnu */ + + fsr->regs[SP_REGNUM] = read_memory_integer (fsr->regs[SP_REGNUM], 4); +} + +/* Return the address of the argument block for the frame + described by FI. Returns 0 if the address is unknown. */ + +CORE_ADDR +frame_args_address (fi, must_be_correct) + struct frame_info *fi; +{ + register FRAME frame; + struct frame_saved_regs fsr; + CORE_ADDR ap; + + /* If g14 was saved in the frame by the function prologue code, return + the saved value. If the frame is current and we are being sloppy, + return the value of g14. Otherwise, return zero. */ + + frame = FRAME_INFO_ID (fi); + get_frame_saved_regs (fi, &fsr); + if (fsr.regs[G14_REGNUM]) + ap = read_memory_integer (fsr.regs[G14_REGNUM],4); + else { + if (must_be_correct) + return 0; /* Don't cache this result */ + if (get_next_frame (frame)) + ap = 0; + else + ap = read_register (G14_REGNUM); + } + fi->arg_pointer = ap; /* Cache it for next time */ + return ap; +} + +/* Return the address of the return struct for the frame + described by FI. Returns 0 if the address is unknown. */ + +CORE_ADDR +frame_struct_result_address (fi) + struct frame_info *fi; +{ + register FRAME frame; + struct frame_saved_regs fsr; + CORE_ADDR ap; + + /* If the frame is non-current, check to see if g14 was saved in the + frame by the function prologue code; return the saved value if so, + zero otherwise. If the frame is current, return the value of g14. + + FIXME, shouldn't this use the saved value as long as we are past + the function prologue, and only use the current value if we have + no saved value and are at TOS? -- gnu@cygnus.com */ + + frame = FRAME_INFO_ID (fi); + if (get_next_frame (frame)) { + get_frame_saved_regs (fi, &fsr); + if (fsr.regs[G13_REGNUM]) + ap = read_memory_integer (fsr.regs[G13_REGNUM],4); + else + ap = 0; + } else { + ap = read_register (G13_REGNUM); + } + return ap; +} + +/* Return address to which the currently executing leafproc will return, + or 0 if ip is not in a leafproc (or if we can't tell if it is). + + Do this by finding the starting address of the routine in which ip lies. + If the instruction there is "mov g14, gx" (where x is in [0,7]), this + is a leafproc and the return address is in register gx. Well, this is + true unless the return address points at a RET instruction in the current + procedure, which indicates that we have a 'dual entry' routine that + has been entered through the CALL entry point. */ + +CORE_ADDR +leafproc_return (ip) + CORE_ADDR ip; /* ip from currently executing function */ +{ + int i; + register struct misc_function *mf; + char *p; + int dst; + unsigned int insn1, insn2; + CORE_ADDR return_addr; + char *index (); + + if ((i = find_pc_misc_function (ip)) >= 0) + { + mf = &misc_function_vector[i]; + if ((p = index (mf->name, '.')) && !strcmp (p, ".lf")) + { + if (next_insn (mf->address, &insn1, &insn2) + && (insn1 & 0xff87ffff) == 0x5c80161e /* mov g14, gx */ + && (dst = REG_SRCDST (insn1)) <= G0_REGNUM + 7) + { + /* Get the return address. If the "mov g14, gx" + instruction hasn't been executed yet, read + the return address from g14; otherwise, read it + from the register into which g14 was moved. */ + + return_addr = read_register ((ip == mf->address) + ? G14_REGNUM : dst); + + /* We know we are in a leaf procedure, but we don't know + whether the caller actually did a "bal" to the ".lf" + entry point, or a normal "call" to the non-leaf entry + point one instruction before. In the latter case, the + return address will be the address of a "ret" + instruction within the procedure itself. We test for + this below. */ + + if (!next_insn (return_addr, &insn1, &insn2) + || (insn1 & 0xff000000) != 0xa000000 /* ret */ + || find_pc_misc_function (return_addr) != i) + return (return_addr); + } + } + } + + return (0); +} + +/* Immediately after a function call, return the saved pc. + Can't go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. + On the i960, the frame *is* set up immediately after the call, + unless the function is a leaf procedure. */ + +CORE_ADDR +saved_pc_after_call (frame) + FRAME frame; +{ + CORE_ADDR saved_pc; + CORE_ADDR get_frame_pc (); + + saved_pc = leafproc_return (get_frame_pc (frame)); + if (!saved_pc) + saved_pc = FRAME_SAVED_PC (frame); + + return (saved_pc); +} + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +pop_frame () +{ + register struct frame_info *current_fi, *prev_fi; + register int i; + CORE_ADDR save_addr; + CORE_ADDR leaf_return_addr; + struct frame_saved_regs fsr; + char local_regs_buf[16 * 4]; + + current_fi = get_frame_info (get_current_frame ()); + + /* First, undo what the hardware does when we return. + If this is a non-leaf procedure, restore local registers from + the save area in the calling frame. Otherwise, load the return + address obtained from leafproc_return () into the rip. */ + + leaf_return_addr = leafproc_return (current_fi->pc); + if (!leaf_return_addr) + { + /* Non-leaf procedure. Restore local registers, incl IP. */ + prev_fi = get_frame_info (get_prev_frame (FRAME_INFO_ID (current_fi))); + read_memory (prev_fi->frame, local_regs_buf, sizeof (local_regs_buf)); + write_register_bytes (REGISTER_BYTE (R0_REGNUM), local_regs_buf, + sizeof (local_regs_buf)); + + /* Restore frame pointer. */ + write_register (FP_REGNUM, prev_fi->frame); + } + else + { + /* Leaf procedure. Just restore the return address into the IP. */ + write_register (RIP_REGNUM, leaf_return_addr); + } + + /* Now restore any global regs that the current function had saved. */ + get_frame_saved_regs (current_fi, &fsr); + for (i = G0_REGNUM; i < G14_REGNUM; i++) + { + if (save_addr = fsr.regs[i]) + write_register (i, read_memory_integer (save_addr, 4)); + } + + /* Flush the frame cache, create a frame for the new innermost frame, + and make it the current frame. */ + + flush_cached_frames (); + set_current_frame (create_new_frame (read_register (FP_REGNUM), read_pc ())); +} + +/* Print out text describing a "signal number" with which the i80960 halted. + + See the file "fault.c" in the nindy monitor source code for a list + of stop codes. */ + +void +print_fault( siggnal ) + int siggnal; /* Signal number, as returned by target_wait() */ +{ + static char unknown[] = "Unknown fault or trace"; + static char *sigmsgs[] = { + /* FAULTS */ + "parallel fault", /* 0x00 */ + unknown, /* 0x01 */ + "operation fault", /* 0x02 */ + "arithmetic fault", /* 0x03 */ + "floating point fault", /* 0x04 */ + "constraint fault", /* 0x05 */ + "virtual memory fault", /* 0x06 */ + "protection fault", /* 0x07 */ + "machine fault", /* 0x08 */ + "structural fault", /* 0x09 */ + "type fault", /* 0x0a */ + "reserved (0xb) fault", /* 0x0b */ + "process fault", /* 0x0c */ + "descriptor fault", /* 0x0d */ + "event fault", /* 0x0e */ + "reserved (0xf) fault", /* 0x0f */ + + /* TRACES */ + "single-step trace", /* 0x10 */ + "branch trace", /* 0x11 */ + "call trace", /* 0x12 */ + "return trace", /* 0x13 */ + "pre-return trace", /* 0x14 */ + "supervisor call trace",/* 0x15 */ + "breakpoint trace", /* 0x16 */ + }; +# define NUMMSGS ((int)( sizeof(sigmsgs) / sizeof(sigmsgs[0]) )) + + if (siggnal < NSIG) { + printf ("\nProgram received signal %d, %s\n", + siggnal, + sys_siglist[siggnal]); + } else { + /* The various target_wait()s bias the 80960 "signal number" + by adding NSIG to it, so it won't get confused with any + of the Unix signals elsewhere in GDB. We need to + "unbias" it before using it. */ + siggnal -= NSIG; + + printf("Program stopped for reason #%d: %s.\n", siggnal, + (siggnal < NUMMSGS && siggnal >= 0)? + sigmsgs[siggnal] : unknown ); + } +} + +/* Initialization stub */ + +_initialize_i960_tdep () +{ + check_host (); +} diff --git a/gdb/ieee-float.c b/gdb/ieee-float.c new file mode 100644 index 0000000..7b7f9f1 --- /dev/null +++ b/gdb/ieee-float.c @@ -0,0 +1,141 @@ +/* IEEE floating point support routines, for GDB, the GNU Debugger. + Copyright (C) 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "param.h" +#include "ieee-float.h" +#include <math.h> /* ldexp */ + +/* Convert an IEEE extended float to a double. + FROM is the address of the extended float. + Store the double in *TO. */ + +void +ieee_extended_to_double (ext_format, from, to) + struct ext_format *ext_format; + char *from; + double *to; +{ + unsigned char *ufrom = (unsigned char *)from; + double dto; + unsigned long mant0, mant1, exp; + + bcopy (&from[MANBYTE_H], &mant0, 4); + bcopy (&from[MANBYTE_L], &mant1, 4); + exp = ((ufrom[EXPBYTE_H] & (unsigned char)~SIGNMASK) << 8) | ufrom[EXPBYTE_L]; + + if (exp == EXT_EXP_NAN) { + /* We have a NaN source. */ + dto = 0.123456789; /* Not much else useful to do */ + } else if (exp == 0 && mant0 == 0 && mant1 == 0) { + dto = 0; + } else { + /* Build the result algebraically. Might go infinite, underflow, etc; + who cares. */ + mant0 |= 0x80000000; + dto = ldexp ((double)mant0, exp - EXT_EXP_BIAS - 31); + dto += ldexp ((double)mant1, exp - EXT_EXP_BIAS - 31 - 32); + } + *to = dto; +} + +/* The converse: convert the double *FROM to an extended float + and store where TO points. */ + +void +double_to_ieee_extended (ext_format, from, to) + struct ext_format *ext_format; + double *from; + char *to; +{ + double dfrom = *from; + unsigned long twolongs[2]; + unsigned long mant0, mant1, exp; + unsigned char twobytes[2]; + + bzero (to, TOTALSIZE); + if (dfrom == 0) + return; /* Result is zero */ + if (dfrom != dfrom) { + /* From is NaN */ + to[EXPBYTE_H] = (unsigned char)(EXT_EXP_NAN >> 8); + to[EXPBYTE_L] = (unsigned char)EXT_EXP_NAN; + to[MANBYTE_H] = 1; /* Be sure it's not infinity, but NaN value is irrel */ + return; /* Result is NaN */ + } + if (dfrom < 0) + to[SIGNBYTE] |= SIGNMASK; /* Set negative sign */ + /* How to tell an infinity from an ordinary number? FIXME-someday */ + + /* The following code assumes that the host has IEEE doubles. FIXME-someday. + It also assumes longs are 32 bits! FIXME-someday. */ + bcopy (from, twolongs, 8); + bcopy (from, twobytes, 2); +#if HOST_BYTE_ORDER == BIG_ENDIAN + exp = ((twobytes[1] & 0xF0) >> 4) | (twobytes[0] & 0x7F) << 4; + mant0 = (twolongs[0] << 11) | twolongs[1] >> 21; + mant1 = (twolongs[1] << 11); +#else + exp = ((twobytes[0] & 0xF0) >> 4) | (twobytes[1] & 0x7F) << 4; + mant0 = (twolongs[1] << 11) | twolongs[0] >> 21; + mant1 = (twolongs[0] << 11); +#endif + + /* Fiddle with leading 1-bit, implied in double, explicit in extended. */ + if (exp == 0) + mant0 &= 0x7FFFFFFF; + else + mant0 |= 0x80000000; + + exp -= DBL_EXP_BIAS; /* Get integer exp */ + exp += EXT_EXP_BIAS; /* Offset for extended *&/ + + /* OK, now store it in extended format. */ + to[EXPBYTE_H] |= (unsigned char)(exp >> 8); /* Retain sign */ + to[EXPBYTE_L] = (unsigned char) exp; + + bcopy (&mant0, &to[MANBYTE_H], 4); + bcopy (&mant1, &to[MANBYTE_L], 4); +} + + +#ifdef DEBUG + +/* Test some numbers to see that extended/double conversion works for them. */ + +ieee_test (n) + int n; +{ + union { double d; int i[2]; } di; + double result; + int i; + char exten[16]; + extern struct ext_format ext_format_68881; + + for (i = 0; i < n; i++) { + di.i[0] = random(); + di.i[1] = random(); + double_to_ieee_extended (ext_format_68881, &di.d, exten); + ieee_extended_to_double (ext_format_68881, exten, &result); + if (di.d != result) + printf ("Differ: %x %x %g => %x %x %g\n", di.d, di.d, result, result); + } +} + +#endif diff --git a/gdb/ieee-float.h b/gdb/ieee-float.h new file mode 100644 index 0000000..9325518 --- /dev/null +++ b/gdb/ieee-float.h @@ -0,0 +1,66 @@ +/* IEEE floating point support declarations, for GDB, the GNU Debugger. + Copyright (C) 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Parameters for extended float format: */ + +struct ext_format { + unsigned totalsize; /* Total size of extended number */ + unsigned signbyte; /* Byte number of sign bit */ + unsigned char signmask; /* Mask for sign bit */ + unsigned expbyte_h; /* High byte of exponent */ + unsigned expbyte_l; /* Low byte of exponent */ + unsigned manbyte_h; /* High byte of mantissa */ + unsigned manbyte_l; /* Low byte of mantissa */ +}; + +#define TOTALSIZE ext_format->totalsize +#define SIGNBYTE ext_format->signbyte +#define SIGNMASK ext_format->signmask +#define EXPBYTE_H ext_format->expbyte_h +#define EXPBYTE_L ext_format->expbyte_l +#define MANBYTE_H ext_format->manbyte_h +#define MANBYTE_L ext_format->manbyte_l + +/* Actual ext_format structs for various machines are in the *-tdep.c file + for each machine. */ + +#define EXT_EXP_NAN 0x7FFF /* Exponent value that indicates NaN */ +#define EXT_EXP_BIAS 0x3FFF /* Amount added to "true" exponent for ext */ +#define DBL_EXP_BIAS 0x3FF /* Ditto, for doubles */ + +/* Convert an IEEE extended float to a double. + FROM is the address of the extended float. + Store the double in *TO. */ + +extern void +ieee_extended_to_double ( +#ifdef __STDC__ + struct ext_format *ext_format, char *from, double *to +#endif +); + +/* The converse: convert the double *FROM to an extended float + and store where TO points. */ + +void +double_to_ieee_extended ( +#ifdef __STDC__ + struct ext_format *ext_format, double *from, char *to +#endif +); diff --git a/gdb/kdb-start.c b/gdb/kdb-start.c new file mode 100644 index 0000000..cbc69fd --- /dev/null +++ b/gdb/kdb-start.c @@ -0,0 +1,40 @@ +/* Main loop for the standalone kernel debugger. + Copyright (C) 1989, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "param.h" + +static char *args[] = {"kdb", "kdb-symbols", 0}; + +static char *environment[] = {0}; + +char **environ; + +start () +{ +#ifdef NAMES_HAVE_UNDERSCORE + INIT_STACK (_kdb_stack_beg, _kdb_stack_end); +#else /* not NAMES_HAVE_UNDERSCORE */ + INIT_STACK (kdb_stack_beg, kdb_stack_end); +#endif /* not NAMES_HAVE_UNDERSCORE */ + + environ = environment; + + main (2, args, environment); +} diff --git a/gdb/m68k-opcode.h b/gdb/m68k-opcode.h new file mode 100755 index 0000000..a0961f6 --- /dev/null +++ b/gdb/m68k-opcode.h @@ -0,0 +1,1680 @@ +/* Opcode table for m68000/m68020 and m68881. + Copyright (C) 1989, Free Software Foundation. + +This file is part of GDB, the GNU Debugger and GAS, the GNU Assembler. + +Both GDB and GAS are free software; you can redistribute and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB and GAS are distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB or GAS; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +struct m68k_opcode +{ + char *name; + unsigned long opcode; + unsigned long match; + char *args; +}; + +/* We store four bytes of opcode for all opcodes because that + is the most any of them need. The actual length of an instruction + is always at least 2 bytes, and is as much longer as necessary to + hold the operands it has. + + The match component is a mask saying which bits must match + particular opcode in order for an instruction to be an instance + of that opcode. + + The args component is a string containing two characters + for each operand of the instruction. The first specifies + the kind of operand; the second, the place it is stored. */ + +/* Kinds of operands: + D data register only. Stored as 3 bits. + A address register only. Stored as 3 bits. + R either kind of register. Stored as 4 bits. + F floating point coprocessor register only. Stored as 3 bits. + O an offset (or width): immediate data 0-31 or data register. + Stored as 6 bits in special format for BF... insns. + + autoincrement only. Stored as 3 bits (number of the address register). + - autodecrement only. Stored as 3 bits (number of the address register). + Q quick immediate data. Stored as 3 bits. + This matches an immediate operand only when value is in range 1 .. 8. + M moveq immediate data. Stored as 8 bits. + This matches an immediate operand only when value is in range -128..127 + T trap vector immediate data. Stored as 4 bits. + + k K-factor for fmove.p instruction. Stored as a 7-bit constant or + a three bit register offset, depending on the field type. + + # immediate data. Stored in special places (b, w or l) + which say how many bits to store. + ^ immediate data for floating point instructions. Special places + are offset by 2 bytes from '#'... + B pc-relative address, converted to an offset + that is treated as immediate data. + d displacement and register. Stores the register as 3 bits + and stores the displacement in the entire second word. + + C the CCR. No need to store it; this is just for filtering validity. + S the SR. No need to store, just as with CCR. + U the USP. No need to store, just as with CCR. + + I Coprocessor ID. Not printed if 1. The Coprocessor ID is always + extracted from the 'd' field of word one, which means that an extended + coprocessor opcode can be skipped using the 'i' place, if needed. + + s System Control register for the floating point coprocessor. + S List of system control registers for floating point coprocessor. + + J Misc register for movec instruction, stored in 'j' format. + Possible values: + 000 SFC Source Function Code reg + 001 DFC Data Function Code reg + 002 CACR Cache Control Register + 800 USP User Stack Pointer + 801 VBR Vector Base reg + 802 CAAR Cache Address Register + 803 MSP Master Stack Pointer + 804 ISP Interrupt Stack Pointer + + L Register list of the type d0-d7/a0-a7 etc. + (New! Improved! Can also hold fp0-fp7, as well!) + The assembler tries to see if the registers match the insn by + looking at where the insn wants them stored. + + l Register list like L, but with all the bits reversed. + Used for going the other way. . . + + They are all stored as 6 bits using an address mode and a register number; + they differ in which addressing modes they match. + + * all (modes 0-6,7.*) + ~ alterable memory (modes 2-6,7.0,7.1)(not 0,1,7.~) + % alterable (modes 0-6,7.0,7.1)(not 7.~) + ; data (modes 0,2-6,7.*)(not 1) + @ data, but not immediate (modes 0,2-6,7.? ? ?)(not 1,7.?) This may really be ;, the 68020 book says it is + ! control (modes 2,5,6,7.*-)(not 0,1,3,4,7.4) + & alterable control (modes 2,5,6,7.0,7.1)(not 0,1,7.? ? ?) + $ alterable data (modes 0,2-6,7.0,7.1)(not 1,7.~) + ? alterable control, or data register (modes 0,2,5,6,7.0,7.1)(not 1,3,4,7.~) + / control, or data register (modes 0,2,5,6,7.0,7.1,7.2,7.3)(not 1,3,4,7.4) +*/ + +/* JF: for the 68851 */ +/* + I didn't use much imagination in choosing the + following codes, so many of them aren't very + mnemonic. -rab + + P pmmu register + Possible values: + 000 TC Translation Control reg + 100 CAL Current Access Level + 101 VAL Validate Access Level + 110 SCC Stack Change Control + 111 AC Access Control + + W wide pmmu registers + Possible values: + 001 DRP Dma Root Pointer + 010 SRP Supervisor Root Pointer + 011 CRP Cpu Root Pointer + + f function code register + 0 SFC + 1 DFC + + V VAL register only + + X BADx, BACx + 100 BAD Breakpoint Acknowledge Data + 101 BAC Breakpoint Acknowledge Control + + Y PSR + Z PCSR + + | memory (modes 2-6, 7.*) + +*/ + +/* Places to put an operand, for non-general operands: + s source, low bits of first word. + d dest, shifted 9 in first word + 1 second word, shifted 12 + 2 second word, shifted 6 + 3 second word, shifted 0 + 4 third word, shifted 12 + 5 third word, shifted 6 + 6 third word, shifted 0 + 7 second word, shifted 7 + 8 second word, shifted 10 + D store in both place 1 and place 3; for divul and divsl. + b second word, low byte + w second word (entire) + l second and third word (entire) + g branch offset for bra and similar instructions. + The place to store depends on the magnitude of offset. + t store in both place 7 and place 8; for floating point operations + c branch offset for cpBcc operations. + The place to store is word two if bit six of word one is zero, + and words two and three if bit six of word one is one. + i Increment by two, to skip over coprocessor extended operands. Only + works with the 'I' format. + k Dynamic K-factor field. Bits 6-4 of word 2, used as a register number. + Also used for dynamic fmovem instruction. + C floating point coprocessor constant - 7 bits. Also used for static + K-factors... + j Movec register #, stored in 12 low bits of second word. + + Places to put operand, for general operands: + d destination, shifted 6 bits in first word + b source, at low bit of first word, and immediate uses one byte + w source, at low bit of first word, and immediate uses two bytes + l source, at low bit of first word, and immediate uses four bytes + s source, at low bit of first word. + Used sometimes in contexts where immediate is not allowed anyway. + f single precision float, low bit of 1st word, immediate uses 4 bytes + F double precision float, low bit of 1st word, immediate uses 8 bytes + x extended precision float, low bit of 1st word, immediate uses 12 bytes + p packed float, low bit of 1st word, immediate uses 12 bytes +*/ + +#define one(x) ((x) << 16) +#define two(x, y) (((x) << 16) + y) + +/* + *** DANGER WILL ROBINSON *** + + The assembler requires that all instances of the same mnemonic must be + consecutive. If they aren't, the assembler will bomb at runtime + */ +struct m68k_opcode m68k_opcodes[] = +{ +{"abcd", one(0140400), one(0170770), "DsDd"}, +{"abcd", one(0140410), one(0170770), "-s-d"}, + + /* Add instructions */ +{"addal", one(0150700), one(0170700), "*lAd"}, +{"addaw", one(0150300), one(0170700), "*wAd"}, +{"addib", one(0003000), one(0177700), "#b$b"}, +{"addil", one(0003200), one(0177700), "#l$l"}, +{"addiw", one(0003100), one(0177700), "#w$w"}, +{"addqb", one(0050000), one(0170700), "Qd$b"}, +{"addql", one(0050200), one(0170700), "Qd%l"}, +{"addqw", one(0050100), one(0170700), "Qd%w"}, + +{"addb", one(0050000), one(0170700), "Qd$b"}, /* addq written as add */ +{"addb", one(0003000), one(0177700), "#b$b"}, /* addi written as add */ +{"addb", one(0150000), one(0170700), ";bDd"}, /* addb <ea>, Dd */ +{"addb", one(0150400), one(0170700), "Dd~b"}, /* addb Dd, <ea> */ + +{"addw", one(0050100), one(0170700), "Qd%w"}, /* addq written as add */ +{"addw", one(0003100), one(0177700), "#w$w"}, /* addi written as add */ +{"addw", one(0150300), one(0170700), "*wAd"}, /* adda written as add */ +{"addw", one(0150100), one(0170700), "*wDd"}, /* addw <ea>, Dd */ +{"addw", one(0150500), one(0170700), "Dd~w"}, /* addw Dd, <ea> */ + +{"addl", one(0050200), one(0170700), "Qd%l"}, /* addq written as add */ +{"addl", one(0003200), one(0177700), "#l$l"}, /* addi written as add */ +{"addl", one(0150700), one(0170700), "*lAd"}, /* adda written as add */ +{"addl", one(0150200), one(0170700), "*lDd"}, /* addl <ea>, Dd */ +{"addl", one(0150600), one(0170700), "Dd~l"}, /* addl Dd, <ea> */ + +{"addxb", one(0150400), one(0170770), "DsDd"}, +{"addxb", one(0150410), one(0170770), "-s-d"}, +{"addxl", one(0150600), one(0170770), "DsDd"}, +{"addxl", one(0150610), one(0170770), "-s-d"}, +{"addxw", one(0150500), one(0170770), "DsDd"}, +{"addxw", one(0150510), one(0170770), "-s-d"}, + +{"andib", one(0001000), one(0177700), "#b$b"}, +{"andib", one(0001074), one(0177777), "#bCb"}, /* andi to ccr */ +{"andiw", one(0001100), one(0177700), "#w$w"}, +{"andiw", one(0001174), one(0177777), "#wSw"}, /* andi to sr */ +{"andil", one(0001200), one(0177700), "#l$l"}, + +{"andb", one(0001000), one(0177700), "#b$b"}, /* andi written as or */ +{"andb", one(0001074), one(0177777), "#bCb"}, /* andi to ccr */ +{"andb", one(0140000), one(0170700), ";bDd"}, /* memory to register */ +{"andb", one(0140400), one(0170700), "Dd~b"}, /* register to memory */ +{"andw", one(0001100), one(0177700), "#w$w"}, /* andi written as or */ +{"andw", one(0001174), one(0177777), "#wSw"}, /* andi to sr */ +{"andw", one(0140100), one(0170700), ";wDd"}, /* memory to register */ +{"andw", one(0140500), one(0170700), "Dd~w"}, /* register to memory */ +{"andl", one(0001200), one(0177700), "#l$l"}, /* andi written as or */ +{"andl", one(0140200), one(0170700), ";lDd"}, /* memory to register */ +{"andl", one(0140600), one(0170700), "Dd~l"}, /* register to memory */ + +{"aslb", one(0160400), one(0170770), "QdDs"}, +{"aslb", one(0160440), one(0170770), "DdDs"}, +{"asll", one(0160600), one(0170770), "QdDs"}, +{"asll", one(0160640), one(0170770), "DdDs"}, +{"aslw", one(0160500), one(0170770), "QdDs"}, +{"aslw", one(0160540), one(0170770), "DdDs"}, +{"aslw", one(0160700), one(0177700), "~s"}, /* Shift memory */ +{"asrb", one(0160000), one(0170770), "QdDs"}, +{"asrb", one(0160040), one(0170770), "DdDs"}, +{"asrl", one(0160200), one(0170770), "QdDs"}, +{"asrl", one(0160240), one(0170770), "DdDs"}, +{"asrw", one(0160100), one(0170770), "QdDs"}, +{"asrw", one(0160140), one(0170770), "DdDs"}, +{"asrw", one(0160300), one(0177700), "~s"}, /* Shift memory */ + +{"bhi", one(0061000), one(0177400), "Bg"}, +{"bls", one(0061400), one(0177400), "Bg"}, +{"bcc", one(0062000), one(0177400), "Bg"}, +{"bcs", one(0062400), one(0177400), "Bg"}, +{"bne", one(0063000), one(0177400), "Bg"}, +{"beq", one(0063400), one(0177400), "Bg"}, +{"bvc", one(0064000), one(0177400), "Bg"}, +{"bvs", one(0064400), one(0177400), "Bg"}, +{"bpl", one(0065000), one(0177400), "Bg"}, +{"bmi", one(0065400), one(0177400), "Bg"}, +{"bge", one(0066000), one(0177400), "Bg"}, +{"blt", one(0066400), one(0177400), "Bg"}, +{"bgt", one(0067000), one(0177400), "Bg"}, +{"ble", one(0067400), one(0177400), "Bg"}, + +{"bchg", one(0000500), one(0170700), "Dd$s"}, +{"bchg", one(0004100), one(0177700), "#b$s"}, +{"bclr", one(0000600), one(0170700), "Dd$s"}, +{"bclr", one(0004200), one(0177700), "#b$s"}, +{"bfchg", two(0165300, 0), two(0177700, 0170000), "?sO2O3"}, +{"bfclr", two(0166300, 0), two(0177700, 0170000), "?sO2O3"}, +{"bfexts", two(0165700, 0), two(0177700, 0100000), "/sO2O3D1"}, +{"bfextu", two(0164700, 0), two(0177700, 0100000), "/sO2O3D1"}, +{"bfffo", two(0166700, 0), two(0177700, 0100000), "/sO2O3D1"}, +{"bfins", two(0167700, 0), two(0177700, 0100000), "D1?sO2O3"}, +{"bfset", two(0167300, 0), two(0177700, 0170000), "?sO2O3"}, +{"bftst", two(0164300, 0), two(0177700, 0170000), "/sO2O3"}, +{"bset", one(0000700), one(0170700), "Dd$s"}, +{"bset", one(0004300), one(0177700), "#b$s"}, +{"btst", one(0000400), one(0170700), "Dd@s"}, +{"btst", one(0004000), one(0177700), "#b@s"}, + +{"bkpt", one(0044110), one(0177770), "Qs"}, +{"bra", one(0060000), one(0177400), "Bg"}, +{"bras", one(0060000), one(0177400), "Bw"}, +{"bsr", one(0060400), one(0177400), "Bg"}, +{"bsrs", one(0060400), one(0177400), "Bw"}, + +{"callm", one(0003300), one(0177700), "#b!s"}, +{"cas2l", two(0007374, 0), two(0177777, 0107070), "D3D6D2D5R1R4"}, /* JF FOO this is really a 3 word ins */ +{"cas2w", two(0006374, 0), two(0177777, 0107070), "D3D6D2D5R1R4"}, /* JF ditto */ +{"casb", two(0005300, 0), two(0177700, 0177070), "D3D2~s"}, +{"casl", two(0007300, 0), two(0177700, 0177070), "D3D2~s"}, +{"casw", two(0006300, 0), two(0177700, 0177070), "D3D2~s"}, + +/* {"chk", one(0040600), one(0170700), ";wDd"}, JF FOO this looks wrong */ +{"chk2b", two(0000300, 0004000), two(0177700, 07777), "!sR1"}, +{"chk2l", two(0002300, 0004000), two(0177700, 07777), "!sR1"}, +{"chk2w", two(0001300, 0004000), two(0177700, 07777), "!sR1"}, +{"chkl", one(0040400), one(0170700), ";lDd"}, +{"chkw", one(0040600), one(0170700), ";wDd"}, +{"clrb", one(0041000), one(0177700), "$s"}, +{"clrl", one(0041200), one(0177700), "$s"}, +{"clrw", one(0041100), one(0177700), "$s"}, + +{"cmp2b", two(0000300, 0), two(0177700, 07777), "!sR1"}, +{"cmp2l", two(0002300, 0), two(0177700, 07777), "!sR1"}, +{"cmp2w", two(0001300, 0), two(0177700, 07777), "!sR1"}, +{"cmpal", one(0130700), one(0170700), "*lAd"}, +{"cmpaw", one(0130300), one(0170700), "*wAd"}, +{"cmpib", one(0006000), one(0177700), "#b;b"}, +{"cmpil", one(0006200), one(0177700), "#l;l"}, +{"cmpiw", one(0006100), one(0177700), "#w;w"}, +{"cmpb", one(0006000), one(0177700), "#b;b"}, /* cmpi written as cmp */ +{"cmpb", one(0130000), one(0170700), ";bDd"}, +{"cmpw", one(0006100), one(0177700), "#w;w"}, +{"cmpw", one(0130100), one(0170700), "*wDd"}, +{"cmpw", one(0130300), one(0170700), "*wAd"}, /* cmpa written as cmp */ +{"cmpl", one(0006200), one(0177700), "#l;l"}, +{"cmpl", one(0130200), one(0170700), "*lDd"}, +{"cmpl", one(0130700), one(0170700), "*lAd"}, +{"cmpmb", one(0130410), one(0170770), "+s+d"}, +{"cmpml", one(0130610), one(0170770), "+s+d"}, +{"cmpmw", one(0130510), one(0170770), "+s+d"}, + +{"dbcc", one(0052310), one(0177770), "DsBw"}, +{"dbcs", one(0052710), one(0177770), "DsBw"}, +{"dbeq", one(0053710), one(0177770), "DsBw"}, +{"dbf", one(0050710), one(0177770), "DsBw"}, +{"dbge", one(0056310), one(0177770), "DsBw"}, +{"dbgt", one(0057310), one(0177770), "DsBw"}, +{"dbhi", one(0051310), one(0177770), "DsBw"}, +{"dble", one(0057710), one(0177770), "DsBw"}, +{"dbls", one(0051710), one(0177770), "DsBw"}, +{"dblt", one(0056710), one(0177770), "DsBw"}, +{"dbmi", one(0055710), one(0177770), "DsBw"}, +{"dbne", one(0053310), one(0177770), "DsBw"}, +{"dbpl", one(0055310), one(0177770), "DsBw"}, +{"dbra", one(0050710), one(0177770), "DsBw"}, +{"dbt", one(0050310), one(0177770), "DsBw"}, +{"dbvc", one(0054310), one(0177770), "DsBw"}, +{"dbvs", one(0054710), one(0177770), "DsBw"}, + +{"divsl", two(0046100, 0006000), two(0177700, 0107770), ";lD3D1"}, +{"divsl", two(0046100, 0004000), two(0177700, 0107770), ";lDD"}, +{"divsll", two(0046100, 0004000), two(0177700, 0107770), ";lD3D1"}, +{"divsw", one(0100700), one(0170700), ";wDd"}, +{"divs", one(0100700), one(0170700), ";wDd"}, +{"divul", two(0046100, 0002000), two(0177700, 0107770), ";lD3D1"}, +{"divul", two(0046100, 0000000), two(0177700, 0107770), ";lDD"}, +{"divull", two(0046100, 0000000), two(0177700, 0107770), ";lD3D1"}, +{"divuw", one(0100300), one(0170700), ";wDd"}, +{"divu", one(0100300), one(0170700), ";wDd"}, +{"eorb", one(0005000), one(0177700), "#b$s"}, /* eori written as or */ +{"eorb", one(0005074), one(0177777), "#bCs"}, /* eori to ccr */ +{"eorb", one(0130400), one(0170700), "Dd$s"}, /* register to memory */ +{"eorib", one(0005000), one(0177700), "#b$s"}, +{"eorib", one(0005074), one(0177777), "#bCs"}, /* eori to ccr */ +{"eoril", one(0005200), one(0177700), "#l$s"}, +{"eoriw", one(0005100), one(0177700), "#w$s"}, +{"eoriw", one(0005174), one(0177777), "#wSs"}, /* eori to sr */ +{"eorl", one(0005200), one(0177700), "#l$s"}, +{"eorl", one(0130600), one(0170700), "Dd$s"}, +{"eorw", one(0005100), one(0177700), "#w$s"}, +{"eorw", one(0005174), one(0177777), "#wSs"}, /* eori to sr */ +{"eorw", one(0130500), one(0170700), "Dd$s"}, + +{"exg", one(0140500), one(0170770), "DdDs"}, +{"exg", one(0140510), one(0170770), "AdAs"}, +{"exg", one(0140610), one(0170770), "DdAs"}, +{"exg", one(0140610), one(0170770), "AsDd"}, + +{"extw", one(0044200), one(0177770), "Ds"}, +{"extl", one(0044300), one(0177770), "Ds"}, +{"extbl", one(0044700), one(0177770), "Ds"}, +{"extb.l", one(0044700), one(0177770), "Ds"}, /* Not sure we should support this one*/ + +{"illegal", one(0045374), one(0177777), ""}, +{"jmp", one(0047300), one(0177700), "!s"}, +{"jsr", one(0047200), one(0177700), "!s"}, +{"lea", one(0040700), one(0170700), "!sAd"}, +{"linkw", one(0047120), one(0177770), "As#w"}, +{"linkl", one(0044010), one(0177770), "As#l"}, +{"link", one(0047120), one(0177770), "As#w"}, +{"link", one(0044010), one(0177770), "As#l"}, + +{"lslb", one(0160410), one(0170770), "QdDs"}, /* lsrb #Q, Ds */ +{"lslb", one(0160450), one(0170770), "DdDs"}, /* lsrb Dd, Ds */ +{"lslw", one(0160510), one(0170770), "QdDs"}, /* lsrb #Q, Ds */ +{"lslw", one(0160550), one(0170770), "DdDs"}, /* lsrb Dd, Ds */ +{"lslw", one(0161700), one(0177700), "~s"}, /* Shift memory */ +{"lsll", one(0160610), one(0170770), "QdDs"}, /* lsrb #Q, Ds */ +{"lsll", one(0160650), one(0170770), "DdDs"}, /* lsrb Dd, Ds */ + +{"lsrb", one(0160010), one(0170770), "QdDs"} /* lsrb #Q, Ds */, +{"lsrb", one(0160050), one(0170770), "DdDs"}, /* lsrb Dd, Ds */ +{"lsrl", one(0160210), one(0170770), "QdDs"}, /* lsrb #Q, Ds */ +{"lsrl", one(0160250), one(0170770), "DdDs"}, /* lsrb #Q, Ds */ +{"lsrw", one(0160110), one(0170770), "QdDs"}, /* lsrb #Q, Ds */ +{"lsrw", one(0160150), one(0170770), "DdDs"}, /* lsrb #Q, Ds */ +{"lsrw", one(0161300), one(0177700), "~s"}, /* Shift memory */ + +{"moveal", one(0020100), one(0170700), "*lAd"}, +{"moveaw", one(0030100), one(0170700), "*wAd"}, +{"moveb", one(0010000), one(0170000), ";b$d"}, /* move */ +{"movel", one(0070000), one(0170400), "MsDd"}, /* moveq written as move */ +{"movel", one(0020000), one(0170000), "*l$d"}, +{"movel", one(0020100), one(0170700), "*lAd"}, +{"movel", one(0047140), one(0177770), "AsUd"}, /* move to USP */ +{"movel", one(0047150), one(0177770), "UdAs"}, /* move from USP */ + +{"movec", one(0047173), one(0177777), "R1Jj"}, +{"movec", one(0047173), one(0177777), "R1#j"}, +{"movec", one(0047172), one(0177777), "JjR1"}, +{"movec", one(0047172), one(0177777), "#jR1"}, + +/* JF added these next four for the assembler */ +{"moveml", one(0044300), one(0177700), "Lw&s"}, /* movem reg to mem. */ +{"moveml", one(0044340), one(0177770), "lw-s"}, /* movem reg to autodecrement. */ +{"moveml", one(0046300), one(0177700), "!sLw"}, /* movem mem to reg. */ +{"moveml", one(0046330), one(0177770), "+sLw"}, /* movem autoinc to reg. */ + +{"moveml", one(0044300), one(0177700), "#w&s"}, /* movem reg to mem. */ +{"moveml", one(0044340), one(0177770), "#w-s"}, /* movem reg to autodecrement. */ +{"moveml", one(0046300), one(0177700), "!s#w"}, /* movem mem to reg. */ +{"moveml", one(0046330), one(0177770), "+s#w"}, /* movem autoinc to reg. */ + +/* JF added these next four for the assembler */ +{"movemw", one(0044200), one(0177700), "Lw&s"}, /* movem reg to mem. */ +{"movemw", one(0044240), one(0177770), "lw-s"}, /* movem reg to autodecrement. */ +{"movemw", one(0046200), one(0177700), "!sLw"}, /* movem mem to reg. */ +{"movemw", one(0046230), one(0177770), "+sLw"}, /* movem autoinc to reg. */ + +{"movemw", one(0044200), one(0177700), "#w&s"}, /* movem reg to mem. */ +{"movemw", one(0044240), one(0177770), "#w-s"}, /* movem reg to autodecrement. */ +{"movemw", one(0046200), one(0177700), "!s#w"}, /* movem mem to reg. */ +{"movemw", one(0046230), one(0177770), "+s#w"}, /* movem autoinc to reg. */ + +{"movepl", one(0000510), one(0170770), "dsDd"}, /* memory to register */ +{"movepl", one(0000710), one(0170770), "Ddds"}, /* register to memory */ +{"movepw", one(0000410), one(0170770), "dsDd"}, /* memory to register */ +{"movepw", one(0000610), one(0170770), "Ddds"}, /* register to memory */ +{"moveq", one(0070000), one(0170400), "MsDd"}, +{"movew", one(0030000), one(0170000), "*w$d"}, +{"movew", one(0030100), one(0170700), "*wAd"}, /* movea, written as move */ +{"movew", one(0040300), one(0177700), "Ss$s"}, /* Move from sr */ +{"movew", one(0041300), one(0177700), "Cs$s"}, /* Move from ccr */ +{"movew", one(0042300), one(0177700), ";wCd"}, /* move to ccr */ +{"movew", one(0043300), one(0177700), ";wSd"}, /* move to sr */ + +{"movesb", two(0007000, 0), two(0177700, 07777), "~sR1"}, /* moves from memory */ +{"movesb", two(0007000, 04000), two(0177700, 07777), "R1~s"}, /* moves to memory */ +{"movesl", two(0007200, 0), two(0177700, 07777), "~sR1"}, /* moves from memory */ +{"movesl", two(0007200, 04000), two(0177700, 07777), "R1~s"}, /* moves to memory */ +{"movesw", two(0007100, 0), two(0177700, 07777), "~sR1"}, /* moves from memory */ +{"movesw", two(0007100, 04000), two(0177700, 07777), "R1~s"}, /* moves to memory */ + +{"mulsl", two(0046000, 004000), two(0177700, 0107770), ";lD1"}, +{"mulsl", two(0046000, 006000), two(0177700, 0107770), ";lD3D1"}, +{"mulsw", one(0140700), one(0170700), ";wDd"}, +{"muls", one(0140700), one(0170700), ";wDd"}, +{"mulul", two(0046000, 000000), two(0177700, 0107770), ";lD1"}, +{"mulul", two(0046000, 002000), two(0177700, 0107770), ";lD3D1"}, +{"muluw", one(0140300), one(0170700), ";wDd"}, +{"mulu", one(0140300), one(0170700), ";wDd"}, +{"nbcd", one(0044000), one(0177700), "$s"}, +{"negb", one(0042000), one(0177700), "$s"}, +{"negl", one(0042200), one(0177700), "$s"}, +{"negw", one(0042100), one(0177700), "$s"}, +{"negxb", one(0040000), one(0177700), "$s"}, +{"negxl", one(0040200), one(0177700), "$s"}, +{"negxw", one(0040100), one(0177700), "$s"}, +{"nop", one(0047161), one(0177777), ""}, +{"notb", one(0043000), one(0177700), "$s"}, +{"notl", one(0043200), one(0177700), "$s"}, +{"notw", one(0043100), one(0177700), "$s"}, + +{"orb", one(0000000), one(0177700), "#b$s"}, /* ori written as or */ +{"orb", one(0000074), one(0177777), "#bCs"}, /* ori to ccr */ +{"orb", one(0100000), one(0170700), ";bDd"}, /* memory to register */ +{"orb", one(0100400), one(0170700), "Dd~s"}, /* register to memory */ +{"orib", one(0000000), one(0177700), "#b$s"}, +{"orib", one(0000074), one(0177777), "#bCs"}, /* ori to ccr */ +{"oril", one(0000200), one(0177700), "#l$s"}, +{"oriw", one(0000100), one(0177700), "#w$s"}, +{"oriw", one(0000174), one(0177777), "#wSs"}, /* ori to sr */ +{"orl", one(0000200), one(0177700), "#l$s"}, +{"orl", one(0100200), one(0170700), ";lDd"}, /* memory to register */ +{"orl", one(0100600), one(0170700), "Dd~s"}, /* register to memory */ +{"orw", one(0000100), one(0177700), "#w$s"}, +{"orw", one(0000174), one(0177777), "#wSs"}, /* ori to sr */ +{"orw", one(0100100), one(0170700), ";wDd"}, /* memory to register */ +{"orw", one(0100500), one(0170700), "Dd~s"}, /* register to memory */ + +{"pack", one(0100500), one(0170770), "DsDd#w"}, /* pack Ds, Dd, #w */ +{"pack", one(0100510), one(0170770), "-s-d#w"}, /* pack -(As), -(Ad), #w */ +{"pea", one(0044100), one(0177700), "!s"}, +{"reset", one(0047160), one(0177777), ""}, + +{"rolb", one(0160430), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"rolb", one(0160470), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"roll", one(0160630), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"roll", one(0160670), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"rolw", one(0160530), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"rolw", one(0160570), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"rolw", one(0163700), one(0177700), "~s"}, /* Rotate memory */ +{"rorb", one(0160030), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"rorb", one(0160070), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"rorl", one(0160230), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"rorl", one(0160270), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"rorw", one(0160130), one(0170770), "QdDs"}, /* rorb #Q, Ds */ +{"rorw", one(0160170), one(0170770), "DdDs"}, /* rorb Dd, Ds */ +{"rorw", one(0163300), one(0177700), "~s"}, /* Rotate memory */ + +{"roxlb", one(0160420), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxlb", one(0160460), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxll", one(0160620), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxll", one(0160660), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxlw", one(0160520), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxlw", one(0160560), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxlw", one(0162700), one(0177700), "~s"}, /* Rotate memory */ +{"roxrb", one(0160020), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxrb", one(0160060), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxrl", one(0160220), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxrl", one(0160260), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxrw", one(0160120), one(0170770), "QdDs"}, /* roxrb #Q, Ds */ +{"roxrw", one(0160160), one(0170770), "DdDs"}, /* roxrb Dd, Ds */ +{"roxrw", one(0162300), one(0177700), "~s"}, /* Rotate memory */ + +{"rtd", one(0047164), one(0177777), "#w"}, +{"rte", one(0047163), one(0177777), ""}, +{"rtm", one(0003300), one(0177760), "Rs"}, +{"rtr", one(0047167), one(0177777), ""}, +{"rts", one(0047165), one(0177777), ""}, + +{"scc", one(0052300), one(0177700), "$s"}, +{"scs", one(0052700), one(0177700), "$s"}, +{"seq", one(0053700), one(0177700), "$s"}, +{"sf", one(0050700), one(0177700), "$s"}, +{"sge", one(0056300), one(0177700), "$s"}, +{"sgt", one(0057300), one(0177700), "$s"}, +{"shi", one(0051300), one(0177700), "$s"}, +{"sle", one(0057700), one(0177700), "$s"}, +{"sls", one(0051700), one(0177700), "$s"}, +{"slt", one(0056700), one(0177700), "$s"}, +{"smi", one(0055700), one(0177700), "$s"}, +{"sne", one(0053300), one(0177700), "$s"}, +{"spl", one(0055300), one(0177700), "$s"}, +{"st", one(0050300), one(0177700), "$s"}, +{"svc", one(0054300), one(0177700), "$s"}, +{"svs", one(0054700), one(0177700), "$s"}, + +{"sbcd", one(0100400), one(0170770), "DsDd"}, +{"sbcd", one(0100410), one(0170770), "-s-d"}, +{"stop", one(0047162), one(0177777), "#w"}, + +{"subal", one(0110700), one(0170700), "*lAd"}, +{"subaw", one(0110300), one(0170700), "*wAd"}, +{"subb", one(0050400), one(0170700), "Qd%s"}, /* subq written as sub */ +{"subb", one(0002000), one(0177700), "#b$s"}, /* subi written as sub */ +{"subb", one(0110000), one(0170700), ";bDd"}, /* subb ? ?, Dd */ +{"subb", one(0110400), one(0170700), "Dd~s"}, /* subb Dd, ? ? */ +{"subib", one(0002000), one(0177700), "#b$s"}, +{"subil", one(0002200), one(0177700), "#l$s"}, +{"subiw", one(0002100), one(0177700), "#w$s"}, +{"subl", one(0050600), one(0170700), "Qd%s"}, +{"subl", one(0002200), one(0177700), "#l$s"}, +{"subl", one(0110700), one(0170700), "*lAd"}, +{"subl", one(0110200), one(0170700), "*lDd"}, +{"subl", one(0110600), one(0170700), "Dd~s"}, +{"subqb", one(0050400), one(0170700), "Qd%s"}, +{"subql", one(0050600), one(0170700), "Qd%s"}, +{"subqw", one(0050500), one(0170700), "Qd%s"}, +{"subw", one(0050500), one(0170700), "Qd%s"}, +{"subw", one(0002100), one(0177700), "#w$s"}, +{"subw", one(0110100), one(0170700), "*wDd"}, +{"subw", one(0110300), one(0170700), "*wAd"}, /* suba written as sub */ +{"subw", one(0110500), one(0170700), "Dd~s"}, +{"subxb", one(0110400), one(0170770), "DsDd"}, /* subxb Ds, Dd */ +{"subxb", one(0110410), one(0170770), "-s-d"}, /* subxb -(As), -(Ad) */ +{"subxl", one(0110600), one(0170770), "DsDd"}, +{"subxl", one(0110610), one(0170770), "-s-d"}, +{"subxw", one(0110500), one(0170770), "DsDd"}, +{"subxw", one(0110510), one(0170770), "-s-d"}, + +{"swap", one(0044100), one(0177770), "Ds"}, + +{"tas", one(0045300), one(0177700), "$s"}, +{"trap", one(0047100), one(0177760), "Ts"}, + +{"trapcc", one(0052374), one(0177777), ""}, +{"trapcs", one(0052774), one(0177777), ""}, +{"trapeq", one(0053774), one(0177777), ""}, +{"trapf", one(0050774), one(0177777), ""}, +{"trapge", one(0056374), one(0177777), ""}, +{"trapgt", one(0057374), one(0177777), ""}, +{"traphi", one(0051374), one(0177777), ""}, +{"traple", one(0057774), one(0177777), ""}, +{"trapls", one(0051774), one(0177777), ""}, +{"traplt", one(0056774), one(0177777), ""}, +{"trapmi", one(0055774), one(0177777), ""}, +{"trapne", one(0053374), one(0177777), ""}, +{"trappl", one(0055374), one(0177777), ""}, +{"trapt", one(0050374), one(0177777), ""}, +{"trapvc", one(0054374), one(0177777), ""}, +{"trapvs", one(0054774), one(0177777), ""}, + +{"trapcc.w", one(0052372), one(0177777), ""}, +{"trapcs.w", one(0052772), one(0177777), ""}, +{"trapeq.w", one(0053772), one(0177777), ""}, +{"trapf.w", one(0050772), one(0177777), ""}, +{"trapge.w", one(0056372), one(0177777), ""}, +{"trapgt.w", one(0057372), one(0177777), ""}, +{"traphi.w", one(0051372), one(0177777), ""}, +{"traple.w", one(0057772), one(0177777), ""}, +{"trapls.w", one(0051772), one(0177777), ""}, +{"traplt.w", one(0056772), one(0177777), ""}, +{"trapmi.w", one(0055772), one(0177777), ""}, +{"trapne.w", one(0053372), one(0177777), ""}, +{"trappl.w", one(0055372), one(0177777), ""}, +{"trapt.w", one(0050372), one(0177777), ""}, +{"trapvc.w", one(0054372), one(0177777), ""}, +{"trapvs.w", one(0054772), one(0177777), ""}, + +{"trapcc.l", one(0052373), one(0177777), ""}, +{"trapcs.l", one(0052773), one(0177777), ""}, +{"trapeq.l", one(0053773), one(0177777), ""}, +{"trapf.l", one(0050773), one(0177777), ""}, +{"trapge.l", one(0056373), one(0177777), ""}, +{"trapgt.l", one(0057373), one(0177777), ""}, +{"traphi.l", one(0051373), one(0177777), ""}, +{"traple.l", one(0057773), one(0177777), ""}, +{"trapls.l", one(0051773), one(0177777), ""}, +{"traplt.l", one(0056773), one(0177777), ""}, +{"trapmi.l", one(0055773), one(0177777), ""}, +{"trapne.l", one(0053373), one(0177777), ""}, +{"trappl.l", one(0055373), one(0177777), ""}, +{"trapt.l", one(0050373), one(0177777), ""}, +{"trapvc.l", one(0054373), one(0177777), ""}, +{"trapvs.l", one(0054773), one(0177777), ""}, + +{"trapv", one(0047166), one(0177777), ""}, + +{"tstb", one(0045000), one(0177700), ";b"}, +{"tstw", one(0045100), one(0177700), "*w"}, +{"tstl", one(0045200), one(0177700), "*l"}, + +{"unlk", one(0047130), one(0177770), "As"}, +{"unpk", one(0100600), one(0170770), "DsDd#w"}, +{"unpk", one(0100610), one(0170770), "-s-d#w"}, + /* JF floating pt stuff moved down here */ + +{"fabsb", two(0xF000, 0x5818), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fabsd", two(0xF000, 0x5418), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fabsl", two(0xF000, 0x4018), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fabsp", two(0xF000, 0x4C18), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fabss", two(0xF000, 0x4418), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fabsw", two(0xF000, 0x5018), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fabsx", two(0xF000, 0x0018), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fabsx", two(0xF000, 0x4818), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fabsx", two(0xF000, 0x0018), two(0xF1C0, 0xE07F), "IiFt"}, + +{"facosb", two(0xF000, 0x581C), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"facosd", two(0xF000, 0x541C), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"facosl", two(0xF000, 0x401C), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"facosp", two(0xF000, 0x4C1C), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"facoss", two(0xF000, 0x441C), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"facosw", two(0xF000, 0x501C), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"facosx", two(0xF000, 0x001C), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"facosx", two(0xF000, 0x481C), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"facosx", two(0xF000, 0x001C), two(0xF1C0, 0xE07F), "IiFt"}, + +{"faddb", two(0xF000, 0x5822), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"faddd", two(0xF000, 0x5422), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"faddl", two(0xF000, 0x4022), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"faddp", two(0xF000, 0x4C22), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fadds", two(0xF000, 0x4422), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"faddw", two(0xF000, 0x5022), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"faddx", two(0xF000, 0x0022), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"faddx", two(0xF000, 0x4822), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"faddx", two(0xF000, 0x0022), two(0xF1C0, 0xE07F), "IiFt"}, JF removed */ + +{"fasinb", two(0xF000, 0x580C), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fasind", two(0xF000, 0x540C), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fasinl", two(0xF000, 0x400C), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fasinp", two(0xF000, 0x4C0C), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fasins", two(0xF000, 0x440C), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fasinw", two(0xF000, 0x500C), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fasinx", two(0xF000, 0x000C), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fasinx", two(0xF000, 0x480C), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fasinx", two(0xF000, 0x000C), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fatanb", two(0xF000, 0x580A), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fatand", two(0xF000, 0x540A), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fatanl", two(0xF000, 0x400A), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fatanp", two(0xF000, 0x4C0A), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fatans", two(0xF000, 0x440A), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fatanw", two(0xF000, 0x500A), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fatanx", two(0xF000, 0x000A), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fatanx", two(0xF000, 0x480A), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fatanx", two(0xF000, 0x000A), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fatanhb", two(0xF000, 0x580D), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fatanhd", two(0xF000, 0x540D), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fatanhl", two(0xF000, 0x400D), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fatanhp", two(0xF000, 0x4C0D), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fatanhs", two(0xF000, 0x440D), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fatanhw", two(0xF000, 0x500D), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fatanhx", two(0xF000, 0x000D), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fatanhx", two(0xF000, 0x480D), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fatanhx", two(0xF000, 0x000D), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fbeq", one(0xF081), one(0xF1BF), "IdBc"}, +{"fbf", one(0xF080), one(0xF1BF), "IdBc"}, +{"fbge", one(0xF093), one(0xF1BF), "IdBc"}, +{"fbgl", one(0xF096), one(0xF1BF), "IdBc"}, +{"fbgle", one(0xF097), one(0xF1BF), "IdBc"}, +{"fbgt", one(0xF092), one(0xF1BF), "IdBc"}, +{"fble", one(0xF095), one(0xF1BF), "IdBc"}, +{"fblt", one(0xF094), one(0xF1BF), "IdBc"}, +{"fbne", one(0xF08E), one(0xF1BF), "IdBc"}, +{"fbnge", one(0xF09C), one(0xF1BF), "IdBc"}, +{"fbngl", one(0xF099), one(0xF1BF), "IdBc"}, +{"fbngle", one(0xF098), one(0xF1BF), "IdBc"}, +{"fbngt", one(0xF09D), one(0xF1BF), "IdBc"}, +{"fbnle", one(0xF09A), one(0xF1BF), "IdBc"}, +{"fbnlt", one(0xF09B), one(0xF1BF), "IdBc"}, +{"fboge", one(0xF083), one(0xF1BF), "IdBc"}, +{"fbogl", one(0xF086), one(0xF1BF), "IdBc"}, +{"fbogt", one(0xF082), one(0xF1BF), "IdBc"}, +{"fbole", one(0xF085), one(0xF1BF), "IdBc"}, +{"fbolt", one(0xF084), one(0xF1BF), "IdBc"}, +{"fbor", one(0xF087), one(0xF1BF), "IdBc"}, +{"fbseq", one(0xF091), one(0xF1BF), "IdBc"}, +{"fbsf", one(0xF090), one(0xF1BF), "IdBc"}, +{"fbsne", one(0xF09E), one(0xF1BF), "IdBc"}, +{"fbst", one(0xF09F), one(0xF1BF), "IdBc"}, +{"fbt", one(0xF08F), one(0xF1BF), "IdBc"}, +{"fbueq", one(0xF089), one(0xF1BF), "IdBc"}, +{"fbuge", one(0xF08B), one(0xF1BF), "IdBc"}, +{"fbugt", one(0xF08A), one(0xF1BF), "IdBc"}, +{"fbule", one(0xF08D), one(0xF1BF), "IdBc"}, +{"fbult", one(0xF08C), one(0xF1BF), "IdBc"}, +{"fbun", one(0xF088), one(0xF1BF), "IdBc"}, + +{"fcmpb", two(0xF000, 0x5838), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fcmpd", two(0xF000, 0x5438), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fcmpl", two(0xF000, 0x4038), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fcmpp", two(0xF000, 0x4C38), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fcmps", two(0xF000, 0x4438), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fcmpw", two(0xF000, 0x5038), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fcmpx", two(0xF000, 0x0038), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fcmpx", two(0xF000, 0x4838), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fcmpx", two(0xF000, 0x0038), two(0xF1C0, 0xE07F), "IiFt"}, JF removed */ + +{"fcosb", two(0xF000, 0x581D), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fcosd", two(0xF000, 0x541D), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fcosl", two(0xF000, 0x401D), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fcosp", two(0xF000, 0x4C1D), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fcoss", two(0xF000, 0x441D), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fcosw", two(0xF000, 0x501D), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fcosx", two(0xF000, 0x001D), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fcosx", two(0xF000, 0x481D), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fcosx", two(0xF000, 0x001D), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fcoshb", two(0xF000, 0x5819), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fcoshd", two(0xF000, 0x5419), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fcoshl", two(0xF000, 0x4019), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fcoshp", two(0xF000, 0x4C19), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fcoshs", two(0xF000, 0x4419), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fcoshw", two(0xF000, 0x5019), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fcoshx", two(0xF000, 0x0019), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fcoshx", two(0xF000, 0x4819), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fcoshx", two(0xF000, 0x0019), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fdbeq", two(0xF048, 0x0001), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbf", two(0xF048, 0x0000), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbge", two(0xF048, 0x0013), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbgl", two(0xF048, 0x0016), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbgle", two(0xF048, 0x0017), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbgt", two(0xF048, 0x0012), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdble", two(0xF048, 0x0015), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdblt", two(0xF048, 0x0014), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbne", two(0xF048, 0x000E), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbnge", two(0xF048, 0x001C), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbngl", two(0xF048, 0x0019), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbngle", two(0xF048, 0x0018), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbngt", two(0xF048, 0x001D), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbnle", two(0xF048, 0x001A), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbnlt", two(0xF048, 0x001B), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdboge", two(0xF048, 0x0003), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbogl", two(0xF048, 0x0006), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbogt", two(0xF048, 0x0002), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbole", two(0xF048, 0x0005), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbolt", two(0xF048, 0x0004), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbor", two(0xF048, 0x0007), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbseq", two(0xF048, 0x0011), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbsf", two(0xF048, 0x0010), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbsne", two(0xF048, 0x001E), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbst", two(0xF048, 0x001F), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbt", two(0xF048, 0x000F), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbueq", two(0xF048, 0x0009), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbuge", two(0xF048, 0x000B), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbugt", two(0xF048, 0x000A), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbule", two(0xF048, 0x000D), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbult", two(0xF048, 0x000C), two(0xF1F8, 0xFFFF), "IiDsBw"}, +{"fdbun", two(0xF048, 0x0008), two(0xF1F8, 0xFFFF), "IiDsBw"}, + +{"fdivb", two(0xF000, 0x5820), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fdivd", two(0xF000, 0x5420), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fdivl", two(0xF000, 0x4020), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fdivp", two(0xF000, 0x4C20), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fdivs", two(0xF000, 0x4420), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fdivw", two(0xF000, 0x5020), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fdivx", two(0xF000, 0x0020), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fdivx", two(0xF000, 0x4820), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fdivx", two(0xF000, 0x0020), two(0xF1C0, 0xE07F), "IiFt"}, JF */ + +{"fetoxb", two(0xF000, 0x5810), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fetoxd", two(0xF000, 0x5410), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fetoxl", two(0xF000, 0x4010), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fetoxp", two(0xF000, 0x4C10), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fetoxs", two(0xF000, 0x4410), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fetoxw", two(0xF000, 0x5010), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fetoxx", two(0xF000, 0x0010), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fetoxx", two(0xF000, 0x4810), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fetoxx", two(0xF000, 0x0010), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fetoxm1b", two(0xF000, 0x5808), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fetoxm1d", two(0xF000, 0x5408), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fetoxm1l", two(0xF000, 0x4008), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fetoxm1p", two(0xF000, 0x4C08), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fetoxm1s", two(0xF000, 0x4408), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fetoxm1w", two(0xF000, 0x5008), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fetoxm1x", two(0xF000, 0x0008), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fetoxm1x", two(0xF000, 0x4808), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fetoxm1x", two(0xF000, 0x0008), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fgetexpb", two(0xF000, 0x581E), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fgetexpd", two(0xF000, 0x541E), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fgetexpl", two(0xF000, 0x401E), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fgetexpp", two(0xF000, 0x4C1E), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fgetexps", two(0xF000, 0x441E), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fgetexpw", two(0xF000, 0x501E), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fgetexpx", two(0xF000, 0x001E), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fgetexpx", two(0xF000, 0x481E), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fgetexpx", two(0xF000, 0x001E), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fgetmanb", two(0xF000, 0x581F), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fgetmand", two(0xF000, 0x541F), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fgetmanl", two(0xF000, 0x401F), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fgetmanp", two(0xF000, 0x4C1F), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fgetmans", two(0xF000, 0x441F), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fgetmanw", two(0xF000, 0x501F), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fgetmanx", two(0xF000, 0x001F), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fgetmanx", two(0xF000, 0x481F), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fgetmanx", two(0xF000, 0x001F), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fintb", two(0xF000, 0x5801), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fintd", two(0xF000, 0x5401), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fintl", two(0xF000, 0x4001), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fintp", two(0xF000, 0x4C01), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fints", two(0xF000, 0x4401), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fintw", two(0xF000, 0x5001), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fintx", two(0xF000, 0x0001), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fintx", two(0xF000, 0x4801), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fintx", two(0xF000, 0x0001), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fintrzb", two(0xF000, 0x5803), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fintrzd", two(0xF000, 0x5403), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fintrzl", two(0xF000, 0x4003), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fintrzp", two(0xF000, 0x4C03), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fintrzs", two(0xF000, 0x4403), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fintrzw", two(0xF000, 0x5003), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fintrzx", two(0xF000, 0x0003), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fintrzx", two(0xF000, 0x4803), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fintrzx", two(0xF000, 0x0003), two(0xF1C0, 0xE07F), "IiFt"}, + +{"flog10b", two(0xF000, 0x5815), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"flog10d", two(0xF000, 0x5415), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"flog10l", two(0xF000, 0x4015), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"flog10p", two(0xF000, 0x4C15), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"flog10s", two(0xF000, 0x4415), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"flog10w", two(0xF000, 0x5015), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"flog10x", two(0xF000, 0x0015), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"flog10x", two(0xF000, 0x4815), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"flog10x", two(0xF000, 0x0015), two(0xF1C0, 0xE07F), "IiFt"}, + +{"flog2b", two(0xF000, 0x5816), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"flog2d", two(0xF000, 0x5416), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"flog2l", two(0xF000, 0x4016), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"flog2p", two(0xF000, 0x4C16), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"flog2s", two(0xF000, 0x4416), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"flog2w", two(0xF000, 0x5016), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"flog2x", two(0xF000, 0x0016), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"flog2x", two(0xF000, 0x4816), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"flog2x", two(0xF000, 0x0016), two(0xF1C0, 0xE07F), "IiFt"}, + +{"flognb", two(0xF000, 0x5814), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"flognd", two(0xF000, 0x5414), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"flognl", two(0xF000, 0x4014), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"flognp", two(0xF000, 0x4C14), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"flogns", two(0xF000, 0x4414), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"flognw", two(0xF000, 0x5014), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"flognx", two(0xF000, 0x0014), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"flognx", two(0xF000, 0x4814), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"flognx", two(0xF000, 0x0014), two(0xF1C0, 0xE07F), "IiFt"}, + +{"flognp1b", two(0xF000, 0x5806), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"flognp1d", two(0xF000, 0x5406), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"flognp1l", two(0xF000, 0x4006), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"flognp1p", two(0xF000, 0x4C06), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"flognp1s", two(0xF000, 0x4406), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"flognp1w", two(0xF000, 0x5006), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"flognp1x", two(0xF000, 0x0006), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"flognp1x", two(0xF000, 0x4806), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"flognp1x", two(0xF000, 0x0006), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fmodb", two(0xF000, 0x5821), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fmodd", two(0xF000, 0x5421), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fmodl", two(0xF000, 0x4021), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fmodp", two(0xF000, 0x4C21), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fmods", two(0xF000, 0x4421), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fmodw", two(0xF000, 0x5021), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fmodx", two(0xF000, 0x0021), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fmodx", two(0xF000, 0x4821), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fmodx", two(0xF000, 0x0021), two(0xF1C0, 0xE07F), "IiFt"}, JF */ + +{"fmoveb", two(0xF000, 0x5800), two(0xF1C0, 0xFC7F), "Ii;bF7"}, /* fmove from <ea> to fp<n> */ +{"fmoveb", two(0xF000, 0x7800), two(0xF1C0, 0xFC7F), "IiF7@b"}, /* fmove from fp<n> to <ea> */ +{"fmoved", two(0xF000, 0x5400), two(0xF1C0, 0xFC7F), "Ii;FF7"}, /* fmove from <ea> to fp<n> */ +{"fmoved", two(0xF000, 0x7400), two(0xF1C0, 0xFC7F), "IiF7@F"}, /* fmove from fp<n> to <ea> */ +{"fmovel", two(0xF000, 0x4000), two(0xF1C0, 0xFC7F), "Ii;lF7"}, /* fmove from <ea> to fp<n> */ +{"fmovel", two(0xF000, 0x6000), two(0xF1C0, 0xFC7F), "IiF7@l"}, /* fmove from fp<n> to <ea> */ +/* Warning: The addressing modes on these are probably not right: + esp, Areg direct is only allowed for FPI */ + /* fmove.l from/to system control registers: */ +{"fmovel", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8@s"}, +{"fmovel", two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*ls8"}, + +/* {"fmovel", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8@s"}, +{"fmovel", two(0xF000, 0x8000), two(0xF2C0, 0xE3FF), "Ii*ss8"}, */ + +{"fmovep", two(0xF000, 0x4C00), two(0xF1C0, 0xFC7F), "Ii;pF7"}, /* fmove from <ea> to fp<n> */ +{"fmovep", two(0xF000, 0x6C00), two(0xF1C0, 0xFC00), "IiF7@pkC"}, /* fmove.p with k-factors: */ +{"fmovep", two(0xF000, 0x7C00), two(0xF1C0, 0xFC0F), "IiF7@pDk"}, /* fmove.p with k-factors: */ + +{"fmoves", two(0xF000, 0x4400), two(0xF1C0, 0xFC7F), "Ii;fF7"}, /* fmove from <ea> to fp<n> */ +{"fmoves", two(0xF000, 0x6400), two(0xF1C0, 0xFC7F), "IiF7@f"}, /* fmove from fp<n> to <ea> */ +{"fmovew", two(0xF000, 0x5000), two(0xF1C0, 0xFC7F), "Ii;wF7"}, /* fmove from <ea> to fp<n> */ +{"fmovew", two(0xF000, 0x7000), two(0xF1C0, 0xFC7F), "IiF7@w"}, /* fmove from fp<n> to <ea> */ +{"fmovex", two(0xF000, 0x0000), two(0xF1C0, 0xE07F), "IiF8F7"}, /* fmove from <ea> to fp<n> */ +{"fmovex", two(0xF000, 0x4800), two(0xF1C0, 0xFC7F), "Ii;xF7"}, /* fmove from <ea> to fp<n> */ +{"fmovex", two(0xF000, 0x6800), two(0xF1C0, 0xFC7F), "IiF7@x"}, /* fmove from fp<n> to <ea> */ +/* JF removed {"fmovex", two(0xF000, 0x0000), two(0xF1C0, 0xE07F), "IiFt"}, / * fmove from <ea> to fp<n> */ + +{"fmovecrx", two(0xF000, 0x5C00), two(0xF1FF, 0xFC00), "Ii#CF7"}, /* fmovecr.x #ccc, FPn */ +{"fmovecr", two(0xF000, 0x5C00), two(0xF1FF, 0xFC00), "Ii#CF7"}, + +/* Other fmovemx. */ +{"fmovemx", two(0xF020, 0xE000), two(0xF1F8, 0xFF00), "IdL3-s"}, /* fmovem.x to autodecrement, static and dynamic */ +{"fmovemx", two(0xF020, 0xE000), two(0xF1F8, 0xFF00), "Id#3-s"}, /* fmovem.x to autodecrement, static and dynamic */ + +{"fmovemx", two(0xF020, 0xE800), two(0xF1F8, 0xFF8F), "IiDk-s"}, /* fmovem.x to autodecrement, static and dynamic */ + +{"fmovemx", two(0xF000, 0xF000), two(0xF1C0, 0xFF00), "Id#3&s"}, /* fmovem.x to control, static and dynamic: */ +{"fmovemx", two(0xF000, 0xF800), two(0xF1C0, 0xFF8F), "IiDk&s"}, /* fmovem.x to control, static and dynamic: */ +{"fmovemx", two(0xF000, 0xD000), two(0xF1C0, 0xFF00), "Id&s#3"}, /* fmovem.x from control, static and dynamic: */ +{"fmovemx", two(0xF000, 0xD800), two(0xF1C0, 0xFF8F), "Ii&sDk"}, /* fmovem.x from control, static and dynamic: */ +{"fmovemx", two(0xF000, 0xF000), two(0xF1C0, 0xFF00), "Idl3&s"}, /* fmovem.x to control, static and dynamic: */ +{"fmovemx", two(0xF000, 0xD000), two(0xF1C0, 0xFF00), "Id&sl3"}, /* fmovem.x from control, static and dynamic: */ + +{"fmovemx", two(0xF018, 0xD000), two(0xF1F8, 0xFF00), "Id+sl3"}, /* fmovem.x from autoincrement, static and dynamic: */ +{"fmovemx", two(0xF018, 0xD000), two(0xF1F8, 0xFF00), "Id+s#3"}, /* fmovem.x from autoincrement, static and dynamic: */ +{"fmovemx", two(0xF018, 0xD800), two(0xF1F8, 0xFF8F), "Ii+sDk"}, /* fmovem.x from autoincrement, static and dynamic: */ + +{"fmoveml", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "IiL8@s"}, +{"fmoveml", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Ii#8@s"}, +{"fmoveml", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8@s"}, + +{"fmoveml", two(0xF000, 0x8000), two(0xF2C0, 0xE3FF), "Ii*sL8"}, +{"fmoveml", two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*s#8"}, +{"fmoveml", two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*ss8"}, + +/* fmovemx with register lists */ +{"fmovem", two(0xF020, 0xE000), two(0xF1F8, 0xFF00), "IdL3-s"}, /* fmovem.x to autodecrement, static and dynamic */ +{"fmovem", two(0xF000, 0xF000), two(0xF1C0, 0xFF00), "Idl3&s"}, /* fmovem.x to control, static and dynamic: */ +{"fmovem", two(0xF018, 0xD000), two(0xF1F8, 0xFF00), "Id+sl3"}, /* fmovem.x from autoincrement, static and dynamic: */ +{"fmovem", two(0xF000, 0xD000), two(0xF1C0, 0xFF00), "Id&sl3"}, /* fmovem.x from control, static and dynamic: */ + + /* Alternate mnemonics for GNU as and GNU CC */ +{"fmovem", two(0xF020, 0xE000), two(0xF1F8, 0xFF00), "Id#3-s"}, /* fmovem.x to autodecrement, static and dynamic */ +{"fmovem", two(0xF020, 0xE800), two(0xF1F8, 0xFF8F), "IiDk-s"}, /* fmovem.x to autodecrement, static and dynamic */ + +{"fmovem", two(0xF000, 0xF000), two(0xF1C0, 0xFF00), "Id#3&s"}, /* fmovem.x to control, static and dynamic: */ +{"fmovem", two(0xF000, 0xF800), two(0xF1C0, 0xFF8F), "IiDk&s"}, /* fmovem.x to control, static and dynamic: */ + +{"fmovem", two(0xF018, 0xD000), two(0xF1F8, 0xFF00), "Id+s#3"}, /* fmovem.x from autoincrement, static and dynamic: */ +{"fmovem", two(0xF018, 0xD800), two(0xF1F8, 0xFF8F), "Ii+sDk"}, /* fmovem.x from autoincrement, static and dynamic: */ + +{"fmovem", two(0xF000, 0xD000), two(0xF1C0, 0xFF00), "Id&s#3"}, /* fmovem.x from control, static and dynamic: */ +{"fmovem", two(0xF000, 0xD800), two(0xF1C0, 0xFF8F), "Ii&sDk"}, /* fmovem.x from control, static and dynamic: */ + +/* fmoveml a FP-control register */ +{"fmovem", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "Iis8@s"}, +{"fmovem", two(0xF000, 0x8000), two(0xF1C0, 0xE3FF), "Ii*ss8"}, + +/* fmoveml a FP-control reglist */ +{"fmovem", two(0xF000, 0xA000), two(0xF1C0, 0xE3FF), "IiL8@s"}, +{"fmovem", two(0xF000, 0x8000), two(0xF2C0, 0xE3FF), "Ii*sL8"}, + +{"fmulb", two(0xF000, 0x5823), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fmuld", two(0xF000, 0x5423), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fmull", two(0xF000, 0x4023), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fmulp", two(0xF000, 0x4C23), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fmuls", two(0xF000, 0x4423), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fmulw", two(0xF000, 0x5023), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fmulx", two(0xF000, 0x0023), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fmulx", two(0xF000, 0x4823), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fmulx", two(0xF000, 0x0023), two(0xF1C0, 0xE07F), "IiFt"}, JF */ + +{"fnegb", two(0xF000, 0x581A), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fnegd", two(0xF000, 0x541A), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fnegl", two(0xF000, 0x401A), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fnegp", two(0xF000, 0x4C1A), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fnegs", two(0xF000, 0x441A), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fnegw", two(0xF000, 0x501A), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fnegx", two(0xF000, 0x001A), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fnegx", two(0xF000, 0x481A), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fnegx", two(0xF000, 0x001A), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fnop", two(0xF280, 0x0000), two(0xFFFF, 0xFFFF), "Ii"}, + +{"fremb", two(0xF000, 0x5825), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fremd", two(0xF000, 0x5425), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"freml", two(0xF000, 0x4025), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fremp", two(0xF000, 0x4C25), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"frems", two(0xF000, 0x4425), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fremw", two(0xF000, 0x5025), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fremx", two(0xF000, 0x0025), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fremx", two(0xF000, 0x4825), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fremx", two(0xF000, 0x0025), two(0xF1C0, 0xE07F), "IiFt"}, JF */ + +{"frestore", one(0xF140), one(0xF1C0), "Id&s"}, +{"frestore", one(0xF158), one(0xF1F8), "Id+s"}, +{"fsave", one(0xF100), one(0xF1C0), "Id&s"}, +{"fsave", one(0xF120), one(0xF1F8), "Id-s"}, + +{"fsincosb", two(0xF000, 0x5830), two(0xF1C0, 0xFC78), "Ii;bF7FC"}, +{"fsincosd", two(0xF000, 0x5430), two(0xF1C0, 0xFC78), "Ii;FF7FC"}, +{"fsincosl", two(0xF000, 0x4030), two(0xF1C0, 0xFC78), "Ii;lF7FC"}, +{"fsincosp", two(0xF000, 0x4C30), two(0xF1C0, 0xFC78), "Ii;pF7FC"}, +{"fsincoss", two(0xF000, 0x4430), two(0xF1C0, 0xFC78), "Ii;fF7FC"}, +{"fsincosw", two(0xF000, 0x5030), two(0xF1C0, 0xFC78), "Ii;wF7FC"}, +{"fsincosx", two(0xF000, 0x0030), two(0xF1C0, 0xE078), "IiF8F7FC"}, +{"fsincosx", two(0xF000, 0x4830), two(0xF1C0, 0xFC78), "Ii;xF7FC"}, + +{"fscaleb", two(0xF000, 0x5826), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fscaled", two(0xF000, 0x5426), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fscalel", two(0xF000, 0x4026), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fscalep", two(0xF000, 0x4C26), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fscales", two(0xF000, 0x4426), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fscalew", two(0xF000, 0x5026), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fscalex", two(0xF000, 0x0026), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fscalex", two(0xF000, 0x4826), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +/* {"fscalex", two(0xF000, 0x0026), two(0xF1C0, 0xE07F), "IiFt"}, JF */ + +/* $ is necessary to prevent the assembler from using PC-relative. + If @ were used, "label: fseq label" could produce "ftrapeq", + because "label" became "pc@label". */ +{"fseq", two(0xF040, 0x0001), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsf", two(0xF040, 0x0000), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsge", two(0xF040, 0x0013), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsgl", two(0xF040, 0x0016), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsgle", two(0xF040, 0x0017), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsgt", two(0xF040, 0x0012), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsle", two(0xF040, 0x0015), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fslt", two(0xF040, 0x0014), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsne", two(0xF040, 0x000E), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsnge", two(0xF040, 0x001C), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsngl", two(0xF040, 0x0019), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsngle", two(0xF040, 0x0018), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsngt", two(0xF040, 0x001D), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsnle", two(0xF040, 0x001A), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsnlt", two(0xF040, 0x001B), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsoge", two(0xF040, 0x0003), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsogl", two(0xF040, 0x0006), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsogt", two(0xF040, 0x0002), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsole", two(0xF040, 0x0005), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsolt", two(0xF040, 0x0004), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsor", two(0xF040, 0x0007), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsseq", two(0xF040, 0x0011), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fssf", two(0xF040, 0x0010), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fssne", two(0xF040, 0x001E), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsst", two(0xF040, 0x001F), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fst", two(0xF040, 0x000F), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsueq", two(0xF040, 0x0009), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsuge", two(0xF040, 0x000B), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsugt", two(0xF040, 0x000A), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsule", two(0xF040, 0x000D), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsult", two(0xF040, 0x000C), two(0xF1C0, 0xFFFF), "Ii$s"}, +{"fsun", two(0xF040, 0x0008), two(0xF1C0, 0xFFFF), "Ii$s"}, + +{"fsgldivb", two(0xF000, 0x5824), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsgldivd", two(0xF000, 0x5424), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsgldivl", two(0xF000, 0x4024), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsgldivp", two(0xF000, 0x4C24), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsgldivs", two(0xF000, 0x4424), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsgldivw", two(0xF000, 0x5024), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsgldivx", two(0xF000, 0x0024), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsgldivx", two(0xF000, 0x4824), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsgldivx", two(0xF000, 0x0024), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fsglmulb", two(0xF000, 0x5827), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsglmuld", two(0xF000, 0x5427), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsglmull", two(0xF000, 0x4027), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsglmulp", two(0xF000, 0x4C27), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsglmuls", two(0xF000, 0x4427), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsglmulw", two(0xF000, 0x5027), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsglmulx", two(0xF000, 0x0027), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsglmulx", two(0xF000, 0x4827), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsglmulx", two(0xF000, 0x0027), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fsinb", two(0xF000, 0x580E), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsind", two(0xF000, 0x540E), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsinl", two(0xF000, 0x400E), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsinp", two(0xF000, 0x4C0E), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsins", two(0xF000, 0x440E), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsinw", two(0xF000, 0x500E), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsinx", two(0xF000, 0x000E), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsinx", two(0xF000, 0x480E), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsinx", two(0xF000, 0x000E), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fsinhb", two(0xF000, 0x5802), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsinhd", two(0xF000, 0x5402), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsinhl", two(0xF000, 0x4002), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsinhp", two(0xF000, 0x4C02), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsinhs", two(0xF000, 0x4402), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsinhw", two(0xF000, 0x5002), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsinhx", two(0xF000, 0x0002), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsinhx", two(0xF000, 0x4802), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsinhx", two(0xF000, 0x0002), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fsqrtb", two(0xF000, 0x5804), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsqrtd", two(0xF000, 0x5404), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsqrtl", two(0xF000, 0x4004), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsqrtp", two(0xF000, 0x4C04), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsqrts", two(0xF000, 0x4404), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsqrtw", two(0xF000, 0x5004), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsqrtx", two(0xF000, 0x0004), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsqrtx", two(0xF000, 0x4804), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsqrtx", two(0xF000, 0x0004), two(0xF1C0, 0xE07F), "IiFt"}, + +{"fsubb", two(0xF000, 0x5828), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"fsubd", two(0xF000, 0x5428), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"fsubl", two(0xF000, 0x4028), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"fsubp", two(0xF000, 0x4C28), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"fsubs", two(0xF000, 0x4428), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"fsubw", two(0xF000, 0x5028), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"fsubx", two(0xF000, 0x0028), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"fsubx", two(0xF000, 0x4828), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"fsubx", two(0xF000, 0x0028), two(0xF1C0, 0xE07F), "IiFt"}, + +{"ftanb", two(0xF000, 0x580F), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"ftand", two(0xF000, 0x540F), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"ftanl", two(0xF000, 0x400F), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"ftanp", two(0xF000, 0x4C0F), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"ftans", two(0xF000, 0x440F), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"ftanw", two(0xF000, 0x500F), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"ftanx", two(0xF000, 0x000F), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"ftanx", two(0xF000, 0x480F), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"ftanx", two(0xF000, 0x000F), two(0xF1C0, 0xE07F), "IiFt"}, + +{"ftanhb", two(0xF000, 0x5809), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"ftanhd", two(0xF000, 0x5409), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"ftanhl", two(0xF000, 0x4009), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"ftanhp", two(0xF000, 0x4C09), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"ftanhs", two(0xF000, 0x4409), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"ftanhw", two(0xF000, 0x5009), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"ftanhx", two(0xF000, 0x0009), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"ftanhx", two(0xF000, 0x4809), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"ftanhx", two(0xF000, 0x0009), two(0xF1C0, 0xE07F), "IiFt"}, + +{"ftentoxb", two(0xF000, 0x5812), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"ftentoxd", two(0xF000, 0x5412), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"ftentoxl", two(0xF000, 0x4012), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"ftentoxp", two(0xF000, 0x4C12), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"ftentoxs", two(0xF000, 0x4412), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"ftentoxw", two(0xF000, 0x5012), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"ftentoxx", two(0xF000, 0x0012), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"ftentoxx", two(0xF000, 0x4812), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"ftentoxx", two(0xF000, 0x0012), two(0xF1C0, 0xE07F), "IiFt"}, + +{"ftrapeq", two(0xF07C, 0x0001), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapf", two(0xF07C, 0x0000), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapge", two(0xF07C, 0x0013), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapgl", two(0xF07C, 0x0016), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapgle", two(0xF07C, 0x0017), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapgt", two(0xF07C, 0x0012), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftraple", two(0xF07C, 0x0015), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftraplt", two(0xF07C, 0x0014), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapne", two(0xF07C, 0x000E), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapnge", two(0xF07C, 0x001C), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapngl", two(0xF07C, 0x0019), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapngle", two(0xF07C, 0x0018), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapngt", two(0xF07C, 0x001D), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapnle", two(0xF07C, 0x001A), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapnlt", two(0xF07C, 0x001B), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapoge", two(0xF07C, 0x0003), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapogl", two(0xF07C, 0x0006), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapogt", two(0xF07C, 0x0002), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapole", two(0xF07C, 0x0005), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapolt", two(0xF07C, 0x0004), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapor", two(0xF07C, 0x0007), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapseq", two(0xF07C, 0x0011), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapsf", two(0xF07C, 0x0010), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapsne", two(0xF07C, 0x001E), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapst", two(0xF07C, 0x001F), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapt", two(0xF07C, 0x000F), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapueq", two(0xF07C, 0x0009), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapuge", two(0xF07C, 0x000B), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapugt", two(0xF07C, 0x000A), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapule", two(0xF07C, 0x000D), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapult", two(0xF07C, 0x000C), two(0xF1FF, 0xFFFF), "Ii"}, +{"ftrapun", two(0xF07C, 0x0008), two(0xF1FF, 0xFFFF), "Ii"}, + +{"ftrapeqw", two(0xF07A, 0x0001), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapfw", two(0xF07A, 0x0000), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapgew", two(0xF07A, 0x0013), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapglw", two(0xF07A, 0x0016), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapglew", two(0xF07A, 0x0017), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapgtw", two(0xF07A, 0x0012), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftraplew", two(0xF07A, 0x0015), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapltw", two(0xF07A, 0x0014), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapnew", two(0xF07A, 0x000E), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapngew", two(0xF07A, 0x001C), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapnglw", two(0xF07A, 0x0019), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapnglew", two(0xF07A, 0x0018), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapngtw", two(0xF07A, 0x001D), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapnlew", two(0xF07A, 0x001A), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapnltw", two(0xF07A, 0x001B), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapogew", two(0xF07A, 0x0003), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapoglw", two(0xF07A, 0x0006), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapogtw", two(0xF07A, 0x0002), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapolew", two(0xF07A, 0x0005), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapoltw", two(0xF07A, 0x0004), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftraporw", two(0xF07A, 0x0007), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapseqw", two(0xF07A, 0x0011), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapsfw", two(0xF07A, 0x0010), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapsnew", two(0xF07A, 0x001E), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapstw", two(0xF07A, 0x001F), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftraptw", two(0xF07A, 0x000F), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapueqw", two(0xF07A, 0x0009), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapugew", two(0xF07A, 0x000B), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapugtw", two(0xF07A, 0x000A), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapulew", two(0xF07A, 0x000D), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapultw", two(0xF07A, 0x000C), two(0xF1FF, 0xFFFF), "Ii^w"}, +{"ftrapunw", two(0xF07A, 0x0008), two(0xF1FF, 0xFFFF), "Ii^w"}, + +{"ftrapeql", two(0xF07B, 0x0001), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapfl", two(0xF07B, 0x0000), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapgel", two(0xF07B, 0x0013), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapgll", two(0xF07B, 0x0016), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapglel", two(0xF07B, 0x0017), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapgtl", two(0xF07B, 0x0012), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftraplel", two(0xF07B, 0x0015), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapltl", two(0xF07B, 0x0014), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapnel", two(0xF07B, 0x000E), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapngel", two(0xF07B, 0x001C), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapngll", two(0xF07B, 0x0019), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapnglel", two(0xF07B, 0x0018), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapngtl", two(0xF07B, 0x001D), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapnlel", two(0xF07B, 0x001A), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapnltl", two(0xF07B, 0x001B), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapogel", two(0xF07B, 0x0003), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapogll", two(0xF07B, 0x0006), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapogtl", two(0xF07B, 0x0002), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapolel", two(0xF07B, 0x0005), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapoltl", two(0xF07B, 0x0004), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftraporl", two(0xF07B, 0x0007), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapseql", two(0xF07B, 0x0011), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapsfl", two(0xF07B, 0x0010), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapsnel", two(0xF07B, 0x001E), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapstl", two(0xF07B, 0x001F), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftraptl", two(0xF07B, 0x000F), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapueql", two(0xF07B, 0x0009), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapugel", two(0xF07B, 0x000B), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapugtl", two(0xF07B, 0x000A), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapulel", two(0xF07B, 0x000D), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapultl", two(0xF07B, 0x000C), two(0xF1FF, 0xFFFF), "Ii^l"}, +{"ftrapunl", two(0xF07B, 0x0008), two(0xF1FF, 0xFFFF), "Ii^l"}, + +{"ftstb", two(0xF000, 0x583A), two(0xF1C0, 0xFC7F), "Ii;b"}, +{"ftstd", two(0xF000, 0x543A), two(0xF1C0, 0xFC7F), "Ii;F"}, +{"ftstl", two(0xF000, 0x403A), two(0xF1C0, 0xFC7F), "Ii;l"}, +{"ftstp", two(0xF000, 0x4C3A), two(0xF1C0, 0xFC7F), "Ii;p"}, +{"ftsts", two(0xF000, 0x443A), two(0xF1C0, 0xFC7F), "Ii;f"}, +{"ftstw", two(0xF000, 0x503A), two(0xF1C0, 0xFC7F), "Ii;w"}, +{"ftstx", two(0xF000, 0x003A), two(0xF1C0, 0xE07F), "IiF8"}, +{"ftstx", two(0xF000, 0x483A), two(0xF1C0, 0xFC7F), "Ii;x"}, + +{"ftwotoxb", two(0xF000, 0x5811), two(0xF1C0, 0xFC7F), "Ii;bF7"}, +{"ftwotoxd", two(0xF000, 0x5411), two(0xF1C0, 0xFC7F), "Ii;FF7"}, +{"ftwotoxl", two(0xF000, 0x4011), two(0xF1C0, 0xFC7F), "Ii;lF7"}, +{"ftwotoxp", two(0xF000, 0x4C11), two(0xF1C0, 0xFC7F), "Ii;pF7"}, +{"ftwotoxs", two(0xF000, 0x4411), two(0xF1C0, 0xFC7F), "Ii;fF7"}, +{"ftwotoxw", two(0xF000, 0x5011), two(0xF1C0, 0xFC7F), "Ii;wF7"}, +{"ftwotoxx", two(0xF000, 0x0011), two(0xF1C0, 0xE07F), "IiF8F7"}, +{"ftwotoxx", two(0xF000, 0x4811), two(0xF1C0, 0xFC7F), "Ii;xF7"}, +{"ftwotoxx", two(0xF000, 0x0011), two(0xF1C0, 0xE07F), "IiFt"}, + + +{"fjeq", one(0xF081), one(0xF1FF), "IdBc"}, +{"fjf", one(0xF080), one(0xF1FF), "IdBc"}, +{"fjge", one(0xF093), one(0xF1FF), "IdBc"}, +{"fjgl", one(0xF096), one(0xF1FF), "IdBc"}, +{"fjgle", one(0xF097), one(0xF1FF), "IdBc"}, +{"fjgt", one(0xF092), one(0xF1FF), "IdBc"}, +{"fjle", one(0xF095), one(0xF1FF), "IdBc"}, +{"fjlt", one(0xF094), one(0xF1FF), "IdBc"}, +{"fjne", one(0xF08E), one(0xF1FF), "IdBc"}, +{"fjnge", one(0xF09C), one(0xF1FF), "IdBc"}, +{"fjngl", one(0xF099), one(0xF1FF), "IdBc"}, +{"fjngle", one(0xF098), one(0xF1FF), "IdBc"}, +{"fjngt", one(0xF09D), one(0xF1FF), "IdBc"}, +{"fjnle", one(0xF09A), one(0xF1FF), "IdBc"}, +{"fjnlt", one(0xF09B), one(0xF1FF), "IdBc"}, +{"fjoge", one(0xF083), one(0xF1FF), "IdBc"}, +{"fjogl", one(0xF086), one(0xF1FF), "IdBc"}, +{"fjogt", one(0xF082), one(0xF1FF), "IdBc"}, +{"fjole", one(0xF085), one(0xF1FF), "IdBc"}, +{"fjolt", one(0xF084), one(0xF1FF), "IdBc"}, +{"fjor", one(0xF087), one(0xF1FF), "IdBc"}, +{"fjseq", one(0xF091), one(0xF1FF), "IdBc"}, +{"fjsf", one(0xF090), one(0xF1FF), "IdBc"}, +{"fjsne", one(0xF09E), one(0xF1FF), "IdBc"}, +{"fjst", one(0xF09F), one(0xF1FF), "IdBc"}, +{"fjt", one(0xF08F), one(0xF1FF), "IdBc"}, +{"fjueq", one(0xF089), one(0xF1FF), "IdBc"}, +{"fjuge", one(0xF08B), one(0xF1FF), "IdBc"}, +{"fjugt", one(0xF08A), one(0xF1FF), "IdBc"}, +{"fjule", one(0xF08D), one(0xF1FF), "IdBc"}, +{"fjult", one(0xF08C), one(0xF1FF), "IdBc"}, +{"fjun", one(0xF088), one(0xF1FF), "IdBc"}, + +/* The assembler will ignore attempts to force a short offset */ + +{"bhis", one(0061000), one(0177400), "Bg"}, +{"blss", one(0061400), one(0177400), "Bg"}, +{"bccs", one(0062000), one(0177400), "Bg"}, +{"bcss", one(0062400), one(0177400), "Bg"}, +{"bnes", one(0063000), one(0177400), "Bg"}, +{"beqs", one(0063400), one(0177400), "Bg"}, +{"bvcs", one(0064000), one(0177400), "Bg"}, +{"bvss", one(0064400), one(0177400), "Bg"}, +{"bpls", one(0065000), one(0177400), "Bg"}, +{"bmis", one(0065400), one(0177400), "Bg"}, +{"bges", one(0066000), one(0177400), "Bg"}, +{"blts", one(0066400), one(0177400), "Bg"}, +{"bgts", one(0067000), one(0177400), "Bg"}, +{"bles", one(0067400), one(0177400), "Bg"}, + +/* Alternate mnemonics for SUN */ + +{"jbsr", one(0060400), one(0177400), "Bg"}, +{"jbsr", one(0047200), one(0177700), "!s"}, +{"jra", one(0060000), one(0177400), "Bg"}, +{"jra", one(0047300), one(0177700), "!s"}, + +{"jhi", one(0061000), one(0177400), "Bg"}, +{"jls", one(0061400), one(0177400), "Bg"}, +{"jcc", one(0062000), one(0177400), "Bg"}, +{"jcs", one(0062400), one(0177400), "Bg"}, +{"jne", one(0063000), one(0177400), "Bg"}, +{"jeq", one(0063400), one(0177400), "Bg"}, +{"jvc", one(0064000), one(0177400), "Bg"}, +{"jvs", one(0064400), one(0177400), "Bg"}, +{"jpl", one(0065000), one(0177400), "Bg"}, +{"jmi", one(0065400), one(0177400), "Bg"}, +{"jge", one(0066000), one(0177400), "Bg"}, +{"jlt", one(0066400), one(0177400), "Bg"}, +{"jgt", one(0067000), one(0177400), "Bg"}, +{"jle", one(0067400), one(0177400), "Bg"}, + +/* Short offsets are ignored */ + +{"jbsrs", one(0060400), one(0177400), "Bg"}, +{"jras", one(0060000), one(0177400), "Bg"}, +{"jhis", one(0061000), one(0177400), "Bg"}, +{"jlss", one(0061400), one(0177400), "Bg"}, +{"jccs", one(0062000), one(0177400), "Bg"}, +{"jcss", one(0062400), one(0177400), "Bg"}, +{"jnes", one(0063000), one(0177400), "Bg"}, +{"jeqs", one(0063400), one(0177400), "Bg"}, +{"jvcs", one(0064000), one(0177400), "Bg"}, +{"jvss", one(0064400), one(0177400), "Bg"}, +{"jpls", one(0065000), one(0177400), "Bg"}, +{"jmis", one(0065400), one(0177400), "Bg"}, +{"jges", one(0066000), one(0177400), "Bg"}, +{"jlts", one(0066400), one(0177400), "Bg"}, +{"jgts", one(0067000), one(0177400), "Bg"}, +{"jles", one(0067400), one(0177400), "Bg"}, + +{"movql", one(0070000), one(0170400), "MsDd"}, +{"moveql", one(0070000), one(0170400), "MsDd"}, +{"moval", one(0020100), one(0170700), "*lAd"}, +{"movaw", one(0030100), one(0170700), "*wAd"}, +{"movb", one(0010000), one(0170000), ";b$d"}, /* mov */ +{"movl", one(0070000), one(0170400), "MsDd"}, /* movq written as mov */ +{"movl", one(0020000), one(0170000), "*l$d"}, +{"movl", one(0020100), one(0170700), "*lAd"}, +{"movl", one(0047140), one(0177770), "AsUd"}, /* mov to USP */ +{"movl", one(0047150), one(0177770), "UdAs"}, /* mov from USP */ +{"movc", one(0047173), one(0177777), "R1Jj"}, +{"movc", one(0047173), one(0177777), "R1#j"}, +{"movc", one(0047172), one(0177777), "JjR1"}, +{"movc", one(0047172), one(0177777), "#jR1"}, +{"movml", one(0044300), one(0177700), "#w&s"}, /* movm reg to mem. */ +{"movml", one(0044340), one(0177770), "#w-s"}, /* movm reg to autodecrement. */ +{"movml", one(0046300), one(0177700), "!s#w"}, /* movm mem to reg. */ +{"movml", one(0046330), one(0177770), "+s#w"}, /* movm autoinc to reg. */ +{"movml", one(0044300), one(0177700), "Lw&s"}, /* movm reg to mem. */ +{"movml", one(0044340), one(0177770), "lw-s"}, /* movm reg to autodecrement. */ +{"movml", one(0046300), one(0177700), "!sLw"}, /* movm mem to reg. */ +{"movml", one(0046330), one(0177770), "+sLw"}, /* movm autoinc to reg. */ +{"movmw", one(0044200), one(0177700), "#w&s"}, /* movm reg to mem. */ +{"movmw", one(0044240), one(0177770), "#w-s"}, /* movm reg to autodecrement. */ +{"movmw", one(0046200), one(0177700), "!s#w"}, /* movm mem to reg. */ +{"movmw", one(0046230), one(0177770), "+s#w"}, /* movm autoinc to reg. */ +{"movmw", one(0044200), one(0177700), "Lw&s"}, /* movm reg to mem. */ +{"movmw", one(0044240), one(0177770), "lw-s"}, /* movm reg to autodecrement. */ +{"movmw", one(0046200), one(0177700), "!sLw"}, /* movm mem to reg. */ +{"movmw", one(0046230), one(0177770), "+sLw"}, /* movm autoinc to reg. */ +{"movpl", one(0000510), one(0170770), "dsDd"}, /* memory to register */ +{"movpl", one(0000710), one(0170770), "Ddds"}, /* register to memory */ +{"movpw", one(0000410), one(0170770), "dsDd"}, /* memory to register */ +{"movpw", one(0000610), one(0170770), "Ddds"}, /* register to memory */ +{"movq", one(0070000), one(0170400), "MsDd"}, +{"movw", one(0030000), one(0170000), "*w$d"}, +{"movw", one(0030100), one(0170700), "*wAd"}, /* mova, written as mov */ +{"movw", one(0040300), one(0177700), "Ss$s"}, /* Move from sr */ +{"movw", one(0041300), one(0177700), "Cs$s"}, /* Move from ccr */ +{"movw", one(0042300), one(0177700), ";wCd"}, /* mov to ccr */ +{"movw", one(0043300), one(0177700), ";wSd"}, /* mov to sr */ + +{"movsb", two(0007000, 0), two(0177700, 07777), "~sR1"}, +{"movsb", two(0007000, 04000), two(0177700, 07777), "R1~s"}, +{"movsl", two(0007200, 0), two(0177700, 07777), "~sR1"}, +{"movsl", two(0007200, 04000), two(0177700, 07777), "R1~s"}, +{"movsw", two(0007100, 0), two(0177700, 07777), "~sR1"}, +{"movsw", two(0007100, 04000), two(0177700, 07777), "R1~s"}, + +#ifdef m68851 + /* name */ /* opcode */ /* match */ /* args */ + +{"pbac", one(0xf0c7), one(0xffbf), "Bc"}, +{"pbacw", one(0xf087), one(0xffbf), "Bc"}, +{"pbas", one(0xf0c6), one(0xffbf), "Bc"}, +{"pbasw", one(0xf086), one(0xffbf), "Bc"}, +{"pbbc", one(0xf0c1), one(0xffbf), "Bc"}, +{"pbbcw", one(0xf081), one(0xffbf), "Bc"}, +{"pbbs", one(0xf0c0), one(0xffbf), "Bc"}, +{"pbbsw", one(0xf080), one(0xffbf), "Bc"}, +{"pbcc", one(0xf0cf), one(0xffbf), "Bc"}, +{"pbccw", one(0xf08f), one(0xffbf), "Bc"}, +{"pbcs", one(0xf0ce), one(0xffbf), "Bc"}, +{"pbcsw", one(0xf08e), one(0xffbf), "Bc"}, +{"pbgc", one(0xf0cd), one(0xffbf), "Bc"}, +{"pbgcw", one(0xf08d), one(0xffbf), "Bc"}, +{"pbgs", one(0xf0cc), one(0xffbf), "Bc"}, +{"pbgsw", one(0xf08c), one(0xffbf), "Bc"}, +{"pbic", one(0xf0cb), one(0xffbf), "Bc"}, +{"pbicw", one(0xf08b), one(0xffbf), "Bc"}, +{"pbis", one(0xf0ca), one(0xffbf), "Bc"}, +{"pbisw", one(0xf08a), one(0xffbf), "Bc"}, +{"pblc", one(0xf0c3), one(0xffbf), "Bc"}, +{"pblcw", one(0xf083), one(0xffbf), "Bc"}, +{"pbls", one(0xf0c2), one(0xffbf), "Bc"}, +{"pblsw", one(0xf082), one(0xffbf), "Bc"}, +{"pbsc", one(0xf0c5), one(0xffbf), "Bc"}, +{"pbscw", one(0xf085), one(0xffbf), "Bc"}, +{"pbss", one(0xf0c4), one(0xffbf), "Bc"}, +{"pbssw", one(0xf084), one(0xffbf), "Bc"}, +{"pbwc", one(0xf0c9), one(0xffbf), "Bc"}, +{"pbwcw", one(0xf089), one(0xffbf), "Bc"}, +{"pbws", one(0xf0c8), one(0xffbf), "Bc"}, +{"pbwsw", one(0xf088), one(0xffbf), "Bc"}, + + +{"pdbac", two(0xf048, 0x0007), two(0xfff8, 0xffff), "DsBw"}, +{"pdbas", two(0xf048, 0x0006), two(0xfff8, 0xffff), "DsBw"}, +{"pdbbc", two(0xf048, 0x0001), two(0xfff8, 0xffff), "DsBw"}, +{"pdbbs", two(0xf048, 0x0000), two(0xfff8, 0xffff), "DsBw"}, +{"pdbcc", two(0xf048, 0x000f), two(0xfff8, 0xffff), "DsBw"}, +{"pdbcs", two(0xf048, 0x000e), two(0xfff8, 0xffff), "DsBw"}, +{"pdbgc", two(0xf048, 0x000d), two(0xfff8, 0xffff), "DsBw"}, +{"pdbgs", two(0xf048, 0x000c), two(0xfff8, 0xffff), "DsBw"}, +{"pdbic", two(0xf048, 0x000b), two(0xfff8, 0xffff), "DsBw"}, +{"pdbis", two(0xf048, 0x000a), two(0xfff8, 0xffff), "DsBw"}, +{"pdblc", two(0xf048, 0x0003), two(0xfff8, 0xffff), "DsBw"}, +{"pdbls", two(0xf048, 0x0002), two(0xfff8, 0xffff), "DsBw"}, +{"pdbsc", two(0xf048, 0x0005), two(0xfff8, 0xffff), "DsBw"}, +{"pdbss", two(0xf048, 0x0004), two(0xfff8, 0xffff), "DsBw"}, +{"pdbwc", two(0xf048, 0x0009), two(0xfff8, 0xffff), "DsBw"}, +{"pdbws", two(0xf048, 0x0008), two(0xfff8, 0xffff), "DsBw"}, + +{"pflusha", two(0xf000, 0x2400), two(0xffff, 0xffff), "" }, + +{"pflush", two(0xf000, 0x3010), two(0xffc0, 0xfe10), "T3T9" }, +{"pflush", two(0xf000, 0x3810), two(0xffc0, 0xfe10), "T3T9&s" }, +{"pflush", two(0xf000, 0x3008), two(0xffc0, 0xfe18), "D3T9" }, +{"pflush", two(0xf000, 0x3808), two(0xffc0, 0xfe18), "D3T9&s" }, +{"pflush", two(0xf000, 0x3000), two(0xffc0, 0xfe1e), "f3T9" }, +{"pflush", two(0xf000, 0x3800), two(0xffc0, 0xfe1e), "f3T9&s" }, + +{"pflushs", two(0xf000, 0x3410), two(0xfff8, 0xfe10), "T3T9" }, +{"pflushs", two(0xf000, 0x3c00), two(0xfff8, 0xfe00), "T3T9&s" }, +{"pflushs", two(0xf000, 0x3408), two(0xfff8, 0xfe18), "D3T9" }, +{"pflushs", two(0xf000, 0x3c08), two(0xfff8, 0xfe18), "D3T9&s" }, +{"pflushs", two(0xf000, 0x3400), two(0xfff8, 0xfe1e), "f3T9" }, +{"pflushs", two(0xf000, 0x3c00), two(0xfff8, 0xfe1e), "f3T9&s"}, + +{"pflushr", two(0xf000, 0xa000), two(0xffc0, 0xffff), "|s" }, + +{"ploadr", two(0xf000, 0x2210), two(0xffc0, 0xfff0), "T3&s" }, +{"ploadr", two(0xf000, 0x2208), two(0xffc0, 0xfff8), "D3&s" }, +{"ploadr", two(0xf000, 0x2200), two(0xffc0, 0xfffe), "f3&s" }, +{"ploadw", two(0xf000, 0x2010), two(0xffc0, 0xfff0), "T3&s" }, +{"ploadw", two(0xf000, 0x2008), two(0xffc0, 0xfff8), "D3&s" }, +{"ploadw", two(0xf000, 0x2000), two(0xffc0, 0xfffe), "f3&s" }, + +/* TC, CRP, DRP, SRP, CAL, VAL, SCC, AC */ +{"pmove", two(0xf000, 0x4000), two(0xffc0, 0xe3ff), "*sP8" }, +{"pmove", two(0xf000, 0x4200), two(0xffc0, 0xe3ff), "P8%s" }, +{"pmove", two(0xf000, 0x4000), two(0xffc0, 0xe3ff), "|sW8" }, +{"pmove", two(0xf000, 0x4200), two(0xffc0, 0xe3ff), "W8~s" }, + +/* BADx, BACx */ +{"pmove", two(0xf000, 0x6200), two(0xffc0, 0xe3e3), "*sX3" }, +{"pmove", two(0xf000, 0x6000), two(0xffc0, 0xe3e3), "X3%s" }, + +/* PSR, PCSR */ +/* {"pmove", two(0xf000, 0x6100), two(oxffc0, oxffff), "*sZ8" }, */ +{"pmove", two(0xf000, 0x6000), two(0xffc0, 0xffff), "*sY8" }, +{"pmove", two(0xf000, 0x6200), two(0xffc0, 0xffff), "Y8%s" }, +{"pmove", two(0xf000, 0x6600), two(0xffc0, 0xffff), "Z8%s" }, + +{"prestore", one(0xf140), one(0xffc0), "&s"}, +{"prestore", one(0xf158), one(0xfff8), "+s"}, +{"psave", one(0xf100), one(0xffc0), "&s"}, +{"psave", one(0xf100), one(0xffc0), "+s"}, + +{"psac", two(0xf040, 0x0007), two(0xffc0, 0xffff), "@s"}, +{"psas", two(0xf040, 0x0006), two(0xffc0, 0xffff), "@s"}, +{"psbc", two(0xf040, 0x0001), two(0xffc0, 0xffff), "@s"}, +{"psbs", two(0xf040, 0x0000), two(0xffc0, 0xffff), "@s"}, +{"pscc", two(0xf040, 0x000f), two(0xffc0, 0xffff), "@s"}, +{"pscs", two(0xf040, 0x000e), two(0xffc0, 0xffff), "@s"}, +{"psgc", two(0xf040, 0x000d), two(0xffc0, 0xffff), "@s"}, +{"psgs", two(0xf040, 0x000c), two(0xffc0, 0xffff), "@s"}, +{"psic", two(0xf040, 0x000b), two(0xffc0, 0xffff), "@s"}, +{"psis", two(0xf040, 0x000a), two(0xffc0, 0xffff), "@s"}, +{"pslc", two(0xf040, 0x0003), two(0xffc0, 0xffff), "@s"}, +{"psls", two(0xf040, 0x0002), two(0xffc0, 0xffff), "@s"}, +{"pssc", two(0xf040, 0x0005), two(0xffc0, 0xffff), "@s"}, +{"psss", two(0xf040, 0x0004), two(0xffc0, 0xffff), "@s"}, +{"pswc", two(0xf040, 0x0009), two(0xffc0, 0xffff), "@s"}, +{"psws", two(0xf040, 0x0008), two(0xffc0, 0xffff), "@s"}, + +{"ptestr", two(0xf000, 0x8210), two(0xffc0, 0xe3f0), "T3&sQ8" }, +{"ptestr", two(0xf000, 0x8310), two(0xffc0, 0xe310), "T3&sQ8A9" }, +{"ptestr", two(0xf000, 0x8208), two(0xffc0, 0xe3f8), "D3&sQ8" }, +{"ptestr", two(0xf000, 0x8308), two(0xffc0, 0xe318), "D3&sQ8A9" }, +{"ptestr", two(0xf000, 0x8200), two(0xffc0, 0xe3fe), "f3&sQ8" }, +{"ptestr", two(0xf000, 0x8300), two(0xffc0, 0xe31e), "f3&sQ8A9" }, + +{"ptestw", two(0xf000, 0x8010), two(0xffc0, 0xe3f0), "T3&sQ8" }, +{"ptestw", two(0xf000, 0x8110), two(0xffc0, 0xe310), "T3&sQ8A9" }, +{"ptestw", two(0xf000, 0x8008), two(0xffc0, 0xe3f8), "D3&sQ8" }, +{"ptestw", two(0xf000, 0x8108), two(0xffc0, 0xe318), "D3&sQ8A9" }, +{"ptestw", two(0xf000, 0x8000), two(0xffc0, 0xe3fe), "f3&sQ8" }, +{"ptestw", two(0xf000, 0x8100), two(0xffc0, 0xe31e), "f3&sQ8A9" }, + +{"ptrapacw", two(0xf07a, 0x0007), two(0xffff, 0xffff), "#w"}, +{"ptrapacl", two(0xf07b, 0x0007), two(0xffff, 0xffff), "#l"}, +{"ptrapac", two(0xf07c, 0x0007), two(0xffff, 0xffff), ""}, + +{"ptrapasw", two(0xf07a, 0x0006), two(0xffff, 0xffff), "#w"}, +{"ptrapasl", two(0xf07b, 0x0006), two(0xffff, 0xffff), "#l"}, +{"ptrapas", two(0xf07c, 0x0006), two(0xffff, 0xffff), ""}, + +{"ptrapbcw", two(0xf07a, 0x0001), two(0xffff, 0xffff), "#w"}, +{"ptrapbcl", two(0xf07b, 0x0001), two(0xffff, 0xffff), "#l"}, +{"ptrapbc", two(0xf07c, 0x0001), two(0xffff, 0xffff), ""}, + +{"ptrapbsw", two(0xf07a, 0x0000), two(0xffff, 0xffff), "#w"}, +{"ptrapbsl", two(0xf07b, 0x0000), two(0xffff, 0xffff), "#l"}, +{"ptrapbs", two(0xf07c, 0x0000), two(0xffff, 0xffff), ""}, + +{"ptrapccw", two(0xf07a, 0x000f), two(0xffff, 0xffff), "#w"}, +{"ptrapccl", two(0xf07b, 0x000f), two(0xffff, 0xffff), "#l"}, +{"ptrapcc", two(0xf07c, 0x000f), two(0xffff, 0xffff), ""}, + +{"ptrapcsw", two(0xf07a, 0x000e), two(0xffff, 0xffff), "#w"}, +{"ptrapcsl", two(0xf07b, 0x000e), two(0xffff, 0xffff), "#l"}, +{"ptrapcs", two(0xf07c, 0x000e), two(0xffff, 0xffff), ""}, + +{"ptrapgcw", two(0xf07a, 0x000d), two(0xffff, 0xffff), "#w"}, +{"ptrapgcl", two(0xf07b, 0x000d), two(0xffff, 0xffff), "#l"}, +{"ptrapgc", two(0xf07c, 0x000d), two(0xffff, 0xffff), ""}, + +{"ptrapgsw", two(0xf07a, 0x000c), two(0xffff, 0xffff), "#w"}, +{"ptrapgsl", two(0xf07b, 0x000c), two(0xffff, 0xffff), "#l"}, +{"ptrapgs", two(0xf07c, 0x000c), two(0xffff, 0xffff), ""}, + +{"ptrapicw", two(0xf07a, 0x000b), two(0xffff, 0xffff), "#w"}, +{"ptrapicl", two(0xf07b, 0x000b), two(0xffff, 0xffff), "#l"}, +{"ptrapic", two(0xf07c, 0x000b), two(0xffff, 0xffff), ""}, + +{"ptrapisw", two(0xf07a, 0x000a), two(0xffff, 0xffff), "#w"}, +{"ptrapisl", two(0xf07b, 0x000a), two(0xffff, 0xffff), "#l"}, +{"ptrapis", two(0xf07c, 0x000a), two(0xffff, 0xffff), ""}, + +{"ptraplcw", two(0xf07a, 0x0003), two(0xffff, 0xffff), "#w"}, +{"ptraplcl", two(0xf07b, 0x0003), two(0xffff, 0xffff), "#l"}, +{"ptraplc", two(0xf07c, 0x0003), two(0xffff, 0xffff), ""}, + +{"ptraplsw", two(0xf07a, 0x0002), two(0xffff, 0xffff), "#w"}, +{"ptraplsl", two(0xf07b, 0x0002), two(0xffff, 0xffff), "#l"}, +{"ptrapls", two(0xf07c, 0x0002), two(0xffff, 0xffff), ""}, + +{"ptrapscw", two(0xf07a, 0x0005), two(0xffff, 0xffff), "#w"}, +{"ptrapscl", two(0xf07b, 0x0005), two(0xffff, 0xffff), "#l"}, +{"ptrapsc", two(0xf07c, 0x0005), two(0xffff, 0xffff), ""}, + +{"ptrapssw", two(0xf07a, 0x0004), two(0xffff, 0xffff), "#w"}, +{"ptrapssl", two(0xf07b, 0x0004), two(0xffff, 0xffff), "#l"}, +{"ptrapss", two(0xf07c, 0x0004), two(0xffff, 0xffff), ""}, + +{"ptrapwcw", two(0xf07a, 0x0009), two(0xffff, 0xffff), "#w"}, +{"ptrapwcl", two(0xf07b, 0x0009), two(0xffff, 0xffff), "#l"}, +{"ptrapwc", two(0xf07c, 0x0009), two(0xffff, 0xffff), ""}, + +{"ptrapwsw", two(0xf07a, 0x0008), two(0xffff, 0xffff), "#w"}, +{"ptrapwsl", two(0xf07b, 0x0008), two(0xffff, 0xffff), "#l"}, +{"ptrapws", two(0xf07c, 0x0008), two(0xffff, 0xffff), ""}, + +{"pvalid", two(0xf000, 0x2800), two(0xffc0, 0xffff), "Vs&s"}, +{"pvalid", two(0xf000, 0x2c00), two(0xffc0, 0xfff8), "A3&s" }, + +#endif /* m68851 */ + +}; + +int numopcodes=sizeof(m68k_opcodes)/sizeof(m68k_opcodes[0]); + +struct m68k_opcode *endop = m68k_opcodes+sizeof(m68k_opcodes)/sizeof(m68k_opcodes[0]); diff --git a/gdb/m68k-pinsn.c b/gdb/m68k-pinsn.c new file mode 100644 index 0000000..608bc25 --- /dev/null +++ b/gdb/m68k-pinsn.c @@ -0,0 +1,774 @@ +/* Print m68k instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "m68k-opcode.h" +#include "gdbcore.h" + +/* 68k instructions are never longer than this many bytes. */ +#define MAXLEN 22 + +/* Number of elements in the opcode table. */ +#define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0]) + +extern char *reg_names[]; +char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr", + "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"}; + +static unsigned char *print_insn_arg (); +static unsigned char *print_indexed (); +static void print_base (); +static int fetch_arg (); + +#define NEXTBYTE(p) (p += 2, ((char *)p)[-1]) + +#define NEXTWORD(p) \ + (p += 2, ((((char *)p)[-2]) << 8) + p[-1]) + +#define NEXTLONG(p) \ + (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1]) + +#define NEXTSINGLE(p) \ + (p += 4, *((float *)(p - 4))) + +#define NEXTDOUBLE(p) \ + (p += 8, *((double *)(p - 8))) + +#define NEXTEXTEND(p) \ + (p += 12, 0.0) /* Need a function to convert from extended to double + precision... */ + +#define NEXTPACKED(p) \ + (p += 12, 0.0) /* Need a function to convert from packed to double + precision. Actually, it's easier to print a + packed number than a double anyway, so maybe + there should be a special case to handle this... */ + +/* Print the m68k instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i; + register unsigned char *p; + register char *d; + register int bestmask; + int best; + + read_memory (memaddr, buffer, MAXLEN); + + bestmask = 0; + best = -1; + for (i = 0; i < NOPCODES; i++) + { + register unsigned int opcode = m68k_opcodes[i].opcode; + register unsigned int match = m68k_opcodes[i].match; + if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24))) + && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16))) + && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8))) + && ((0xff & buffer[3] & match) == (0xff & opcode))) + { + /* Don't use for printout the variants of divul and divsl + that have the same register number in two places. + The more general variants will match instead. */ + for (d = m68k_opcodes[i].args; *d; d += 2) + if (d[1] == 'D') + break; + + /* Don't use for printout the variants of most floating + point coprocessor instructions which use the same + register number in two places, as above. */ + if (*d == 0) + for (d = m68k_opcodes[i].args; *d; d += 2) + if (d[1] == 't') + break; + + if (*d == 0 && match > bestmask) + { + best = i; + bestmask = match; + } + } + } + + /* Handle undefined instructions. */ + if (best < 0) + { + fprintf_filtered (stream, "0%o", (buffer[0] << 8) + buffer[1]); + return 2; + } + + fprintf_filtered (stream, "%s", m68k_opcodes[best].name); + + /* Point at first word of argument data, + and at descriptor for first argument. */ + p = buffer + 2; + + /* Why do this this way? -MelloN */ + for (d = m68k_opcodes[best].args; *d; d += 2) + { + if (d[0] == '#') + { + if (d[1] == 'l' && p - buffer < 6) + p = buffer + 6; + else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' ) + p = buffer + 4; + } + if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4) + p = buffer + 4; + if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6) + p = buffer + 6; + if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4) + p = buffer + 4; + } + + d = m68k_opcodes[best].args; + + if (*d) + fputs_filtered (" ", stream); + + while (*d) + { + p = print_insn_arg (d, buffer, p, memaddr + p - buffer, stream); + d += 2; + if (*d && *(d - 2) != 'I' && *d != 'k') + fputs_filtered (",", stream); + } + return p - buffer; +} + +static unsigned char * +print_insn_arg (d, buffer, p, addr, stream) + char *d; + unsigned char *buffer; + register unsigned char *p; + CORE_ADDR addr; /* PC for this arg to be relative to */ + FILE *stream; +{ + register int val; + register int place = d[1]; + int regno; + register char *regname; + register unsigned char *p1; + register double flval; + int flt_p; + + switch (*d) + { + case 'C': + fprintf_filtered (stream, "ccr"); + break; + + case 'S': + fprintf_filtered (stream, "sr"); + break; + + case 'U': + fprintf_filtered (stream, "usp"); + break; + + case 'J': + { + static struct { char *name; int value; } names[] + = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002}, + {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802}, + {"msp", 0x803}, {"isp", 0x804}}; + + val = fetch_arg (buffer, place, 12); + for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--) + if (names[regno].value == val) + { + fprintf_filtered (stream, names[regno].name); + break; + } + if (regno < 0) + fprintf_filtered (stream, "%d", val); + } + break; + + case 'Q': + val = fetch_arg (buffer, place, 3); + /* 0 means 8, except for the bkpt instruction... */ + if (val == 0 && d[1] != 's') + val = 8; + fprintf_filtered (stream, "#%d", val); + break; + + case 'M': + val = fetch_arg (buffer, place, 8); + if (val & 0x80) + val = val - 0x100; + fprintf_filtered (stream, "#%d", val); + break; + + case 'T': + val = fetch_arg (buffer, place, 4); + fprintf_filtered (stream, "#%d", val); + break; + + case 'D': + fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]); + break; + + case 'A': + fprintf_filtered (stream, "%s", + reg_names[fetch_arg (buffer, place, 3) + 010]); + break; + + case 'R': + fprintf_filtered (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]); + break; + + case 'F': + fprintf_filtered (stream, "fp%d", fetch_arg (buffer, place, 3)); + break; + + case 'O': + val = fetch_arg (buffer, place, 6); + if (val & 0x20) + fprintf_filtered (stream, "%s", reg_names [val & 7]); + else + fprintf_filtered (stream, "%d", val); + break; + + case '+': + fprintf_filtered (stream, "%s@+", + reg_names[fetch_arg (buffer, place, 3) + 8]); + break; + + case '-': + fprintf_filtered (stream, "%s@-", + reg_names[fetch_arg (buffer, place, 3) + 8]); + break; + + case 'k': + if (place == 'k') + fprintf_filtered (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]); + else if (place == 'C') + { + val = fetch_arg (buffer, place, 7); + if ( val > 63 ) /* This is a signed constant. */ + val -= 128; + fprintf_filtered (stream, "{#%d}", val); + } + else + error ("Invalid arg format in opcode table: \"%c%c\".", + *d, place); + break; + + case '#': + case '^': + p1 = buffer + (*d == '#' ? 2 : 4); + if (place == 's') + val = fetch_arg (buffer, place, 4); + else if (place == 'C') + val = fetch_arg (buffer, place, 7); + else if (place == '8') + val = fetch_arg (buffer, place, 3); + else if (place == '3') + val = fetch_arg (buffer, place, 8); + else if (place == 'b') + val = NEXTBYTE (p1); + else if (place == 'w') + val = NEXTWORD (p1); + else if (place == 'l') + val = NEXTLONG (p1); + else + error ("Invalid arg format in opcode table: \"%c%c\".", + *d, place); + fprintf_filtered (stream, "#%d", val); + break; + + case 'B': + if (place == 'b') + val = NEXTBYTE (p); + else if (place == 'w') + val = NEXTWORD (p); + else if (place == 'l') + val = NEXTLONG (p); + else if (place == 'g') + { + val = ((char *)buffer)[1]; + if (val == 0) + val = NEXTWORD (p); + else if (val == -1) + val = NEXTLONG (p); + } + else if (place == 'c') + { + if (buffer[1] & 0x40) /* If bit six is one, long offset */ + val = NEXTLONG (p); + else + val = NEXTWORD (p); + } + else + error ("Invalid arg format in opcode table: \"%c%c\".", + *d, place); + + print_address (addr + val, stream); + break; + + case 'd': + val = NEXTWORD (p); + fprintf_filtered (stream, "%s@(%d)", + reg_names[fetch_arg (buffer, place, 3)], val); + break; + + case 's': + fprintf_filtered (stream, "%s", + fpcr_names[fetch_arg (buffer, place, 3)]); + break; + + case 'I': + val = fetch_arg (buffer, 'd', 3); /* Get coprocessor ID... */ + if (val != 1) /* Unusual coprocessor ID? */ + fprintf_filtered (stream, "(cpid=%d) ", val); + if (place == 'i') + p += 2; /* Skip coprocessor extended operands */ + break; + + case '*': + case '~': + case '%': + case ';': + case '@': + case '!': + case '$': + case '?': + case '/': + case '&': + + if (place == 'd') + { + val = fetch_arg (buffer, 'x', 6); + val = ((val & 7) << 3) + ((val >> 3) & 7); + } + else + val = fetch_arg (buffer, 's', 6); + + /* Get register number assuming address register. */ + regno = (val & 7) + 8; + regname = reg_names[regno]; + switch (val >> 3) + { + case 0: + fprintf_filtered (stream, "%s", reg_names[val]); + break; + + case 1: + fprintf_filtered (stream, "%s", regname); + break; + + case 2: + fprintf_filtered (stream, "%s@", regname); + break; + + case 3: + fprintf_filtered (stream, "%s@+", regname); + break; + + case 4: + fprintf_filtered (stream, "%s@-", regname); + break; + + case 5: + val = NEXTWORD (p); + fprintf_filtered (stream, "%s@(%d)", regname, val); + break; + + case 6: + p = print_indexed (regno, p, addr, stream); + break; + + case 7: + switch (val & 7) + { + case 0: + val = NEXTWORD (p); + fprintf_filtered (stream, "@#"); + print_address (val, stream); + break; + + case 1: + val = NEXTLONG (p); + fprintf_filtered (stream, "@#"); + print_address (val, stream); + break; + + case 2: + val = NEXTWORD (p); + print_address (addr + val, stream); + break; + + case 3: + p = print_indexed (-1, p, addr, stream); + break; + + case 4: + flt_p = 1; /* Assume it's a float... */ + switch( place ) + { + case 'b': + val = NEXTBYTE (p); + flt_p = 0; + break; + + case 'w': + val = NEXTWORD (p); + flt_p = 0; + break; + + case 'l': + val = NEXTLONG (p); + flt_p = 0; + break; + + case 'f': + flval = NEXTSINGLE(p); + break; + + case 'F': + flval = NEXTDOUBLE(p); + break; + + case 'x': + flval = NEXTEXTEND(p); + break; + + case 'p': + flval = NEXTPACKED(p); + break; + + default: + error ("Invalid arg format in opcode table: \"%c%c\".", + *d, place); + } + if ( flt_p ) /* Print a float? */ + fprintf_filtered (stream, "#%g", flval); + else + fprintf_filtered (stream, "#%d", val); + break; + + default: + fprintf_filtered (stream, "<invalid address mode 0%o>", val); + } + } + break; + + case 'L': + case 'l': + if (place == 'w') + { + char doneany; + p1 = buffer + 2; + val = NEXTWORD (p1); + /* Move the pointer ahead if this point is farther ahead + than the last. */ + p = p1 > p ? p1 : p; + if (val == 0) + { + fputs_filtered ("#0", stream); + break; + } + if (*d == 'l') + { + register int newval = 0; + for (regno = 0; regno < 16; ++regno) + if (val & (0x8000 >> regno)) + newval |= 1 << regno; + val = newval; + } + val &= 0xffff; + doneany = 0; + for (regno = 0; regno < 16; ++regno) + if (val & (1 << regno)) + { + int first_regno; + if (doneany) + fputs_filtered ("/", stream); + doneany = 1; + fprintf_filtered (stream, "%s", reg_names[regno]); + first_regno = regno; + while (val & (1 << (regno + 1))) + ++regno; + if (regno > first_regno) + fprintf_filtered (stream, "-%s", reg_names[regno]); + } + } + else if (place == '3') + { + /* `fmovem' insn. */ + char doneany; + val = fetch_arg (buffer, place, 8); + if (val == 0) + { + fputs_filtered ("#0", stream); + break; + } + if (*d == 'l') + { + register int newval = 0; + for (regno = 0; regno < 8; ++regno) + if (val & (0x80 >> regno)) + newval |= 1 << regno; + val = newval; + } + val &= 0xff; + doneany = 0; + for (regno = 0; regno < 8; ++regno) + if (val & (1 << regno)) + { + int first_regno; + if (doneany) + fputs_filtered ("/", stream); + doneany = 1; + fprintf_filtered (stream, "fp%d", regno); + first_regno = regno; + while (val & (1 << (regno + 1))) + ++regno; + if (regno > first_regno) + fprintf_filtered (stream, "-fp%d", regno); + } + } + else + abort (); + break; + + default: + error ("Invalid arg format in opcode table: \"%c\".", *d); + } + + return (unsigned char *) p; +} + +/* Fetch BITS bits from a position in the instruction specified by CODE. + CODE is a "place to put an argument", or 'x' for a destination + that is a general address (mode and register). + BUFFER contains the instruction. */ + +static int +fetch_arg (buffer, code, bits) + unsigned char *buffer; + char code; + int bits; +{ + register int val; + switch (code) + { + case 's': + val = buffer[1]; + break; + + case 'd': /* Destination, for register or quick. */ + val = (buffer[0] << 8) + buffer[1]; + val >>= 9; + break; + + case 'x': /* Destination, for general arg */ + val = (buffer[0] << 8) + buffer[1]; + val >>= 6; + break; + + case 'k': + val = (buffer[3] >> 4); + break; + + case 'C': + val = buffer[3]; + break; + + case '1': + val = (buffer[2] << 8) + buffer[3]; + val >>= 12; + break; + + case '2': + val = (buffer[2] << 8) + buffer[3]; + val >>= 6; + break; + + case '3': + case 'j': + val = (buffer[2] << 8) + buffer[3]; + break; + + case '4': + val = (buffer[4] << 8) + buffer[5]; + val >>= 12; + break; + + case '5': + val = (buffer[4] << 8) + buffer[5]; + val >>= 6; + break; + + case '6': + val = (buffer[4] << 8) + buffer[5]; + break; + + case '7': + val = (buffer[2] << 8) + buffer[3]; + val >>= 7; + break; + + case '8': + val = (buffer[2] << 8) + buffer[3]; + val >>= 10; + break; + + default: + abort (); + } + + switch (bits) + { + case 3: + return val & 7; + case 4: + return val & 017; + case 5: + return val & 037; + case 6: + return val & 077; + case 7: + return val & 0177; + case 8: + return val & 0377; + case 12: + return val & 07777; + default: + abort (); + } +} + +/* Print an indexed argument. The base register is BASEREG (-1 for pc). + P points to extension word, in buffer. + ADDR is the nominal core address of that extension word. */ + +static unsigned char * +print_indexed (basereg, p, addr, stream) + int basereg; + unsigned char *p; + FILE *stream; + CORE_ADDR addr; +{ + register int word; + static char *scales[] = {"", "*2", "*4", "*8"}; + register int base_disp; + register int outer_disp; + char buf[40]; + + word = NEXTWORD (p); + + /* Generate the text for the index register. + Where this will be output is not yet determined. */ + sprintf (buf, "[%s.%c%s]", + reg_names[(word >> 12) & 0xf], + (word & 0x800) ? 'l' : 'w', + scales[(word >> 9) & 3]); + + /* Handle the 68000 style of indexing. */ + + if ((word & 0x100) == 0) + { + print_base (basereg, + ((word & 0x80) ? word | 0xff00 : word & 0xff) + + ((basereg == -1) ? addr : 0), + stream); + fputs_filtered (buf, stream); + return p; + } + + /* Handle the generalized kind. */ + /* First, compute the displacement to add to the base register. */ + + if (word & 0200) + basereg = -2; + if (word & 0100) + buf[0] = 0; + base_disp = 0; + switch ((word >> 4) & 3) + { + case 2: + base_disp = NEXTWORD (p); + break; + case 3: + base_disp = NEXTLONG (p); + } + if (basereg == -1) + base_disp += addr; + + /* Handle single-level case (not indirect) */ + + if ((word & 7) == 0) + { + print_base (basereg, base_disp, stream); + fputs_filtered (buf, stream); + return p; + } + + /* Two level. Compute displacement to add after indirection. */ + + outer_disp = 0; + switch (word & 3) + { + case 2: + outer_disp = NEXTWORD (p); + break; + case 3: + outer_disp = NEXTLONG (p); + } + + fprintf_filtered (stream, "%d(", outer_disp); + print_base (basereg, base_disp, stream); + + /* If postindexed, print the closeparen before the index. */ + if (word & 4) + fprintf_filtered (stream, ")%s", buf); + /* If preindexed, print the closeparen after the index. */ + else + fprintf_filtered (stream, "%s)", buf); + + return p; +} + +/* Print a base register REGNO and displacement DISP, on STREAM. + REGNO = -1 for pc, -2 for none (suppressed). */ + +static void +print_base (regno, disp, stream) + int regno; + int disp; + FILE *stream; +{ + if (regno == -2) + fprintf_filtered (stream, "%d", disp); + else if (regno == -1) + fprintf_filtered (stream, "0x%x", disp); + else + fprintf_filtered (stream, "%d(%s)", disp, reg_names[regno]); +} diff --git a/gdb/mcheck.c b/gdb/mcheck.c new file mode 100755 index 0000000..8b63d72 --- /dev/null +++ b/gdb/mcheck.c @@ -0,0 +1,119 @@ +/* Standard debugging hooks for `malloc'. + Copyright 1990 Free Software Foundation + Written May 1989 by Mike Haertel. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + The author may be reached (Email) at the address mike@ai.mit.edu, + or (US mail) as Mike Haertel c/o Free Software Foundation. */ + +#include "ansidecl.h" +#include <stdlib.h> +#include "gmalloc.h" + +/* Old hook values. */ +static void EXFUN((*old_free_hook), (PTR ptr)); +static PTR EXFUN((*old_malloc_hook), (size_t size)); +static PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size)); + +/* Function to call when something awful happens. */ +static void EXFUN((*abortfunc), (void)) = abort; + +/* Arbitrary magical numbers. */ +#define MAGICWORD 0xfedabeeb +#define MAGICBYTE ((char) 0xd7) + +struct hdr + { + size_t size; /* Exact size requested by user. */ + unsigned int magic; /* Magic number to check header integrity. */ + }; + +static void +DEFUN(checkhdr, (hdr), CONST struct hdr *hdr) +{ + if (hdr->magic != MAGICWORD || ((char *) &hdr[1])[hdr->size] != MAGICBYTE) + (*abortfunc)(); +} + +static void +DEFUN(freehook, (ptr), PTR ptr) +{ + struct hdr *hdr = ((struct hdr *) ptr) - 1; + checkhdr(hdr); + hdr->magic = 0; + __free_hook = old_free_hook; + free(hdr); + __free_hook = freehook; +} + +static PTR +DEFUN(mallochook, (size), size_t size) +{ + struct hdr *hdr; + + __malloc_hook = old_malloc_hook; + hdr = (struct hdr *) malloc(sizeof(struct hdr) + size + 1); + __malloc_hook = mallochook; + if (hdr == NULL) + return NULL; + + hdr->size = size; + hdr->magic = MAGICWORD; + ((char *) &hdr[1])[size] = MAGICBYTE; + return (PTR) (hdr + 1); +} + +static PTR +DEFUN(reallochook, (ptr, size), PTR ptr AND size_t size) +{ + struct hdr *hdr = ((struct hdr *) ptr) - 1; + + checkhdr(hdr); + __free_hook = old_free_hook; + __malloc_hook = old_malloc_hook; + __realloc_hook = old_realloc_hook; + hdr = (struct hdr *) realloc((PTR) hdr, sizeof(struct hdr) + size + 1); + __free_hook = freehook; + __malloc_hook = mallochook; + __realloc_hook = reallochook; + if (hdr == NULL) + return NULL; + + hdr->size = size; + ((char *) &hdr[1])[size] = MAGICBYTE; + return (PTR) (hdr + 1); +} + +void +DEFUN(mcheck, (func), void EXFUN((*func), (void))) +{ + static int mcheck_used = 0; + + if (func) + abortfunc = func; + + /* These hooks may not be safely inserted if malloc is already in use. */ + if (!__malloc_initialized && !mcheck_used) + { + old_free_hook = __free_hook; + __free_hook = freehook; + old_malloc_hook = __malloc_hook; + __malloc_hook = mallochook; + old_realloc_hook = __realloc_hook; + __realloc_hook = reallochook; + mcheck_used = 1; + } +} diff --git a/gdb/mips-opcode.h b/gdb/mips-opcode.h new file mode 100755 index 0000000..fd92c78 --- /dev/null +++ b/gdb/mips-opcode.h @@ -0,0 +1,363 @@ +/* Mips opcde list for GDB, the GNU debugger. + Copyright (C) 1989 Free Software Foundation, Inc. + Contributed by Nobuyuki Hikichi(hikichi@sra.junet) + Made to work for little-endian machines, and debugged + by Per Bothner (bothner@cs.wisc.edu). + Many fixes contributed by Frank Yellin (fy@lucid.com). + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifdef BITS_BIG_ENDIAN +#define BIT_FIELDS_2(a,b) a;b; +#define BIT_FIELDS_4(a,b,c,d) a;b;c;d; +#define BIT_FIELDS_6(a,b,c,d,e,f) a;b;c;d;e;f; +#else +#define BIT_FIELDS_2(a,b) b;a; +#define BIT_FIELDS_4(a,b,c,d) d;c;b;a; +#define BIT_FIELDS_6(a,b,c,d,e,f) f;e;d;c;b;a; +#endif + +struct op_i_fmt +{ +BIT_FIELDS_4( + unsigned op : 6, + unsigned rs : 5, + unsigned rt : 5, + unsigned immediate : 16) +}; + +struct op_j_fmt +{ +BIT_FIELDS_2( + unsigned op : 6, + unsigned target : 26) +}; + +struct op_r_fmt +{ +BIT_FIELDS_6( + unsigned op : 6, + unsigned rs : 5, + unsigned rt : 5, + unsigned rd : 5, + unsigned shamt : 5, + unsigned funct : 6) +}; + + +struct fop_i_fmt +{ +BIT_FIELDS_4( + unsigned op : 6, + unsigned rs : 5, + unsigned rt : 5, + unsigned immediate : 16) +}; + +struct op_b_fmt +{ +BIT_FIELDS_4( + unsigned op : 6, + unsigned rs : 5, + unsigned rt : 5, + short delta : 16) +}; + +struct fop_r_fmt +{ +BIT_FIELDS_6( + unsigned op : 6, + unsigned fmt : 5, + unsigned ft : 5, + unsigned fs : 5, + unsigned fd : 5, + unsigned funct : 6) +}; + +struct mips_opcode +{ + char *name; + unsigned long opcode; + unsigned long match; + char *args; + int bdelay; /* Nonzero if delayed branch. */ +}; + +/* args format; + + "s" rs: source register specifier + "t" rt: target register + "i" immediate + "a" target address + "c" branch condition + "d" rd: destination register specifier + "h" shamt: shift amount + "f" funct: function field + + for fpu + "S" fs source 1 register + "T" ft source 2 register + "D" distination register +*/ + +#define one(x) (x << 26) +#define op_func(x, y) ((x << 26) | y) +#define op_cond(x, y) ((x << 26) | (y << 16)) +#define op_rs_func(x, y, z) ((x << 26) | (y << 21) | z) +#define op_rs_b11(x, y, z) ((x << 26) | (y << 21) | z) +#define op_o16(x, y) ((x << 26) | (y << 16)) +#define op_bc(x, y, z) ((x << 26) | (y << 21) | (z << 16)) + +struct mips_opcode mips_opcodes[] = +{ +/* These first opcodes are special cases of the ones in the comments */ + {"nop", 0, 0xffffffff, /*li*/ "", 0}, + {"li", op_bc(9,0,0), op_bc(0x3f,31,0), /*addiu*/ "t,j", 0}, + {"b", one(4), 0xffff0000, /*beq*/ "b", 1}, + {"move", op_func(0, 33), op_cond(0x3f,31)|0x7ff,/*addu*/ "d,s", 0}, + + {"sll", op_func(0, 0), op_func(0x3f, 0x3f), "d,t,h", 0}, + {"srl", op_func(0, 2), op_func(0x3f, 0x3f), "d,t,h", 0}, + {"sra", op_func(0, 3), op_func(0x3f, 0x3f), "d,t,h", 0}, + {"sllv", op_func(0, 4), op_func(0x3f, 0x7ff), "d,t,s", 0}, + {"srlv", op_func(0, 6), op_func(0x3f, 0x7ff), "d,t,s", 0}, + {"srav", op_func(0, 7), op_func(0x3f, 0x7ff), "d,t,s", 0}, + {"jr", op_func(0, 8), op_func(0x3f, 0x1fffff), "s", 1}, + {"jalr", op_func(0, 9), op_func(0x3f, 0x1f07ff), "d,s", 1}, + {"syscall", op_func(0, 12), op_func(0x3f, 0x3f), "", 0}, + {"break", op_func(0, 13), op_func(0x3f, 0x3f), "", 0}, + {"mfhi", op_func(0, 16), op_func(0x3f, 0x03ff07ff), "d", 0}, + {"mthi", op_func(0, 17), op_func(0x3f, 0x1fffff), "s", 0}, + {"mflo", op_func(0, 18), op_func(0x3f, 0x03ff07ff), "d", 0}, + {"mtlo", op_func(0, 19), op_func(0x3f, 0x1fffff), "s", 0}, + {"mult", op_func(0, 24), op_func(0x3f, 0xffff), "s,t", 0}, + {"multu", op_func(0, 25), op_func(0x3f, 0xffff), "s,t", 0}, + {"div", op_func(0, 26), op_func(0x3f, 0xffff), "s,t", 0}, + {"divu", op_func(0, 27), op_func(0x3f, 0xffff), "s,t", 0}, + {"add", op_func(0, 32), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"addu", op_func(0, 33), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"sub", op_func(0, 34), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"subu", op_func(0, 35), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"and", op_func(0, 36), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"or", op_func(0, 37), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"xor", op_func(0, 38), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"nor", op_func(0, 39), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"slt", op_func(0, 42), op_func(0x3f, 0x7ff), "d,s,t", 0}, + {"sltu", op_func(0, 43), op_func(0x3f, 0x7ff), "d,s,t", 0}, + + {"bltz", op_cond (1, 0), op_cond(0x3f, 0x1f), "s,b", 1}, + {"bgez", op_cond (1, 1), op_cond(0x3f, 0x1f), "s,b", 1}, + {"bltzal", op_cond (1, 16),op_cond(0x3f, 0x1f), "s,b", 1}, + {"bgezal", op_cond (1, 17),op_cond(0x3f, 0x1f), "s,b", 1}, + + + {"j", one(2), one(0x3f), "a", 1}, + {"jal", one(3), one(0x3f), "a", 1}, + {"beq", one(4), one(0x3f), "s,t,b", 1}, + {"bne", one(5), one(0x3f), "s,t,b", 1}, + {"blez", one(6), one(0x3f) | 0x1f0000, "s,b", 1}, + {"bgtz", one(7), one(0x3f) | 0x1f0000, "s,b", 1}, + {"addi", one(8), one(0x3f), "t,s,j", 0}, + {"addiu", one(9), one(0x3f), "t,s,j", 0}, + {"slti", one(10), one(0x3f), "t,s,j", 0}, + {"sltiu", one(11), one(0x3f), "t,s,j", 0}, + {"andi", one(12), one(0x3f), "t,s,i", 0}, + {"ori", one(13), one(0x3f), "t,s,i", 0}, + {"xori", one(14), one(0x3f), "t,s,i", 0}, + /* rs field is don't care field? */ + {"lui", one(15), one(0x3f), "t,i", 0}, + +/* co processor 0 instruction */ + {"mfc0", op_rs_b11 (16, 0, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"cfc0", op_rs_b11 (16, 2, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"mtc0", op_rs_b11 (16, 4, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"ctc0", op_rs_b11 (16, 6, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + + {"bc0f", op_o16(16, 0x100), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc0f", op_o16(16, 0x180), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc0t", op_o16(16, 0x101), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc0t", op_o16(16, 0x181), op_o16(0x3f, 0x3ff), "b", 1}, + + {"tlbr", op_rs_func(16, 0x10, 1), ~0, "", 0}, + {"tlbwi", op_rs_func(16, 0x10, 2), ~0, "", 0}, + {"tlbwr", op_rs_func(16, 0x10, 6), ~0, "", 0}, + {"tlbp", op_rs_func(16, 0x10, 8), ~0, "", 0}, + {"rfe", op_rs_func(16, 0x10, 16), ~0, "", 0}, + + {"mfc1", op_rs_b11 (17, 0, 0), op_rs_b11(0x3f, 0x1f, 0),"t,S", 0}, + {"cfc1", op_rs_b11 (17, 2, 0), op_rs_b11(0x3f, 0x1f, 0),"t,S", 0}, + {"mtc1", op_rs_b11 (17, 4, 0), op_rs_b11(0x3f, 0x1f, 0),"t,S", 0}, + {"ctc1", op_rs_b11 (17, 6, 0), op_rs_b11(0x3f, 0x1f, 0),"t,S", 0}, + + {"bc1f", op_o16(17, 0x100), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc1f", op_o16(17, 0x180), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc1t", op_o16(17, 0x101), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc1t", op_o16(17, 0x181), op_o16(0x3f, 0x3ff), "b", 1}, + +/* fpu instruction */ + {"add.s", op_rs_func(17, 0x10, 0), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"add.d", op_rs_func(17, 0x11, 0), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"sub.s", op_rs_func(17, 0x10, 1), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"sub.d", op_rs_func(17, 0x11, 1), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"mul.s", op_rs_func(17, 0x10, 2), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"mul.d", op_rs_func(17, 0x11, 2), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"div.s", op_rs_func(17, 0x10, 3), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"div.d", op_rs_func(17, 0x11, 3), + op_rs_func(0x3f, 0x1f, 0x3f), "D,S,T", 0}, + {"abs.s", op_rs_func(17, 0x10, 5), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"abs.d", op_rs_func(17, 0x11, 5), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"mov.s", op_rs_func(17, 0x10, 6), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"mov.d", op_rs_func(17, 0x11, 6), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"neg.s", op_rs_func(17, 0x10, 7), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"neg.d", op_rs_func(17, 0x11, 7), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.s.s", op_rs_func(17, 0x10, 32), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.s.d", op_rs_func(17, 0x11, 32), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.s.w", op_rs_func(17, 0x14, 32), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.d.s", op_rs_func(17, 0x10, 33), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.d.d", op_rs_func(17, 0x11, 33), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.d.w", op_rs_func(17, 0x14, 33), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.w.s", op_rs_func(17, 0x10, 36), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"cvt.w.d", op_rs_func(17, 0x11, 36), + op_rs_func(0x3f, 0x1f, 0x1f003f), "D,S", 0}, + {"c.f.s", op_rs_func(17, 0x10, 48), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.f.d", op_rs_func(17, 0x11, 48), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.un.s", op_rs_func(17, 0x10, 49), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.un.d", op_rs_func(17, 0x11, 49), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.eq.s", op_rs_func(17, 0x10, 50), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.eq.d", op_rs_func(17, 0x11, 50), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ueq.s", op_rs_func(17, 0x10, 51), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ueq.d", op_rs_func(17, 0x11, 51), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.olt.s", op_rs_func(17, 0x10, 52), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.olt.d", op_rs_func(17, 0x11, 52), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ult.s", op_rs_func(17, 0x10, 53), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ult.d", op_rs_func(17, 0x11, 53), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ole.s", op_rs_func(17, 0x10, 54), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ole.d", op_rs_func(17, 0x11, 54), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ule.s", op_rs_func(17, 0x10, 55), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ule.d", op_rs_func(17, 0x11, 55), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.sf.s", op_rs_func(17, 0x10, 56), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.sf.d", op_rs_func(17, 0x11, 56), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngle.s", op_rs_func(17, 0x10, 57), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngle.d", op_rs_func(17, 0x11, 57), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.seq.s", op_rs_func(17, 0x10, 58), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.seq.d", op_rs_func(17, 0x11, 58), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngl.s", op_rs_func(17, 0x10, 59), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngl.d", op_rs_func(17, 0x11, 59), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.lt.s", op_rs_func(17, 0x10, 60), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.lt.d", op_rs_func(17, 0x11, 60), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.nge.s", op_rs_func(17, 0x10, 61), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.nge.d", op_rs_func(17, 0x11, 61), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.le.s", op_rs_func(17, 0x10, 62), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.le.d", op_rs_func(17, 0x11, 62), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngt.s", op_rs_func(17, 0x10, 63), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + {"c.ngt.d", op_rs_func(17, 0x11, 63), + op_rs_func(0x3f, 0x1f, 0x7ff), "S,T", 0}, + +/* co processor 2 instruction */ + {"mfc2", op_rs_b11 (18, 0, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"cfc2", op_rs_b11 (18, 2, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"mtc2", op_rs_b11 (18, 4, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"ctc2", op_rs_b11 (18, 6, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"bc2f", op_o16(18, 0x100), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc2f", op_o16(18, 0x180), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc2f", op_o16(18, 0x101), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc2t", op_o16(18, 0x181), op_o16(0x3f, 0x3ff), "b", 1}, + +/* co processor 3 instruction */ + {"mtc3", op_rs_b11 (19, 0, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"cfc3", op_rs_b11 (19, 2, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"mtc3", op_rs_b11 (19, 4, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"ctc3", op_rs_b11 (19, 6, 0), op_rs_b11(0x3f, 0x1f, 0x1ffff), "t,d", 0}, + {"bc3f", op_o16(19, 0x100), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc3f", op_o16(19, 0x180), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc3t", op_o16(19, 0x101), op_o16(0x3f, 0x3ff), "b", 1}, + {"bc3t", op_o16(19, 0x181), op_o16(0x3f, 0x3ff), "b", 1}, + + {"lb", one(32), one(0x3f), "t,j(s)", 0}, + {"lh", one(33), one(0x3f), "t,j(s)", 0}, + {"lwl", one(34), one(0x3f), "t,j(s)", 0}, + {"lw", one(35), one(0x3f), "t,j(s)", 0}, + {"lbu", one(36), one(0x3f), "t,j(s)", 0}, + {"lhu", one(37), one(0x3f), "t,j(s)", 0}, + {"lwr", one(38), one(0x3f), "t,j(s)", 0}, + {"sb", one(40), one(0x3f), "t,j(s)", 0}, + {"sh", one(41), one(0x3f), "t,j(s)", 0}, + {"swl", one(42), one(0x3f), "t,j(s)", 0}, + {"swr", one(46), one(0x3f), "t,j(s)", 0}, + {"sw", one(43), one(0x3f), "t,j(s)", 0}, + {"lwc0", one(48), one(0x3f), "t,j(s)", 0}, +/* for fpu */ + {"lwc1", one(49), one(0x3f), "T,j(s)", 0}, + {"lwc2", one(50), one(0x3f), "t,j(s)", 0}, + {"lwc3", one(51), one(0x3f), "t,j(s)", 0}, + {"swc0", one(56), one(0x3f), "t,j(s)", 0}, +/* for fpu */ + {"swc1", one(57), one(0x3f), "T,j(s)", 0}, + {"swc2", one(58), one(0x3f), "t,j(s)", 0}, + {"swc3", one(59), one(0x3f), "t,j(s)", 0}, +}; diff --git a/gdb/mips-pinsn.c b/gdb/mips-pinsn.c new file mode 100644 index 0000000..b348339 --- /dev/null +++ b/gdb/mips-pinsn.c @@ -0,0 +1,149 @@ +/* Print mips instructions for GDB, the GNU debugger. + Copyright (C) 1989 Free Software Foundation, Inc. + Contributed by Nobuyuki Hikichi(hikichi@sra.co.jp) + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "mips-opcode.h" + +/* Mips instructions are never longer than this many bytes. */ +#define MAXLEN 4 + +/* Number of elements in the opcode table. */ +#define NOPCODES (sizeof mips_opcodes / sizeof mips_opcodes[0]) + +#define MKLONG(p) *(unsigned long*)p + +extern char *reg_names[]; + + +/* subroutine */ +static unsigned char * +print_insn_arg (d, l, stream, pc) + char *d; + register unsigned long int *l; + FILE *stream; + CORE_ADDR pc; +{ + switch (*d) + { + case ',': + case '(': + case ')': + fputc (*d, stream); + break; + + case 's': + fprintf (stream, "$%s", reg_names[((struct op_i_fmt *) l)->rs]); + break; + + case 't': + fprintf (stream, "$%s", reg_names[((struct op_i_fmt *) l)->rt]); + break; + + case 'i': + fprintf (stream, "%d", ((struct op_i_fmt *) l)->immediate); + break; + + case 'j': /* same as i, but sign-extended */ + fprintf (stream, "%d", ((struct op_b_fmt *) l)->delta); + break; + + case 'a': + print_address ((pc & 0xF0000000) | (((struct op_j_fmt *)l)->target << 2), + stream); + break; + + case 'b': + print_address ((((struct op_b_fmt *) l)->delta << 2) + pc + 4, stream); + break; + + case 'd': + fprintf (stream, "%s", reg_names[((struct op_r_fmt *) l)->rd]); + break; + + case 'h': + fprintf (stream, "0x%x", ((struct op_r_fmt *) l)->shamt); + break; + + case 'S': + fprintf (stream, "$f%d", ((struct fop_r_fmt *) l)->fs); + break; + + case 'T': + fprintf (stream, "$f%d", ((struct fop_r_fmt *) l)->ft); + break; + + case 'D': + fprintf (stream, "$f%d", ((struct fop_r_fmt *) l)->fd); + break; + + default: + fprintf (stream, "# internal error, undefined modifier(%c)", *d); + break; + } +} + +/* Print the mips instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes, which + is always 4. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i; + register char *d; + unsigned long int l; + + read_memory (memaddr, buffer, MAXLEN); + + for (i = 0; i < NOPCODES; i++) + { + register unsigned int opcode = mips_opcodes[i].opcode; + register unsigned int match = mips_opcodes[i].match; + if ((*(unsigned int*)buffer & match) == opcode) + break; + } + + l = MKLONG (buffer); + /* Handle undefined instructions. */ + if (i == NOPCODES) + { + fprintf (stream, "0x%x",l); + return 4; + } + + fprintf (stream, "%s", mips_opcodes[i].name); + + if (!(d = mips_opcodes[i].args)) + return 4; + + fputc (' ', stream); + + while (*d) + print_insn_arg (d++, &l, stream, memaddr); + + return 4; +} diff --git a/gdb/mips-xdep.c b/gdb/mips-xdep.c new file mode 100644 index 0000000..7748f1c --- /dev/null +++ b/gdb/mips-xdep.c @@ -0,0 +1,132 @@ +/* Low level MIPS interface to ptrace, for GDB when running under Unix. + Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc. + Contributed by Alessandro Forin(af@cs.cmu.edu) at CMU + and by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <mips/inst.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "symtab.h" +#include "value.h" + +#ifdef USG +#include <sys/types.h> +#endif + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/ioctl.h> +/* #include <fcntl.h> Can we live without this? */ + +#include "gdbcore.h" + +#include <sys/user.h> /* After a.out.h */ +#include <sys/file.h> +#include <sys/stat.h> + +/* Get all registers from the inferior */ + +void +fetch_inferior_registers () +{ + register int regno; + register unsigned int regaddr; + char buf[MAX_REGISTER_RAW_SIZE]; + register int i; + + registers_fetched (); + + for (regno = 1; regno < NUM_REGS; regno++) + { + regaddr = register_addr (regno, 1); + for (i = 0; i < REGISTER_RAW_SIZE (regno); i += sizeof (int)) + { + *(int *) &buf[i] = ptrace (3, inferior_pid, regaddr, 0); + regaddr += sizeof (int); + } + supply_register (regno, buf); + } +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + register unsigned int regaddr; + char buf[80]; + + if (regno == 0) + return; + + if (regno > 0) + { + regaddr = register_addr (regno, 1); + errno = 0; + ptrace (6, inferior_pid, regaddr, read_register (regno)); + if (errno != 0) + { + sprintf (buf, "writing register number %d", regno); + perror_with_name (buf); + } + } + else + { + for (regno = 1; regno < NUM_REGS; regno++) + { + if (regno == 32 || regno == 35 || regno == 36 || regno == 71) + continue; + regaddr = register_addr (regno, 1); + errno = 0; + ptrace (6, inferior_pid, regaddr, read_register (regno)); + if (errno != 0) + { + sprintf (buf, "writing all regs, number %d", regno); + perror_with_name (buf); + } + } + } +} + +void +fetch_core_registers () +{ + register int regno; + int val; + + for (regno = 1; regno < NUM_REGS; regno++) { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = bfd_seek (core_bfd, register_addr (regno, 0)); + if (val < 0 || (val = bfd_read (core_bfd, buf, sizeof buf)) < 0) { + char buffer[50]; + strcpy (buffer, "Reading register "); + strcat (buffer, reg_names[regno]); + + perror_with_name (buffer); + } + supply_register (regno, buf); + } +} diff --git a/gdb/munch b/gdb/munch new file mode 100755 index 0000000..8b59ed0 --- /dev/null +++ b/gdb/munch @@ -0,0 +1,21 @@ +#!/bin/sh + +# create an initialization procedure from a list of .o files + +echo '/* Do not modify this file. It is created automatically by "munch". */' +echo 'void initialize_all_files () {' + +# make it easy to use a different nm, e.g. for cross-developing +MUNCH_NM=${MUNCH_NM-nm} +if test "`$MUNCH_NM main.o | egrep 'T _?main$'`" = "" ; then + # System V style nm + shift; + $MUNCH_NM $* | egrep '^(.*[^a-zA-Z_]_|_)_?initialize_.*\.text' | \ + sed -e 's/^.*\(_initialize_[a-zA-Z0-9_]*\)[^a-zA-Z0-9_].*$/ {extern void \1 (); \1 ();}/' +else + # BSD style nm + $MUNCH_NM -p $* | egrep 'T *_?_initialize_' | \ + sed -e 's/^.*T *_*\(.*\)/ {extern void _\1 (); _\1 ();}/' +fi + +echo '}' diff --git a/gdb/news-xdep.c b/gdb/news-xdep.c new file mode 100644 index 0000000..58a9191 --- /dev/null +++ b/gdb/news-xdep.c @@ -0,0 +1,65 @@ +/* Low level interface to ptrace, for GDB when running under Unix. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifdef __GNUC__ +/* Bad implement execle(3). It's depend for "/bin/cc". + + main() + { + printf("execle:\n"); + execle(FILE, ARGS, envp); + exit(1); + } + + GCC: + link a6,#0 + pea LC5 ; call printf + jbsr _printf + ; ; (not popd stack) + pea _envp ; call execle + clrl sp@- + pea LC4 + pea LC4 + pea LC4 + pea LC3 + pea LC6 + jbsr _execle + addw #32,sp ; delayed pop !! + + /bin/cc: + link.l fp,#L23 + movem.l #L24,(sp) + pea L26 ; call printf + jbsr _printf + addq.l #4,sp ; <--- popd stack !! + pea _envp ; call execle + clr.l -(sp) + pea L32 + + */ + +execle(name, args) + char *name, *args; +{ + register char **env = &args; + while (*env++) + ; + execve(name, (char **)&args, (char **)*env); +} +#endif diff --git a/gdb/nindy-tdep.c b/gdb/nindy-tdep.c new file mode 100644 index 0000000..b609fd7 --- /dev/null +++ b/gdb/nindy-tdep.c @@ -0,0 +1,77 @@ +/* Target-machine dependent code for the NINDY monitor running on the Intel 960 + Copyright (C) 1991 Free Software Foundation, Inc. + Contributed by Intel Corporation. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Miscellaneous NINDY-dependent routines. + Some replace macros normally defined in "tm.h". */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "frame.h" + +/* 'start_frame' is a variable in the NINDY runtime startup routine + that contains the frame pointer of the 'start' routine (the routine + that calls 'main'). By reading its contents out of remote memory, + we can tell where the frame chain ends: backtraces should halt before + they display this frame. */ + +int +nindy_frame_chain_valid (chain, curframe) + unsigned int chain; + FRAME curframe; +{ + struct symbol *sym; + int i; + + /* crtnindy.o is an assembler module that is assumed to be linked + * first in an i80960 executable. It contains the true entry point; + * it performs startup up initialization and then calls 'main'. + * + * 'sf' is the name of a variable in crtnindy.o that is set + * during startup to the address of the first frame. + * + * 'a' is the address of that variable in 80960 memory. + */ + static char sf[] = "start_frame"; + CORE_ADDR a; + + + chain &= ~0x3f; /* Zero low 6 bits because previous frame pointers + contain return status info in them. */ + if ( chain == 0 ){ + return 0; + } + + sym = lookup_symbol(sf, 0, VAR_NAMESPACE, (int *)NULL, + (struct symtab **)NULL); + if ( sym != 0 ){ + a = sym->value.value; + } else { + for ( i = 0; strcmp(misc_function_vector[i].name,sf); i++ ){ + if ( i >= misc_function_count ){ + return 0; + } + } + a = misc_function_vector[i].address; + } + + return ( chain != read_memory_integer(a,4) ); +} diff --git a/gdb/np1-opcode.h b/gdb/np1-opcode.h new file mode 100755 index 0000000..6546825 --- /dev/null +++ b/gdb/np1-opcode.h @@ -0,0 +1,422 @@ +/* Print GOULD NPL instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +struct gld_opcode +{ + char *name; + unsigned long opcode; + unsigned long mask; + char *args; + int length; +}; + +/* We store four bytes of opcode for all opcodes because that + is the most any of them need. The actual length of an instruction + is always at least 2 bytes, and at most four. The length of the + instruction is based on the opcode. + + The mask component is a mask saying which bits must match + particular opcode in order for an instruction to be an instance + of that opcode. + + The args component is a string containing characters + that are used to format the arguments to the instruction. */ + +/* Kinds of operands: + r Register in first field + R Register in second field + b Base register in first field + B Base register in second field + v Vector register in first field + V Vector register in first field + A Optional address register (base register) + X Optional index register + I Immediate data (16bits signed) + O Offset field (16bits signed) + h Offset field (15bits signed) + d Offset field (14bits signed) + S Shift count field + + any other characters are printed as is... +*/ + +/* The assembler requires that this array be sorted as follows: + all instances of the same mnemonic must be consecutive. + All instances of the same mnemonic with the same number of operands + must be consecutive. + */ +struct gld_opcode gld_opcodes[] = +{ +{ "lb", 0xb4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lnb", 0xb8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lbs", 0xec080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lh", 0xb4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "lnh", 0xb8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "lw", 0xb4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lnw", 0xb8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "ld", 0xb4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "lnd", 0xb8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "li", 0xf8000000, 0xfc7f0000, "r,I", 4 }, +{ "lpa", 0x50080000, 0xfc080000, "r,xOA,X", 4 }, +{ "la", 0x50000000, 0xfc080000, "r,xOA,X", 4 }, +{ "labr", 0x58080000, 0xfc080000, "b,xOA,X", 4 }, +{ "lbp", 0x90080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lhp", 0x90000001, 0xfc080001, "r,xOA,X", 4 }, +{ "lwp", 0x90000000, 0xfc080000, "r,xOA,X", 4 }, +{ "ldp", 0x90000002, 0xfc080002, "r,xOA,X", 4 }, +{ "suabr", 0x58000000, 0xfc080000, "b,xOA,X", 4 }, +{ "lf", 0xbc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lfbr", 0xbc080000, 0xfc080000, "b,xOA,X", 4 }, +{ "lwbr", 0x5c000000, 0xfc080000, "b,xOA,X", 4 }, +{ "stb", 0xd4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "sth", 0xd4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "stw", 0xd4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "std", 0xd4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "stf", 0xdc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "stfbr", 0xdc080000, 0xfc080000, "b,xOA,X", 4 }, +{ "stwbr", 0x54000000, 0xfc080000, "b,xOA,X", 4 }, +{ "zmb", 0xd8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "zmh", 0xd8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "zmw", 0xd8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "zmd", 0xd8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "stbp", 0x94080000, 0xfc080000, "r,xOA,X", 4 }, +{ "sthp", 0x94000001, 0xfc080001, "r,xOA,X", 4 }, +{ "stwp", 0x94000000, 0xfc080000, "r,xOA,X", 4 }, +{ "stdp", 0x94000002, 0xfc080002, "r,xOA,X", 4 }, +{ "lil", 0xf80b0000, 0xfc7f0000, "r,D", 4 }, +{ "lwsl1", 0xec000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lwsl2", 0xfc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lwsl3", 0xfc080000, 0xfc080000, "r,xOA,X", 4 }, + +{ "lvb", 0xb0080000, 0xfc080000, "v,xOA,X", 4 }, +{ "lvh", 0xb0000001, 0xfc080001, "v,xOA,X", 4 }, +{ "lvw", 0xb0000000, 0xfc080000, "v,xOA,X", 4 }, +{ "lvd", 0xb0000002, 0xfc080002, "v,xOA,X", 4 }, +{ "liv", 0x3c040000, 0xfc0f0000, "v,R", 2 }, +{ "livf", 0x3c080000, 0xfc0f0000, "v,R", 2 }, +{ "stvb", 0xd0080000, 0xfc080000, "v,xOA,X", 4 }, +{ "stvh", 0xd0000001, 0xfc080001, "v,xOA,X", 4 }, +{ "stvw", 0xd0000000, 0xfc080000, "v,xOA,X", 4 }, +{ "stvd", 0xd0000002, 0xfc080002, "v,xOA,X", 4 }, + +{ "trr", 0x2c000000, 0xfc0f0000, "r,R", 2 }, +{ "trn", 0x2c040000, 0xfc0f0000, "r,R", 2 }, +{ "trnd", 0x2c0c0000, 0xfc0f0000, "r,R", 2 }, +{ "trabs", 0x2c010000, 0xfc0f0000, "r,R", 2 }, +{ "trabsd", 0x2c090000, 0xfc0f0000, "r,R", 2 }, +{ "trc", 0x2c030000, 0xfc0f0000, "r,R", 2 }, +{ "xcr", 0x28040000, 0xfc0f0000, "r,R", 2 }, +{ "cxcr", 0x2c060000, 0xfc0f0000, "r,R", 2 }, +{ "cxcrd", 0x2c0e0000, 0xfc0f0000, "r,R", 2 }, +{ "tbrr", 0x2c020000, 0xfc0f0000, "r,B", 2 }, +{ "trbr", 0x28030000, 0xfc0f0000, "b,R", 2 }, +{ "xcbr", 0x28020000, 0xfc0f0000, "b,B", 2 }, +{ "tbrbr", 0x28010000, 0xfc0f0000, "b,B", 2 }, + +{ "trvv", 0x28050000, 0xfc0f0000, "v,V", 2 }, +{ "trvvn", 0x2c050000, 0xfc0f0000, "v,V", 2 }, +{ "trvvnd", 0x2c0d0000, 0xfc0f0000, "v,V", 2 }, +{ "trvab", 0x2c070000, 0xfc0f0000, "v,V", 2 }, +{ "trvabd", 0x2c0f0000, 0xfc0f0000, "v,V", 2 }, +{ "cmpv", 0x14060000, 0xfc0f0000, "v,V", 2 }, +{ "expv", 0x14070000, 0xfc0f0000, "v,V", 2 }, +{ "mrvvlt", 0x10030000, 0xfc0f0000, "v,V", 2 }, +{ "mrvvle", 0x10040000, 0xfc0f0000, "v,V", 2 }, +{ "mrvvgt", 0x14030000, 0xfc0f0000, "v,V", 2 }, +{ "mrvvge", 0x14040000, 0xfc0f0000, "v,V", 2 }, +{ "mrvveq", 0x10050000, 0xfc0f0000, "v,V", 2 }, +{ "mrvvne", 0x10050000, 0xfc0f0000, "v,V", 2 }, +{ "mrvrlt", 0x100d0000, 0xfc0f0000, "v,R", 2 }, +{ "mrvrle", 0x100e0000, 0xfc0f0000, "v,R", 2 }, +{ "mrvrgt", 0x140d0000, 0xfc0f0000, "v,R", 2 }, +{ "mrvrge", 0x140e0000, 0xfc0f0000, "v,R", 2 }, +{ "mrvreq", 0x100f0000, 0xfc0f0000, "v,R", 2 }, +{ "mrvrne", 0x140f0000, 0xfc0f0000, "v,R", 2 }, +{ "trvr", 0x140b0000, 0xfc0f0000, "r,V", 2 }, +{ "trrv", 0x140c0000, 0xfc0f0000, "v,R", 2 }, + +{ "bu", 0x40000000, 0xff880000, "xOA,X", 4 }, +{ "bns", 0x70080000, 0xff880000, "xOA,X", 4 }, +{ "bnco", 0x70880000, 0xff880000, "xOA,X", 4 }, +{ "bge", 0x71080000, 0xff880000, "xOA,X", 4 }, +{ "bne", 0x71880000, 0xff880000, "xOA,X", 4 }, +{ "bunge", 0x72080000, 0xff880000, "xOA,X", 4 }, +{ "bunle", 0x72880000, 0xff880000, "xOA,X", 4 }, +{ "bgt", 0x73080000, 0xff880000, "xOA,X", 4 }, +{ "bnany", 0x73880000, 0xff880000, "xOA,X", 4 }, +{ "bs" , 0x70000000, 0xff880000, "xOA,X", 4 }, +{ "bco", 0x70800000, 0xff880000, "xOA,X", 4 }, +{ "blt", 0x71000000, 0xff880000, "xOA,X", 4 }, +{ "beq", 0x71800000, 0xff880000, "xOA,X", 4 }, +{ "buge", 0x72000000, 0xff880000, "xOA,X", 4 }, +{ "bult", 0x72800000, 0xff880000, "xOA,X", 4 }, +{ "ble", 0x73000000, 0xff880000, "xOA,X", 4 }, +{ "bany", 0x73800000, 0xff880000, "xOA,X", 4 }, +{ "brlnk", 0x44000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bib", 0x48000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bih", 0x48080000, 0xfc080000, "r,xOA,X", 4 }, +{ "biw", 0x4c000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bid", 0x4c080000, 0xfc080000, "r,xOA,X", 4 }, +{ "bivb", 0x60000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bivh", 0x60080000, 0xfc080000, "r,xOA,X", 4 }, +{ "bivw", 0x64000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bivd", 0x64080000, 0xfc080000, "r,xOA,X", 4 }, +{ "bvsb", 0x68000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bvsh", 0x68080000, 0xfc080000, "r,xOA,X", 4 }, +{ "bvsw", 0x6c000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bvsd", 0x6c080000, 0xfc080000, "r,xOA,X", 4 }, + +{ "camb", 0x80080000, 0xfc080000, "r,xOA,X", 4 }, +{ "camh", 0x80000001, 0xfc080001, "r,xOA,X", 4 }, +{ "camw", 0x80000000, 0xfc080000, "r,xOA,X", 4 }, +{ "camd", 0x80000002, 0xfc080002, "r,xOA,X", 4 }, +{ "car", 0x10000000, 0xfc0f0000, "r,R", 2 }, +{ "card", 0x14000000, 0xfc0f0000, "r,R", 2 }, +{ "ci", 0xf8050000, 0xfc7f0000, "r,I", 4 }, +{ "chkbnd", 0x5c080000, 0xfc080000, "r,xOA,X", 4 }, + +{ "cavv", 0x10010000, 0xfc0f0000, "v,V", 2 }, +{ "cavr", 0x10020000, 0xfc0f0000, "v,R", 2 }, +{ "cavvd", 0x10090000, 0xfc0f0000, "v,V", 2 }, +{ "cavrd", 0x100b0000, 0xfc0f0000, "v,R", 2 }, + +{ "anmb", 0x84080000, 0xfc080000, "r,xOA,X", 4 }, +{ "anmh", 0x84000001, 0xfc080001, "r,xOA,X", 4 }, +{ "anmw", 0x84000000, 0xfc080000, "r,xOA,X", 4 }, +{ "anmd", 0x84000002, 0xfc080002, "r,xOA,X", 4 }, +{ "anr", 0x04000000, 0xfc0f0000, "r,R", 2 }, +{ "ani", 0xf8080000, 0xfc7f0000, "r,I", 4 }, +{ "ormb", 0xb8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "ormh", 0xb8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "ormw", 0xb8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "ormd", 0xb8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "orr", 0x08000000, 0xfc0f0000, "r,R", 2 }, +{ "oi", 0xf8090000, 0xfc7f0000, "r,I", 4 }, +{ "eomb", 0x8c080000, 0xfc080000, "r,xOA,X", 4 }, +{ "eomh", 0x8c000001, 0xfc080001, "r,xOA,X", 4 }, +{ "eomw", 0x8c000000, 0xfc080000, "r,xOA,X", 4 }, +{ "eomd", 0x8c000002, 0xfc080002, "r,xOA,X", 4 }, +{ "eor", 0x0c000000, 0xfc0f0000, "r,R", 2 }, +{ "eoi", 0xf80a0000, 0xfc7f0000, "r,I", 4 }, + +{ "anvv", 0x04010000, 0xfc0f0000, "v,V", 2 }, +{ "anvr", 0x04020000, 0xfc0f0000, "v,R", 2 }, +{ "orvv", 0x08010000, 0xfc0f0000, "v,V", 2 }, +{ "orvr", 0x08020000, 0xfc0f0000, "v,R", 2 }, +{ "eovv", 0x0c010000, 0xfc0f0000, "v,V", 2 }, +{ "eovr", 0x0c020000, 0xfc0f0000, "v,R", 2 }, + +{ "sacz", 0x100c0000, 0xfc0f0000, "r,R", 2 }, +{ "sla", 0x1c400000, 0xfc600000, "r,S", 2 }, +{ "sll", 0x1c600000, 0xfc600000, "r,S", 2 }, +{ "slc", 0x24400000, 0xfc600000, "r,S", 2 }, +{ "slad", 0x20400000, 0xfc600000, "r,S", 2 }, +{ "slld", 0x20600000, 0xfc600000, "r,S", 2 }, +{ "sra", 0x1c000000, 0xfc600000, "r,S", 2 }, +{ "srl", 0x1c200000, 0xfc600000, "r,S", 2 }, +{ "src", 0x24000000, 0xfc600000, "r,S", 2 }, +{ "srad", 0x20000000, 0xfc600000, "r,S", 2 }, +{ "srld", 0x20200000, 0xfc600000, "r,S", 2 }, +{ "sda", 0x3c030000, 0xfc0f0000, "r,R", 2 }, +{ "sdl", 0x3c020000, 0xfc0f0000, "r,R", 2 }, +{ "sdc", 0x3c010000, 0xfc0f0000, "r,R", 2 }, +{ "sdad", 0x3c0b0000, 0xfc0f0000, "r,R", 2 }, +{ "sdld", 0x3c0a0000, 0xfc0f0000, "r,R", 2 }, + +{ "svda", 0x3c070000, 0xfc0f0000, "v,R", 2 }, +{ "svdl", 0x3c060000, 0xfc0f0000, "v,R", 2 }, +{ "svdc", 0x3c050000, 0xfc0f0000, "v,R", 2 }, +{ "svdad", 0x3c0e0000, 0xfc0f0000, "v,R", 2 }, +{ "svdld", 0x3c0d0000, 0xfc0f0000, "v,R", 2 }, + +{ "sbm", 0xac080000, 0xfc080000, "f,xOA,X", 4 }, +{ "zbm", 0xac000000, 0xfc080000, "f,xOA,X", 4 }, +{ "tbm", 0xa8080000, 0xfc080000, "f,xOA,X", 4 }, +{ "incmb", 0xa0000000, 0xfc080000, "xOA,X", 4 }, +{ "incmh", 0xa0080000, 0xfc080000, "xOA,X", 4 }, +{ "incmw", 0xa4000000, 0xfc080000, "xOA,X", 4 }, +{ "incmd", 0xa4080000, 0xfc080000, "xOA,X", 4 }, +{ "sbmd", 0x7c080000, 0xfc080000, "r,xOA,X", 4 }, +{ "zbmd", 0x7c000000, 0xfc080000, "r,xOA,X", 4 }, +{ "tbmd", 0x78080000, 0xfc080000, "r,xOA,X", 4 }, + +{ "ssm", 0x9c080000, 0xfc080000, "f,xOA,X", 4 }, +{ "zsm", 0x9c000000, 0xfc080000, "f,xOA,X", 4 }, +{ "tsm", 0x98080000, 0xfc080000, "f,xOA,X", 4 }, + +{ "admb", 0xc8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "admh", 0xc8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "admw", 0xc8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "admd", 0xc8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "adr", 0x38000000, 0xfc0f0000, "r,R", 2 }, +{ "armb", 0xe8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "armh", 0xe8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "armw", 0xe8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "armd", 0xe8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "adi", 0xf8010000, 0xfc0f0000, "r,I", 4 }, +{ "sumb", 0xcc080000, 0xfc080000, "r,xOA,X", 4 }, +{ "sumh", 0xcc000001, 0xfc080001, "r,xOA,X", 4 }, +{ "sumw", 0xcc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "sumd", 0xcc000002, 0xfc080002, "r,xOA,X", 4 }, +{ "sur", 0x3c000000, 0xfc0f0000, "r,R", 2 }, +{ "sui", 0xf8020000, 0xfc0f0000, "r,I", 4 }, +{ "mpmb", 0xc0080000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpmh", 0xc0000001, 0xfc080001, "r,xOA,X", 4 }, +{ "mpmw", 0xc0000000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpr", 0x38020000, 0xfc0f0000, "r,R", 2 }, +{ "mprd", 0x3c0f0000, 0xfc0f0000, "r,R", 2 }, +{ "mpi", 0xf8030000, 0xfc0f0000, "r,I", 4 }, +{ "dvmb", 0xc4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "dvmh", 0xc4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "dvmw", 0xc4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "dvr", 0x380a0000, 0xfc0f0000, "r,R", 2 }, +{ "dvi", 0xf8040000, 0xfc0f0000, "r,I", 4 }, +{ "exs", 0x38080000, 0xfc0f0000, "r,R", 2 }, + +{ "advv", 0x30000000, 0xfc0f0000, "v,V", 2 }, +{ "advvd", 0x30080000, 0xfc0f0000, "v,V", 2 }, +{ "adrv", 0x34000000, 0xfc0f0000, "v,R", 2 }, +{ "adrvd", 0x34080000, 0xfc0f0000, "v,R", 2 }, +{ "suvv", 0x30010000, 0xfc0f0000, "v,V", 2 }, +{ "suvvd", 0x30090000, 0xfc0f0000, "v,V", 2 }, +{ "surv", 0x34010000, 0xfc0f0000, "v,R", 2 }, +{ "survd", 0x34090000, 0xfc0f0000, "v,R", 2 }, +{ "mpvv", 0x30020000, 0xfc0f0000, "v,V", 2 }, +{ "mprv", 0x34020000, 0xfc0f0000, "v,R", 2 }, + +{ "adfw", 0xe0080000, 0xfc080000, "r,xOA,X", 4 }, +{ "adfd", 0xe0080002, 0xfc080002, "r,xOA,X", 4 }, +{ "adrfw", 0x38010000, 0xfc0f0000, "r,R", 2 }, +{ "adrfd", 0x38090000, 0xfc0f0000, "r,R", 2 }, +{ "surfw", 0xe0000000, 0xfc080000, "r,xOA,X", 4 }, +{ "surfd", 0xe0000002, 0xfc080002, "r,xOA,X", 4 }, +{ "surfw", 0x38030000, 0xfc0f0000, "r,R", 2 }, +{ "surfd", 0x380b0000, 0xfc0f0000, "r,R", 2 }, +{ "mpfw", 0xe4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpfd", 0xe4080002, 0xfc080002, "r,xOA,X", 4 }, +{ "mprfw", 0x38060000, 0xfc0f0000, "r,R", 2 }, +{ "mprfd", 0x380e0000, 0xfc0f0000, "r,R", 2 }, +{ "rfw", 0xe4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "rfd", 0xe4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "rrfw", 0x0c0e0000, 0xfc0f0000, "r", 2 }, +{ "rrfd", 0x0c0f0000, 0xfc0f0000, "r", 2 }, + +{ "advvfw", 0x30040000, 0xfc0f0000, "v,V", 2 }, +{ "advvfd", 0x300c0000, 0xfc0f0000, "v,V", 2 }, +{ "adrvfw", 0x34040000, 0xfc0f0000, "v,R", 2 }, +{ "adrvfd", 0x340c0000, 0xfc0f0000, "v,R", 2 }, +{ "suvvfw", 0x30050000, 0xfc0f0000, "v,V", 2 }, +{ "suvvfd", 0x300d0000, 0xfc0f0000, "v,V", 2 }, +{ "survfw", 0x34050000, 0xfc0f0000, "v,R", 2 }, +{ "survfd", 0x340d0000, 0xfc0f0000, "v,R", 2 }, +{ "mpvvfw", 0x30060000, 0xfc0f0000, "v,V", 2 }, +{ "mpvvfd", 0x300e0000, 0xfc0f0000, "v,V", 2 }, +{ "mprvfw", 0x34060000, 0xfc0f0000, "v,R", 2 }, +{ "mprvfd", 0x340e0000, 0xfc0f0000, "v,R", 2 }, +{ "rvfw", 0x30070000, 0xfc0f0000, "v", 2 }, +{ "rvfd", 0x300f0000, 0xfc0f0000, "v", 2 }, + +{ "fltw", 0x38070000, 0xfc0f0000, "r,R", 2 }, +{ "fltd", 0x380f0000, 0xfc0f0000, "r,R", 2 }, +{ "fixw", 0x38050000, 0xfc0f0000, "r,R", 2 }, +{ "fixd", 0x380d0000, 0xfc0f0000, "r,R", 2 }, +{ "cfpds", 0x3c090000, 0xfc0f0000, "r,R", 2 }, + +{ "fltvw", 0x080d0000, 0xfc0f0000, "v,V", 2 }, +{ "fltvd", 0x080f0000, 0xfc0f0000, "v,V", 2 }, +{ "fixvw", 0x080c0000, 0xfc0f0000, "v,V", 2 }, +{ "fixvd", 0x080e0000, 0xfc0f0000, "v,V", 2 }, +{ "cfpvds", 0x0c0d0000, 0xfc0f0000, "v,V", 2 }, + +{ "orvrn", 0x000a0000, 0xfc0f0000, "r,V", 2 }, +{ "andvrn", 0x00080000, 0xfc0f0000, "r,V", 2 }, +{ "frsteq", 0x04090000, 0xfc0f0000, "r,V", 2 }, +{ "sigma", 0x0c080000, 0xfc0f0000, "r,V", 2 }, +{ "sigmad", 0x0c0a0000, 0xfc0f0000, "r,V", 2 }, +{ "sigmf", 0x08080000, 0xfc0f0000, "r,V", 2 }, +{ "sigmfd", 0x080a0000, 0xfc0f0000, "r,V", 2 }, +{ "prodf", 0x04080000, 0xfc0f0000, "r,V", 2 }, +{ "prodfd", 0x040a0000, 0xfc0f0000, "r,V", 2 }, +{ "maxv", 0x10080000, 0xfc0f0000, "r,V", 2 }, +{ "maxvd", 0x100a0000, 0xfc0f0000, "r,V", 2 }, +{ "minv", 0x14080000, 0xfc0f0000, "r,V", 2 }, +{ "minvd", 0x140a0000, 0xfc0f0000, "r,V", 2 }, + +{ "lpsd", 0xf0000000, 0xfc080000, "xOA,X", 4 }, +{ "ldc", 0xf0080000, 0xfc080000, "xOA,X", 4 }, +{ "spm", 0x040c0000, 0xfc0f0000, "r", 2 }, +{ "rpm", 0x040d0000, 0xfc0f0000, "r", 2 }, +{ "tritr", 0x00070000, 0xfc0f0000, "r", 2 }, +{ "trrit", 0x00060000, 0xfc0f0000, "r", 2 }, +{ "rpswt", 0x04080000, 0xfc0f0000, "r", 2 }, +{ "exr", 0xf8070000, 0xfc0f0000, "", 4 }, +{ "halt", 0x00000000, 0xfc0f0000, "", 2 }, +{ "wait", 0x00010000, 0xfc0f0000, "", 2 }, +{ "nop", 0x00020000, 0xfc0f0000, "", 2 }, +{ "eiae", 0x00030000, 0xfc0f0000, "", 2 }, +{ "efae", 0x000d0000, 0xfc0f0000, "", 2 }, +{ "diae", 0x000e0000, 0xfc0f0000, "", 2 }, +{ "dfae", 0x000f0000, 0xfc0f0000, "", 2 }, +{ "spvc", 0xf8060000, 0xfc0f0000, "r,T,N", 4 }, +{ "rdsts", 0x00090000, 0xfc0f0000, "r", 2 }, +{ "setcpu", 0x000c0000, 0xfc0f0000, "r", 2 }, +{ "cmc", 0x000b0000, 0xfc0f0000, "r", 2 }, +{ "trrcu", 0x00040000, 0xfc0f0000, "r", 2 }, +{ "attnio", 0x00050000, 0xfc0f0000, "", 2 }, +{ "fudit", 0x28080000, 0xfc0f0000, "", 2 }, +{ "break", 0x28090000, 0xfc0f0000, "", 2 }, +{ "frzss", 0x280a0000, 0xfc0f0000, "", 2 }, +{ "ripi", 0x04040000, 0xfc0f0000, "r,R", 2 }, +{ "xcp", 0x04050000, 0xfc0f0000, "r", 2 }, +{ "block", 0x04060000, 0xfc0f0000, "", 2 }, +{ "unblock", 0x04070000, 0xfc0f0000, "", 2 }, +{ "trsc", 0x08060000, 0xfc0f0000, "r,R", 2 }, +{ "tscr", 0x08070000, 0xfc0f0000, "r,R", 2 }, +{ "fq", 0x04080000, 0xfc0f0000, "r", 2 }, +{ "flupte", 0x2c080000, 0xfc0f0000, "r", 2 }, +{ "rviu", 0x040f0000, 0xfc0f0000, "", 2 }, +{ "ldel", 0x280c0000, 0xfc0f0000, "r,R", 2 }, +{ "ldu", 0x280d0000, 0xfc0f0000, "r,R", 2 }, +{ "stdecc", 0x280b0000, 0xfc0f0000, "r,R", 2 }, +{ "trpc", 0x08040000, 0xfc0f0000, "r", 2 }, +{ "tpcr", 0x08050000, 0xfc0f0000, "r", 2 }, +{ "ghalt", 0x0c050000, 0xfc0f0000, "r", 2 }, +{ "grun", 0x0c040000, 0xfc0f0000, "", 2 }, +{ "tmpr", 0x2c0a0000, 0xfc0f0000, "r,R", 2 }, +{ "trmp", 0x2c0b0000, 0xfc0f0000, "r,R", 2 }, + +{ "trrve", 0x28060000, 0xfc0f0000, "r", 2 }, +{ "trver", 0x28070000, 0xfc0f0000, "r", 2 }, +{ "trvlr", 0x280f0000, 0xfc0f0000, "r", 2 }, + +{ "linkfl", 0x18000000, 0xfc0f0000, "r,R", 2 }, +{ "linkbl", 0x18020000, 0xfc0f0000, "r,R", 2 }, +{ "linkfp", 0x18010000, 0xfc0f0000, "r,R", 2 }, +{ "linkbp", 0x18030000, 0xfc0f0000, "r,R", 2 }, +{ "linkpl", 0x18040000, 0xfc0f0000, "r,R", 2 }, +{ "ulinkl", 0x18080000, 0xfc0f0000, "r,R", 2 }, +{ "ulinkp", 0x18090000, 0xfc0f0000, "r,R", 2 }, +{ "ulinktl", 0x180a0000, 0xfc0f0000, "r,R", 2 }, +{ "ulinktp", 0x180b0000, 0xfc0f0000, "r,R", 2 }, +}; + +int numopcodes = sizeof(gld_opcodes) / sizeof(gld_opcodes[0]); + +struct gld_opcode *endop = gld_opcodes + sizeof(gld_opcodes) / + sizeof(gld_opcodes[0]); diff --git a/gdb/ns32k-opcode.h b/gdb/ns32k-opcode.h new file mode 100644 index 0000000..5f336e9 --- /dev/null +++ b/gdb/ns32k-opcode.h @@ -0,0 +1,328 @@ +/* ns32k-opcode.h */ + +#ifndef ns32k_opcodeT +#define ns32k_opcodeT int +#endif /* no ns32k_opcodeT */ + +struct not_wot /* ns32k opcode table: wot to do with this */ + /* particular opcode */ +{ + int obits; /* number of opcode bits */ + int ibits; /* number of instruction bits */ + ns32k_opcodeT code; /* op-code (may be > 8 bits!) */ + char *args; /* how to compile said opcode */ +}; + +struct not /* ns32k opcode text */ +{ + char * name; /* opcode name: lowercase string [key] */ + struct not_wot detail; /* rest of opcode table [datum] */ +}; + +/* Instructions look like this: + + basic instruction--1, 2, or 3 bytes + index byte for operand A, if operand A is indexed--1 byte + index byte for operand B, if operand B is indexed--1 byte + addressing extension for operand A + addressing extension for operand B + implied operands + + Operand A is the operand listed first in the following opcode table. + Operand B is the operand listed second in the following opcode table. + All instructions have at most 2 general operands, so this is enough. + The implied operands are associated with operands other than A and B. + + Each operand has a digit and a letter. + + The digit gives the position in the assembly language. The letter, + one of the following, tells us what kind of operand it is. */ + +/* F : 32 bit float + * L : 64 bit float + * B : byte + * W : word + * D : double-word + * Q : quad-word + * d : displacement + * q : quick + * i : immediate (8 bits) + * r : register number (3 bits) + * p : displacement - pc relative addressing +*/ +static struct not +notstrs[] = +{ + { "absf", 14,24, 0x35be, "1F2F" }, + { "absl", 14,24, 0x34be, "1L2L" }, + { "absb", 14,24, 0x304e, "1B2B" }, + { "absw", 14,24, 0x314e, "1W2W" }, + { "absd", 14,24, 0x334e, "1D2D" }, + { "acbb", 7,16, 0x4c, "2B1q3p" }, + { "acbw", 7,16, 0x4d, "2W1q3p" }, + { "acbd", 7,16, 0x4f, "2D1q3p" }, + { "addf", 14,24, 0x01be, "1F2F" }, + { "addl", 14,24, 0x00be, "1L2L" }, + { "addb", 6,16, 0x00, "1B2B" }, + { "addw", 6,16, 0x01, "1W2W" }, + { "addd", 6,16, 0x03, "1D2D" }, + { "addcb", 6,16, 0x10, "1B2B" }, + { "addcw", 6,16, 0x11, "1W2W" }, + { "addcd", 6,16, 0x13, "1D2D" }, + { "addpb", 14,24, 0x3c4e, "1B2B" }, + { "addpw", 14,24, 0x3d4e, "1W2W" }, + { "addpd", 14,24, 0x3f4e, "1D2D" }, + { "addqb", 7,16, 0x0c, "2B1q" }, + { "addqw", 7,16, 0x0d, "2W1q" }, + { "addqd", 7,16, 0x0f, "2D1q" }, + { "addr", 6,16, 0x27, "1D2D" }, + { "adjspb", 11,16, 0x057c, "1B" }, + { "adjspw", 11,16, 0x057d, "1W" }, + { "adjspd", 11,16, 0x057f, "1D" }, + { "andb", 6,16, 0x28, "1B2B" }, + { "andw", 6,16, 0x29, "1W2W" }, + { "andd", 6,16, 0x2b, "1D2D" }, + { "ashb", 14,24, 0x044e, "1B2B" }, + { "ashw", 14,24, 0x054e, "1B2W" }, + { "ashd", 14,24, 0x074e, "1B2D" }, + { "beq", 8,8, 0x0a, "1p" }, + { "bne", 8,8, 0x1a, "1p" }, + { "bcs", 8,8, 0x2a, "1p" }, + { "bcc", 8,8, 0x3a, "1p" }, + { "bhi", 8,8, 0x4a, "1p" }, + { "bls", 8,8, 0x5a, "1p" }, + { "bgt", 8,8, 0x6a, "1p" }, + { "ble", 8,8, 0x7a, "1p" }, + { "bfs", 8,8, 0x8a, "1p" }, + { "bfc", 8,8, 0x9a, "1p" }, + { "blo", 8,8, 0xaa, "1p" }, + { "bhs", 8,8, 0xba, "1p" }, + { "blt", 8,8, 0xca, "1p" }, + { "bge", 8,8, 0xda, "1p" }, + { "bicb", 6,16, 0x08, "1B2B" }, + { "bicw", 6,16, 0x09, "1W2W" }, + { "bicd", 6,16, 0x0b, "1D2D" }, + { "bicpsrb", 11,16, 0x17c, "1B" }, + { "bicpsrw", 11,16, 0x17d, "1W" }, + { "bispsrb", 11,16, 0x37c, "1B" }, + { "bispsrw", 11,16, 0x37d, "1W" }, + { "bpt", 8,8, 0xf2, "" }, + { "br", 8,8, 0xea, "1p" }, + { "bsr", 8,8, 0x02, "1p" }, + { "caseb", 11,16, 0x77c, "1B" }, + { "casew", 11,16, 0x77d, "1W" }, + { "cased", 11,16, 0x77f, "1D" }, + { "cbitb", 14,24, 0x084e, "1B2D" }, + { "cbitw", 14,24, 0x094e, "1W2D" }, + { "cbitd", 14,24, 0x0b4e, "1D2D" }, + { "cbitib", 14,24, 0x0c4e, "1B2D" }, + { "cbitiw", 14,24, 0x0d4e, "1W2D" }, + { "cbitid", 14,24, 0x0f4e, "1D2D" }, + { "checkb", 11,24, 0x0ee, "2A3B1r" }, + { "checkw", 11,24, 0x1ee, "2A3B1r" }, + { "checkd", 11,24, 0x3ee, "2A3D1r" }, + { "cmpf", 14,24, 0x09be, "1F2F" }, + { "cmpl", 14,24, 0x08be, "1L2L" }, + { "cmpb", 6,16, 0x04, "1B2B" }, + { "cmpw", 6,16, 0x05, "1W2W" }, + { "cmpd", 6,16, 0x07, "1D2D" }, + { "cmpmb", 14,24, 0x04ce, "1D2D3d" }, + { "cmpmw", 14,24, 0x05ce, "1D2D3d" }, + { "cmpmd", 14,24, 0x07ce, "1D2D3d" }, + { "cmpqb", 7,16, 0x1c, "2B1q" }, + { "cmpqw", 7,16, 0x1d, "2W1q" }, + { "cmpqd", 7,16, 0x1f, "2D1q" }, + { "cmpsb", 16,16, 0x040e, "1i" }, + { "cmpsw", 16,16, 0x050e, "1i" }, + { "cmpsd", 16,16, 0x070e, "1i" }, + { "cmpst", 16,16, 0x840e, "1i" }, + { "comb", 14,24, 0x344e, "1B2B" }, + { "comw", 14,24, 0x354e, "1W2W" }, + { "comd", 14,24, 0x374e, "1D2D" }, + { "cvtp", 11,24, 0x036e, "2D3D1r" }, + { "cxp", 8,8, 0x22, "1p" }, + { "cxpd", 11,16, 0x07f, "1D" }, + { "deib", 14,24, 0x2cce, "1B2W" }, + { "deiw", 14,24, 0x2dce, "1W2D" }, + { "deid", 14,24, 0x2fce, "1D2Q" }, + { "dia", 8,8, 0xc2, "" }, + { "divf", 14,24, 0x21be, "1F2F" }, + { "divl", 14,24, 0x20be, "1L2L" }, + { "divb", 14,24, 0x3cce, "1B2B" }, + { "divw", 14,24, 0x3dce, "1W2W" }, + { "divd", 14,24, 0x3fce, "1D2D" }, + { "enter", 8,8, 0x82, "1i2d" }, + { "exit", 8,8, 0x92, "1i" }, + { "extb", 11,24, 0x02e, "2D3B1r4d" }, + { "extw", 11,24, 0x12e, "2D3W1r4d" }, + { "extd", 11,24, 0x32e, "2D3D1r4d" }, + { "extsb", 14,24, 0x0cce, "1D2B3i" }, + { "extsw", 14,24, 0x0dce, "1D2W3i" }, + { "extsd", 14,24, 0x0fce, "1D2D3i" }, + { "ffsb", 14,24, 0x046e, "1B2B" }, + { "ffsw", 14,24, 0x056e, "1W2B" }, + { "ffsd", 14,24, 0x076e, "1D2B" }, + { "flag", 8,8, 0xd2, "" }, + { "floorfb", 14,24, 0x3c3e, "1F2B" }, + { "floorfw", 14,24, 0x3d3e, "1F2W" }, + { "floorfd", 14,24, 0x3f3e, "1F2D" }, + { "floorlb", 14,24, 0x383e, "1L2B" }, + { "floorlw", 14,24, 0x393e, "1L2W" }, + { "floorld", 14,24, 0x3b3e, "1L2D" }, + { "ibitb", 14,24, 0x384e, "1B2D" }, + { "ibitw", 14,24, 0x394e, "1W2D" }, + { "ibitd", 14,24, 0x3b4e, "1D2D" }, + { "indexb", 11,24, 0x42e, "2B3B1r" }, + { "indexw", 11,24, 0x52e, "2W3W1r" }, + { "indexd", 11,24, 0x72e, "2D3D1r" }, + { "insb", 11,24, 0x0ae, "2B3B1r4d" }, + { "insw", 11,24, 0x1ae, "2W3W1r4d" }, + { "insd", 11,24, 0x3ae, "2D3D1r4d" }, + { "inssb", 14,24, 0x08ce, "1B2D3i" }, + { "inssw", 14,24, 0x09ce, "1W2D3i" }, + { "inssd", 14,24, 0x0bce, "1D2D3i" }, + { "jsr", 11,16, 0x67f, "1A" }, + { "jump", 11,16, 0x27f, "1A" }, + { "lfsr", 19,24, 0x00f3e,"1D" }, + { "lmr", 15,24, 0x0b1e, "2D1q" }, + { "lprb", 7,16, 0x6c, "2B1q" }, + { "lprw", 7,16, 0x6d, "2W1q" }, + { "lprd", 7,16, 0x6f, "2D1q" }, + { "lshb", 14,24, 0x144e, "1B2B" }, + { "lshw", 14,24, 0x154e, "1B2W" }, + { "lshd", 14,24, 0x174e, "1B2D" }, + { "meib", 14,24, 0x24ce, "1B2W" }, + { "meiw", 14,24, 0x25ce, "1W2D" }, + { "meid", 14,24, 0x27ce, "1D2Q" }, + { "modb", 14,24, 0x38ce, "1B2B" }, + { "modw", 14,24, 0x39ce, "1W2W" }, + { "modd", 14,24, 0x3bce, "1D2D" }, + { "movf", 14,24, 0x05be, "1F2F" }, + { "movl", 14,24, 0x04be, "1L2L" }, + { "movb", 6,16, 0x14, "1B2B" }, + { "movw", 6,16, 0x15, "1W2W" }, + { "movd", 6,16, 0x17, "1D2D" }, + { "movbf", 14,24, 0x043e, "1B2F" }, + { "movwf", 14,24, 0x053e, "1W2F" }, + { "movdf", 14,24, 0x073e, "1D2F" }, + { "movbl", 14,24, 0x003e, "1B2L" }, + { "movwl", 14,24, 0x013e, "1W2L" }, + { "movdl", 14,24, 0x033e, "1D2L" }, + { "movfl", 14,24, 0x1b3e, "1F2L" }, + { "movlf", 14,24, 0x163e, "1L2F" }, + { "movmb", 14,24, 0x00ce, "1D2D3d" }, + { "movmw", 14,24, 0x00de, "1D2D3d" }, + { "movmd", 14,24, 0x00fe, "1D2D3d" }, + { "movqb", 7,16, 0x5c, "2B1q" }, + { "movqw", 7,16, 0x5d, "2B1q" }, + { "movqd", 7,16, 0x5f, "2B1q" }, + { "movsb", 16,16, 0x000e, "1i" }, + { "movsw", 16,16, 0x010e, "1i" }, + { "movsd", 16,16, 0x030e, "1i" }, + { "movst", 16,16, 0x800e, "1i" }, + { "movsub", 14,24, 0x0cae, "1A1A" }, + { "movsuw", 14,24, 0x0dae, "1A1A" }, + { "movsud", 14,24, 0x0fae, "1A1A" }, + { "movusb", 14,24, 0x1cae, "1A1A" }, + { "movusw", 14,24, 0x1dae, "1A1A" }, + { "movusd", 14,24, 0x1fae, "1A1A" }, + { "movxbd", 14,24, 0x1cce, "1B2D" }, + { "movxwd", 14,24, 0x1dce, "1W2D" }, + { "movxbw", 14,24, 0x10ce, "1B2W" }, + { "movzbd", 14,24, 0x18ce, "1B2D" }, + { "movzwd", 14,24, 0x19ce, "1W2D" }, + { "movzbw", 14,24, 0x14ce, "1B2W" }, + { "mulf", 14,24, 0x31be, "1F2F" }, + { "mull", 14,24, 0x30be, "1L2L" }, + { "mulb", 14,24, 0x20ce, "1B2B" }, + { "mulw", 14,24, 0x21ce, "1W2W" }, + { "muld", 14,24, 0x23ce, "1D2D" }, + { "negf", 14,24, 0x15be, "1F2F" }, + { "negl", 14,24, 0x14be, "1L2L" }, + { "negb", 14,24, 0x204e, "1B2B" }, + { "negw", 14,24, 0x214e, "1W2W" }, + { "negd", 14,24, 0x234e, "1D2D" }, + { "nop", 8,8, 0xa2, "" }, + { "notb", 14,24, 0x244e, "1B2B" }, + { "notw", 14,24, 0x254e, "1W2W" }, + { "notd", 14,24, 0x274e, "1D2D" }, + { "orb", 6,16, 0x18, "1B1B" }, + { "orw", 6,16, 0x19, "1W1W" }, + { "ord", 6,16, 0x1b, "1D2D" }, + { "quob", 14,24, 0x30ce, "1B2B" }, + { "quow", 14,24, 0x31ce, "1W2W" }, + { "quod", 14,24, 0x33ce, "1D2D" }, + { "rdval", 19,24, 0x0031e,"1A" }, + { "remb", 14,24, 0x34ce, "1B2B" }, + { "remw", 14,24, 0x35ce, "1W2W" }, + { "remd", 14,24, 0x37ce, "1D2D" }, + { "restore", 8,8, 0x72, "1i" }, + { "ret", 8,8, 0x12, "1d" }, + { "reti", 8,8, 0x52, "" }, + { "rett", 8,8, 0x42, "" }, + { "rotb", 14,24, 0x004e, "1B2B" }, + { "rotw", 14,24, 0x014e, "1B2W" }, + { "rotd", 14,24, 0x034e, "1B2D" }, + { "roundfb", 14,24, 0x243e, "1F2B" }, + { "roundfw", 14,24, 0x253e, "1F2W" }, + { "roundfd", 14,24, 0x273e, "1F2D" }, + { "roundlb", 14,24, 0x203e, "1L2B" }, + { "roundlw", 14,24, 0x213e, "1L2W" }, + { "roundld", 14,24, 0x233e, "1L2D" }, + { "rxp", 8,8, 0x32, "1d" }, + { "sCONDb", 7,16, 0x3c, "2B1q" }, + { "sCONDw", 7,16, 0x3d, "2D1q" }, + { "sCONDd", 7,16, 0x3f, "2D1q" }, + { "save", 8,8, 0x62, "1i" }, + { "sbitb", 14,24, 0x184e, "1B2A" }, + { "sbitw", 14,24, 0x194e, "1W2A" }, + { "sbitd", 14,24, 0x1b4e, "1D2A" }, + { "sbitib", 14,24, 0x1c4e, "1B2A" }, + { "sbitiw", 14,24, 0x1d4e, "1W2A" }, + { "sbitid", 14,24, 0x1f4e, "1D2A" }, + { "setcfg", 15,24, 0x0b0e, "5D1q" }, + { "sfsr", 14,24, 0x673e, "5D1D" }, + { "skpsb", 16,16, 0x0c0e, "1i" }, + { "skpsw", 16,16, 0x0d0e, "1i" }, + { "skpsd", 16,16, 0x0f0e, "1i" }, + { "skpst", 16,16, 0x8c0e, "1i" }, + { "smr", 15,24, 0x0f1e, "2D1q" }, + { "sprb", 7,16, 0x2c, "2B1q" }, + { "sprw", 7,16, 0x2d, "2W1q" }, + { "sprd", 7,16, 0x2f, "2D1q" }, + { "subf", 14,24, 0x11be, "1F2F" }, + { "subl", 14,24, 0x10be, "1L2L" }, + { "subb", 6,16, 0x20, "1B2B" }, + { "subw", 6,16, 0x21, "1W2W" }, + { "subd", 6,16, 0x23, "1D2D" }, + { "subcb", 6,16, 0x30, "1B2B" }, + { "subcw", 6,16, 0x31, "1W2W" }, + { "subcd", 6,16, 0x33, "1D2D" }, + { "subpb", 14,24, 0x2c4e, "1B2B" }, + { "subpw", 14,24, 0x2d4e, "1W2W" }, + { "subpd", 14,24, 0x2f4e, "1D2D" }, +#ifndef NS32K_SVC_IMMED_OPERANDS + { "svc", 8,8, 0xe2, "2i1i" }, /* not really, but unix uses it */ +#else + { "svc", 8,8, 0xe2, "" }, /* not really, but unix uses it */ +#endif + { "tbitb", 6,16, 0x34, "1B2A" }, + { "tbitw", 6,16, 0x35, "1W2A" }, + { "tbitd", 6,16, 0x37, "1D2A" }, + { "truncfb", 14,24, 0x2c3e, "1F2B" }, + { "truncfw", 14,24, 0x2d3e, "1F2W" }, + { "truncfd", 14,24, 0x2f3e, "1F2D" }, + { "trunclb", 14,24, 0x283e, "1L2B" }, + { "trunclw", 14,24, 0x293e, "1L2W" }, + { "truncld", 14,24, 0x2b3e, "1L2D" }, + { "wait", 8,8, 0xb2, "" }, + { "wrval", 19,24, 0x0071e,"1A" }, + { "xorb", 6,16, 0x38, "1B2B" }, + { "xorw", 6,16, 0x39, "1W2W" }, + { "xord", 6,16, 0x3b, "1D2D" }, +}; /* notstrs */ + +/* end: ns32k.opcode.h */ + +#define MAX_ARGS 4 +#define ARG_LEN 50 diff --git a/gdb/ns32k-pinsn.c b/gdb/ns32k-pinsn.c new file mode 100644 index 0000000..1c558e9 --- /dev/null +++ b/gdb/ns32k-pinsn.c @@ -0,0 +1,523 @@ +/* Print 32000 instructions for GDB, the GNU debugger. + Copyright (C) 1986,1988 Free Software Foundation, Inc. + +GDB is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY. No author or distributor accepts responsibility to anyone +for the consequences of using it or for whether it serves any +particular purpose or works at all, unless he says so in writing. +Refer to the GDB General Public License for full details. + +Everyone is granted permission to copy, modify and redistribute GDB, +but only under the conditions described in the GDB General Public +License. A copy of this license is supposed to have been given to you +along with GDB so you can know your rights and responsibilities. It +should be in a file named COPYING. Among other things, the copyright +notice and this notice must be preserved on all copies. + +In other words, go ahead and share GDB, but don't try to stop +anyone else from sharing it farther. Help stamp out software hoarding! +*/ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "ns32k-opcode.h" +#include "gdbcore.h" + +/* 32000 instructions are never longer than this. */ +#define MAXLEN 62 + +/* Number of elements in the opcode table. */ +#define NOPCODES (sizeof notstrs / sizeof notstrs[0]) + +extern char *reg_names[]; + +#define NEXT_IS_ADDR '|' + +/* + * extract "count" bits starting "offset" bits + * into buffer + */ + +int +bit_extract (buffer, offset, count) + char *buffer; + int offset; + int count; +{ + int result; + int mask; + int bit; + + buffer += offset >> 3; + offset &= 7; + bit = 1; + result = 0; + while (count--) + { + if ((*buffer & (1 << offset))) + result |= bit; + if (++offset == 8) + { + offset = 0; + buffer++; + } + bit <<= 1; + } + return result; +} + +float +fbit_extract (buffer, offset, count) +{ + union { + int ival; + float fval; + } foo; + + foo.ival = bit_extract (buffer, offset, 32); + return foo.fval; +} + +double +dbit_extract (buffer, offset, count) +{ + union { + struct {int low, high; } ival; + double dval; + } foo; + + foo.ival.low = bit_extract (buffer, offset, 32); + foo.ival.high = bit_extract (buffer, offset+32, 32); + return foo.dval; +} + +sign_extend (value, bits) +{ + value = value & ((1 << bits) - 1); + return (value & (1 << (bits-1)) + ? value | (~((1 << bits) - 1)) + : value); +} + +flip_bytes (ptr, count) + char *ptr; + int count; +{ + char tmp; + + while (count > 0) + { + tmp = *ptr; + ptr[0] = ptr[count-1]; + ptr[count-1] = tmp; + ptr++; + count -= 2; + } +} + +/* Given a character C, does it represent a general addressing mode? */ +#define Is_gen(c) \ + ((c) == 'F' || (c) == 'L' || (c) == 'B' \ + || (c) == 'W' || (c) == 'D' || (c) == 'A') + +/* Adressing modes. */ +#define Adrmod_index_byte 0x1c +#define Adrmod_index_word 0x1d +#define Adrmod_index_doubleword 0x1e +#define Adrmod_index_quadword 0x1f + +/* Is MODE an indexed addressing mode? */ +#define Adrmod_is_index(mode) \ + (mode == Adrmod_index_byte \ + || mode == Adrmod_index_word \ + || mode == Adrmod_index_doubleword \ + || mode == Adrmod_index_quadword) + + +/* Print the 32000 instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i; + register unsigned char *p; + register char *d; + unsigned short first_word; + int gen, disp; + int ioffset; /* bits into instruction */ + int aoffset; /* bits into arguments */ + char arg_bufs[MAX_ARGS+1][ARG_LEN]; + int argnum; + int maxarg; + + read_memory (memaddr, buffer, MAXLEN); + + first_word = *(unsigned short *) buffer; + for (i = 0; i < NOPCODES; i++) + if ((first_word & ((1 << notstrs[i].detail.obits) - 1)) + == notstrs[i].detail.code) + break; + + /* Handle undefined instructions. */ + if (i == NOPCODES) + { + fprintf (stream, "0%o", buffer[0]); + return 1; + } + + fprintf (stream, "%s", notstrs[i].name); + + ioffset = notstrs[i].detail.ibits; + aoffset = notstrs[i].detail.ibits; + d = notstrs[i].detail.args; + + if (*d) + { + /* Offset in bits of the first thing beyond each index byte. + Element 0 is for operand A and element 1 is for operand B. + The rest are irrelevant, but we put them here so we don't + index outside the array. */ + int index_offset[MAX_ARGS]; + + /* 0 for operand A, 1 for operand B, greater for other args. */ + int whicharg = 0; + + fputc ('\t', stream); + + maxarg = 0; + + /* First we have to find and keep track of the index bytes, + if we are using scaled indexed addressing mode, since the index + bytes occur right after the basic instruction, not as part + of the addressing extension. */ + if (Is_gen(d[1])) + { + int addr_mode = bit_extract (buffer, ioffset - 5, 5); + + if (Adrmod_is_index (addr_mode)) + { + aoffset += 8; + index_offset[0] = aoffset; + } + } + if (d[2] && Is_gen(d[3])) + { + int addr_mode = bit_extract (buffer, ioffset - 10, 5); + + if (Adrmod_is_index (addr_mode)) + { + aoffset += 8; + index_offset[1] = aoffset; + } + } + + while (*d) + { + argnum = *d - '1'; + d++; + if (argnum > maxarg && argnum < MAX_ARGS) + maxarg = argnum; + ioffset = print_insn_arg (*d, ioffset, &aoffset, buffer, + memaddr, arg_bufs[argnum], + index_offset[whicharg]); + d++; + whicharg++; + } + for (argnum = 0; argnum <= maxarg; argnum++) + { + CORE_ADDR addr; + char *ch, *index (); + for (ch = arg_bufs[argnum]; *ch;) + { + if (*ch == NEXT_IS_ADDR) + { + ++ch; + addr = atoi (ch); + print_address (addr, stream); + while (*ch && *ch != NEXT_IS_ADDR) + ++ch; + if (*ch) + ++ch; + } + else + putc (*ch++, stream); + } + if (argnum < maxarg) + fprintf (stream, ", "); + } + } + return aoffset / 8; +} + +/* Print an instruction operand of category given by d. IOFFSET is + the bit position below which small (<1 byte) parts of the operand can + be found (usually in the basic instruction, but for indexed + addressing it can be in the index byte). AOFFSETP is a pointer to the + bit position of the addressing extension. BUFFER contains the + instruction. ADDR is where BUFFER was read from. Put the disassembled + version of the operand in RESULT. INDEX_OFFSET is the bit position + of the index byte (it contains garbage if this operand is not a + general operand using scaled indexed addressing mode). */ + +print_insn_arg (d, ioffset, aoffsetp, buffer, addr, result, index_offset) + char d; + int ioffset, *aoffsetp; + char *buffer; + CORE_ADDR addr; + char *result; + int index_offset; +{ + int addr_mode; + float Fvalue; + double Lvalue; + int Ivalue; + int disp1, disp2; + int index; + + switch (d) + { + case 'F': + case 'L': + case 'B': + case 'W': + case 'D': + case 'A': + addr_mode = bit_extract (buffer, ioffset-5, 5); + ioffset -= 5; + switch (addr_mode) + { + case 0x0: case 0x1: case 0x2: case 0x3: + case 0x4: case 0x5: case 0x6: case 0x7: + switch (d) + { + case 'F': + case 'L': + sprintf (result, "f%d", addr_mode); + break; + default: + sprintf (result, "r%d", addr_mode); + } + break; + case 0x8: case 0x9: case 0xa: case 0xb: + case 0xc: case 0xd: case 0xe: case 0xf: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "%d(r%d)", disp1, addr_mode & 7); + break; + case 0x10: + case 0x11: + case 0x12: + disp1 = get_displacement (buffer, aoffsetp); + disp2 = get_displacement (buffer, aoffsetp); + sprintf (result, "%d(%d(%s))", disp2, disp1, + addr_mode==0x10?"fp":addr_mode==0x11?"sp":"sb"); + break; + case 0x13: + sprintf (result, "reserved"); + break; + case 0x14: + switch (d) + { + case 'B': + Ivalue = bit_extract (buffer, *aoffsetp, 8); + Ivalue = sign_extend (Ivalue, 8); + *aoffsetp += 8; + sprintf (result, "$%d", Ivalue); + break; + case 'W': + Ivalue = bit_extract (buffer, *aoffsetp, 16); + flip_bytes (&Ivalue, 2); + *aoffsetp += 16; + Ivalue = sign_extend (Ivalue, 16); + sprintf (result, "$%d", Ivalue); + break; + case 'D': + Ivalue = bit_extract (buffer, *aoffsetp, 32); + flip_bytes (&Ivalue, 4); + *aoffsetp += 32; + sprintf (result, "$%d", Ivalue); + break; + case 'A': + Ivalue = bit_extract (buffer, *aoffsetp, 32); + flip_bytes (&Ivalue, 4); + *aoffsetp += 32; + sprintf (result, "$|%d|", Ivalue); + break; + case 'F': + Fvalue = fbit_extract (buffer, *aoffsetp, 32); + flip_bytes (&Fvalue, 4); + *aoffsetp += 32; + sprintf (result, "$%g", Fvalue); + break; + case 'L': + Lvalue = dbit_extract (buffer, *aoffsetp, 64); + flip_bytes (&Lvalue, 8); + *aoffsetp += 64; + sprintf (result, "$%g", Lvalue); + break; + } + break; + case 0x15: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "@|%d|", disp1); + break; + case 0x16: + disp1 = get_displacement (buffer, aoffsetp); + disp2 = get_displacement (buffer, aoffsetp); + sprintf (result, "EXT(%d) + %d", disp1, disp2); + break; + case 0x17: + sprintf (result, "tos"); + break; + case 0x18: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "%d(fp)", disp1); + break; + case 0x19: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "%d(sp)", disp1); + break; + case 0x1a: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "%d(sb)", disp1); + break; + case 0x1b: + disp1 = get_displacement (buffer, aoffsetp); + sprintf (result, "|%d|", addr + disp1); + break; + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: + index = bit_extract (buffer, index_offset - 8, 3); + print_insn_arg (d, index_offset, aoffsetp, buffer, addr, + result, 0); + { + static char *ind[] = {"b", "w", "d", "q"}; + char *off; + + off = result + strlen (result); + sprintf (off, "[r%d:%s]", index, + ind[addr_mode & 3]); + } + break; + } + break; + case 'q': + Ivalue = bit_extract (buffer, ioffset-4, 4); + Ivalue = sign_extend (Ivalue, 4); + sprintf (result, "%d", Ivalue); + ioffset -= 4; + break; + case 'r': + Ivalue = bit_extract (buffer, ioffset-3, 3); + sprintf (result, "r%d", Ivalue&7); + ioffset -= 3; + break; + case 'd': + sprintf (result, "%d", get_displacement (buffer, aoffsetp)); + break; + case 'p': + sprintf (result, "%c%d%c", NEXT_IS_ADDR, + addr + get_displacement (buffer, aoffsetp), + NEXT_IS_ADDR); + break; + case 'i': + Ivalue = bit_extract (buffer, *aoffsetp, 8); + *aoffsetp += 8; + sprintf (result, "0x%x", Ivalue); + break; + } + return ioffset; +} + +get_displacement (buffer, aoffsetp) + char *buffer; + int *aoffsetp; +{ + int Ivalue; + + Ivalue = bit_extract (buffer, *aoffsetp, 8); + switch (Ivalue & 0xc0) + { + case 0x00: + case 0x40: + Ivalue = sign_extend (Ivalue, 7); + *aoffsetp += 8; + break; + case 0x80: + Ivalue = bit_extract (buffer, *aoffsetp, 16); + flip_bytes (&Ivalue, 2); + Ivalue = sign_extend (Ivalue, 14); + *aoffsetp += 16; + break; + case 0xc0: + Ivalue = bit_extract (buffer, *aoffsetp, 32); + flip_bytes (&Ivalue, 4); + Ivalue = sign_extend (Ivalue, 30); + *aoffsetp += 32; + break; + } + return Ivalue; +} + +/* Return the number of locals in the current frame given a pc + pointing to the enter instruction. This is used in the macro + FRAME_FIND_SAVED_REGS. */ + +ns32k_localcount (enter_pc) + CORE_ADDR enter_pc; +{ + unsigned char localtype; + int localcount; + + localtype = read_memory_integer (enter_pc+2, 1); + if ((localtype & 0x80) == 0) + localcount = localtype; + else if ((localtype & 0xc0) == 0x80) + localcount = (((localtype & 0x3f) << 8) + | (read_memory_integer (enter_pc+3, 1) & 0xff)); + else + localcount = (((localtype & 0x3f) << 24) + | ((read_memory_integer (enter_pc+3, 1) & 0xff) << 16) + | ((read_memory_integer (enter_pc+4, 1) & 0xff) << 8 ) + | (read_memory_integer (enter_pc+5, 1) & 0xff)); + return localcount; +} + +/* + * Get the address of the enter opcode for the function + * containing PC, if there is an enter for the function, + * and if the pc is between the enter and exit. + * Returns positive address if pc is between enter/exit, + * 1 if pc before enter or after exit, 0 otherwise. + */ + +CORE_ADDR +ns32k_get_enter_addr (pc) + CORE_ADDR pc; +{ + CORE_ADDR enter_addr; + unsigned char op; + + if (ABOUT_TO_RETURN (pc)) + return 1; /* after exit */ + + enter_addr = get_pc_function_start (pc); + + if (pc == enter_addr) + return 1; /* before enter */ + + op = read_memory_integer (enter_addr, 1); + + if (op != 0x82) + return 0; /* function has no enter/exit */ + + return enter_addr; /* pc is between enter and exit */ +} diff --git a/gdb/obstack.c b/gdb/obstack.c new file mode 100755 index 0000000..590fcaa --- /dev/null +++ b/gdb/obstack.c @@ -0,0 +1,333 @@ +/* obstack.c - subroutines used implicitly by object stack macros + Copyright (C) 1988 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 1, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "obstack.h" + +#ifdef __STDC__ +#define POINTER void * +#else +#define POINTER char * +#endif + +/* Determine default alignment. */ +struct fooalign {char x; double d;}; +#define DEFAULT_ALIGNMENT ((char *)&((struct fooalign *) 0)->d - (char *)0) +/* If malloc were really smart, it would round addresses to DEFAULT_ALIGNMENT. + But in fact it might be less smart and round addresses to as much as + DEFAULT_ROUNDING. So we prepare for it to do that. */ +union fooround {long x; double d;}; +#define DEFAULT_ROUNDING (sizeof (union fooround)) + +/* When we copy a long block of data, this is the unit to do it with. + On some machines, copying successive ints does not work; + in such a case, redefine COPYING_UNIT to `long' (if that works) + or `char' as a last resort. */ +#ifndef COPYING_UNIT +#define COPYING_UNIT int +#endif + +/* The non-GNU-C macros copy the obstack into this global variable + to avoid multiple evaluation. */ + +struct obstack *_obstack; + +/* Initialize an obstack H for use. Specify chunk size SIZE (0 means default). + Objects start on multiples of ALIGNMENT (0 means use default). + CHUNKFUN is the function to use to allocate chunks, + and FREEFUN the function to free them. */ + +void +_obstack_begin (h, size, alignment, chunkfun, freefun) + struct obstack *h; + int size; + int alignment; + POINTER (*chunkfun) (); + void (*freefun) (); +{ + register struct _obstack_chunk* chunk; /* points to new chunk */ + + if (alignment == 0) + alignment = DEFAULT_ALIGNMENT; + if (size == 0) + /* Default size is what GNU malloc can fit in a 4096-byte block. */ + { + /* 12 is sizeof (mhead) and 4 is EXTRA from GNU malloc. + Use the values for range checking, because if range checking is off, + the extra bytes won't be missed terribly, but if range checking is on + and we used a larger request, a whole extra 4096 bytes would be + allocated. + + These number are irrelevant to the new GNU malloc. I suspect it is + less sensitive to the size of the request. */ + int extra = ((((12 + DEFAULT_ROUNDING - 1) & ~(DEFAULT_ROUNDING - 1)) + + 4 + DEFAULT_ROUNDING - 1) + & ~(DEFAULT_ROUNDING - 1)); + size = 4096 - extra; + } + + h->chunkfun = chunkfun; + h->freefun = freefun; + h->chunk_size = size; + h->alignment_mask = alignment - 1; + + chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (h->chunk_size); + h->next_free = h->object_base = chunk->contents; + h->chunk_limit = chunk->limit + = (char *) chunk + h->chunk_size; + chunk->prev = 0; +} + +/* Allocate a new current chunk for the obstack *H + on the assumption that LENGTH bytes need to be added + to the current object, or a new object of length LENGTH allocated. + Copies any partial object from the end of the old chunk + to the beginning of the new one. + + The function must be "int" so it can be used in non-ANSI C + compilers in a : expression. */ + +int +_obstack_newchunk (h, length) + struct obstack *h; + int length; +{ + register struct _obstack_chunk* old_chunk = h->chunk; + register struct _obstack_chunk* new_chunk; + register long new_size; + register int obj_size = h->next_free - h->object_base; + register int i; + int already; + + /* Compute size for new chunk. */ + new_size = (obj_size + length) + (obj_size >> 3) + 100; + if (new_size < h->chunk_size) + new_size = h->chunk_size; + + /* Allocate and initialize the new chunk. */ + new_chunk = h->chunk = (struct _obstack_chunk *)(*h->chunkfun) (new_size); + new_chunk->prev = old_chunk; + new_chunk->limit = h->chunk_limit = (char *) new_chunk + new_size; + + /* Move the existing object to the new chunk. + Word at a time is fast and is safe if the object + is sufficiently aligned. */ + if (h->alignment_mask + 1 >= DEFAULT_ALIGNMENT) + { + for (i = obj_size / sizeof (COPYING_UNIT) - 1; + i >= 0; i--) + ((COPYING_UNIT *)new_chunk->contents)[i] + = ((COPYING_UNIT *)h->object_base)[i]; + /* We used to copy the odd few remaining bytes as one extra COPYING_UNIT, + but that can cross a page boundary on a machine + which does not do strict alignment for COPYING_UNITS. */ + already = obj_size / sizeof (COPYING_UNIT) * sizeof (COPYING_UNIT); + } + else + already = 0; + /* Copy remaining bytes one by one. */ + for (i = already; i < obj_size; i++) + new_chunk->contents[i] = h->object_base[i]; + + h->object_base = new_chunk->contents; + h->next_free = h->object_base + obj_size; +} + +/* Return nonzero if object OBJ has been allocated from obstack H. + This is here for debugging. + If you use it in a program, you are probably losing. */ + +int +_obstack_allocated_p (h, obj) + struct obstack *h; + POINTER obj; +{ + register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */ + register struct _obstack_chunk* plp; /* point to previous chunk if any */ + + lp = (h)->chunk; + while (lp != 0 && ((POINTER)lp > obj || (POINTER)(lp)->limit < obj)) + { + plp = lp -> prev; + lp = plp; + } + return lp != 0; +} + +/* Free objects in obstack H, including OBJ and everything allocate + more recently than OBJ. If OBJ is zero, free everything in H. */ + +#ifdef __STDC__ +#undef obstack_free +void +obstack_free (struct obstack *h, POINTER obj) +#else +int +_obstack_free (h, obj) + struct obstack *h; + POINTER obj; +#endif +{ + register struct _obstack_chunk* lp; /* below addr of any objects in this chunk */ + register struct _obstack_chunk* plp; /* point to previous chunk if any */ + + lp = (h)->chunk; + /* We use >= because there cannot be an object at the beginning of a chunk. + But there can be an empty object at that address + at the end of another chunk. */ + while (lp != 0 && ((POINTER)lp >= obj || (POINTER)(lp)->limit < obj)) + { + plp = lp -> prev; + (*h->freefun) ((POINTER) lp); + lp = plp; + } + if (lp) + { + (h)->object_base = (h)->next_free = (char *)(obj); + (h)->chunk_limit = lp->limit; + (h)->chunk = lp; + } + else if (obj != 0) + /* obj is not in any of the chunks! */ + abort (); +} + +/* Let same .o link with output of gcc and other compilers. */ + +#ifdef __STDC__ +int +_obstack_free (h, obj) + struct obstack *h; + POINTER obj; +{ + obstack_free (h, obj); +} +#endif + +/* #if 0 */ +/* These are now turned off because the applications do not use it + and it uses bcopy via obstack_grow, which causes trouble on sysV. */ + +/* Now define the functional versions of the obstack macros. + Define them to simply use the corresponding macros to do the job. */ + +#ifdef __STDC__ +/* These function definitions do not work with non-ANSI preprocessors; + they won't pass through the macro names in parentheses. */ + +/* The function names appear in parentheses in order to prevent + the macro-definitions of the names from being expanded there. */ + +POINTER (obstack_base) (obstack) + struct obstack *obstack; +{ + return obstack_base (obstack); +} + +POINTER (obstack_next_free) (obstack) + struct obstack *obstack; +{ + return obstack_next_free (obstack); +} + +int (obstack_object_size) (obstack) + struct obstack *obstack; +{ + return obstack_object_size (obstack); +} + +int (obstack_room) (obstack) + struct obstack *obstack; +{ + return obstack_room (obstack); +} + +void (obstack_grow) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + obstack_grow (obstack, pointer, length); +} + +void (obstack_grow0) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + obstack_grow0 (obstack, pointer, length); +} + +void (obstack_1grow) (obstack, character) + struct obstack *obstack; + int character; +{ + obstack_1grow (obstack, character); +} + +void (obstack_blank) (obstack, length) + struct obstack *obstack; + int length; +{ + obstack_blank (obstack, length); +} + +void (obstack_1grow_fast) (obstack, character) + struct obstack *obstack; + int character; +{ + obstack_1grow_fast (obstack, character); +} + +void (obstack_blank_fast) (obstack, length) + struct obstack *obstack; + int length; +{ + obstack_blank_fast (obstack, length); +} + +POINTER (obstack_finish) (obstack) + struct obstack *obstack; +{ + return obstack_finish (obstack); +} + +POINTER (obstack_alloc) (obstack, length) + struct obstack *obstack; + int length; +{ + return obstack_alloc (obstack, length); +} + +POINTER (obstack_copy) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + return obstack_copy (obstack, pointer, length); +} + +POINTER (obstack_copy0) (obstack, pointer, length) + struct obstack *obstack; + POINTER pointer; + int length; +{ + return obstack_copy0 (obstack, pointer, length); +} + +#endif /* __STDC__ */ + +/* #endif 0 */ diff --git a/gdb/obstack.h b/gdb/obstack.h new file mode 100755 index 0000000..2e80c9c --- /dev/null +++ b/gdb/obstack.h @@ -0,0 +1,416 @@ +/* obstack.h - object stack macros + Copyright (C) 1988 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify it +under the terms of the GNU General Public License as published by the +Free Software Foundation; either version 1, or (at your option) any +later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; if not, write to the Free Software +Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Summary: + +All the apparent functions defined here are macros. The idea +is that you would use these pre-tested macros to solve a +very specific set of problems, and they would run fast. +Caution: no side-effects in arguments please!! They may be +evaluated MANY times!! + +These macros operate a stack of objects. Each object starts life +small, and may grow to maturity. (Consider building a word syllable +by syllable.) An object can move while it is growing. Once it has +been "finished" it never changes address again. So the "top of the +stack" is typically an immature growing object, while the rest of the +stack is of mature, fixed size and fixed address objects. + +These routines grab large chunks of memory, using a function you +supply, called `obstack_chunk_alloc'. On occasion, they free chunks, +by calling `obstack_chunk_free'. You must define them and declare +them before using any obstack macros. + +Each independent stack is represented by a `struct obstack'. +Each of the obstack macros expects a pointer to such a structure +as the first argument. + +One motivation for this package is the problem of growing char strings +in symbol tables. Unless you are "fascist pig with a read-only mind" +[Gosper's immortal quote from HAKMEM item 154, out of context] you +would not like to put any arbitrary upper limit on the length of your +symbols. + +In practice this often means you will build many short symbols and a +few long symbols. At the time you are reading a symbol you don't know +how long it is. One traditional method is to read a symbol into a +buffer, realloc()ating the buffer every time you try to read a symbol +that is longer than the buffer. This is beaut, but you still will +want to copy the symbol from the buffer to a more permanent +symbol-table entry say about half the time. + +With obstacks, you can work differently. Use one obstack for all symbol +names. As you read a symbol, grow the name in the obstack gradually. +When the name is complete, finalize it. Then, if the symbol exists already, +free the newly read name. + +The way we do this is to take a large chunk, allocating memory from +low addresses. When you want to build a symbol in the chunk you just +add chars above the current "high water mark" in the chunk. When you +have finished adding chars, because you got to the end of the symbol, +you know how long the chars are, and you can create a new object. +Mostly the chars will not burst over the highest address of the chunk, +because you would typically expect a chunk to be (say) 100 times as +long as an average object. + +In case that isn't clear, when we have enough chars to make up +the object, THEY ARE ALREADY CONTIGUOUS IN THE CHUNK (guaranteed) +so we just point to it where it lies. No moving of chars is +needed and this is the second win: potentially long strings need +never be explicitly shuffled. Once an object is formed, it does not +change its address during its lifetime. + +When the chars burst over a chunk boundary, we allocate a larger +chunk, and then copy the partly formed object from the end of the old +chunk to the beginning of the new larger chunk. We then carry on +accreting characters to the end of the object as we normally would. + +A special macro is provided to add a single char at a time to a +growing object. This allows the use of register variables, which +break the ordinary 'growth' macro. + +Summary: + We allocate large chunks. + We carve out one object at a time from the current chunk. + Once carved, an object never moves. + We are free to append data of any size to the currently + growing object. + Exactly one object is growing in an obstack at any one time. + You can run one obstack per control block. + You may have as many control blocks as you dare. + Because of the way we do it, you can `unwind' a obstack + back to a previous state. (You may remove objects much + as you would with a stack.) +*/ + + +/* Don't do the contents of this file more than once. */ + +#ifndef __OBSTACKS__ +#define __OBSTACKS__ + +/* We use subtraction of (char *)0 instead of casting to int + because on word-addressable machines a simple cast to int + may ignore the byte-within-word field of the pointer. */ + +#ifndef __PTR_TO_INT +#define __PTR_TO_INT(P) ((P) - (char *)0) +#endif + +#ifndef __INT_TO_PTR +#define __INT_TO_PTR(P) ((P) + (char *)0) +#endif + +struct _obstack_chunk /* Lives at front of each chunk. */ +{ + char *limit; /* 1 past end of this chunk */ + struct _obstack_chunk *prev; /* address of prior chunk or NULL */ + char contents[4]; /* objects begin here */ +}; + +struct obstack /* control current object in current chunk */ +{ + long chunk_size; /* preferred size to allocate chunks in */ + struct _obstack_chunk* chunk; /* address of current struct obstack_chunk */ + char *object_base; /* address of object we are building */ + char *next_free; /* where to add next char to current object */ + char *chunk_limit; /* address of char after current chunk */ + int temp; /* Temporary for some macros. */ + int alignment_mask; /* Mask of alignment for each object. */ +#ifdef __STDC__ + void *(*chunkfun) (); /* User's fcn to allocate a chunk. */ +#else + char *(*chunkfun) (); /* User's fcn to allocate a chunk. */ +#endif + void (*freefun) (); /* User's function to free a chunk. */ +}; + +#ifdef __STDC__ + +/* Do the function-declarations after the structs + but before defining the macros. */ + +void obstack_init (struct obstack *obstack); + +void * obstack_alloc (struct obstack *obstack, int size); + +void * obstack_copy (struct obstack *obstack, void *address, int size); +void * obstack_copy0 (struct obstack *obstack, void *address, int size); + +void obstack_free (struct obstack *obstack, void *block); + +void obstack_blank (struct obstack *obstack, int size); + +void obstack_grow (struct obstack *obstack, void *data, int size); +void obstack_grow0 (struct obstack *obstack, void *data, int size); + +void obstack_1grow (struct obstack *obstack, int data_char); +void obstack_ptr_grow (struct obstack *obstack, void *data); +void obstack_int_grow (struct obstack *obstack, int data); + +void * obstack_finish (struct obstack *obstack); + +int obstack_object_size (struct obstack *obstack); + +int obstack_room (struct obstack *obstack); +void obstack_1grow_fast (struct obstack *obstack, int data_char); +void obstack_ptr_grow_fast (struct obstack *obstack, void *data); +void obstack_int_grow_fast (struct obstack *obstack, int data); +void obstack_blank_fast (struct obstack *obstack, int size); + +void * obstack_base (struct obstack *obstack); +void * obstack_next_free (struct obstack *obstack); +int obstack_alignment_mask (struct obstack *obstack); +int obstack_chunk_size (struct obstack *obstack); + +#endif /* __STDC__ */ + +/* Non-ANSI C cannot really support alternative functions for these macros, + so we do not declare them. */ + +/* Pointer to beginning of object being allocated or to be allocated next. + Note that this might not be the final address of the object + because a new chunk might be needed to hold the final size. */ + +#define obstack_base(h) ((h)->object_base) + +/* Size for allocating ordinary chunks. */ + +#define obstack_chunk_size(h) ((h)->chunk_size) + +/* Pointer to next byte not yet allocated in current chunk. */ + +#define obstack_next_free(h) ((h)->next_free) + +/* Mask specifying low bits that should be clear in address of an object. */ + +#define obstack_alignment_mask(h) ((h)->alignment_mask) + +#define obstack_init(h) \ + _obstack_begin ((h), 0, 0, obstack_chunk_alloc, obstack_chunk_free) + +#define obstack_begin(h, size) \ + _obstack_begin ((h), (size), 0, obstack_chunk_alloc, obstack_chunk_free) + +#define obstack_1grow_fast(h,achar) (*((h)->next_free)++ = achar) + +#define obstack_blank_fast(h,n) ((h)->next_free += (n)) + +#if defined (__GNUC__) && defined (__STDC__) + +/* For GNU C, if not -traditional, + we can define these macros to compute all args only once + without using a global variable. + Also, we can avoid using the `temp' slot, to make faster code. */ + +#define obstack_object_size(OBSTACK) \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->next_free - __o->object_base); }) + +#define obstack_room(OBSTACK) \ + ({ struct obstack *__o = (OBSTACK); \ + (unsigned) (__o->chunk_limit - __o->next_free); }) + +#define obstack_grow(OBSTACK,where,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->next_free + __len > __o->chunk_limit) \ + ? _obstack_newchunk (__o, __len) : 0); \ + bcopy (where, __o->next_free, __len); \ + __o->next_free += __len; \ + (void) 0; }) + +#define obstack_grow0(OBSTACK,where,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->next_free + __len + 1 > __o->chunk_limit) \ + ? _obstack_newchunk (__o, __len + 1) : 0), \ + bcopy (where, __o->next_free, __len), \ + __o->next_free += __len, \ + *(__o->next_free)++ = 0; \ + (void) 0; }) + +#define obstack_1grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + 1 > __o->chunk_limit) \ + ? _obstack_newchunk (__o, 1) : 0), \ + *(__o->next_free)++ = (datum); \ + (void) 0; }) + +/* These assume that the obstack alignment is good enough for pointers or ints, + and that the data added so far to the current object + shares that much alignment. */ + +#define obstack_ptr_grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + sizeof (void *) > __o->chunk_limit) \ + ? _obstack_newchunk (__o, sizeof (void *)) : 0), \ + *(*(void ***)&__o->next_free)++ = ((void *)datum); \ + (void) 0; }) + +#define obstack_int_grow(OBSTACK,datum) \ +({ struct obstack *__o = (OBSTACK); \ + ((__o->next_free + sizeof (int) > __o->chunk_limit) \ + ? _obstack_newchunk (__o, sizeof (int)) : 0), \ + *(*(int **)&__o->next_free)++ = ((int)datum); \ + (void) 0; }) + +#define obstack_ptr_grow_fast(h,aptr) (*(*(void ***)&(h)->next_free)++ = (void *)aptr) +#define obstack_int_grow_fast(h,aint) (*(*(int **)&(h)->next_free)++ = (int)aint) + +#define obstack_blank(OBSTACK,length) \ +({ struct obstack *__o = (OBSTACK); \ + int __len = (length); \ + ((__o->chunk_limit - __o->next_free < __len) \ + ? _obstack_newchunk (__o, __len) : 0); \ + __o->next_free += __len; \ + (void) 0; }) + +#define obstack_alloc(OBSTACK,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_blank (__h, (length)); \ + obstack_finish (__h); }) + +#define obstack_copy(OBSTACK,where,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow (__h, (where), (length)); \ + obstack_finish (__h); }) + +#define obstack_copy0(OBSTACK,where,length) \ +({ struct obstack *__h = (OBSTACK); \ + obstack_grow0 (__h, (where), (length)); \ + obstack_finish (__h); }) + +#define obstack_finish(OBSTACK) \ +({ struct obstack *__o = (OBSTACK); \ + void *value = (void *) __o->object_base; \ + __o->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT (__o->next_free)+__o->alignment_mask)\ + & ~ (__o->alignment_mask)); \ + ((__o->next_free - (char *)__o->chunk \ + > __o->chunk_limit - (char *)__o->chunk) \ + ? (__o->next_free = __o->chunk_limit) : 0); \ + __o->object_base = __o->next_free; \ + value; }) + +#define obstack_free(OBSTACK, OBJ) \ +({ struct obstack *__o = (OBSTACK); \ + void *__obj = (OBJ); \ + if (__obj > (void *)__o->chunk && __obj < (void *)__o->chunk_limit) \ + __o->next_free = __o->object_base = __obj; \ + else (obstack_free) (__o, __obj); }) + +#else /* not __GNUC__ or not __STDC__ */ + +#define obstack_object_size(h) \ + (unsigned) ((h)->next_free - (h)->object_base) + +#define obstack_room(h) \ + (unsigned) ((h)->chunk_limit - (h)->next_free) + +#define obstack_grow(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), (h)->temp) : 0), \ + bcopy (where, (h)->next_free, (h)->temp), \ + (h)->next_free += (h)->temp) + +#define obstack_grow0(h,where,length) \ +( (h)->temp = (length), \ + (((h)->next_free + (h)->temp + 1 > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), (h)->temp + 1) : 0), \ + bcopy (where, (h)->next_free, (h)->temp), \ + (h)->next_free += (h)->temp, \ + *((h)->next_free)++ = 0) + +#define obstack_1grow(h,datum) \ +( (((h)->next_free + 1 > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), 1) : 0), \ + *((h)->next_free)++ = (datum)) + +#define obstack_ptr_grow(h,datum) \ +( (((h)->next_free + sizeof (char *) > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), sizeof (char *)) : 0), \ + *(*(char ***)&(h)->next_free)++ = ((char *)datum)) + +#define obstack_int_grow(h,datum) \ +( (((h)->next_free + sizeof (int) > (h)->chunk_limit) \ + ? _obstack_newchunk ((h), sizeof (int)) : 0), \ + *(*(int **)&(h)->next_free)++ = ((int)datum)) + +#define obstack_ptr_grow_fast(h,aptr) (*(*(char ***)&(h)->next_free)++ = (char *)aptr) +#define obstack_int_grow_fast(h,aint) (*(*(int **)&(h)->next_free)++ = (int)aint) + +#define obstack_blank(h,length) \ +( (h)->temp = (length), \ + (((h)->chunk_limit - (h)->next_free < (h)->temp) \ + ? _obstack_newchunk ((h), (h)->temp) : 0), \ + (h)->next_free += (h)->temp) + +#define obstack_alloc(h,length) \ + (obstack_blank ((h), (length)), obstack_finish ((h))) + +#define obstack_copy(h,where,length) \ + (obstack_grow ((h), (where), (length)), obstack_finish ((h))) + +#define obstack_copy0(h,where,length) \ + (obstack_grow0 ((h), (where), (length)), obstack_finish ((h))) + +#define obstack_finish(h) \ +( (h)->temp = __PTR_TO_INT ((h)->object_base), \ + (h)->next_free \ + = __INT_TO_PTR ((__PTR_TO_INT ((h)->next_free)+(h)->alignment_mask) \ + & ~ ((h)->alignment_mask)), \ + (((h)->next_free - (char *)(h)->chunk \ + > (h)->chunk_limit - (char *)(h)->chunk) \ + ? ((h)->next_free = (h)->chunk_limit) : 0), \ + (h)->object_base = (h)->next_free, \ + __INT_TO_PTR ((h)->temp)) + +#ifdef __STDC__ +#define obstack_free(h,obj) \ +( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ + (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ + ? (int) ((h)->next_free = (h)->object_base \ + = (h)->temp + (char *) (h)->chunk) \ + : ((obstack_free) ((h), (h)->temp + (char *) (h)->chunk), 0))) +#else +#define obstack_free(h,obj) \ +( (h)->temp = (char *)(obj) - (char *) (h)->chunk, \ + (((h)->temp >= 0 && (h)->temp < (h)->chunk_limit - (char *) (h)->chunk)\ + ? (int) ((h)->next_free = (h)->object_base \ + = (h)->temp + (char *) (h)->chunk) \ + : (int) _obstack_free ((h), (h)->temp + (char *) (h)->chunk))) +#endif + +#endif /* not __GNUC__ or not __STDC__ */ + +/* Declare the external functions we use; they are in obstack.c. */ + +#ifdef __STDC__ + extern int _obstack_newchunk (struct obstack *h, int length); + extern int _obstack_free (struct obstack *h, void *obj); + extern void _obstack_begin (struct obstack *h, int size, int alignment, + void *(*chunkfun) (), void (*freefun) ()); +#else + extern int _obstack_newchunk (); + extern int _obstack_free (); + extern void _obstack_begin (); +#endif + +#endif /* not __OBSTACKS__ */ + diff --git a/gdb/param-no-tm.h b/gdb/param-no-tm.h new file mode 100755 index 0000000..2e4af53 --- /dev/null +++ b/gdb/param-no-tm.h @@ -0,0 +1,76 @@ +/* Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#if !defined (PARAM_H) +#define PARAM_H 1 + +/* DO NOT #include "tm.h" -- a particular tm file has been inc'd by caller */ + +#include "xm.h" + +/* TARGET_BYTE_ORDER and HOST_BYTE_ORDER should be defined to one of these. */ +#if !defined (BIG_ENDIAN) +#define BIG_ENDIAN 4321 +#endif + +#if !defined (LITTLE_ENDIAN) +#define LITTLE_ENDIAN 1234 +#endif + +/* The bit byte-order has to do just with numbering of bits in + debugging symbols and such. Conceptually, it's quite separate + from byte/word byte order. */ + +#if TARGET_BYTE_ORDER == BIG_ENDIAN +#define BITS_BIG_ENDIAN 1 +#endif + +#if TARGET_BYTE_ORDER == LITTLE_ENDIAN +/*#define BITS_BIG_ENDIAN */ +#endif + +/* Swap LEN bytes at BUFFER between target and host byte-order. */ +#if TARGET_BYTE_ORDER == HOST_BYTE_ORDER +#define SWAP_TARGET_AND_HOST(buffer,len) +#else /* Target and host byte order differ. */ +#define SWAP_TARGET_AND_HOST(buffer,len) \ + { \ + char tmp; \ + char *p = (char *)(buffer); \ + char *q = ((char *)(buffer)) + len - 1; \ + for (; p < q; p++, q--) \ + { \ + tmp = *q; \ + *q = *p; \ + *p = tmp; \ + } \ + } +#endif /* Target and host byte order differ. */ + +/* On some machines there are bits in addresses which are not really + part of the address, but are used by the kernel, the hardware, etc. + for special purposes. ADDR_BITS_REMOVE takes out any such bits + so we get a "real" address such as one would find in a symbol + table. ADDR_BITS_SET sets those bits the way the system wants + them. */ +#if !defined (ADDR_BITS_REMOVE) +#define ADDR_BITS_REMOVE(addr) (addr) +#define ADDR_BITS_SET(addr) (addr) +#endif /* No ADDR_BITS_REMOVE. */ + +#endif /* param.h not already included. */ diff --git a/gdb/param.h b/gdb/param.h new file mode 100755 index 0000000..0a56936 --- /dev/null +++ b/gdb/param.h @@ -0,0 +1,30 @@ +/* Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* The standard thing is to include param.h. However, files that are + specific to a particular target can include that tm-xxx.h file and + param-no-tm.h. Any future inclusions of param.h will be protected + against by the #if !defined stuff below. */ + +#if !defined (PARAM_H) +#include "tm.h" +#endif + +#include "param-no-tm.h" + +#define PARAM_H 1 diff --git a/gdb/pn-opcode.h b/gdb/pn-opcode.h new file mode 100755 index 0000000..fde4764 --- /dev/null +++ b/gdb/pn-opcode.h @@ -0,0 +1,282 @@ +/* Print GOULD PN (PowerNode) instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +struct gld_opcode +{ + char *name; + unsigned long opcode; + unsigned long mask; + char *args; + int length; +}; + +/* We store four bytes of opcode for all opcodes because that + is the most any of them need. The actual length of an instruction + is always at least 2 bytes, and at most four. The length of the + instruction is based on the opcode. + + The mask component is a mask saying which bits must match + particular opcode in order for an instruction to be an instance + of that opcode. + + The args component is a string containing characters + that are used to format the arguments to the instruction. */ + +/* Kinds of operands: + r Register in first field + R Register in second field + b Base register in first field + B Base register in second field + v Vector register in first field + V Vector register in first field + A Optional address register (base register) + X Optional index register + I Immediate data (16bits signed) + O Offset field (16bits signed) + h Offset field (15bits signed) + d Offset field (14bits signed) + S Shift count field + + any other characters are printed as is... +*/ + +/* The assembler requires that this array be sorted as follows: + all instances of the same mnemonic must be consecutive. + All instances of the same mnemonic with the same number of operands + must be consecutive. + */ +struct gld_opcode gld_opcodes[] = +{ +{ "abm", 0xa0080000, 0xfc080000, "f,xOA,X", 4 }, +{ "abr", 0x18080000, 0xfc0c0000, "r,f", 2 }, +{ "aci", 0xfc770000, 0xfc7f8000, "r,I", 4 }, +{ "adfd", 0xe0080002, 0xfc080002, "r,xOA,X", 4 }, +{ "adfw", 0xe0080000, 0xfc080000, "r,xOA,X", 4 }, +{ "adi", 0xc8010000, 0xfc7f0000, "r,I", 4 }, +{ "admb", 0xb8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "admd", 0xb8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "admh", 0xb8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "admw", 0xb8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "adr", 0x38000000, 0xfc0f0000, "r,R", 2 }, +{ "adrfd", 0x38090000, 0xfc0f0000, "r,R", 2 }, +{ "adrfw", 0x38010000, 0xfc0f0000, "r,R", 2 }, +{ "adrm", 0x38080000, 0xfc0f0000, "r,R", 2 }, +{ "ai", 0xfc030000, 0xfc07ffff, "I", 4 }, +{ "anmb", 0x84080000, 0xfc080000, "r,xOA,X", 4 }, +{ "anmd", 0x84000002, 0xfc080002, "r,xOA,X", 4 }, +{ "anmh", 0x84000001, 0xfc080001, "r,xOA,X", 4 }, +{ "anmw", 0x84000000, 0xfc080000, "r,xOA,X", 4 }, +{ "anr", 0x04000000, 0xfc0f0000, "r,R", 2 }, +{ "armb", 0xe8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "armd", 0xe8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "armh", 0xe8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "armw", 0xe8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "bcf", 0xf0000000, 0xfc080000, "I,xOA,X", 4 }, +{ "bct", 0xec000000, 0xfc080000, "I,xOA,X", 4 }, +{ "bei", 0x00060000, 0xffff0000, "", 2 }, +{ "bft", 0xf0000000, 0xff880000, "xOA,X", 4 }, +{ "bib", 0xf4000000, 0xfc780000, "r,xOA", 4 }, +{ "bid", 0xf4600000, 0xfc780000, "r,xOA", 4 }, +{ "bih", 0xf4200000, 0xfc780000, "r,xOA", 4 }, +{ "biw", 0xf4400000, 0xfc780000, "r,xOA", 4 }, +{ "bl", 0xf8800000, 0xff880000, "xOA,X", 4 }, +{ "bsub", 0x5c080000, 0xff8f0000, "", 2 }, +{ "bsubm", 0x28080000, 0xfc080000, "", 4 }, +{ "bu", 0xec000000, 0xff880000, "xOA,X", 4 }, +{ "call", 0x28080000, 0xfc0f0000, "", 2 }, +{ "callm", 0x5c080000, 0xff880000, "", 4 }, +{ "camb", 0x90080000, 0xfc080000, "r,xOA,X", 4 }, +{ "camd", 0x90000002, 0xfc080002, "r,xOA,X", 4 }, +{ "camh", 0x90000001, 0xfc080001, "r,xOA,X", 4 }, +{ "camw", 0x90000000, 0xfc080000, "r.xOA,X", 4 }, +{ "car", 0x10000000, 0xfc0f0000, "r,R", 2 }, +{ "cd", 0xfc060000, 0xfc070000, "r,f", 4 }, +{ "cea", 0x000f0000, 0xffff0000, "", 2 }, +{ "ci", 0xc8050000, 0xfc7f0000, "r,I", 4 }, +{ "cmc", 0x040a0000, 0xfc7f0000, "r", 2 }, +{ "cmmb", 0x94080000, 0xfc080000, "r,xOA,X", 4 }, +{ "cmmd", 0x94000002, 0xfc080002, "r,xOA,X", 4 }, +{ "cmmh", 0x94000001, 0xfc080001, "r,xOA,X", 4 }, +{ "cmmw", 0x94000000, 0xfc080000, "r,xOA,X", 4 }, +{ "cmr", 0x14000000, 0xfc0f0000, "r,R", 2 }, +{ "daci", 0xfc7f0000, 0xfc7f8000, "r,I", 4 }, +{ "dae", 0x000e0000, 0xffff0000, "", 2 }, +{ "dai", 0xfc040000, 0xfc07ffff, "I", 4 }, +{ "dci", 0xfc6f0000, 0xfc7f8000, "r,I", 4 }, +{ "di", 0xfc010000, 0xfc07ffff, "I", 4 }, +{ "dvfd", 0xe4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "dvfw", 0xe4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "dvi", 0xc8040000, 0xfc7f0000, "r,I", 4 }, +{ "dvmb", 0xc4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "dvmh", 0xc4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "dvmw", 0xc4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "dvr", 0x380a0000, 0xfc0f0000, "r,R", 2 }, +{ "dvrfd", 0x380c0000, 0xfc0f0000, "r,R", 4 }, +{ "dvrfw", 0x38040000, 0xfc0f0000, "r,xOA,X", 4 }, +{ "eae", 0x00080000, 0xffff0000, "", 2 }, +{ "eci", 0xfc670000, 0xfc7f8080, "r,I", 4 }, +{ "ecwcs", 0xfc4f0000, 0xfc7f8000, "", 4 }, +{ "ei", 0xfc000000, 0xfc07ffff, "I", 4 }, +{ "eomb", 0x8c080000, 0xfc080000, "r,xOA,X", 4 }, +{ "eomd", 0x8c000002, 0xfc080002, "r,xOA,X", 4 }, +{ "eomh", 0x8c000001, 0xfc080001, "r,xOA,X", 4 }, +{ "eomw", 0x8c000000, 0xfc080000, "r,xOA,X", 4 }, +{ "eor", 0x0c000000, 0xfc0f0000, "r,R", 2 }, +{ "eorm", 0x0c080000, 0xfc0f0000, "r,R", 2 }, +{ "es", 0x00040000, 0xfc7f0000, "r", 2 }, +{ "exm", 0xa8000000, 0xff880000, "xOA,X", 4 }, +{ "exr", 0xc8070000, 0xfc7f0000, "r", 2 }, +{ "exrr", 0xc8070002, 0xfc7f0002, "r", 2 }, +{ "fixd", 0x380d0000, 0xfc0f0000, "r,R", 2 }, +{ "fixw", 0x38050000, 0xfc0f0000, "r,R", 2 }, +{ "fltd", 0x380f0000, 0xfc0f0000, "r,R", 2 }, +{ "fltw", 0x38070000, 0xfc0f0000, "r,R", 2 }, +{ "grio", 0xfc3f0000, 0xfc7f8000, "r,I", 4 }, +{ "halt", 0x00000000, 0xffff0000, "", 2 }, +{ "hio", 0xfc370000, 0xfc7f8000, "r,I", 4 }, +{ "jwcs", 0xfa080000, 0xff880000, "xOA,X", 4 }, +{ "la", 0x50000000, 0xfc000000, "r,xOA,X", 4 }, +{ "labr", 0x58080000, 0xfc080000, "b,xOA,X", 4 }, +{ "lb", 0xac080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lcs", 0x00030000, 0xfc7f0000, "r", 2 }, +{ "ld", 0xac000002, 0xfc080002, "r,xOA,X", 4 }, +{ "lear", 0x80000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lf", 0xcc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lfbr", 0xcc080000, 0xfc080000, "b,xOA,X", 4 }, +{ "lh", 0xac000001, 0xfc080001, "r,xOA,X", 4 }, +{ "li", 0xc8000000, 0xfc7f0000, "r,I", 4 }, +{ "lmap", 0x2c070000, 0xfc7f0000, "r", 2 }, +{ "lmb", 0xb0080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lmd", 0xb0000002, 0xfc080002, "r,xOA,X", 4 }, +{ "lmh", 0xb0000001, 0xfc080001, "r,xOA,X", 4 }, +{ "lmw", 0xb0000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lnb", 0xb4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "lnd", 0xb4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "lnh", 0xb4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "lnw", 0xb4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lpsd", 0xf9800000, 0xff880000, "r,xOA,X", 4 }, +{ "lpsdcm", 0xfa800000, 0xff880000, "r,xOA,X", 4 }, +{ "lw", 0xac000000, 0xfc080000, "r,xOA,X", 4 }, +{ "lwbr", 0x5c000000, 0xfc080000, "b,xOA,X", 4 }, +{ "mpfd", 0xe4080002, 0xfc080002, "r,xOA,X", 4 }, +{ "mpfw", 0xe4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpi", 0xc8030000, 0xfc7f0000, "r,I", 4 }, +{ "mpmb", 0xc0080000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpmh", 0xc0000001, 0xfc080001, "r,xOA,X", 4 }, +{ "mpmw", 0xc0000000, 0xfc080000, "r,xOA,X", 4 }, +{ "mpr", 0x38020000, 0xfc0f0000, "r,R", 2 }, +{ "mprfd", 0x380e0000, 0xfc0f0000, "r,R", 2 }, +{ "mprfw", 0x38060000, 0xfc0f0000, "r,R", 2 }, +{ "nop", 0x00020000, 0xffff0000, "", 2 }, +{ "ormb", 0x88080000, 0xfc080000, "r,xOA,X", 4 }, +{ "ormd", 0x88000002, 0xfc080002, "r,xOA,X", 4 }, +{ "ormh", 0x88000001, 0xfc080001, "r,xOA,X", 4 }, +{ "ormw", 0x88000000, 0xfc080000, "r,xOA,X", 4 }, +{ "orr", 0x08000000, 0xfc0f0000, "r,R", 2 }, +{ "orrm", 0x08080000, 0xfc0f0000, "r,R", 2 }, +{ "rdsts", 0x00090000, 0xfc7f0000, "r", 2 }, +{ "return", 0x280e0000, 0xfc7f0000, "", 2 }, +{ "ri", 0xfc020000, 0xfc07ffff, "I", 4 }, +{ "rnd", 0x00050000, 0xfc7f0000, "r", 2 }, +{ "rpswt", 0x040b0000, 0xfc7f0000, "r", 2 }, +{ "rschnl", 0xfc2f0000, 0xfc7f8000, "r,I", 4 }, +{ "rsctl", 0xfc470000, 0xfc7f8000, "r,I", 4 }, +{ "rwcs", 0x000b0000, 0xfc0f0000, "r,R", 2 }, +{ "sacz", 0x10080000, 0xfc0f0000, "r,R", 2 }, +{ "sbm", 0x98080000, 0xfc080000, "f,xOA,X", 4 }, +{ "sbr", 0x18000000, 0xfc0c0000, "r,f", 4 }, +{ "sea", 0x000d0000, 0xffff0000, "", 2 }, +{ "setcpu", 0x2c090000, 0xfc7f0000, "r", 2 }, +{ "sio", 0xfc170000, 0xfc7f8000, "r,I", 4 }, +{ "sipu", 0x000a0000, 0xffff0000, "", 2 }, +{ "sla", 0x1c400000, 0xfc600000, "r,S", 2 }, +{ "slad", 0x20400000, 0xfc600000, "r,S", 2 }, +{ "slc", 0x24400000, 0xfc600000, "r,S", 2 }, +{ "sll", 0x1c600000, 0xfc600000, "r,S", 2 }, +{ "slld", 0x20600000, 0xfc600000, "r,S", 2 }, +{ "smc", 0x04070000, 0xfc070000, "", 2 }, +{ "sra", 0x1c000000, 0xfc600000, "r,S", 2 }, +{ "srad", 0x20000000, 0xfc600000, "r,S", 2 }, +{ "src", 0x24000000, 0xfc600000, "r,S", 2 }, +{ "srl", 0x1c200000, 0xfc600000, "r,S", 2 }, +{ "srld", 0x20200000, 0xfc600000, "r,S", 2 }, +{ "stb", 0xd4080000, 0xfc080000, "r,xOA,X", 4 }, +{ "std", 0xd4000002, 0xfc080002, "r,xOA,X", 4 }, +{ "stf", 0xdc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "stfbr", 0x54000000, 0xfc080000, "b,xOA,X", 4 }, +{ "sth", 0xd4000001, 0xfc080001, "r,xOA,X", 4 }, +{ "stmb", 0xd8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "stmd", 0xd8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "stmh", 0xd8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "stmw", 0xd8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "stpio", 0xfc270000, 0xfc7f8000, "r,I", 4 }, +{ "stw", 0xd4000000, 0xfc080000, "r,xOA,X", 4 }, +{ "stwbr", 0x54000000, 0xfc080000, "b,xOA,X", 4 }, +{ "suabr", 0x58000000, 0xfc080000, "b,xOA,X", 4 }, +{ "sufd", 0xe0000002, 0xfc080002, "r,xOA,X", 4 }, +{ "sufw", 0xe0000000, 0xfc080000, "r,xOA,X", 4 }, +{ "sui", 0xc8020000, 0xfc7f0000, "r,I", 4 }, +{ "sumb", 0xbc080000, 0xfc080000, "r,xOA,X", 4 }, +{ "sumd", 0xbc000002, 0xfc080002, "r,xOA,X", 4 }, +{ "sumh", 0xbc000001, 0xfc080001, "r,xOA,X", 4 }, +{ "sumw", 0xbc000000, 0xfc080000, "r,xOA,X", 4 }, +{ "sur", 0x3c000000, 0xfc0f0000, "r,R", 2 }, +{ "surfd", 0x380b0000, 0xfc0f0000, "r,xOA,X", 4 }, +{ "surfw", 0x38030000, 0xfc0f0000, "r,R", 2 }, +{ "surm", 0x3c080000, 0xfc0f0000, "r,R", 2 }, +{ "svc", 0xc8060000, 0xffff0000, "", 4 }, +{ "tbm", 0xa4080000, 0xfc080000, "f,xOA,X", 4 }, +{ "tbr", 0x180c0000, 0xfc0c0000, "r,f", 2 }, +{ "tbrr", 0x2c020000, 0xfc0f0000, "r,B", 2 }, +{ "tccr", 0x28040000, 0xfc7f0000, "", 2 }, +{ "td", 0xfc050000, 0xfc070000, "r,f", 4 }, +{ "tio", 0xfc1f0000, 0xfc7f8000, "r,I", 4 }, +{ "tmapr", 0x2c0a0000, 0xfc0f0000, "r,R", 2 }, +{ "tpcbr", 0x280c0000, 0xfc7f0000, "r", 2 }, +{ "trbr", 0x2c010000, 0xfc0f0000, "b,R", 2 }, +{ "trc", 0x2c030000, 0xfc0f0000, "r,R", 2 }, +{ "trcc", 0x28050000, 0xfc7f0000, "", 2 }, +{ "trcm", 0x2c0b0000, 0xfc0f0000, "r,R", 2 }, +{ "trn", 0x2c040000, 0xfc0f0000, "r,R", 2 }, +{ "trnm", 0x2c0c0000, 0xfc0f0000, "r,R", 2 }, +{ "trr", 0x2c000000, 0xfc0f0000, "r,R", 2 }, +{ "trrm", 0x2c080000, 0xfc0f0000, "r,R", 2 }, +{ "trsc", 0x2c0e0000, 0xfc0f0000, "r,R", 2 }, +{ "trsw", 0x28000000, 0xfc7f0000, "r", 2 }, +{ "tscr", 0x2c0f0000, 0xfc0f0000, "r,R", 2 }, +{ "uei", 0x00070000, 0xffff0000, "", 2 }, +{ "wait", 0x00010000, 0xffff0000, "", 2 }, +{ "wcwcs", 0xfc5f0000, 0xfc7f8000, "", 4 }, +{ "wwcs", 0x000c0000, 0xfc0f0000, "r,R", 2 }, +{ "xcbr", 0x28020000, 0xfc0f0000, "b,B", 2 }, +{ "xcr", 0x2c050000, 0xfc0f0000, "r,R", 2 }, +{ "xcrm", 0x2c0d0000, 0xfc0f0000, "r,R", 2 }, +{ "zbm", 0x9c080000, 0xfc080000, "f,xOA,X", 4 }, +{ "zbr", 0x18040000, 0xfc0c0000, "r,f", 2 }, +{ "zmb", 0xf8080000, 0xfc080000, "r,xOA,X", 4 }, +{ "zmd", 0xf8000002, 0xfc080002, "r,xOA,X", 4 }, +{ "zmh", 0xf8000001, 0xfc080001, "r,xOA,X", 4 }, +{ "zmw", 0xf8000000, 0xfc080000, "r,xOA,X", 4 }, +{ "zr", 0x0c000000, 0xfc0f0000, "r", 2 }, +}; + +int numopcodes = sizeof(gld_opcodes) / sizeof(gld_opcodes[0]); + +struct gld_opcode *endop = gld_opcodes + sizeof(gld_opcodes) / + sizeof(gld_opcodes[0]); diff --git a/gdb/pyr-opcode.h b/gdb/pyr-opcode.h new file mode 100755 index 0000000..06632b8 --- /dev/null +++ b/gdb/pyr-opcode.h @@ -0,0 +1,287 @@ +/* pyramid.opcode.h -- gdb initial attempt. */ + +/* pyramid opcode table: wot to do with this + particular opcode */ + +struct pyr_datum +{ + char nargs; + char * args; /* how to compile said opcode */ + unsigned long mask; /* Bit vector: which operand modes are valid + for this opcode */ + unsigned char code; /* op-code (always 6(?) bits */ +}; + +typedef struct pyr_insn_format { + unsigned int mode :4; + unsigned int operator :8; + unsigned int index_scale :2; + unsigned int index_reg :6; + unsigned int operand_1 :6; + unsigned int operand_2:6; +} pyr_insn_format; + + +/* We store four bytes of opcode for all opcodes. + Pyramid is sufficiently RISCy that: + - insns are always an integral number of words; + - the length of any insn can be told from the first word of + the insn. (ie, if there are zero, one, or two words of + immediate operand/offset). + + + The args component is a string containing two characters for each + operand of the instruction. The first specifies the kind of operand; + the second, the place it is stored. */ + +/* Kinds of operands: + mask assembler syntax description + 0x0001: movw Rn,Rn register to register + 0x0002: movw K,Rn quick immediate to register + 0x0004: movw I,Rn long immediate to register + 0x0008: movw (Rn),Rn register indirect to register + movw (Rn)[x],Rn register indirect to register + 0x0010: movw I(Rn),Rn offset register indirect to register + movw I(Rn)[x],Rn offset register indirect, indexed, to register + + 0x0020: movw Rn,(Rn) register to register indirect + 0x0040: movw K,(Rn) quick immediate to register indirect + 0x0080: movw I,(Rn) long immediate to register indirect + 0x0100: movw (Rn),(Rn) register indirect to-register indirect + 0x0100: movw (Rn),(Rn) register indirect to-register indirect + 0x0200: movw I(Rn),(Rn) register indirect+offset to register indirect + 0x0200: movw I(Rn),(Rn) register indirect+offset to register indirect + + 0x0400: movw Rn,I(Rn) register to register indirect+offset + 0x0800: movw K,I(Rn) quick immediate to register indirect+offset + 0x1000: movw I,I(Rn) long immediate to register indirect+offset + 0x1000: movw (Rn),I(Rn) register indirect to-register indirect+offset + 0x1000: movw I(Rn),I(Rn) register indirect+offset to register indirect + +offset + 0x0000: (irregular) ??? + + + Each insn has a four-bit field encoding the type(s) of its operands. +*/ + +/* Some common combinations + */ + +/* the first 5,(0x1|0x2|0x4|0x8|0x10) ie (1|2|4|8|16), ie ( 32 -1)*/ +#define GEN_TO_REG (31) + +#define UNKNOWN ((unsigned long)-1) +#define ANY (GEN_TO_REG | (GEN_TO_REG << 5) | (GEN_TO_REG << 15)) + +#define CONVERT (1|8|0x10|0x20|0x200) + +#define K_TO_REG (2) +#define I_TO_REG (4) +#define NOTK_TO_REG (GEN_TO_REG & ~K_TO_REG) +#define NOTI_TO_REG (GEN_TO_REG & ~I_TO_REG) + +/* The assembler requires that this array be sorted as follows: + all instances of the same mnemonic must be consecutive. + All instances of the same mnemonic with the same number of operands + must be consecutive. + */ + +struct pyr_opcode /* pyr opcode text */ +{ + char * name; /* opcode name: lowercase string [key] */ + struct pyr_datum datum; /* rest of opcode table [datum] */ +}; + +#define pyr_how args +#define pyr_nargs nargs +#define pyr_mask mask +#define pyr_name name + +struct pyr_opcode pyr_opcodes[] = +{ + {"movb", { 2, "", UNKNOWN, 0x11}, }, + {"movh", { 2, "", UNKNOWN, 0x12} }, + {"movw", { 2, "", ANY, 0x10} }, + {"movl", { 2, "", ANY, 0x13} }, + {"mnegw", { 2, "", (0x1|0x8|0x10), 0x14} }, + {"mnegf", { 2, "", 0x1, 0x15} }, + {"mnegd", { 2, "", 0x1, 0x16} }, + {"mcomw", { 2, "", (0x1|0x8|0x10), 0x17} }, + {"mabsw", { 2, "", (0x1|0x8|0x10), 0x18} }, + {"mabsf", { 2, "", 0x1, 0x19} }, + {"mabsd", { 2, "", 0x1, 0x1a} }, + {"mtstw", { 2, "", (0x1|0x8|0x10), 0x1c} }, + {"mtstf", { 2, "", 0x1, 0x1d} }, + {"mtstd", { 2, "", 0x1, 0x1e} }, + {"mova", { 2, "", 0x8|0x10, 0x1f} }, + {"movzbw", { 2, "", (0x1|0x8|0x10), 0x20} }, + {"movzhw", { 2, "", (0x1|0x8|0x10), 0x21} }, + /* 2 insns out of order here */ + {"movbl", { 2, "", 1, 0x4f} }, + {"filbl", { 2, "", 1, 0x4e} }, + + {"cvtbw", { 2, "", CONVERT, 0x22} }, + {"cvthw", { 2, "", CONVERT, 0x23} }, + {"cvtwb", { 2, "", CONVERT, 0x24} }, + {"cvtwh", { 2, "", CONVERT, 0x25} }, + {"cvtwf", { 2, "", CONVERT, 0x26} }, + {"cvtwd", { 2, "", CONVERT, 0x27} }, + {"cvtfw", { 2, "", CONVERT, 0x28} }, + {"cvtfd", { 2, "", CONVERT, 0x29} }, + {"cvtdw", { 2, "", CONVERT, 0x2a} }, + {"cvtdf", { 2, "", CONVERT, 0x2b} }, + + {"addw", { 2, "", GEN_TO_REG, 0x40} }, + {"addwc", { 2, "", GEN_TO_REG, 0x41} }, + {"subw", { 2, "", GEN_TO_REG, 0x42} }, + {"subwb", { 2, "", GEN_TO_REG, 0x43} }, + {"rsubw", { 2, "", GEN_TO_REG, 0x44} }, + {"mulw", { 2, "", GEN_TO_REG, 0x45} }, + {"emul", { 2, "", GEN_TO_REG, 0x47} }, + {"umulw", { 2, "", GEN_TO_REG, 0x46} }, + {"divw", { 2, "", GEN_TO_REG, 0x48} }, + {"ediv", { 2, "", GEN_TO_REG, 0x4a} }, + {"rdivw", { 2, "", GEN_TO_REG, 0x4b} }, + {"udivw", { 2, "", GEN_TO_REG, 0x49} }, + {"modw", { 2, "", GEN_TO_REG, 0x4c} }, + {"umodw", { 2, "", GEN_TO_REG, 0x4d} }, + + + {"addf", { 2, "", 1, 0x50} }, + {"addd", { 2, "", 1, 0x51} }, + {"subf", { 2, "", 1, 0x52} }, + {"subd", { 2, "", 1, 0x53} }, + {"mulf", { 2, "", 1, 0x56} }, + {"muld", { 2, "", 1, 0x57} }, + {"divf", { 2, "", 1, 0x58} }, + {"divd", { 2, "", 1, 0x59} }, + + + {"cmpb", { 2, "", UNKNOWN, 0x61} }, + {"cmph", { 2, "", UNKNOWN, 0x62} }, + {"cmpw", { 2, "", UNKNOWN, 0x60} }, + {"ucmpb", { 2, "", UNKNOWN, 0x66} }, + /* WHY no "ucmph"??? */ + {"ucmpw", { 2, "", UNKNOWN, 0x65} }, + {"xchw", { 2, "", UNKNOWN, 0x0f} }, + + + {"andw", { 2, "", GEN_TO_REG, 0x30} }, + {"orw", { 2, "", GEN_TO_REG, 0x31} }, + {"xorw", { 2, "", GEN_TO_REG, 0x32} }, + {"bicw", { 2, "", GEN_TO_REG, 0x33} }, + {"lshlw", { 2, "", GEN_TO_REG, 0x38} }, + {"ashlw", { 2, "", GEN_TO_REG, 0x3a} }, + {"ashll", { 2, "", GEN_TO_REG, 0x3c} }, + {"ashrw", { 2, "", GEN_TO_REG, 0x3b} }, + {"ashrl", { 2, "", GEN_TO_REG, 0x3d} }, + {"rotlw", { 2, "", GEN_TO_REG, 0x3e} }, + {"rotrw", { 2, "", GEN_TO_REG, 0x3f} }, + + /* push and pop insns are "going away next release". */ + {"pushw", { 2, "", GEN_TO_REG, 0x0c} }, + {"popw", { 2, "", (0x1|0x8|0x10), 0x0d} }, + {"pusha", { 2, "", (0x8|0x10), 0x0e} }, + + {"bitsw", { 2, "", UNKNOWN, 0x35} }, + {"bitcw", { 2, "", UNKNOWN, 0x36} }, + /* some kind of ibra/dbra insns??*/ + {"icmpw", { 2, "", UNKNOWN, 0x67} }, + {"dcmpw", { 2, "", (1|4|0x20|0x80|0x400|0x1000), 0x69} },/*FIXME*/ + {"acmpw", { 2, "", 1, 0x6b} }, + + /* Call is written as a 1-op insn, but is always (dis)assembled as a 2-op + insn with a 2nd op of tr14. The assembler will have to grok this. */ + {"call", { 2, "", GEN_TO_REG, 0x04} }, + {"call", { 1, "", GEN_TO_REG, 0x04} }, + + {"callk", { 1, "", UNKNOWN, 0x06} },/* system call?*/ + /* Ret is usually written as a 0-op insn, but gets disassembled as a + 1-op insn. The operand is always tr15. */ + {"ret", { 0, "", UNKNOWN, 0x09} }, + {"ret", { 1, "", UNKNOWN, 0x09} }, + {"adsf", { 2, "", (1|2|4), 0x08} }, + {"retd", { 2, "", UNKNOWN, 0x0a} }, + {"btc", { 2, "", UNKNOWN, 0x01} }, + {"bfc", { 2, "", UNKNOWN, 0x02} }, + /* Careful: halt is 0x00000000. Jump must have some other (mode?)bit set?? */ + {"jump", { 1, "", UNKNOWN, 0x00} }, + {"btp", { 2, "", UNKNOWN, 0xf00} }, + /* read control-stack pointer is another 1-or-2 operand insn. */ + {"rcsp", { 2, "", UNKNOWN, 0x01f} }, + {"rcsp", { 1, "", UNKNOWN, 0x01f} } +}; + +/* end: pyramid.opcode.h */ +/* One day I will have to take the time to find out what operands + are valid for these insns, and guess at what they mean. + + I can't imagine what the "I???" insns (iglob, etc) do. + + the arithmetic-sounding insns ending in "p" sound awfully like BCD + arithmetic insns: + dshlp -> Decimal SHift Left Packed + dshrp -> Decimal SHift Right Packed + and cvtlp would be convert long to packed. + I have no idea how the operands are interpreted; but having them be + a long register with (address, length) of an in-memory packed BCD operand + would not be surprising. + They are unlikely to be a packed bcd string: 64 bits of long give + is only 15 digits+sign, which isn't enough for COBOL. + */ +#if 0 + {"wcsp", { 2, "", UNKNOWN, 0x00} }, /*write csp?*/ + /* The OSx Operating System Porting Guide claims SSL does things + with tr12 (a register reserved to it) to do with static block-structure + references. SSL=Set Static Link? It's "Going away next release". */ + {"ssl", { 2, "", UNKNOWN, 0x00} }, + {"ccmps", { 2, "", UNKNOWN, 0x00} }, + {"lcd", { 2, "", UNKNOWN, 0x00} }, + {"uemul", { 2, "", UNKNOWN, 0x00} }, /*unsigned emul*/ + {"srf", { 2, "", UNKNOWN, 0x00} }, /*Gidget time???*/ + {"mnegp", { 2, "", UNKNOWN, 0x00} }, /move-neg phys?*/ + {"ldp", { 2, "", UNKNOWN, 0x00} }, /*load phys?*/ + {"ldti", { 2, "", UNKNOWN, 0x00} }, + {"ldb", { 2, "", UNKNOWN, 0x00} }, + {"stp", { 2, "", UNKNOWN, 0x00} }, + {"stti", { 2, "", UNKNOWN, 0x00} }, + {"stb", { 2, "", UNKNOWN, 0x00} }, + {"stu", { 2, "", UNKNOWN, 0x00} }, + {"addp", { 2, "", UNKNOWN, 0x00} }, + {"subp", { 2, "", UNKNOWN, 0x00} }, + {"mulp", { 2, "", UNKNOWN, 0x00} }, + {"divp", { 2, "", UNKNOWN, 0x00} }, + {"dshlp", { 2, "", UNKNOWN, 0x00} }, /* dec shl packed? */ + {"dshrp", { 2, "", UNKNOWN, 0x00} }, /* dec shr packed? */ + {"movs", { 2, "", UNKNOWN, 0x00} }, /*move (string?)?*/ + {"cmpp", { 2, "", UNKNOWN, 0x00} }, /* cmp phys?*/ + {"cmps", { 2, "", UNKNOWN, 0x00} }, /* cmp (string?)?*/ + {"cvtlp", { 2, "", UNKNOWN, 0x00} }, /* cvt long to p??*/ + {"cvtpl", { 2, "", UNKNOWN, 0x00} }, /* cvt p to l??*/ + {"dintr", { 2, "", UNKNOWN, 0x00} }, /* ?? intr ?*/ + {"rphysw", { 2, "", UNKNOWN, 0x00} }, /* read phys word?*/ + {"wphysw", { 2, "", UNKNOWN, 0x00} }, /* write phys word?*/ + {"cmovs", { 2, "", UNKNOWN, 0x00} }, + {"rsubw", { 2, "", UNKNOWN, 0x00} }, + {"bicpsw", { 2, "", UNKNOWN, 0x00} }, /* clr bit in psw? */ + {"bispsw", { 2, "", UNKNOWN, 0x00} }, /* set bit in psw? */ + {"eio", { 2, "", UNKNOWN, 0x00} }, /* ?? ?io ? */ + {"callp", { 2, "", UNKNOWN, 0x00} }, /* call phys?*/ + {"callr", { 2, "", UNKNOWN, 0x00} }, + {"lpcxt", { 2, "", UNKNOWN, 0x00} }, /*load proc context*/ + {"rei", { 2, "", UNKNOWN, 0x00} }, /*ret from intrpt*/ + {"rport", { 2, "", UNKNOWN, 0x00} }, /*read-port?*/ + {"rtod", { 2, "", UNKNOWN, 0x00} }, /*read-time-of-day?*/ + {"ssi", { 2, "", UNKNOWN, 0x00} }, + {"vtpa", { 2, "", UNKNOWN, 0x00} }, /*virt-to-phys-addr?*/ + {"wicl", { 2, "", UNKNOWN, 0x00} }, /* write icl ? */ + {"wport", { 2, "", UNKNOWN, 0x00} }, /*write-port?*/ + {"wtod", { 2, "", UNKNOWN, 0x00} }, /*write-time-of-day?*/ + {"flic", { 2, "", UNKNOWN, 0x00} }, + {"iglob", { 2, "", UNKNOWN, 0x00} }, /* I global? */ + {"iphys", { 2, "", UNKNOWN, 0x00} }, /* I physical? */ + {"ipid", { 2, "", UNKNOWN, 0x00} }, /* I pid? */ + {"ivect", { 2, "", UNKNOWN, 0x00} }, /* I vector? */ + {"lamst", { 2, "", UNKNOWN, 0x00} }, + {"tio", { 2, "", UNKNOWN, 0x00} }, +#endif diff --git a/gdb/pyr-pinsn.c b/gdb/pyr-pinsn.c new file mode 100644 index 0000000..d58ae47 --- /dev/null +++ b/gdb/pyr-pinsn.c @@ -0,0 +1,347 @@ +/* Disassembler for the Pyramid Technology 90x + Copyright (C) 1988,1989 Free Software Foundation, Inc. + +This file is part of GDB, the GNU disassembler. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "pyr-opcode.h" +#include "gdbcore.h" + + +/* A couple of functions used for debugging frame-handling on + Pyramids. (The Pyramid-dependent handling of register values for + windowed registers is known to be buggy.) + + When debugging, these functions supplant the normal definitions of some + of the macros in m-pyramid.h The quantity of information produced + when these functions are used makes the gdb unusable as a + debugger for user programs. */ + +extern unsigned pyr_saved_pc(), pyr_frame_chain(); + +CORE_ADDR pyr_frame_chain(frame) + CORE_ADDR frame; +{ + int foo=frame - CONTROL_STACK_FRAME_SIZE; + /* printf ("...following chain from %x: got %x\n", frame, foo);*/ + return foo; +} + +CORE_ADDR pyr_saved_pc(frame) + CORE_ADDR frame; +{ + int foo=0; + foo = read_memory_integer (((CORE_ADDR)(frame))+60, 4); + printf ("..reading pc from frame 0x%0x+%d regs: got %0x\n", + frame, 60/4, foo); + return foo; +} + + +/* Pyramid instructions are never longer than this many bytes. */ +#define MAXLEN 24 + +/* Number of elements in the opcode table. */ +/*const*/ static int nopcodes = (sizeof (pyr_opcodes) / sizeof( pyr_opcodes[0])); +#define NOPCODES (nopcodes) + +extern char *reg_names[]; + +/* Let's be byte-independent so we can use this as a cross-assembler. + (will this ever be useful? + */ + +#define NEXTLONG(p) \ + (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1]) + + +/* Print one instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i, nargs, insn_size =4; + register unsigned char *p; + register char *d; + register int insn_opcode, operand_mode; + register int index_multiplier, index_reg_regno, op_1_regno, op_2_regno ; + long insn; /* first word of the insn, not broken down. */ + pyr_insn_format insn_decode; /* the same, broken out into op{code,erands} */ + long extra_1, extra_2; + + read_memory (memaddr, buffer, MAXLEN); + insn_decode = *((pyr_insn_format *) buffer); + insn = * ((int *) buffer); + insn_opcode = insn_decode.operator; + operand_mode = insn_decode.mode; + index_multiplier = insn_decode.index_scale; + index_reg_regno = insn_decode.index_reg; + op_1_regno = insn_decode.operand_1; + op_2_regno = insn_decode.operand_2; + + + if (*((int *)buffer) == 0x0) { + /* "halt" looks just like an invalid "jump" to the insn decoder, + so is dealt with as a special case */ + fprintf (stream, "halt"); + return (4); + } + + for (i = 0; i < NOPCODES; i++) + if (pyr_opcodes[i].datum.code == insn_opcode) + break; + + if (i == NOPCODES) + /* FIXME: Handle unrecognised instructions better. */ + fprintf (stream, "???\t#%08x\t(op=%x mode =%x)", + insn, insn_decode.operator, insn_decode.mode); + else + { + /* Print the mnemonic for the instruction. Pyramid insn operands + are so regular that we can deal with almost all of them + separately. + Unconditional branches are an exception: they are encoded as + conditional branches (branch if false condition, I think) + with no condition specified. The average user will not be + aware of this. To maintain their illusion that an + unconditional branch insn exists, we will have to FIXME to + treat the insn mnemnonic of all branch instructions here as a + special case: check the operands of branch insn and print an + appropriate mnemonic. */ + + fprintf (stream, "%s\t", pyr_opcodes[i].name); + + /* Print the operands of the insn (as specified in + insn.operand_mode). + Branch operands of branches are a special case: they are a word + offset, not a byte offset. */ + + if (insn_decode.operator == 0x01 || insn_decode.operator == 0x02) { + register int bit_codes=(insn >> 16)&0xf; + register int i; + register int displacement = (insn & 0x0000ffff) << 2; + + static char cc_bit_names[] = "cvzn"; /* z,n,c,v: strange order? */ + + /* Is bfc and no bits specified an unconditional branch?*/ + for (i=0;i<4;i++) { + if ((bit_codes) & 0x1) + fputc (cc_bit_names[i], stream); + bit_codes >>= 1; + } + + fprintf (stream, ",%0x", + displacement + memaddr); + return (insn_size); + } + + switch (operand_mode) { + case 0: + fprintf (stream, "%s,%s", + reg_names [op_1_regno], + reg_names [op_2_regno]); + break; + + case 1: + fprintf (stream, " 0x%0x,%s", + op_1_regno, + reg_names [op_2_regno]); + break; + + case 2: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, " $0x%0x,%s", + extra_1, + reg_names [op_2_regno]); + break; + case 3: + fprintf (stream, " (%s),%s", + reg_names [op_1_regno], + reg_names [op_2_regno]); + break; + + case 4: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, " 0x%0x(%s),%s", + extra_1, + reg_names [op_1_regno], + reg_names [op_2_regno]); + break; + + /* S1 destination mode */ + case 5: + fprintf (stream, + ((index_reg_regno) ? "%s,(%s)[%s*%1d]" : "%s,(%s)"), + reg_names [op_1_regno], + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + case 6: + fprintf (stream, + ((index_reg_regno) ? " $%#0x,(%s)[%s*%1d]" + : " $%#0x,(%s)"), + op_1_regno, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + case 7: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) ? " $%#0x,(%s)[%s*%1d]" + : " $%#0x,(%s)"), + extra_1, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + case 8: + fprintf (stream, + ((index_reg_regno) ? " (%s),(%s)[%s*%1d]" : " (%s),(%s)"), + reg_names [op_1_regno], + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + case 9: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) + ? "%#0x(%s),(%s)[%s*%1d]" + : "%#0x(%s),(%s)"), + extra_1, + reg_names [op_1_regno], + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + /* S2 destination mode */ + case 10: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) ? "%s,%#0x(%s)[%s*%1d]" : "%s,%#0x(%s)"), + reg_names [op_1_regno], + extra_1, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + case 11: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) ? + " $%#0x,%#0x(%s)[%s*%1d]" : " $%#0x,%#0x(%s)"), + op_1_regno, + extra_1, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + case 12: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + read_memory (memaddr+8, buffer, MAXLEN); + insn_size += 4; + extra_2 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) ? + " $%#0x,%#0x(%s)[%s*%1d]" : " $%#0x,%#0x(%s)"), + extra_1, + extra_2, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + case 13: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) + ? " (%s),%#0x(%s)[%s*%1d]" + : " (%s),%#0x(%s)"), + reg_names [op_1_regno], + extra_1, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + case 14: + read_memory (memaddr+4, buffer, MAXLEN); + insn_size += 4; + extra_1 = * ((int *) buffer); + read_memory (memaddr+8, buffer, MAXLEN); + insn_size += 4; + extra_2 = * ((int *) buffer); + fprintf (stream, + ((index_reg_regno) ? "%#0x(%s),%#0x(%s)[%s*%1d]" + : "%#0x(%s),%#0x(%s) "), + extra_1, + reg_names [op_1_regno], + extra_2, + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + break; + + default: + fprintf (stream, + ((index_reg_regno) ? "%s,%s [%s*%1d]" : "%s,%s"), + reg_names [op_1_regno], + reg_names [op_2_regno], + reg_names [index_reg_regno], + index_multiplier); + fprintf (stream, + "\t\t# unknown mode in %08x", + insn); + break; + } /* switch */ + } + + { + return insn_size; + } + abort (); +} diff --git a/gdb/pyr-tdep.c b/gdb/pyr-tdep.c new file mode 100644 index 0000000..b79ea0c --- /dev/null +++ b/gdb/pyr-tdep.c @@ -0,0 +1,129 @@ +/* Low level interface to ptrace, for GDB when running under Unix. + Copyright (C) 1988, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/*** Prettier register printing. ***/ + +/* Print registers in the same format as pyramid's dbx, adb, sdb. */ +pyr_print_registers(reg_buf, regnum) + long *reg_buf[]; +{ + register int regno; + int usp, ksp; + struct user u; + + for (regno = 0; regno < 16; regno++) { + printf/*_filtered*/ ("%6.6s: %8x %6.6s: %8x %6s: %8x %6s: %8x\n", + reg_names[regno], reg_buf[regno], + reg_names[regno+16], reg_buf[regno+16], + reg_names[regno+32], reg_buf[regno+32], + reg_names[regno+48], reg_buf[regno+48]); + } + usp = ptrace (3, inferior_pid, + ((char *)&u.u_pcb.pcb_usp) - + ((char *)&u), 0); + ksp = ptrace (3, inferior_pid, + ((char *)&u.u_pcb.pcb_ksp) - + ((char *)&u), 0); + printf/*_filtered*/ ("\n%6.6s: %8x %6.6s: %8x (%08x) %6.6s %8x\n", + reg_names[CSP_REGNUM],reg_buf[CSP_REGNUM], + reg_names[KSP_REGNUM], reg_buf[KSP_REGNUM], ksp, + "usp", usp); +} + +/* Print the register regnum, or all registers if regnum is -1. */ + +pyr_do_registers_info (regnum) + int regnum; +{ + /* On a pyr, we know a virtual register can always fit in an long. + Here (and elsewhere) we take advantage of that. Yuk. */ + long raw_regs[MAX_REGISTER_RAW_SIZE*NUM_REGS]; + register int i; + + for (i = 0 ; i < 64 ; i++) { + read_relative_register_raw_bytes(i, raw_regs+i); + } + if (regnum == -1) + pyr_print_registers (raw_regs, regnum); + else + for (i = 0; i < NUM_REGS; i++) + if (i == regnum) { + long val = raw_regs[i]; + + fputs_filtered (reg_names[i], stdout); + printf_filtered(":"); + print_spaces_filtered (6 - strlen (reg_names[i]), stdout); + if (val == 0) + printf_filtered ("0"); + else + printf_filtered ("0x%08x %d", val, val); + printf_filtered("\n"); + } +} + +/*** Debugging editions of various macros from m-pyr.h ****/ + +CORE_ADDR frame_locals_address (frame) + FRAME frame; +{ + register int addr = find_saved_register (frame,CFP_REGNUM); + register int result = read_memory_integer (addr, 4); +#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING + fprintf (stderr, + "\t[[..frame_locals:%8x, %s= %x @%x fcfp= %x foo= %x\n\t gr13=%x pr13=%x tr13=%x @%x]]\n", + frame->frame, + reg_names[CFP_REGNUM], + result, addr, + frame->frame_cfp, (CFP_REGNUM), + + + read_register(13), read_register(29), read_register(61), + find_saved_register(frame, 61)); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + + /* FIXME: I thought read_register (CFP_REGNUM) should be the right answer; + or at least CFP_REGNUM relative to FRAME (ie, result). + There seems to be a bug in the way the innermost frame is set up. */ + + return ((frame->next) ? result: frame->frame_cfp); +} + +CORE_ADDR frame_args_addr (frame) + FRAME frame; +{ + register int addr = find_saved_register (frame,CFP_REGNUM); + register int result = read_memory_integer (addr, 4); + +#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING + fprintf (stderr, + "\t[[..frame_args:%8x, %s= %x @%x fcfp= %x r_r= %x\n\t gr13=%x pr13=%x tr13=%x @%x]]\n", + frame->frame, + reg_names[CFP_REGNUM], + result, addr, + frame->frame_cfp, read_register(CFP_REGNUM), + + read_register(13), read_register(29), read_register(61), + find_saved_register(frame, 61)); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + + /* FIXME: I thought read_register (CFP_REGNUM) should be the right answer; + or at least CFP_REGNUM relative to FRAME (ie, result). + There seems to be a bug in the way the innermost frame is set up. */ + return ((frame->next) ? result: frame->frame_cfp); +} diff --git a/gdb/pyr-xdep.c b/gdb/pyr-xdep.c new file mode 100644 index 0000000..5ba4a8d --- /dev/null +++ b/gdb/pyr-xdep.c @@ -0,0 +1,366 @@ +/* Low level Pyramid interface to ptrace, for GDB when running under Unix. + Copyright (C) 1988, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/ioctl.h> +/* #include <fcntl.h> Can we live without this? */ + +#include "gdbcore.h" +#include <sys/user.h> /* After a.out.h */ +#include <sys/file.h> +#include <sys/stat.h> + +void +fetch_inferior_registers () +{ + register int regno, datum; + register unsigned int regaddr; + int reg_buf[NUM_REGS+1]; + struct user u; + register int skipped_frames = 0; + + registers_fetched (); + + for (regno = 0; regno < 64; regno++) { + reg_buf[regno] = ptrace (3, inferior_pid, regno, 0); + +#if defined(PYRAMID_CONTROL_FRAME_DEBUGGING) + printf ("Fetching %s from inferior, got %0x\n", + reg_names[regno], + reg_buf[regno]); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + + if (reg_buf[regno] == -1 && errno == EIO) { + printf("fetch_interior_registers: fetching %s from inferior\n", + reg_names[regno]); + errno = 0; + } + supply_register (regno, reg_buf+regno); + } + /* that leaves regs 64, 65, and 66 */ + datum = ptrace (3, inferior_pid, + ((char *)&u.u_pcb.pcb_csp) - + ((char *)&u), 0); + + + + /* FIXME: Find the Current Frame Pointer (CFP). CFP is a global + register (ie, NOT windowed), that gets saved in a frame iff + the code for that frame has a prologue (ie, "adsf N"). If + there is a prologue, the adsf insn saves the old cfp in + pr13, cfp is set to sp, and N bytes of locals are allocated + (sp is decremented by n). + This makes finding CFP hard. I guess the right way to do it + is: + - If this is the innermost frame, believe ptrace() or + the core area. + - Otherwise: + Find the first insn of the current frame. + - find the saved pc; + - find the call insn that saved it; + - figure out where the call is to; + - if the first insn is an adsf, we got a frame + pointer. */ + + + /* Normal processors have separate stack pointers for user and + kernel mode. Getting the last user mode frame on such + machines is easy: the kernel context of the ptrace()'d + process is on the kernel stack, and the USP points to what + we want. But Pyramids only have a single cfp for both user and + kernel mode. And processes being ptrace()'d have some + kernel-context control frames on their stack. + To avoid tracing back into the kernel context of an inferior, + we skip 0 or more contiguous control frames where the pc is + in the kernel. */ + + while (1) { + register int inferior_saved_pc; + inferior_saved_pc = ptrace (1, inferior_pid, datum+((32+15)*4), 0); + if (inferior_saved_pc > 0) break; +#if defined(PYRAMID_CONTROL_FRAME_DEBUGGING) + printf("skipping kernel frame %08x, pc=%08x\n", datum, + inferior_saved_pc); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + skipped_frames++; + datum -= CONTROL_STACK_FRAME_SIZE; + } + + reg_buf[CSP_REGNUM] = datum; + supply_register(CSP_REGNUM, reg_buf+CSP_REGNUM); +#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING + if (skipped_frames) { + fprintf (stderr, + "skipped %d frames from %x to %x; cfp was %x, now %x\n", + skipped_frames, reg_buf[CSP_REGNUM]); + } +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + register unsigned int regaddr; + char buf[80]; + + if (regno >= 0) + { + if ((0 <= regno) && (regno < 64)) { + /*regaddr = register_addr (regno, offset);*/ + regaddr = regno; + errno = 0; + ptrace (6, inferior_pid, regaddr, read_register (regno)); + if (errno != 0) + { + sprintf (buf, "writing register number %d", regno); + perror_with_name (buf); + } + } + } + else + { + for (regno = 0; regno < NUM_REGS; regno++) + { + /*regaddr = register_addr (regno, offset);*/ + regaddr = regno; + errno = 0; + ptrace (6, inferior_pid, regaddr, read_register (regno)); + if (errno != 0) + { + sprintf (buf, "writing all regs, number %d", regno); + perror_with_name (buf); + } + } +} + +/*** Extensions to core and dump files, for GDB. */ + +extern unsigned int last_frame_offset; + +#ifdef PYRAMID_CORE + +/* Can't make definitions here static, since core.c needs them + to do bounds checking on the core-file areas. O well. */ + +/* have two stacks: one for data, one for register windows. */ +extern CORE_ADDR reg_stack_start; +extern CORE_ADDR reg_stack_end; + +/* need this so we can find the global registers: they never get saved. */ +CORE_ADDR global_reg_offset; +static CORE_ADDR last_frame_address; +CORE_ADDR last_frame_offset; + + +/* Address in core file of start of register window stack area. + Don't know if is this any of meaningful, useful or necessary. */ +extern int reg_stack_offset; + +#endif /* PYRAMID_CORE */ + + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + +#ifdef PYRAMID_CORE + reg_stack_start = CONTROL_STACK_ADDR; + reg_stack_end = CONTROL_STACK_ADDR; /* this isn't strictly true...*/ +#endif /* PYRAMID_CORE */ + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct user u; + + unsigned int reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name ("Not a core file: reading upage"); + if (val != sizeof u) + error ("Not a core file: could only read %d bytes", val); + data_start = exec_data_start; + + data_end = data_start + NBPG * u.u_dsize; + data_offset = NBPG * UPAGES; + stack_offset = NBPG * (UPAGES + u.u_dsize); + + /* find registers in core file */ +#ifdef PYRAMID_PTRACE + stack_start = stack_end - NBPG * u.u_ussize; + reg_stack_offset = stack_offset + (NBPG *u.u_ussize); + reg_stack_end = reg_stack_start + NBPG * u.u_cssize; + + last_frame_address = ((int) u.u_pcb.pcb_csp); + last_frame_offset = reg_stack_offset + last_frame_address + - CONTROL_STACK_ADDR ; + global_reg_offset = (char *)&u - (char *)&u.u_pcb.pcb_gr0 ; + + /* skip any control-stack frames that were executed in the + kernel. */ + + while (1) { + char buf[4]; + val = lseek (corechan, last_frame_offset+(47*4), 0); + if (val < 0) + perror_with_name (filename); + val = myread (corechan, buf, sizeof buf); + if (val < 0) + perror_with_name (filename); + + if (*(int *)buf >= 0) + break; + printf ("skipping frame %0x\n", last_frame_address); + last_frame_offset -= CONTROL_STACK_FRAME_SIZE; + last_frame_address -= CONTROL_STACK_FRAME_SIZE; + } + reg_offset = last_frame_offset; + +#if 1 || defined(PYRAMID_CONTROL_FRAME_DEBUGGING) + printf ("Control stack pointer = 0x%08x\n", + u.u_pcb.pcb_csp); + printf ("offset to control stack %d outermost frame %d (%0x)\n", + reg_stack_offset, reg_offset, last_frame_address); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + +#else /* not PYRAMID_CORE */ + stack_start = stack_end - NBPG * u.u_ssize; + reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR; +#endif /* not PYRAMID_CORE */ + +#ifdef __not_on_pyr_yet + /* Some machines put an absolute address in here and some put + the offset in the upage of the regs. */ + reg_offset = (int) u.u_ar0; + if (reg_offset > NBPG * UPAGES) + reg_offset -= KERNEL_U_ADDR; +#endif + + /* I don't know where to find this info. + So, for now, mark it as not available. */ + N_SET_MAGIC (core_aouthdr, 0); + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < 64; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = lseek (corechan, register_addr (regno, reg_offset), 0); + if (val < 0 + || (val = myread (corechan, buf, sizeof buf)) < 0) + { + char * buffer = (char *) alloca (strlen (reg_names[regno]) + + 30); + strcpy (buffer, "Reading register "); + strcat (buffer, reg_names[regno]); + + perror_with_name (buffer); + } + + if (val < 0) + perror_with_name (filename); +#ifdef PYRAMID_CONTROL_FRAME_DEBUGGING + printf ("[reg %s(%d), offset in file %s=0x%0x, addr =0x%0x, =%0x]\n", + reg_names[regno], regno, filename, + register_addr(regno, reg_offset), + regno * 4 + last_frame_address, + *((int *)buf)); +#endif /* PYRAMID_CONTROL_FRAME_DEBUGGING */ + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + +#if 1 || defined(PYRAMID_CONTROL_FRAME_DEBUGGING) + printf ("Providing CSP (%0x) as nominal address of current frame.\n", + last_frame_address); +#endif PYRAMID_CONTROL_FRAME_DEBUGGING + /* FIXME: Which of the following is correct? */ +#if 0 + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); +#else + set_current_frame ( create_new_frame (last_frame_address, + read_pc ())); +#endif + + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} diff --git a/gdb/regex.c b/gdb/regex.c new file mode 100644 index 0000000..45c3478 --- /dev/null +++ b/gdb/regex.c @@ -0,0 +1,1738 @@ +/* Extended regular expression matching and search library. + Copyright (C) 1985, 1989 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + + +/* To test, compile with -Dtest. + This Dtestable feature turns this into a self-contained program + which reads a pattern, describes how it compiles, + then reads a string and searches for it. */ + +#ifdef emacs + +/* The `emacs' switch turns on certain special matching commands + that make sense only in emacs. */ + +#include "config.h" +#include "lisp.h" +#include "buffer.h" +#include "syntax.h" + +#else /* not emacs */ + +#ifdef USG +#ifndef BSTRING +#define bcopy(s,d,n) memcpy((d),(s),(n)) +#define bcmp(s1,s2,n) memcmp((s1),(s2),(n)) +#define bzero(s,n) memset((s),0,(n)) +#endif +#endif + +/* Make alloca work the best possible way. */ +#ifdef __GNUC__ +#define alloca __builtin_alloca +#else +#ifdef sparc +#include <alloca.h> +#endif +#endif + +/* + * Define the syntax stuff, so we can do the \<...\> things. + */ + +#ifndef Sword /* must be non-zero in some of the tests below... */ +#define Sword 1 +#endif + +#define SYNTAX(c) re_syntax_table[c] + +#ifdef SYNTAX_TABLE + +char *re_syntax_table; + +#else + +static char re_syntax_table[256]; + +static void +init_syntax_once () +{ + register int c; + static int done = 0; + + if (done) + return; + + bzero (re_syntax_table, sizeof re_syntax_table); + + for (c = 'a'; c <= 'z'; c++) + re_syntax_table[c] = Sword; + + for (c = 'A'; c <= 'Z'; c++) + re_syntax_table[c] = Sword; + + for (c = '0'; c <= '9'; c++) + re_syntax_table[c] = Sword; + + done = 1; +} + +#endif /* SYNTAX_TABLE */ +#endif /* not emacs */ + +#include "regex.h" + +/* Number of failure points to allocate space for initially, + when matching. If this number is exceeded, more space is allocated, + so it is not a hard limit. */ + +#ifndef NFAILURES +#define NFAILURES 80 +#endif /* NFAILURES */ + +/* width of a byte in bits */ + +#define BYTEWIDTH 8 + +#ifndef SIGN_EXTEND_CHAR +#define SIGN_EXTEND_CHAR(x) (x) +#endif + +static int obscure_syntax = 0; + +/* Specify the precise syntax of regexp for compilation. + This provides for compatibility for various utilities + which historically have different, incompatible syntaxes. + + The argument SYNTAX is a bit-mask containing the two bits + RE_NO_BK_PARENS and RE_NO_BK_VBAR. */ + +int +re_set_syntax (syntax) +{ + int ret; + + ret = obscure_syntax; + obscure_syntax = syntax; + return ret; +} + +/* re_compile_pattern takes a regular-expression string + and converts it into a buffer full of byte commands for matching. + + PATTERN is the address of the pattern string + SIZE is the length of it. + BUFP is a struct re_pattern_buffer * which points to the info + on where to store the byte commands. + This structure contains a char * which points to the + actual space, which should have been obtained with malloc. + re_compile_pattern may use realloc to grow the buffer space. + + The number of bytes of commands can be found out by looking in + the struct re_pattern_buffer that bufp pointed to, + after re_compile_pattern returns. +*/ + +#define PATPUSH(ch) (*b++ = (char) (ch)) + +#define PATFETCH(c) \ + {if (p == pend) goto end_of_pattern; \ + c = * (unsigned char *) p++; \ + if (translate) c = translate[c]; } + +#define PATFETCH_RAW(c) \ + {if (p == pend) goto end_of_pattern; \ + c = * (unsigned char *) p++; } + +#define PATUNFETCH p-- + +#define EXTEND_BUFFER \ + { char *old_buffer = bufp->buffer; \ + if (bufp->allocated == (1<<16)) goto too_big; \ + bufp->allocated *= 2; \ + if (bufp->allocated > (1<<16)) bufp->allocated = (1<<16); \ + if (!(bufp->buffer = (char *) realloc (bufp->buffer, bufp->allocated))) \ + goto memory_exhausted; \ + c = bufp->buffer - old_buffer; \ + b += c; \ + if (fixup_jump) \ + fixup_jump += c; \ + if (laststart) \ + laststart += c; \ + begalt += c; \ + if (pending_exact) \ + pending_exact += c; \ + } + +static int store_jump (), insert_jump (); + +char * +re_compile_pattern (pattern, size, bufp) + char *pattern; + int size; + struct re_pattern_buffer *bufp; +{ + register char *b = bufp->buffer; + register char *p = pattern; + char *pend = pattern + size; + register unsigned c, c1; + char *p1; + unsigned char *translate = (unsigned char *) bufp->translate; + + /* address of the count-byte of the most recently inserted "exactn" command. + This makes it possible to tell whether a new exact-match character + can be added to that command or requires a new "exactn" command. */ + + char *pending_exact = 0; + + /* address of the place where a forward-jump should go + to the end of the containing expression. + Each alternative of an "or", except the last, ends with a forward-jump + of this sort. */ + + char *fixup_jump = 0; + + /* address of start of the most recently finished expression. + This tells postfix * where to find the start of its operand. */ + + char *laststart = 0; + + /* In processing a repeat, 1 means zero matches is allowed */ + + char zero_times_ok; + + /* In processing a repeat, 1 means many matches is allowed */ + + char many_times_ok; + + /* address of beginning of regexp, or inside of last \( */ + + char *begalt = b; + + /* Stack of information saved by \( and restored by \). + Four stack elements are pushed by each \(: + First, the value of b. + Second, the value of fixup_jump. + Third, the value of regnum. + Fourth, the value of begalt. */ + + int stackb[40]; + int *stackp = stackb; + int *stacke = stackb + 40; + int *stackt; + + /* Counts \('s as they are encountered. Remembered for the matching \), + where it becomes the "register number" to put in the stop_memory command */ + + int regnum = 1; + + bufp->fastmap_accurate = 0; + +#ifndef emacs +#ifndef SYNTAX_TABLE + /* + * Initialize the syntax table. + */ + init_syntax_once(); +#endif +#endif + + if (bufp->allocated == 0) + { + bufp->allocated = 28; + if (bufp->buffer) + /* EXTEND_BUFFER loses when bufp->allocated is 0 */ + bufp->buffer = (char *) realloc (bufp->buffer, 28); + else + /* Caller did not allocate a buffer. Do it for him */ + bufp->buffer = (char *) malloc (28); + if (!bufp->buffer) goto memory_exhausted; + begalt = b = bufp->buffer; + } + + while (p != pend) + { + if (b - bufp->buffer > bufp->allocated - 10) + /* Note that EXTEND_BUFFER clobbers c */ + EXTEND_BUFFER; + + PATFETCH (c); + + switch (c) + { + case '$': + if (obscure_syntax & RE_TIGHT_VBAR) + { + if (! (obscure_syntax & RE_CONTEXT_INDEP_OPS) && p != pend) + goto normal_char; + /* Make operand of last vbar end before this `$'. */ + if (fixup_jump) + store_jump (fixup_jump, jump, b); + fixup_jump = 0; + PATPUSH (endline); + break; + } + + /* $ means succeed if at end of line, but only in special contexts. + If randomly in the middle of a pattern, it is a normal character. */ + if (p == pend || *p == '\n' + || (obscure_syntax & RE_CONTEXT_INDEP_OPS) + || (obscure_syntax & RE_NO_BK_PARENS + ? *p == ')' + : *p == '\\' && p[1] == ')') + || (obscure_syntax & RE_NO_BK_VBAR + ? *p == '|' + : *p == '\\' && p[1] == '|')) + { + PATPUSH (endline); + break; + } + goto normal_char; + + case '^': + /* ^ means succeed if at beg of line, but only if no preceding pattern. */ + + if (laststart && p[-2] != '\n' + && ! (obscure_syntax & RE_CONTEXT_INDEP_OPS)) + goto normal_char; + if (obscure_syntax & RE_TIGHT_VBAR) + { + if (p != pattern + 1 + && ! (obscure_syntax & RE_CONTEXT_INDEP_OPS)) + goto normal_char; + PATPUSH (begline); + begalt = b; + } + else + PATPUSH (begline); + break; + + case '+': + case '?': + if (obscure_syntax & RE_BK_PLUS_QM) + goto normal_char; + handle_plus: + case '*': + /* If there is no previous pattern, char not special. */ + if (!laststart && ! (obscure_syntax & RE_CONTEXT_INDEP_OPS)) + goto normal_char; + /* If there is a sequence of repetition chars, + collapse it down to equivalent to just one. */ + zero_times_ok = 0; + many_times_ok = 0; + while (1) + { + zero_times_ok |= c != '+'; + many_times_ok |= c != '?'; + if (p == pend) + break; + PATFETCH (c); + if (c == '*') + ; + else if (!(obscure_syntax & RE_BK_PLUS_QM) + && (c == '+' || c == '?')) + ; + else if ((obscure_syntax & RE_BK_PLUS_QM) + && c == '\\') + { + int c1; + PATFETCH (c1); + if (!(c1 == '+' || c1 == '?')) + { + PATUNFETCH; + PATUNFETCH; + break; + } + c = c1; + } + else + { + PATUNFETCH; + break; + } + } + + /* Star, etc. applied to an empty pattern is equivalent + to an empty pattern. */ + if (!laststart) + break; + + /* Now we know whether 0 matches is allowed, + and whether 2 or more matches is allowed. */ + if (many_times_ok) + { + /* If more than one repetition is allowed, + put in a backward jump at the end. */ + store_jump (b, maybe_finalize_jump, laststart - 3); + b += 3; + } + insert_jump (on_failure_jump, laststart, b + 3, b); + pending_exact = 0; + b += 3; + if (!zero_times_ok) + { + /* At least one repetition required: insert before the loop + a skip over the initial on-failure-jump instruction */ + insert_jump (dummy_failure_jump, laststart, laststart + 6, b); + b += 3; + } + break; + + case '.': + laststart = b; + PATPUSH (anychar); + break; + + case '[': + while (b - bufp->buffer + > bufp->allocated - 3 - (1 << BYTEWIDTH) / BYTEWIDTH) + /* Note that EXTEND_BUFFER clobbers c */ + EXTEND_BUFFER; + + laststart = b; + if (*p == '^') + PATPUSH (charset_not), p++; + else + PATPUSH (charset); + p1 = p; + + PATPUSH ((1 << BYTEWIDTH) / BYTEWIDTH); + /* Clear the whole map */ + bzero (b, (1 << BYTEWIDTH) / BYTEWIDTH); + /* Read in characters and ranges, setting map bits */ + while (1) + { + PATFETCH (c); + if (c == ']' && p != p1 + 1) break; + if (*p == '-' && p[1] != ']') + { + PATFETCH (c1); + PATFETCH (c1); + while (c <= c1) + b[c / BYTEWIDTH] |= 1 << (c % BYTEWIDTH), c++; + } + else + { + b[c / BYTEWIDTH] |= 1 << (c % BYTEWIDTH); + } + } + /* Discard any bitmap bytes that are all 0 at the end of the map. + Decrement the map-length byte too. */ + while ((int) b[-1] > 0 && b[b[-1] - 1] == 0) + b[-1]--; + b += b[-1]; + break; + + case '(': + if (! (obscure_syntax & RE_NO_BK_PARENS)) + goto normal_char; + else + goto handle_open; + + case ')': + if (! (obscure_syntax & RE_NO_BK_PARENS)) + goto normal_char; + else + goto handle_close; + + case '\n': + if (! (obscure_syntax & RE_NEWLINE_OR)) + goto normal_char; + else + goto handle_bar; + + case '|': + if (! (obscure_syntax & RE_NO_BK_VBAR)) + goto normal_char; + else + goto handle_bar; + + case '\\': + if (p == pend) goto invalid_pattern; + PATFETCH_RAW (c); + switch (c) + { + case '(': + if (obscure_syntax & RE_NO_BK_PARENS) + goto normal_backsl; + handle_open: + if (stackp == stacke) goto nesting_too_deep; + if (regnum < RE_NREGS) + { + PATPUSH (start_memory); + PATPUSH (regnum); + } + *stackp++ = b - bufp->buffer; + *stackp++ = fixup_jump ? fixup_jump - bufp->buffer + 1 : 0; + *stackp++ = regnum++; + *stackp++ = begalt - bufp->buffer; + fixup_jump = 0; + laststart = 0; + begalt = b; + break; + + case ')': + if (obscure_syntax & RE_NO_BK_PARENS) + goto normal_backsl; + handle_close: + if (stackp == stackb) goto unmatched_close; + begalt = *--stackp + bufp->buffer; + if (fixup_jump) + store_jump (fixup_jump, jump, b); + if (stackp[-1] < RE_NREGS) + { + PATPUSH (stop_memory); + PATPUSH (stackp[-1]); + } + stackp -= 2; + fixup_jump = 0; + if (*stackp) + fixup_jump = *stackp + bufp->buffer - 1; + laststart = *--stackp + bufp->buffer; + break; + + case '|': + if (obscure_syntax & RE_NO_BK_VBAR) + goto normal_backsl; + handle_bar: + insert_jump (on_failure_jump, begalt, b + 6, b); + pending_exact = 0; + b += 3; + if (fixup_jump) + store_jump (fixup_jump, jump, b); + fixup_jump = b; + b += 3; + laststart = 0; + begalt = b; + break; + +#ifdef emacs + case '=': + PATPUSH (at_dot); + break; + + case 's': + laststart = b; + PATPUSH (syntaxspec); + PATFETCH (c); + PATPUSH (syntax_spec_code[c]); + break; + + case 'S': + laststart = b; + PATPUSH (notsyntaxspec); + PATFETCH (c); + PATPUSH (syntax_spec_code[c]); + break; +#endif /* emacs */ + + case 'w': + laststart = b; + PATPUSH (wordchar); + break; + + case 'W': + laststart = b; + PATPUSH (notwordchar); + break; + + case '<': + PATPUSH (wordbeg); + break; + + case '>': + PATPUSH (wordend); + break; + + case 'b': + PATPUSH (wordbound); + break; + + case 'B': + PATPUSH (notwordbound); + break; + + case '`': + PATPUSH (begbuf); + break; + + case '\'': + PATPUSH (endbuf); + break; + + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + c1 = c - '0'; + if (c1 >= regnum) + goto normal_char; + for (stackt = stackp - 2; stackt > stackb; stackt -= 4) + if (*stackt == c1) + goto normal_char; + laststart = b; + PATPUSH (duplicate); + PATPUSH (c1); + break; + + case '+': + case '?': + if (obscure_syntax & RE_BK_PLUS_QM) + goto handle_plus; + + default: + normal_backsl: + /* You might think it would be useful for \ to mean + not to translate; but if we don't translate it + it will never match anything. */ + if (translate) c = translate[c]; + goto normal_char; + } + break; + + default: + normal_char: + if (!pending_exact || pending_exact + *pending_exact + 1 != b + || *pending_exact == 0177 || *p == '*' || *p == '^' + || ((obscure_syntax & RE_BK_PLUS_QM) + ? *p == '\\' && (p[1] == '+' || p[1] == '?') + : (*p == '+' || *p == '?'))) + { + laststart = b; + PATPUSH (exactn); + pending_exact = b; + PATPUSH (0); + } + PATPUSH (c); + (*pending_exact)++; + } + } + + if (fixup_jump) + store_jump (fixup_jump, jump, b); + + if (stackp != stackb) goto unmatched_open; + + bufp->used = b - bufp->buffer; + return 0; + + invalid_pattern: + return "Invalid regular expression"; + + unmatched_open: + return "Unmatched \\("; + + unmatched_close: + return "Unmatched \\)"; + + end_of_pattern: + return "Premature end of regular expression"; + + nesting_too_deep: + return "Nesting too deep"; + + too_big: + return "Regular expression too big"; + + memory_exhausted: + return "Memory exhausted"; +} + +/* Store where `from' points a jump operation to jump to where `to' points. + `opcode' is the opcode to store. */ + +static int +store_jump (from, opcode, to) + char *from, *to; + char opcode; +{ + from[0] = opcode; + from[1] = (to - (from + 3)) & 0377; + from[2] = (to - (from + 3)) >> 8; +} + +/* Open up space at char FROM, and insert there a jump to TO. + CURRENT_END gives te end of the storage no in use, + so we know how much data to copy up. + OP is the opcode of the jump to insert. + + If you call this function, you must zero out pending_exact. */ + +static int +insert_jump (op, from, to, current_end) + char op; + char *from, *to, *current_end; +{ + register char *pto = current_end + 3; + register char *pfrom = current_end; + while (pfrom != from) + *--pto = *--pfrom; + store_jump (from, op, to); +} + +/* Given a pattern, compute a fastmap from it. + The fastmap records which of the (1 << BYTEWIDTH) possible characters + can start a string that matches the pattern. + This fastmap is used by re_search to skip quickly over totally implausible text. + + The caller must supply the address of a (1 << BYTEWIDTH)-byte data area + as bufp->fastmap. + The other components of bufp describe the pattern to be used. */ + +void +re_compile_fastmap (bufp) + struct re_pattern_buffer *bufp; +{ + unsigned char *pattern = (unsigned char *) bufp->buffer; + int size = bufp->used; + register char *fastmap = bufp->fastmap; + register unsigned char *p = pattern; + register unsigned char *pend = pattern + size; + register int j, k; + unsigned char *translate = (unsigned char *) bufp->translate; + + unsigned char *stackb[NFAILURES]; + unsigned char **stackp = stackb; + + bzero (fastmap, (1 << BYTEWIDTH)); + bufp->fastmap_accurate = 1; + bufp->can_be_null = 0; + + while (p) + { + if (p == pend) + { + bufp->can_be_null = 1; + break; + } +#ifdef SWITCH_ENUM_BUG + switch ((int) ((enum regexpcode) *p++)) +#else + switch ((enum regexpcode) *p++) +#endif + { + case exactn: + if (translate) + fastmap[translate[p[1]]] = 1; + else + fastmap[p[1]] = 1; + break; + + case begline: + case before_dot: + case at_dot: + case after_dot: + case begbuf: + case endbuf: + case wordbound: + case notwordbound: + case wordbeg: + case wordend: + continue; + + case endline: + if (translate) + fastmap[translate['\n']] = 1; + else + fastmap['\n'] = 1; + if (bufp->can_be_null != 1) + bufp->can_be_null = 2; + break; + + case finalize_jump: + case maybe_finalize_jump: + case jump: + case dummy_failure_jump: + bufp->can_be_null = 1; + j = *p++ & 0377; + j += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p += j + 1; /* The 1 compensates for missing ++ above */ + if (j > 0) + continue; + /* Jump backward reached implies we just went through + the body of a loop and matched nothing. + Opcode jumped to should be an on_failure_jump. + Just treat it like an ordinary jump. + For a * loop, it has pushed its failure point already; + if so, discard that as redundant. */ + if ((enum regexpcode) *p != on_failure_jump) + continue; + p++; + j = *p++ & 0377; + j += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p += j + 1; /* The 1 compensates for missing ++ above */ + if (stackp != stackb && *stackp == p) + stackp--; + continue; + + case on_failure_jump: + j = *p++ & 0377; + j += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p++; + *++stackp = p + j; + continue; + + case start_memory: + case stop_memory: + p++; + continue; + + case duplicate: + bufp->can_be_null = 1; + fastmap['\n'] = 1; + case anychar: + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (j != '\n') + fastmap[j] = 1; + if (bufp->can_be_null) + return; + /* Don't return; check the alternative paths + so we can set can_be_null if appropriate. */ + break; + + case wordchar: + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) == Sword) + fastmap[j] = 1; + break; + + case notwordchar: + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) != Sword) + fastmap[j] = 1; + break; + +#ifdef emacs + case syntaxspec: + k = *p++; + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) == (enum syntaxcode) k) + fastmap[j] = 1; + break; + + case notsyntaxspec: + k = *p++; + for (j = 0; j < (1 << BYTEWIDTH); j++) + if (SYNTAX (j) != (enum syntaxcode) k) + fastmap[j] = 1; + break; +#endif /* emacs */ + + case charset: + for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) + if (p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH))) + { + if (translate) + fastmap[translate[j]] = 1; + else + fastmap[j] = 1; + } + break; + + case charset_not: + /* Chars beyond end of map must be allowed */ + for (j = *p * BYTEWIDTH; j < (1 << BYTEWIDTH); j++) + if (translate) + fastmap[translate[j]] = 1; + else + fastmap[j] = 1; + + for (j = *p++ * BYTEWIDTH - 1; j >= 0; j--) + if (!(p[j / BYTEWIDTH] & (1 << (j % BYTEWIDTH)))) + { + if (translate) + fastmap[translate[j]] = 1; + else + fastmap[j] = 1; + } + break; + } + + /* Get here means we have successfully found the possible starting characters + of one path of the pattern. We need not follow this path any farther. + Instead, look at the next alternative remembered in the stack. */ + if (stackp != stackb) + p = *stackp--; + else + break; + } +} + +/* Like re_search_2, below, but only one string is specified. */ + +int +re_search (pbufp, string, size, startpos, range, regs) + struct re_pattern_buffer *pbufp; + char *string; + int size, startpos, range; + struct re_registers *regs; +{ + return re_search_2 (pbufp, 0, 0, string, size, startpos, range, regs, size); +} + +/* Like re_match_2 but tries first a match starting at index STARTPOS, + then at STARTPOS + 1, and so on. + RANGE is the number of places to try before giving up. + If RANGE is negative, the starting positions tried are + STARTPOS, STARTPOS - 1, etc. + It is up to the caller to make sure that range is not so large + as to take the starting position outside of the input strings. + +The value returned is the position at which the match was found, + or -1 if no match was found, + or -2 if error (such as failure stack overflow). */ + +int +re_search_2 (pbufp, string1, size1, string2, size2, startpos, range, regs, mstop) + struct re_pattern_buffer *pbufp; + char *string1, *string2; + int size1, size2; + int startpos; + register int range; + struct re_registers *regs; + int mstop; +{ + register char *fastmap = pbufp->fastmap; + register unsigned char *translate = (unsigned char *) pbufp->translate; + int total = size1 + size2; + int val; + + /* Update the fastmap now if not correct already */ + if (fastmap && !pbufp->fastmap_accurate) + re_compile_fastmap (pbufp); + + /* Don't waste time in a long search for a pattern + that says it is anchored. */ + if (pbufp->used > 0 && (enum regexpcode) pbufp->buffer[0] == begbuf + && range > 0) + { + if (startpos > 0) + return -1; + else + range = 1; + } + + while (1) + { + /* If a fastmap is supplied, skip quickly over characters + that cannot possibly be the start of a match. + Note, however, that if the pattern can possibly match + the null string, we must test it at each starting point + so that we take the first null string we get. */ + + if (fastmap && startpos < total && pbufp->can_be_null != 1) + { + if (range > 0) + { + register int lim = 0; + register unsigned char *p; + int irange = range; + if (startpos < size1 && startpos + range >= size1) + lim = range - (size1 - startpos); + + p = ((unsigned char *) + &(startpos >= size1 ? string2 - size1 : string1)[startpos]); + + if (translate) + { + while (range > lim && !fastmap[translate[*p++]]) + range--; + } + else + { + while (range > lim && !fastmap[*p++]) + range--; + } + startpos += irange - range; + } + else + { + register unsigned char c; + if (startpos >= size1) + c = string2[startpos - size1]; + else + c = string1[startpos]; + c &= 0xff; + if (translate ? !fastmap[translate[c]] : !fastmap[c]) + goto advance; + } + } + + if (range >= 0 && startpos == total + && fastmap && pbufp->can_be_null == 0) + return -1; + + val = re_match_2 (pbufp, string1, size1, string2, size2, startpos, regs, mstop); + if (0 <= val) + { + if (val == -2) + return -2; + return startpos; + } + +#ifdef C_ALLOCA + alloca (0); +#endif /* C_ALLOCA */ + + advance: + if (!range) break; + if (range > 0) range--, startpos++; else range++, startpos--; + } + return -1; +} + +#ifndef emacs /* emacs never uses this */ +int +re_match (pbufp, string, size, pos, regs) + struct re_pattern_buffer *pbufp; + char *string; + int size, pos; + struct re_registers *regs; +{ + return re_match_2 (pbufp, 0, 0, string, size, pos, regs, size); +} +#endif /* emacs */ + +/* Maximum size of failure stack. Beyond this, overflow is an error. */ + +int re_max_failures = 2000; + +static int bcmp_translate(); +/* Match the pattern described by PBUFP + against data which is the virtual concatenation of STRING1 and STRING2. + SIZE1 and SIZE2 are the sizes of the two data strings. + Start the match at position POS. + Do not consider matching past the position MSTOP. + + If pbufp->fastmap is nonzero, then it had better be up to date. + + The reason that the data to match are specified as two components + which are to be regarded as concatenated + is so this function can be used directly on the contents of an Emacs buffer. + + -1 is returned if there is no match. -2 is returned if there is + an error (such as match stack overflow). Otherwise the value is the length + of the substring which was matched. */ + +int +re_match_2 (pbufp, string1, size1, string2, size2, pos, regs, mstop) + struct re_pattern_buffer *pbufp; + unsigned char *string1, *string2; + int size1, size2; + int pos; + struct re_registers *regs; + int mstop; +{ + register unsigned char *p = (unsigned char *) pbufp->buffer; + register unsigned char *pend = p + pbufp->used; + /* End of first string */ + unsigned char *end1; + /* End of second string */ + unsigned char *end2; + /* Pointer just past last char to consider matching */ + unsigned char *end_match_1, *end_match_2; + register unsigned char *d, *dend; + register int mcnt; + unsigned char *translate = (unsigned char *) pbufp->translate; + + /* Failure point stack. Each place that can handle a failure further down the line + pushes a failure point on this stack. It consists of two char *'s. + The first one pushed is where to resume scanning the pattern; + the second pushed is where to resume scanning the strings. + If the latter is zero, the failure point is a "dummy". + If a failure happens and the innermost failure point is dormant, + it discards that failure point and tries the next one. */ + + unsigned char *initial_stack[2 * NFAILURES]; + unsigned char **stackb = initial_stack; + unsigned char **stackp = stackb, **stacke = &stackb[2 * NFAILURES]; + + /* Information on the "contents" of registers. + These are pointers into the input strings; they record + just what was matched (on this attempt) by some part of the pattern. + The start_memory command stores the start of a register's contents + and the stop_memory command stores the end. + + At that point, regstart[regnum] points to the first character in the register, + regend[regnum] points to the first character beyond the end of the register, + regstart_seg1[regnum] is true iff regstart[regnum] points into string1, + and regend_seg1[regnum] is true iff regend[regnum] points into string1. */ + + unsigned char *regstart[RE_NREGS]; + unsigned char *regend[RE_NREGS]; + unsigned char regstart_seg1[RE_NREGS], regend_seg1[RE_NREGS]; + + /* Set up pointers to ends of strings. + Don't allow the second string to be empty unless both are empty. */ + if (!size2) + { + string2 = string1; + size2 = size1; + string1 = 0; + size1 = 0; + } + end1 = string1 + size1; + end2 = string2 + size2; + + /* Compute where to stop matching, within the two strings */ + if (mstop <= size1) + { + end_match_1 = string1 + mstop; + end_match_2 = string2; + } + else + { + end_match_1 = end1; + end_match_2 = string2 + mstop - size1; + } + + /* Initialize \) text positions to -1 + to mark ones that no \( or \) has been seen for. */ + + for (mcnt = 0; mcnt < sizeof (regend) / sizeof (*regend); mcnt++) + regend[mcnt] = (unsigned char *) -1; + + /* `p' scans through the pattern as `d' scans through the data. + `dend' is the end of the input string that `d' points within. + `d' is advanced into the following input string whenever necessary, + but this happens before fetching; + therefore, at the beginning of the loop, + `d' can be pointing at the end of a string, + but it cannot equal string2. */ + + if (pos <= size1) + d = string1 + pos, dend = end_match_1; + else + d = string2 + pos - size1, dend = end_match_2; + +/* Write PREFETCH; just before fetching a character with *d. */ +#define PREFETCH \ + while (d == dend) \ + { if (dend == end_match_2) goto fail; /* end of string2 => failure */ \ + d = string2; /* end of string1 => advance to string2. */ \ + dend = end_match_2; } + + /* This loop loops over pattern commands. + It exits by returning from the function if match is complete, + or it drops through if match fails at this starting point in the input data. */ + + while (1) + { + if (p == pend) + /* End of pattern means we have succeeded! */ + { + /* If caller wants register contents data back, convert it to indices */ + if (regs) + { + regs->start[0] = pos; + if (dend == end_match_1) + regs->end[0] = d - string1; + else + regs->end[0] = d - string2 + size1; + for (mcnt = 1; mcnt < RE_NREGS; mcnt++) + { + if (regend[mcnt] == (unsigned char *) -1) + { + regs->start[mcnt] = -1; + regs->end[mcnt] = -1; + continue; + } + if (regstart_seg1[mcnt]) + regs->start[mcnt] = regstart[mcnt] - string1; + else + regs->start[mcnt] = regstart[mcnt] - string2 + size1; + if (regend_seg1[mcnt]) + regs->end[mcnt] = regend[mcnt] - string1; + else + regs->end[mcnt] = regend[mcnt] - string2 + size1; + } + } + if (dend == end_match_1) + return (d - string1 - pos); + else + return d - string2 + size1 - pos; + } + + /* Otherwise match next pattern command */ +#ifdef SWITCH_ENUM_BUG + switch ((int) ((enum regexpcode) *p++)) +#else + switch ((enum regexpcode) *p++) +#endif + { + + /* \( is represented by a start_memory, \) by a stop_memory. + Both of those commands contain a "register number" argument. + The text matched within the \( and \) is recorded under that number. + Then, \<digit> turns into a `duplicate' command which + is followed by the numeric value of <digit> as the register number. */ + + case start_memory: + regstart[*p] = d; + regstart_seg1[*p++] = (dend == end_match_1); + break; + + case stop_memory: + regend[*p] = d; + regend_seg1[*p++] = (dend == end_match_1); + break; + + case duplicate: + { + int regno = *p++; /* Get which register to match against */ + register unsigned char *d2, *dend2; + + d2 = regstart[regno]; + dend2 = ((regstart_seg1[regno] == regend_seg1[regno]) + ? regend[regno] : end_match_1); + while (1) + { + /* Advance to next segment in register contents, if necessary */ + while (d2 == dend2) + { + if (dend2 == end_match_2) break; + if (dend2 == regend[regno]) break; + d2 = string2, dend2 = regend[regno]; /* end of string1 => advance to string2. */ + } + /* At end of register contents => success */ + if (d2 == dend2) break; + + /* Advance to next segment in data being matched, if necessary */ + PREFETCH; + + /* mcnt gets # consecutive chars to compare */ + mcnt = dend - d; + if (mcnt > dend2 - d2) + mcnt = dend2 - d2; + /* Compare that many; failure if mismatch, else skip them. */ + if (translate ? bcmp_translate (d, d2, mcnt, translate) : bcmp (d, d2, mcnt)) + goto fail; + d += mcnt, d2 += mcnt; + } + } + break; + + case anychar: + /* fetch a data character */ + PREFETCH; + /* Match anything but a newline. */ + if ((translate ? translate[*d++] : *d++) == '\n') + goto fail; + break; + + case charset: + case charset_not: + { + /* Nonzero for charset_not */ + int not = 0; + register int c; + if (*(p - 1) == (unsigned char) charset_not) + not = 1; + + /* fetch a data character */ + PREFETCH; + + if (translate) + c = translate [*d]; + else + c = *d; + + if (c < *p * BYTEWIDTH + && p[1 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) + not = !not; + + p += 1 + *p; + + if (!not) goto fail; + d++; + break; + } + + case begline: + if (d == string1 || d[-1] == '\n') + break; + goto fail; + + case endline: + if (d == end2 + || (d == end1 ? (size2 == 0 || *string2 == '\n') : *d == '\n')) + break; + goto fail; + + /* "or" constructs ("|") are handled by starting each alternative + with an on_failure_jump that points to the start of the next alternative. + Each alternative except the last ends with a jump to the joining point. + (Actually, each jump except for the last one really jumps + to the following jump, because tensioning the jumps is a hassle.) */ + + /* The start of a stupid repeat has an on_failure_jump that points + past the end of the repeat text. + This makes a failure point so that, on failure to match a repetition, + matching restarts past as many repetitions have been found + with no way to fail and look for another one. */ + + /* A smart repeat is similar but loops back to the on_failure_jump + so that each repetition makes another failure point. */ + + case on_failure_jump: + if (stackp == stacke) + { + unsigned char **stackx; + if (stacke - stackb > re_max_failures * 2) + return -2; + stackx = (unsigned char **) alloca (2 * (stacke - stackb) + * sizeof (char *)); + bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *)); + stackp = stackx + (stackp - stackb); + stacke = stackx + 2 * (stacke - stackb); + stackb = stackx; + } + mcnt = *p++ & 0377; + mcnt += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p++; + *stackp++ = mcnt + p; + *stackp++ = d; + break; + + /* The end of a smart repeat has an maybe_finalize_jump back. + Change it either to a finalize_jump or an ordinary jump. */ + + case maybe_finalize_jump: + mcnt = *p++ & 0377; + mcnt += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p++; + { + register unsigned char *p2 = p; + /* Compare what follows with the begining of the repeat. + If we can establish that there is nothing that they would + both match, we can change to finalize_jump */ + while (p2 != pend + && (*p2 == (unsigned char) stop_memory + || *p2 == (unsigned char) start_memory)) + p2++; + if (p2 == pend) + p[-3] = (unsigned char) finalize_jump; + else if (*p2 == (unsigned char) exactn + || *p2 == (unsigned char) endline) + { + register int c = *p2 == (unsigned char) endline ? '\n' : p2[2]; + register unsigned char *p1 = p + mcnt; + /* p1[0] ... p1[2] are an on_failure_jump. + Examine what follows that */ + if (p1[3] == (unsigned char) exactn && p1[5] != c) + p[-3] = (unsigned char) finalize_jump; + else if (p1[3] == (unsigned char) charset + || p1[3] == (unsigned char) charset_not) + { + int not = p1[3] == (unsigned char) charset_not; + if (c < p1[4] * BYTEWIDTH + && p1[5 + c / BYTEWIDTH] & (1 << (c % BYTEWIDTH))) + not = !not; + /* not is 1 if c would match */ + /* That means it is not safe to finalize */ + if (!not) + p[-3] = (unsigned char) finalize_jump; + } + } + } + p -= 2; + if (p[-1] != (unsigned char) finalize_jump) + { + p[-1] = (unsigned char) jump; + goto nofinalize; + } + + /* The end of a stupid repeat has a finalize-jump + back to the start, where another failure point will be made + which will point after all the repetitions found so far. */ + + case finalize_jump: + stackp -= 2; + + case jump: + nofinalize: + mcnt = *p++ & 0377; + mcnt += SIGN_EXTEND_CHAR (*(char *)p) << 8; + p += mcnt + 1; /* The 1 compensates for missing ++ above */ + break; + + case dummy_failure_jump: + if (stackp == stacke) + { + unsigned char **stackx + = (unsigned char **) alloca (2 * (stacke - stackb) + * sizeof (char *)); + bcopy (stackb, stackx, (stacke - stackb) * sizeof (char *)); + stackp = stackx + (stackp - stackb); + stacke = stackx + 2 * (stacke - stackb); + stackb = stackx; + } + *stackp++ = 0; + *stackp++ = 0; + goto nofinalize; + + case wordbound: + if (d == string1 /* Points to first char */ + || d == end2 /* Points to end */ + || (d == end1 && size2 == 0)) /* Points to end */ + break; + if ((SYNTAX (d[-1]) == Sword) + != (SYNTAX (d == end1 ? *string2 : *d) == Sword)) + break; + goto fail; + + case notwordbound: + if (d == string1 /* Points to first char */ + || d == end2 /* Points to end */ + || (d == end1 && size2 == 0)) /* Points to end */ + goto fail; + if ((SYNTAX (d[-1]) == Sword) + != (SYNTAX (d == end1 ? *string2 : *d) == Sword)) + goto fail; + break; + + case wordbeg: + if (d == end2 /* Points to end */ + || (d == end1 && size2 == 0) /* Points to end */ + || SYNTAX (* (d == end1 ? string2 : d)) != Sword) /* Next char not a letter */ + goto fail; + if (d == string1 /* Points to first char */ + || SYNTAX (d[-1]) != Sword) /* prev char not letter */ + break; + goto fail; + + case wordend: + if (d == string1 /* Points to first char */ + || SYNTAX (d[-1]) != Sword) /* prev char not letter */ + goto fail; + if (d == end2 /* Points to end */ + || (d == end1 && size2 == 0) /* Points to end */ + || SYNTAX (d == end1 ? *string2 : *d) != Sword) /* Next char not a letter */ + break; + goto fail; + +#ifdef emacs + case before_dot: + if (((d - string2 <= (unsigned) size2) + ? d - bf_p2 : d - bf_p1) + <= point) + goto fail; + break; + + case at_dot: + if (((d - string2 <= (unsigned) size2) + ? d - bf_p2 : d - bf_p1) + == point) + goto fail; + break; + + case after_dot: + if (((d - string2 <= (unsigned) size2) + ? d - bf_p2 : d - bf_p1) + >= point) + goto fail; + break; + + case wordchar: + mcnt = (int) Sword; + goto matchsyntax; + + case syntaxspec: + mcnt = *p++; + matchsyntax: + PREFETCH; + if (SYNTAX (*d++) != (enum syntaxcode) mcnt) goto fail; + break; + + case notwordchar: + mcnt = (int) Sword; + goto matchnotsyntax; + + case notsyntaxspec: + mcnt = *p++; + matchnotsyntax: + PREFETCH; + if (SYNTAX (*d++) == (enum syntaxcode) mcnt) goto fail; + break; +#else + case wordchar: + PREFETCH; + if (SYNTAX (*d++) == 0) goto fail; + break; + + case notwordchar: + PREFETCH; + if (SYNTAX (*d++) != 0) goto fail; + break; +#endif /* not emacs */ + + case begbuf: + if (d == string1) /* Note, d cannot equal string2 */ + break; /* unless string1 == string2. */ + goto fail; + + case endbuf: + if (d == end2 || (d == end1 && size2 == 0)) + break; + goto fail; + + case exactn: + /* Match the next few pattern characters exactly. + mcnt is how many characters to match. */ + mcnt = *p++; + if (translate) + { + do + { + PREFETCH; + if (translate[*d++] != *p++) goto fail; + } + while (--mcnt); + } + else + { + do + { + PREFETCH; + if (*d++ != *p++) goto fail; + } + while (--mcnt); + } + break; + } + continue; /* Successfully matched one pattern command; keep matching */ + + /* Jump here if any matching operation fails. */ + fail: + if (stackp != stackb) + /* A restart point is known. Restart there and pop it. */ + { + if (!stackp[-2]) + { /* If innermost failure point is dormant, flush it and keep looking */ + stackp -= 2; + goto fail; + } + d = *--stackp; + p = *--stackp; + if (d >= string1 && d <= end1) + dend = end_match_1; + } + else break; /* Matching at this starting point really fails! */ + } + return -1; /* Failure to match */ +} + +static int +bcmp_translate (s1, s2, len, translate) + unsigned char *s1, *s2; + register int len; + unsigned char *translate; +{ + register unsigned char *p1 = s1, *p2 = s2; + while (len) + { + if (translate [*p1++] != translate [*p2++]) return 1; + len--; + } + return 0; +} + +/* Entry points compatible with bsd4.2 regex library */ + +#ifndef emacs + +static struct re_pattern_buffer re_comp_buf; + +char * +re_comp (s) + char *s; +{ + if (!s) + { + if (!re_comp_buf.buffer) + return "No previous regular expression"; + return 0; + } + + if (!re_comp_buf.buffer) + { + if (!(re_comp_buf.buffer = (char *) malloc (200))) + return "Memory exhausted"; + re_comp_buf.allocated = 200; + if (!(re_comp_buf.fastmap = (char *) malloc (1 << BYTEWIDTH))) + return "Memory exhausted"; + } + return re_compile_pattern (s, strlen (s), &re_comp_buf); +} + +int +re_exec (s) + char *s; +{ + int len = strlen (s); + return 0 <= re_search (&re_comp_buf, s, len, 0, len, 0); +} + +#endif /* emacs */ + +#ifdef test + +#include <stdio.h> + +/* Indexed by a character, gives the upper case equivalent of the character */ + +static char upcase[0400] = + { 000, 001, 002, 003, 004, 005, 006, 007, + 010, 011, 012, 013, 014, 015, 016, 017, + 020, 021, 022, 023, 024, 025, 026, 027, + 030, 031, 032, 033, 034, 035, 036, 037, + 040, 041, 042, 043, 044, 045, 046, 047, + 050, 051, 052, 053, 054, 055, 056, 057, + 060, 061, 062, 063, 064, 065, 066, 067, + 070, 071, 072, 073, 074, 075, 076, 077, + 0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107, + 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, + 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, + 0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137, + 0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107, + 0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117, + 0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127, + 0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177, + 0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207, + 0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217, + 0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227, + 0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237, + 0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247, + 0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257, + 0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267, + 0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277, + 0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307, + 0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317, + 0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327, + 0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337, + 0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347, + 0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357, + 0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367, + 0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377 + }; + +main (argc, argv) + int argc; + char **argv; +{ + char pat[80]; + struct re_pattern_buffer buf; + int i; + char c; + char fastmap[(1 << BYTEWIDTH)]; + + /* Allow a command argument to specify the style of syntax. */ + if (argc > 1) + obscure_syntax = atoi (argv[1]); + + buf.allocated = 40; + buf.buffer = (char *) malloc (buf.allocated); + buf.fastmap = fastmap; + buf.translate = upcase; + + while (1) + { + gets (pat); + + if (*pat) + { + re_compile_pattern (pat, strlen(pat), &buf); + + for (i = 0; i < buf.used; i++) + printchar (buf.buffer[i]); + + putchar ('\n'); + + printf ("%d allocated, %d used.\n", buf.allocated, buf.used); + + re_compile_fastmap (&buf); + printf ("Allowed by fastmap: "); + for (i = 0; i < (1 << BYTEWIDTH); i++) + if (fastmap[i]) printchar (i); + putchar ('\n'); + } + + gets (pat); /* Now read the string to match against */ + + i = re_match (&buf, pat, strlen (pat), 0, 0); + printf ("Match value %d.\n", i); + } +} + +#ifdef NOTDEF +print_buf (bufp) + struct re_pattern_buffer *bufp; +{ + int i; + + printf ("buf is :\n----------------\n"); + for (i = 0; i < bufp->used; i++) + printchar (bufp->buffer[i]); + + printf ("\n%d allocated, %d used.\n", bufp->allocated, bufp->used); + + printf ("Allowed by fastmap: "); + for (i = 0; i < (1 << BYTEWIDTH); i++) + if (bufp->fastmap[i]) + printchar (i); + printf ("\nAllowed by translate: "); + if (bufp->translate) + for (i = 0; i < (1 << BYTEWIDTH); i++) + if (bufp->translate[i]) + printchar (i); + printf ("\nfastmap is%s accurate\n", bufp->fastmap_accurate ? "" : "n't"); + printf ("can %s be null\n----------", bufp->can_be_null ? "" : "not"); +} +#endif + +printchar (c) + char c; +{ + if (c < 041 || c >= 0177) + { + putchar ('\\'); + putchar (((c >> 6) & 3) + '0'); + putchar (((c >> 3) & 7) + '0'); + putchar ((c & 7) + '0'); + } + else + putchar (c); +} + +error (string) + char *string; +{ + puts (string); + exit (1); +} + +#endif /* test */ diff --git a/gdb/regex.h b/gdb/regex.h new file mode 100644 index 0000000..d0d8a82 --- /dev/null +++ b/gdb/regex.h @@ -0,0 +1,185 @@ +/* Definitions for data structures callers pass the regex library. + Copyright (C) 1985, 1989 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + + + In other words, you are welcome to use, share and improve this program. + You are forbidden to forbid anyone else to use, share and improve + what you give them. Help stamp out software-hoarding! */ + + +/* Define number of parens for which we record the beginnings and ends. + This affects how much space the `struct re_registers' type takes up. */ +#ifndef RE_NREGS +#define RE_NREGS 10 +#endif + +/* These bits are used in the obscure_syntax variable to choose among + alternative regexp syntaxes. */ + +/* 1 means plain parentheses serve as grouping, and backslash + parentheses are needed for literal searching. + 0 means backslash-parentheses are grouping, and plain parentheses + are for literal searching. */ +#define RE_NO_BK_PARENS 1 + +/* 1 means plain | serves as the "or"-operator, and \| is a literal. + 0 means \| serves as the "or"-operator, and | is a literal. */ +#define RE_NO_BK_VBAR 2 + +/* 0 means plain + or ? serves as an operator, and \+, \? are literals. + 1 means \+, \? are operators and plain +, ? are literals. */ +#define RE_BK_PLUS_QM 4 + +/* 1 means | binds tighter than ^ or $. + 0 means the contrary. */ +#define RE_TIGHT_VBAR 8 + +/* 1 means treat \n as an _OR operator + 0 means treat it as a normal character */ +#define RE_NEWLINE_OR 16 + +/* 0 means that a special characters (such as *, ^, and $) always have + their special meaning regardless of the surrounding context. + 1 means that special characters may act as normal characters in some + contexts. Specifically, this applies to: + ^ - only special at the beginning, or after ( or | + $ - only special at the end, or before ) or | + *, +, ? - only special when not after the beginning, (, or | */ +#define RE_CONTEXT_INDEP_OPS 32 + +/* Now define combinations of bits for the standard possibilities. */ +#define RE_SYNTAX_AWK (RE_NO_BK_PARENS | RE_NO_BK_VBAR | RE_CONTEXT_INDEP_OPS) +#define RE_SYNTAX_EGREP (RE_SYNTAX_AWK | RE_NEWLINE_OR) +#define RE_SYNTAX_GREP (RE_BK_PLUS_QM | RE_NEWLINE_OR) +#define RE_SYNTAX_EMACS 0 + +/* This data structure is used to represent a compiled pattern. */ + +struct re_pattern_buffer + { + char *buffer; /* Space holding the compiled pattern commands. */ + int allocated; /* Size of space that buffer points to */ + int used; /* Length of portion of buffer actually occupied */ + char *fastmap; /* Pointer to fastmap, if any, or zero if none. */ + /* re_search uses the fastmap, if there is one, + to skip quickly over totally implausible characters */ + char *translate; /* Translate table to apply to all characters before comparing. + Or zero for no translation. + The translation is applied to a pattern when it is compiled + and to data when it is matched. */ + char fastmap_accurate; + /* Set to zero when a new pattern is stored, + set to one when the fastmap is updated from it. */ + char can_be_null; /* Set to one by compiling fastmap + if this pattern might match the null string. + It does not necessarily match the null string + in that case, but if this is zero, it cannot. + 2 as value means can match null string + but at end of range or before a character + listed in the fastmap. */ + }; + +/* Structure to store "register" contents data in. + + Pass the address of such a structure as an argument to re_match, etc., + if you want this information back. + + start[i] and end[i] record the string matched by \( ... \) grouping i, + for i from 1 to RE_NREGS - 1. + start[0] and end[0] record the entire string matched. */ + +struct re_registers + { + int start[RE_NREGS]; + int end[RE_NREGS]; + }; + +/* These are the command codes that appear in compiled regular expressions, one per byte. + Some command codes are followed by argument bytes. + A command code can specify any interpretation whatever for its arguments. + Zero-bytes may appear in the compiled regular expression. */ + +enum regexpcode + { + unused, + exactn, /* followed by one byte giving n, and then by n literal bytes */ + begline, /* fails unless at beginning of line */ + endline, /* fails unless at end of line */ + jump, /* followed by two bytes giving relative address to jump to */ + on_failure_jump, /* followed by two bytes giving relative address of place + to resume at in case of failure. */ + finalize_jump, /* Throw away latest failure point and then jump to address. */ + maybe_finalize_jump, /* Like jump but finalize if safe to do so. + This is used to jump back to the beginning + of a repeat. If the command that follows + this jump is clearly incompatible with the + one at the beginning of the repeat, such that + we can be sure that there is no use backtracking + out of repetitions already completed, + then we finalize. */ + dummy_failure_jump, /* jump, and push a dummy failure point. + This failure point will be thrown away + if an attempt is made to use it for a failure. + A + construct makes this before the first repeat. */ + anychar, /* matches any one character */ + charset, /* matches any one char belonging to specified set. + First following byte is # bitmap bytes. + Then come bytes for a bit-map saying which chars are in. + Bits in each byte are ordered low-bit-first. + A character is in the set if its bit is 1. + A character too large to have a bit in the map + is automatically not in the set */ + charset_not, /* similar but match any character that is NOT one of those specified */ + start_memory, /* starts remembering the text that is matched + and stores it in a memory register. + followed by one byte containing the register number. + Register numbers must be in the range 0 through NREGS. */ + stop_memory, /* stops remembering the text that is matched + and stores it in a memory register. + followed by one byte containing the register number. + Register numbers must be in the range 0 through NREGS. */ + duplicate, /* match a duplicate of something remembered. + Followed by one byte containing the index of the memory register. */ + before_dot, /* Succeeds if before dot */ + at_dot, /* Succeeds if at dot */ + after_dot, /* Succeeds if after dot */ + begbuf, /* Succeeds if at beginning of buffer */ + endbuf, /* Succeeds if at end of buffer */ + wordchar, /* Matches any word-constituent character */ + notwordchar, /* Matches any char that is not a word-constituent */ + wordbeg, /* Succeeds if at word beginning */ + wordend, /* Succeeds if at word end */ + wordbound, /* Succeeds if at a word boundary */ + notwordbound, /* Succeeds if not at a word boundary */ + syntaxspec, /* Matches any character whose syntax is specified. + followed by a byte which contains a syntax code, Sword or such like */ + notsyntaxspec /* Matches any character whose syntax differs from the specified. */ + }; + +extern char *re_compile_pattern (); +/* Is this really advertised? */ +extern void re_compile_fastmap (); +extern int re_search (), re_search_2 (); +extern int re_match (), re_match_2 (); + +/* 4.2 bsd compatibility (yuck) */ +extern char *re_comp (); +extern int re_exec (); + +#ifdef SYNTAX_TABLE +extern char *re_syntax_table; +#endif diff --git a/gdb/remote-eb.c b/gdb/remote-eb.c new file mode 100644 index 0000000..a140905 --- /dev/null +++ b/gdb/remote-eb.c @@ -0,0 +1,932 @@ +/* Remote debugging interface for AMD 29000 EBMON on IBM PC, for GDB. + Copyright 1990-1991 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon for Cygnus. + +This file is part of GDB. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is like remote.c but is for an esoteric situation-- + having a 29k board in a PC hooked up to a unix machine with + a serial line, and running ctty com1 on the PC, through which + the unix machine can run ebmon. Not to mention that the PC + has PC/NFS, so it can access the same executables that gdb can, + over the net in real time. */ + +#include <stdio.h> +#include <string.h> +#include "defs.h" +#include "tm-29k.h" +#include "param-no-tm.h" +#include "inferior.h" +#include "wait.h" +#include "value.h" +#include <ctype.h> +#include <fcntl.h> +#include <signal.h> +#include <errno.h> +#include "terminal.h" +#include "target.h" + +extern void add_syms_addr_command (); +extern struct value *call_function_by_hand(); + +extern struct target_ops eb_ops; /* Forward declaration */ + +#define LOG_FILE "eb.log" +#if defined (LOG_FILE) +FILE *log_file; +#endif + +static int timeout = 5; + +/* Descriptor for I/O to remote machine. Initialize it to -1 so that + eb_open knows that we don't have a file open when the program + starts. */ +int eb_desc = -1; + +/* stream which is fdopen'd from eb_desc. Only valid when + eb_desc != -1. */ +FILE *eb_stream; + +/* Read a character from the remote system, doing all the fancy + timeout stuff. */ +static int +readchar () +{ + char buf; + + buf = '\0'; +#ifdef HAVE_TERMIO + /* termio does the timeout for us. */ + read (eb_desc, &buf, 1); +#else + alarm (timeout); + if (read (eb_desc, &buf, 1) < 0) + { + if (errno == EINTR) + error ("Timeout reading from remote system."); + else + perror_with_name ("remote"); + } + alarm (0); +#endif + + if (buf == '\0') + error ("Timeout reading from remote system."); +#if defined (LOG_FILE) + putc (buf & 0x7f, log_file); +#endif + return buf & 0x7f; +} + +/* Keep discarding input from the remote system, until STRING is found. + Let the user break out immediately. */ +static void +expect (string) + char *string; +{ + char *p = string; + + immediate_quit = 1; + while (1) + { + if (readchar() == *p) + { + p++; + if (*p == '\0') + { + immediate_quit = 0; + return; + } + } + else + p = string; + } +} + +/* Keep discarding input until we see the ebmon prompt. + + The convention for dealing with the prompt is that you + o give your command + o *then* wait for the prompt. + + Thus the last thing that a procedure does with the serial line + will be an expect_prompt(). Exception: eb_resume does not + wait for the prompt, because the terminal is being handed over + to the inferior. However, the next thing which happens after that + is a eb_wait which does wait for the prompt. + Note that this includes abnormal exit, e.g. error(). This is + necessary to prevent getting into states from which we can't + recover. */ +static void +expect_prompt () +{ +#if defined (LOG_FILE) + /* This is a convenient place to do this. The idea is to do it often + enough that we never lose much data if we terminate abnormally. */ + fflush (log_file); +#endif + expect ("\n# "); +} + +/* Get a hex digit from the remote system & return its value. + If ignore_space is nonzero, ignore spaces (not newline, tab, etc). */ +static int +get_hex_digit (ignore_space) + int ignore_space; +{ + int ch; + while (1) + { + ch = readchar (); + if (ch >= '0' && ch <= '9') + return ch - '0'; + else if (ch >= 'A' && ch <= 'F') + return ch - 'A' + 10; + else if (ch >= 'a' && ch <= 'f') + return ch - 'a' + 10; + else if (ch == ' ' && ignore_space) + ; + else + { + expect_prompt (); + error ("Invalid hex digit from remote system."); + } + } +} + +/* Get a byte from eb_desc and put it in *BYT. Accept any number + leading spaces. */ +static void +get_hex_byte (byt) + char *byt; +{ + int val; + + val = get_hex_digit (1) << 4; + val |= get_hex_digit (0); + *byt = val; +} + +/* Get N 32-bit words from remote, each preceded by a space, + and put them in registers starting at REGNO. */ +static void +get_hex_regs (n, regno) + int n; + int regno; +{ + long val; + int i; + + for (i = 0; i < n; i++) + { + int j; + + val = 0; + for (j = 0; j < 8; j++) + val = (val << 4) + get_hex_digit (j == 0); + supply_register (regno++, &val); + } +} + +/* Called when SIGALRM signal sent due to alarm() timeout. */ +#ifndef HAVE_TERMIO + +#ifndef __STDC__ +#define volatile /**/ +#endif +volatile int n_alarms; + +void +eb_timer () +{ +#if 0 + if (kiodebug) + printf ("eb_timer called\n"); +#endif + n_alarms++; +} +#endif + +/* malloc'd name of the program on the remote system. */ +static char *prog_name = NULL; + +/* Nonzero if we have loaded the file ("yc") and not yet issued a "gi" + command. "gi" is supposed to happen exactly once for each "yc". */ +static int need_gi = 0; + +/* Number of SIGTRAPs we need to simulate. That is, the next + NEED_ARTIFICIAL_TRAP calls to eb_wait should just return + SIGTRAP without actually waiting for anything. */ + +static int need_artificial_trap = 0; + +/* This is called not only when we first attach, but also when the + user types "run" after having attached. */ +void +eb_start (inferior_args) +char *inferior_args; +{ + /* OK, now read in the file. Y=read, C=COFF, D=no symbols + 0=start address, %s=filename. */ + + fprintf (eb_stream, "YC D,0:%s", prog_name); + + if (inferior_args != NULL) + fprintf(eb_stream, " %s", inferior_args); + + fprintf (eb_stream, "\n"); + fflush (eb_stream); + + expect_prompt (); + + need_gi = 1; +} + +/* Translate baud rates from integers to damn B_codes. Unix should + have outgrown this crap years ago, but even POSIX wouldn't buck it. */ + +#ifndef B19200 +#define B19200 EXTA +#endif +#ifndef B38400 +#define B38400 EXTB +#endif + +struct {int rate, damn_b;} baudtab[] = { + {0, B0}, + {50, B50}, + {75, B75}, + {110, B110}, + {134, B134}, + {150, B150}, + {200, B200}, + {300, B300}, + {600, B600}, + {1200, B1200}, + {1800, B1800}, + {2400, B2400}, + {4800, B4800}, + {9600, B9600}, + {19200, B19200}, + {38400, B38400}, + {-1, -1}, +}; + +int damn_b (rate) + int rate; +{ + int i; + + for (i = 0; baudtab[i].rate != -1; i++) + if (rate == baudtab[i].rate) return baudtab[i].damn_b; + return B38400; /* Random */ +} + + +/* Open a connection to a remote debugger. + NAME is the filename used for communication, then a space, + then the name of the program as we should name it to EBMON. */ + +static int baudrate = 9600; +static char *dev_name; +void +eb_open (name, from_tty) + char *name; + int from_tty; +{ + TERMINAL sg; + + char *p; + + /* Find the first whitespace character, it separates dev_name from + prog_name. */ + if (name == 0) + goto erroid; + + for (p = name; + *p != '\0' && !isspace (*p); p++) + ; + if (*p == '\0') +erroid: + error ("\ +Please include the name of the device for the serial port,\n\ +the baud rate, and the name of the program to run on the remote system."); + dev_name = alloca (p - name + 1); + strncpy (dev_name, name, p - name); + dev_name[p - name] = '\0'; + + /* Skip over the whitespace after dev_name */ + for (; isspace (*p); p++) + /*EMPTY*/; + + if (1 != sscanf (p, "%d ", &baudrate)) + goto erroid; + + /* Skip the number and then the spaces */ + for (; isdigit (*p); p++) + /*EMPTY*/; + for (; isspace (*p); p++) + /*EMPTY*/; + + if (prog_name != NULL) + free (prog_name); + prog_name = savestring (p, strlen (p)); + + eb_close (0); + + eb_desc = open (dev_name, O_RDWR); + if (eb_desc < 0) + perror_with_name (dev_name); + ioctl (eb_desc, TIOCGETP, &sg); +#ifdef HAVE_TERMIO + sg.c_cc[VMIN] = 0; /* read with timeout. */ + sg.c_cc[VTIME] = timeout * 10; + sg.c_lflag &= ~(ICANON | ECHO); + sg.c_cflag = (sg.c_cflag & ~CBAUD) | damn_b (baudrate); +#else + sg.sg_ispeed = damn_b (baudrate); + sg.sg_ospeed = damn_b (baudrate); + sg.sg_flags |= RAW | ANYP; + sg.sg_flags &= ~ECHO; +#endif + + ioctl (eb_desc, TIOCSETP, &sg); + eb_stream = fdopen (eb_desc, "r+"); + + push_target (&eb_ops); + if (from_tty) + printf ("Remote %s debugging %s using %s\n", target_shortname, + prog_name, dev_name); + +#ifndef HAVE_TERMIO +#ifndef NO_SIGINTERRUPT + /* Cause SIGALRM's to make reads fail with EINTR instead of resuming + the read. */ + if (siginterrupt (SIGALRM, 1) != 0) + perror ("eb_open: error in siginterrupt"); +#endif + + /* Set up read timeout timer. */ + if ((void (*)) signal (SIGALRM, eb_timer) == (void (*)) -1) + perror ("eb_open: error in signal"); +#endif + +#if defined (LOG_FILE) + log_file = fopen (LOG_FILE, "w"); + if (log_file == NULL) + perror_with_name (LOG_FILE); +#endif + + /* Hello? Are you there? */ + write (eb_desc, "\n", 1); + + expect_prompt (); +} + +/* Close out all files and local state before this target loses control. */ + +void +eb_close (quitting) + int quitting; +{ + + /* Due to a bug in Unix, fclose closes not only the stdio stream, + but also the file descriptor. So we don't actually close + eb_desc. */ + if (eb_stream) + fclose (eb_stream); /* This also closes eb_desc */ + if (eb_desc >= 0) + /* close (eb_desc); */ + + /* Do not try to close eb_desc again, later in the program. */ + eb_stream = NULL; + eb_desc = -1; + +#if defined (LOG_FILE) + if (ferror (log_file)) + printf ("Error writing log file.\n"); + if (fclose (log_file) != 0) + printf ("Error closing log file.\n"); +#endif +} + +/* Terminate the open connection to the remote debugger. + Use this when you want to detach and do something else + with your gdb. */ +void +eb_detach (from_tty) + int from_tty; +{ + pop_target(); /* calls eb_close to do the real work */ + if (from_tty) + printf ("Ending remote %s debugging\n", target_shortname); +} + +/* Tell the remote machine to resume. */ + +void +eb_resume (step, sig) + int step, sig; +{ + if (step) + { + write (eb_desc, "t 1,s\n", 6); + /* Wait for the echo. */ + expect ("t 1,s\r"); + /* Then comes a line containing the instruction we stepped to. */ + expect ("\n@"); + /* Then we get the prompt. */ + expect_prompt (); + + /* Force the next eb_wait to return a trap. Not doing anything + about I/O from the target means that the user has to type + "continue" to see any. This should be fixed. */ + need_artificial_trap = 1; + } + else + { + if (need_gi) + { + need_gi = 0; + write (eb_desc, "gi\n", 3); + + /* Swallow the echo of "gi". */ + expect ("gi\r"); + } + else + { + write (eb_desc, "GR\n", 3); + /* Swallow the echo. */ + expect ("GR\r"); + } + } +} + +/* Wait until the remote machine stops, then return, + storing status in STATUS just as `wait' would. */ + +int +eb_wait (status) + WAITTYPE *status; +{ + /* Strings to look for. '?' means match any single character. + Note that with the algorithm we use, the initial character + of the string cannot recur in the string, or we will not + find some cases of the string in the input. */ + + static char bpt[] = "Invalid interrupt taken - #0x50 - "; + /* It would be tempting to look for "\n[__exit + 0x8]\n" + but that requires loading symbols with "yc i" and even if + we did do that we don't know that the file has symbols. */ + static char exitmsg[] = "\n@????????I JMPTI GR121,LR0"; + char *bp = bpt; + char *ep = exitmsg; + + /* Large enough for either sizeof (bpt) or sizeof (exitmsg) chars. */ + char swallowed[50]; + /* Current position in swallowed. */ + char *swallowed_p = swallowed; + + int ch; + int ch_handled; + + int old_timeout = timeout; + + WSETEXIT ((*status), 0); + + if (need_artificial_trap != 0) + { + WSETSTOP ((*status), SIGTRAP); + need_artificial_trap--; + return 0; + } + + timeout = 0; /* Don't time out -- user program is running. */ + while (1) + { + ch_handled = 0; + ch = readchar (); + if (ch == *bp) + { + bp++; + if (*bp == '\0') + break; + ch_handled = 1; + + *swallowed_p++ = ch; + } + else + bp = bpt; + + if (ch == *ep || *ep == '?') + { + ep++; + if (*ep == '\0') + break; + + if (!ch_handled) + *swallowed_p++ = ch; + ch_handled = 1; + } + else + ep = exitmsg; + + if (!ch_handled) + { + char *p; + + /* Print out any characters which have been swallowed. */ + for (p = swallowed; p < swallowed_p; ++p) + putc (*p, stdout); + swallowed_p = swallowed; + + putc (ch, stdout); + } + } + expect_prompt (); + if (*bp== '\0') + WSETSTOP ((*status), SIGTRAP); + else + WSETEXIT ((*status), 0); + timeout = old_timeout; + + return 0; +} + +/* Return the name of register number REGNO + in the form input and output by EBMON. + + Returns a pointer to a static buffer containing the answer. */ +static char * +get_reg_name (regno) + int regno; +{ + static char buf[80]; + if (regno >= GR96_REGNUM && regno < GR96_REGNUM + 32) + sprintf (buf, "GR%03d", regno - GR96_REGNUM + 96); + else if (regno >= LR0_REGNUM && regno < LR0_REGNUM + 128) + sprintf (buf, "LR%03d", regno - LR0_REGNUM); + else if (regno == Q_REGNUM) + strcpy (buf, "SR131"); + else if (regno >= BP_REGNUM && regno <= CR_REGNUM) + sprintf (buf, "SR%03d", regno - BP_REGNUM + 133); + else if (regno == ALU_REGNUM) + strcpy (buf, "SR132"); + else if (regno >= IPC_REGNUM && regno <= IPB_REGNUM) + sprintf (buf, "SR%03d", regno - IPC_REGNUM + 128); + else if (regno >= VAB_REGNUM && regno <= LRU_REGNUM) + sprintf (buf, "SR%03d", regno - VAB_REGNUM); + else if (regno == GR1_REGNUM) + strcpy (buf, "GR001"); + return buf; +} + +/* Read the remote registers into the block REGS. */ + +static void +eb_fetch_registers () +{ + int reg_index; + int regnum_index; + char tempbuf[10]; + int i; + +#if 0 + /* This should not be necessary, because one is supposed to read the + registers only when the inferior is stopped (at least with + ptrace() and why not make it the same for remote?). */ + /* ^A is the "normal character" used to make sure we are talking to EBMON + and not to the program being debugged. */ + write (eb_desc, "\001\n"); + expect_prompt (); +#endif + + write (eb_desc, "dw gr96,gr127\n", 14); + for (reg_index = 96, regnum_index = GR96_REGNUM; + reg_index < 128; + reg_index += 4, regnum_index += 4) + { + sprintf (tempbuf, "GR%03d ", reg_index); + expect (tempbuf); + get_hex_regs (4, regnum_index); + expect ("\n"); + } + + for (i = 0; i < 128; i += 32) + { + /* The PC has a tendency to hang if we get these + all in one fell swoop ("dw lr0,lr127"). */ + sprintf (tempbuf, "dw lr%d\n", i); + write (eb_desc, tempbuf, strlen (tempbuf)); + for (reg_index = i, regnum_index = LR0_REGNUM + i; + reg_index < i + 32; + reg_index += 4, regnum_index += 4) + { + sprintf (tempbuf, "LR%03d ", reg_index); + expect (tempbuf); + get_hex_regs (4, regnum_index); + expect ("\n"); + } + } + + write (eb_desc, "dw sr133,sr133\n", 15); + expect ("SR133 "); + get_hex_regs (1, BP_REGNUM); + expect ("\n"); + + write (eb_desc, "dw sr134,sr134\n", 15); + expect ("SR134 "); + get_hex_regs (1, FC_REGNUM); + expect ("\n"); + + write (eb_desc, "dw sr135,sr135\n", 15); + expect ("SR135 "); + get_hex_regs (1, CR_REGNUM); + expect ("\n"); + + write (eb_desc, "dw sr131,sr131\n", 15); + expect ("SR131 "); + get_hex_regs (1, Q_REGNUM); + expect ("\n"); + + write (eb_desc, "dw sr0,sr14\n", 12); + for (reg_index = 0, regnum_index = VAB_REGNUM; + regnum_index <= LRU_REGNUM; + regnum_index += 4, reg_index += 4) + { + sprintf (tempbuf, "SR%03d ", reg_index); + expect (tempbuf); + get_hex_regs (reg_index == 12 ? 3 : 4, regnum_index); + expect ("\n"); + } + + /* There doesn't seem to be any way to get these. */ + { + int val = -1; + supply_register (FPE_REGNUM, &val); + supply_register (INT_REGNUM, &val); + supply_register (FPS_REGNUM, &val); + supply_register (EXO_REGNUM, &val); + } + + write (eb_desc, "dw gr1,gr1\n", 11); + expect ("GR001 "); + get_hex_regs (1, GR1_REGNUM); + expect_prompt (); +} + +/* Fetch register REGNO, or all registers if REGNO is -1. + Returns errno value. */ +int +eb_fetch_register (regno) + int regno; +{ + if (regno == -1) + eb_fetch_registers (); + else + { + char *name = get_reg_name (regno); + fprintf (eb_stream, "dw %s,%s\n", name, name); + expect (name); + expect (" "); + get_hex_regs (1, regno); + expect_prompt (); + } + return 0; +} + +/* Store the remote registers from the contents of the block REGS. */ + +static void +eb_store_registers () +{ + int i, j; + fprintf (eb_stream, "s gr1,%x\n", read_register (GR1_REGNUM)); + expect_prompt (); + + for (j = 0; j < 32; j += 16) + { + fprintf (eb_stream, "s gr%d,", j + 96); + for (i = 0; i < 15; ++i) + fprintf (eb_stream, "%x,", read_register (GR96_REGNUM + j + i)); + fprintf (eb_stream, "%x\n", read_register (GR96_REGNUM + j + 15)); + expect_prompt (); + } + + for (j = 0; j < 128; j += 16) + { + fprintf (eb_stream, "s lr%d,", j); + for (i = 0; i < 15; ++i) + fprintf (eb_stream, "%x,", read_register (LR0_REGNUM + j + i)); + fprintf (eb_stream, "%x\n", read_register (LR0_REGNUM + j + 15)); + expect_prompt (); + } + + fprintf (eb_stream, "s sr133,%x,%x,%x\n", read_register (BP_REGNUM), + read_register (FC_REGNUM), read_register (CR_REGNUM)); + expect_prompt (); + fprintf (eb_stream, "s sr131,%x\n", read_register (Q_REGNUM)); + expect_prompt (); + fprintf (eb_stream, "s sr0,"); + for (i = 0; i < 11; ++i) + fprintf (eb_stream, "%x,", read_register (VAB_REGNUM + i)); + fprintf (eb_stream, "%x\n", read_register (VAB_REGNUM + 11)); + expect_prompt (); +} + +/* Store register REGNO, or all if REGNO == 0. + Return errno value. */ +int +eb_store_register (regno) + int regno; +{ + if (regno == -1) + eb_store_registers (); + else + { + char *name = get_reg_name (regno); + fprintf (eb_stream, "s %s,%x\n", name, read_register (regno)); + /* Setting GR1 changes the numbers of all the locals, so + invalidate the register cache. Do this *after* calling + read_register, because we want read_register to return the + value that write_register has just stuffed into the registers + array, not the value of the register fetched from the + inferior. */ + if (regno == GR1_REGNUM) + registers_changed (); + expect_prompt (); + } + return 0; +} + +/* Get ready to modify the registers array. On machines which store + individual registers, this doesn't need to do anything. On machines + which store all the registers in one fell swoop, this makes sure + that registers contains all the registers from the program being + debugged. */ + +void +eb_prepare_to_store () +{ + /* Do nothing, since we can store individual regs */ +} + +/* FIXME! Merge these two. */ +int +eb_xfer_inferior_memory (memaddr, myaddr, len, write) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; +{ + if (write) + return eb_write_inferior_memory (memaddr, myaddr, len); + else + return eb_write_inferior_memory (memaddr, myaddr, len); +} + +void +eb_files_info () +{ + printf ("\tAttached to %s at %d baud and running program %s.\n", + dev_name, baudrate, prog_name); +} + +/* Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. Returns errno value. */ +int +eb_write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int i; + + for (i = 0; i < len; i++) + { + if ((i % 16) == 0) + fprintf (eb_stream, "sb %x,", memaddr + i); + if ((i % 16) == 15 || i == len - 1) + { + fprintf (eb_stream, "%x\n", ((unsigned char *)myaddr)[i]); + expect_prompt (); + } + else + fprintf (eb_stream, "%x,", ((unsigned char *)myaddr)[i]); + } + return 0; +} + +/* Read LEN bytes from inferior memory at MEMADDR. Put the result + at debugger address MYADDR. Returns errno value. */ +int +eb_read_inferior_memory(memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int i; + + /* Number of bytes read so far. */ + int count; + + /* Starting address of this pass. */ + unsigned long startaddr; + + /* Number of bytes to read in this pass. */ + int len_this_pass; + + /* Note that this code works correctly if startaddr is just less + than UINT_MAX (well, really CORE_ADDR_MAX if there was such a + thing). That is, something like + eb_read_bytes (CORE_ADDR_MAX - 4, foo, 4) + works--it never adds len to memaddr and gets 0. */ + /* However, something like + eb_read_bytes (CORE_ADDR_MAX - 3, foo, 4) + doesn't need to work. Detect it and give up if there's an attempt + to do that. */ + if (((memaddr - 1) + len) < memaddr) + return EIO; + + startaddr = memaddr; + count = 0; + while (count < len) + { + len_this_pass = 16; + if ((startaddr % 16) != 0) + len_this_pass -= startaddr % 16; + if (len_this_pass > (len - count)) + len_this_pass = (len - count); + + fprintf (eb_stream, "db %x,%x\n", startaddr, + (startaddr - 1) + len_this_pass); + expect ("\n"); + + /* Look for 8 hex digits. */ + i = 0; + while (1) + { + if (isxdigit (readchar ())) + ++i; + else + { + expect_prompt (); + error ("Hex digit expected from remote system."); + } + if (i >= 8) + break; + } + + expect (" "); + + for (i = 0; i < len_this_pass; i++) + get_hex_byte (&myaddr[count++]); + + expect_prompt (); + + startaddr += len_this_pass; + } + return 0; +} + +/* Define the target subroutine names */ + +struct target_ops eb_ops = { + "amd-eb", "Remote serial AMD EBMON target", + eb_open, eb_close, + 0, eb_detach, eb_resume, eb_wait, + eb_fetch_register, eb_store_register, + eb_prepare_to_store, 0, 0, /* conv_to, conv_from */ + eb_xfer_inferior_memory, eb_files_info, + 0, 0, /* Breakpoints */ + 0, 0, 0, 0, 0, /* Terminal handling */ + 0, /* FIXME, kill */ + 0, add_syms_addr_command, /* load */ + call_function_by_hand, + 0, /* lookup_symbol */ + 0, /* create_inferior FIXME, eb_start here or something? */ + 0, /* mourn_inferior FIXME */ + process_stratum, 0, /* next */ + 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ + OPS_MAGIC, /* Always the last thing */ +}; + +void +_initialize_remote_eb () +{ + add_target (&eb_ops); +} diff --git a/gdb/remote-multi.shar b/gdb/remote-multi.shar new file mode 100755 index 0000000..86c9cf0 --- /dev/null +++ b/gdb/remote-multi.shar @@ -0,0 +1,1313 @@ +#!/bin/sh +# This is a shell archive. +# Run the file through sh to extract its contents. +# shar: Shell Archiver +# Run the following text with /bin/sh to create: +# Remote_Makefile +# remote_gutils.c +# remote_inflow.c +# remote_server.c +# remote_utils.c +# This archive created: Fri Jun 23 17:06:55 1989 +cat << \SHAR_EOF > Remote_Makefile +# Makefile for the remote server for GDB, the GNU debugger. +# Copyright (C) 1986, 1989 Free Software Foundation, Inc. +# +# This file is part of GDB. +# +# GDB is free software; you can redistribute it and/or modify +# it under the terms of the GNU General Public License as published by +# the Free Software Foundation; either version 1, or (at your option) +# any later version. +# +# GDB is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU General Public License for more details. +# +# You should have received a copy of the GNU General Public License +# along with GDB; see the file COPYING. If not, write to +# the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +CFLAGS = -g +CC = cc + +SERVER = remote_server.o\ + remote_inflow.o\ + remote_utils.o\ + remote_gutils.o + +prog : $(SERVER) + $(CC) -g -o serve $(SERVER) +SHAR_EOF +cat << \SHAR_EOF > remote_gutils.c +/* General utility routines for the remote server for GDB, the GNU debugger. + Copyright (C) 1986, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <sys/ioctl.h> +#include "defs.h" + +void error (); +void fatal (); + +/* Chain of cleanup actions established with make_cleanup, + to be executed if an error happens. */ + +static struct cleanup *cleanup_chain; + +/* Nonzero means a quit has been requested. */ + +int quit_flag; + +/* Nonzero means quit immediately if Control-C is typed now, + rather than waiting until QUIT is executed. */ + +int immediate_quit; + +/* Add a new cleanup to the cleanup_chain, + and return the previous chain pointer + to be passed later to do_cleanups or discard_cleanups. + Args are FUNCTION to clean up with, and ARG to pass to it. */ + +struct cleanup * +make_cleanup (function, arg) + void (*function) (); + int arg; +{ + register struct cleanup *new + = (struct cleanup *) xmalloc (sizeof (struct cleanup)); + register struct cleanup *old_chain = cleanup_chain; + + new->next = cleanup_chain; + new->function = function; + new->arg = arg; + cleanup_chain = new; + + return old_chain; +} + +/* Discard cleanups and do the actions they describe + until we get back to the point OLD_CHAIN in the cleanup_chain. */ + +void +do_cleanups (old_chain) + register struct cleanup *old_chain; +{ + register struct cleanup *ptr; + while ((ptr = cleanup_chain) != old_chain) + { + (*ptr->function) (ptr->arg); + cleanup_chain = ptr->next; + free (ptr); + } +} + +/* Discard cleanups, not doing the actions they describe, + until we get back to the point OLD_CHAIN in the cleanup_chain. */ + +void +discard_cleanups (old_chain) + register struct cleanup *old_chain; +{ + register struct cleanup *ptr; + while ((ptr = cleanup_chain) != old_chain) + { + cleanup_chain = ptr->next; + free (ptr); + } +} + +/* This function is useful for cleanups. + Do + + foo = xmalloc (...); + old_chain = make_cleanup (free_current_contents, &foo); + + to arrange to free the object thus allocated. */ + +void +free_current_contents (location) + char **location; +{ + free (*location); +} + +/* Generally useful subroutines used throughout the program. */ + +/* Like malloc but get error if no storage available. */ + +char * +xmalloc (size) + long size; +{ + register char *val = (char *) malloc (size); + if (!val) + fatal ("virtual memory exhausted.", 0); + return val; +} + +/* Like realloc but get error if no storage available. */ + +char * +xrealloc (ptr, size) + char *ptr; + long size; +{ + register char *val = (char *) realloc (ptr, size); + if (!val) + fatal ("virtual memory exhausted.", 0); + return val; +} + +/* Print the system error message for errno, and also mention STRING + as the file name for which the error was encountered. + Then return to command level. */ + +void +perror_with_name (string) + char *string; +{ + extern int sys_nerr; + extern char *sys_errlist[]; + extern int errno; + char *err; + char *combined; + + if (errno < sys_nerr) + err = sys_errlist[errno]; + else + err = "unknown error"; + + combined = (char *) alloca (strlen (err) + strlen (string) + 3); + strcpy (combined, string); + strcat (combined, ": "); + strcat (combined, err); + + error ("%s.", combined); +} + +/* Print the system error message for ERRCODE, and also mention STRING + as the file name for which the error was encountered. */ + +void +print_sys_errmsg (string, errcode) + char *string; + int errcode; +{ + extern int sys_nerr; + extern char *sys_errlist[]; + char *err; + char *combined; + + if (errcode < sys_nerr) + err = sys_errlist[errcode]; + else + err = "unknown error"; + + combined = (char *) alloca (strlen (err) + strlen (string) + 3); + strcpy (combined, string); + strcat (combined, ": "); + strcat (combined, err); + + printf ("%s.\n", combined); +} + +void +quit () +{ + fflush (stdout); + ioctl (fileno (stdout), TIOCFLUSH, 0); + error ("Quit"); +} + +/* Control C comes here */ + +void +request_quit () +{ + quit_flag = 1; + if (immediate_quit) + quit (); +} + +/* Print an error message and return to command level. + STRING is the error message, used as a fprintf string, + and ARG is passed as an argument to it. */ + +void +error (string, arg1, arg2, arg3) + char *string; + int arg1, arg2, arg3; +{ + fflush (stdout); + fprintf (stderr, string, arg1, arg2, arg3); + fprintf (stderr, "\n"); + /************return_to_top_level ();************/ +} + +/* Print an error message and exit reporting failure. + This is for a error that we cannot continue from. + STRING and ARG are passed to fprintf. */ + +void +fatal (string, arg) + char *string; + int arg; +{ + fprintf (stderr, "gdb: "); + fprintf (stderr, string, arg); + fprintf (stderr, "\n"); + exit (1); +} + +/* Make a copy of the string at PTR with SIZE characters + (and add a null character at the end in the copy). + Uses malloc to get the space. Returns the address of the copy. */ + +char * +savestring (ptr, size) + char *ptr; + int size; +{ + register char *p = (char *) xmalloc (size + 1); + bcopy (ptr, p, size); + p[size] = 0; + return p; +} + +char * +concat (s1, s2, s3) + char *s1, *s2, *s3; +{ + register int len = strlen (s1) + strlen (s2) + strlen (s3) + 1; + register char *val = (char *) xmalloc (len); + strcpy (val, s1); + strcat (val, s2); + strcat (val, s3); + return val; +} + +void +print_spaces (n, file) + register int n; + register FILE *file; +{ + while (n-- > 0) + fputc (' ', file); +} + +/* Ask user a y-or-n question and return 1 iff answer is yes. + Takes three args which are given to printf to print the question. + The first, a control string, should end in "? ". + It should not say how to answer, because we do that. */ + +int +query (ctlstr, arg1, arg2) + char *ctlstr; +{ + register int answer; + + /* Automatically answer "yes" if input is not from a terminal. */ + /***********if (!input_from_terminal_p ()) + return 1; *************************/ + + while (1) + { + printf (ctlstr, arg1, arg2); + printf ("(y or n) "); + fflush (stdout); + answer = fgetc (stdin); + clearerr (stdin); /* in case of C-d */ + if (answer != '\n') + while (fgetc (stdin) != '\n') clearerr (stdin); + if (answer >= 'a') + answer -= 040; + if (answer == 'Y') + return 1; + if (answer == 'N') + return 0; + printf ("Please answer y or n.\n"); + } +} + +/* Parse a C escape sequence. STRING_PTR points to a variable + containing a pointer to the string to parse. That pointer + is updated past the characters we use. The value of the + escape sequence is returned. + + A negative value means the sequence \ newline was seen, + which is supposed to be equivalent to nothing at all. + + If \ is followed by a null character, we return a negative + value and leave the string pointer pointing at the null character. + + If \ is followed by 000, we return 0 and leave the string pointer + after the zeros. A value of 0 does not mean end of string. */ + +int +parse_escape (string_ptr) + char **string_ptr; +{ + register int c = *(*string_ptr)++; + switch (c) + { + case 'a': + return '\a'; + case 'b': + return '\b'; + case 'e': + return 033; + case 'f': + return '\f'; + case 'n': + return '\n'; + case 'r': + return '\r'; + case 't': + return '\t'; + case 'v': + return '\v'; + case '\n': + return -2; + case 0: + (*string_ptr)--; + return 0; + case '^': + c = *(*string_ptr)++; + if (c == '\\') + c = parse_escape (string_ptr); + if (c == '?') + return 0177; + return (c & 0200) | (c & 037); + + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + { + register int i = c - '0'; + register int count = 0; + while (++count < 3) + { + if ((c = *(*string_ptr)++) >= '0' && c <= '7') + { + i *= 8; + i += c - '0'; + } + else + { + (*string_ptr)--; + break; + } + } + return i; + } + default: + return c; + } +} + +void +printchar (ch, stream) + unsigned char ch; + FILE *stream; +{ + register int c = ch; + if (c < 040 || c >= 0177) + { + if (c == '\n') + fprintf (stream, "\\n"); + else if (c == '\b') + fprintf (stream, "\\b"); + else if (c == '\t') + fprintf (stream, "\\t"); + else if (c == '\f') + fprintf (stream, "\\f"); + else if (c == '\r') + fprintf (stream, "\\r"); + else if (c == 033) + fprintf (stream, "\\e"); + else if (c == '\a') + fprintf (stream, "\\a"); + else + fprintf (stream, "\\%03o", c); + } + else + { + if (c == '\\' || c == '"' || c == '\'') + fputc ('\\', stream); + fputc (c, stream); + } +} +SHAR_EOF +cat << \SHAR_EOF > remote_inflow.c +/* Low level interface to ptrace, for GDB when running under Unix. + Copyright (C) 1986, 1987 Free Software Foundation, Inc. +*/ + +#include "defs.h" +#include "param.h" +#include "wait.h" +#include "frame.h" +#include "inferior.h" +/*************************** +#include "initialize.h" +****************************/ + +#include <stdio.h> +#include <sys/param.h> +#include <sys/dir.h> +#include <sys/user.h> +#include <signal.h> +#include <sys/ioctl.h> +#include <sgtty.h> +#include <fcntl.h> + +/***************Begin MY defs*********************/ +int quit_flag = 0; +char registers[REGISTER_BYTES]; + +/* Index within `registers' of the first byte of the space for + register N. */ + + +char buf2[MAX_REGISTER_RAW_SIZE]; +/***************End MY defs*********************/ + +#ifdef NEW_SUN_PTRACE +#include <sys/ptrace.h> +#include <machine/reg.h> +#endif + +extern char **environ; +extern int errno; +extern int inferior_pid; +void error(), quit(), perror_with_name(); +int query(); +void supply_register(), write_register(); +CORE_ADDR read_register(); + +/* Nonzero if we are debugging an attached outside process + rather than an inferior. */ + + +/* Start an inferior process and returns its pid. + ALLARGS is a vector of program-name and args. + ENV is the environment vector to pass. */ + +int +create_inferior (allargs, env) + char **allargs; + char **env; +{ + int pid; + extern int sys_nerr; + extern char *sys_errlist[]; + extern int errno; + + /* exec is said to fail if the executable is open. */ + /****************close_exec_file ();*****************/ + + pid = vfork (); + if (pid < 0) + perror_with_name ("vfork"); + + if (pid == 0) + { + /* Run inferior in a separate process group. */ + setpgrp (getpid (), getpid ()); + +/* Not needed on Sun, at least, and loses there + because it clobbers the superior. */ +/*??? signal (SIGQUIT, SIG_DFL); + signal (SIGINT, SIG_DFL); */ + + errno = 0; + ptrace (0); + + execle ("/bin/sh", "sh", "-c", allargs, 0, env); + + fprintf (stderr, "Cannot exec /bin/sh: %s.\n", + errno < sys_nerr ? sys_errlist[errno] : "unknown error"); + fflush (stderr); + _exit (0177); + } + return pid; +} + +/* Kill the inferior process. Make us have no inferior. */ + +kill_inferior () +{ + if (inferior_pid == 0) + return; + ptrace (8, inferior_pid, 0, 0); + wait (0); + /*************inferior_died ();****VK**************/ +} + +/* Resume execution of the inferior process. + If STEP is nonzero, single-step it. + If SIGNAL is nonzero, give it that signal. */ + +unsigned char +resume (step, signal,status) + int step; + int signal; + char *status; +{ + int pid ; + WAITTYPE w; + + errno = 0; + ptrace (step ? 9 : 7, inferior_pid, 1, signal); + if (errno) + perror_with_name ("ptrace"); + pid = wait(&w); + if(pid != inferior_pid) + perror_with_name ("wait"); + + if(WIFEXITED(w)) + { + printf("\nchild exited with retcode = %x \n",WRETCODE(w)); + *status = 'E'; + return((unsigned char) WRETCODE(w)); + } + else if(!WIFSTOPPED(w)) + { + printf("\nchild did terminated with signal = %x \n",WTERMSIG(w)); + *status = 'T'; + return((unsigned char) WTERMSIG(w)); + } + else + { + printf("\nchild stopped with signal = %x \n",WSTOPSIG(w)); + *status = 'S'; + return((unsigned char) WSTOPSIG(w)); + } + +} + + +#ifdef NEW_SUN_PTRACE + +void +fetch_inferior_registers () +{ + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + extern char registers[]; + + ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers); + if (errno) + perror_with_name ("ptrace"); + /**********debugging begin **********/ + print_some_registers(&inferior_registers); + /**********debugging end **********/ + ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers); + if (errno) + perror_with_name ("ptrace"); + + bcopy (&inferior_registers, registers, 16 * 4); + bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.fps_regs); + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; + bcopy (&inferior_fp_registers.fps_control, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + extern char registers[]; + + bcopy (registers, &inferior_registers, 16 * 4); + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, + sizeof inferior_fp_registers.fps_regs); + inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; + inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; + bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], + &inferior_fp_registers.fps_control, + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + + ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers); + if (errno) + perror_with_name ("ptrace"); + ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers); + if (errno) + perror_with_name ("ptrace"); +} + +#endif /* not NEW_SUN_PTRACE */ + + +/* NOTE! I tried using PTRACE_READDATA, etc., to read and write memory + in the NEW_SUN_PTRACE case. + It ought to be straightforward. But it appears that writing did + not write the data that I specified. I cannot understand where + it got the data that it actually did write. */ + +/* Copy LEN bytes from inferior's memory starting at MEMADDR + to debugger memory starting at MYADDR. */ + +read_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + register int i; + /* Round starting address down to longword boundary. */ + register CORE_ADDR addr = memaddr & - sizeof (int); + /* Round ending address up; get number of longwords that makes. */ + register int count + = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); + /* Allocate buffer of that many longwords. */ + register int *buffer = (int *) alloca (count * sizeof (int)); + + /* Read all the longwords */ + for (i = 0; i < count; i++, addr += sizeof (int)) + { + buffer[i] = ptrace (1, inferior_pid, addr, 0); + } + + /* Copy appropriate bytes out of the buffer. */ + bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len); +} + +/* Copy LEN bytes of data from debugger memory at MYADDR + to inferior's memory at MEMADDR. + On failure (cannot write the inferior) + returns the value of errno. */ + +int +write_inferior_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + register int i; + /* Round starting address down to longword boundary. */ + register CORE_ADDR addr = memaddr & - sizeof (int); + /* Round ending address up; get number of longwords that makes. */ + register int count + = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); + /* Allocate buffer of that many longwords. */ + register int *buffer = (int *) alloca (count * sizeof (int)); + extern int errno; + + /* Fill start and end extra bytes of buffer with existing memory data. */ + + buffer[0] = ptrace (1, inferior_pid, addr, 0); + + if (count > 1) + { + buffer[count - 1] + = ptrace (1, inferior_pid, + addr + (count - 1) * sizeof (int), 0); + } + + /* Copy data to be written over corresponding part of buffer */ + + bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len); + + /* Write the entire buffer. */ + + for (i = 0; i < count; i++, addr += sizeof (int)) + { + errno = 0; + ptrace (4, inferior_pid, addr, buffer[i]); + if (errno) + return errno; + } + + return 0; +} + +void +try_writing_regs_command () +{ + register int i; + register int value; + extern int errno; + + if (inferior_pid == 0) + error ("There is no inferior process now."); + + fetch_inferior_registers(); + for (i = 0;i<18 ; i ++) + { + QUIT; + errno = 0; + value = read_register(i); + write_register ( i, value); + if (errno == 0) + { + printf (" Succeeded with register %d; value 0x%x (%d).\n", + i, value, value); + } + else + printf (" Failed with register %d.\n", i); + } +} + +void +initialize () +{ + + inferior_pid = 0; + + +} + + +/* Return the contents of register REGNO, + regarding it as an integer. */ + +CORE_ADDR +read_register (regno) + int regno; +{ + /* This loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */ + return *(int *) ®isters[REGISTER_BYTE (regno)]; +} + +/* Store VALUE in the register number REGNO, regarded as an integer. */ + +void +write_register (regno, val) + int regno, val; +{ + /* This loses when REGISTER_RAW_SIZE (regno) != sizeof (int) */ + *(int *) ®isters[REGISTER_BYTE (regno)] = val; + + if (have_inferior_p ()) + store_inferior_registers (regno); +} + + +int +have_inferior_p () +{ + return inferior_pid != 0; +} + +print_some_registers(regs) +int regs[]; +{ + register int i; + for (i = 0; i < 18; i++) { + printf("reg[%d] = %x\n", i, regs[i]); + } +} + +SHAR_EOF +cat << \SHAR_EOF > remote_server.c +/* Main code for remote server for GDB, the GNU Debugger. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "param.h" +#include <stdio.h> + +void read_inferior_memory(), fetch_inferior_registers(); +unsigned char resume(); +void kill_inferior(); +void initialize(), try_writing_regs_command(); +int create_inferior(), read_register(); + +extern char registers[]; +int inferior_pid; +extern char **environ; + +/* Descriptor for I/O to remote machine. */ +int remote_desc; +int kiodebug = 0; +int remote_debugging; + +void remote_send (); +void putpkt (); +void getpkt (); +void remote_open(); +void write_ok(); +void write_enn(); +void convert_ascii_to_int(); +void convert_int_to_ascii(); +void prepare_resume_reply(); +void decode_m_packet(); +void decode_M_packet(); + + +main(argc,argv) +int argc; char *argv[]; +{ + char ch,status, own_buf[2000], mem_buf[2000]; + int i=0; + unsigned char signal; + unsigned int mem_addr, len; + + initialize(); + printf("\nwill open serial link\n"); + remote_open("/dev/ttya",0); + + if(argc < 2) + { + printf("Enter name of program to be run with command line args\n"); + gets(own_buf); + inferior_pid = create_inferior(own_buf,environ); + printf("\nProcess %s created; pid = %d\n",own_buf,inferior_pid); + } + else + { + inferior_pid = create_inferior(argv[1],environ); + printf("\nProcess %s created; pid = %d\n",argv[1],inferior_pid); + } + + do { + getpkt(own_buf); + printf("\nPacket received is>:%s\n",own_buf); + i = 0; + ch = own_buf[i++]; + switch (ch) { + case 'h': /**********This is only for tweaking the gdb+ program *******/ + signal = resume(1,0,&status); + prepare_resume_reply(own_buf,status,signal); + break; + /*************end tweak*************************************/ + + case 'g': fetch_inferior_registers(); + convert_int_to_ascii(registers,own_buf,REGISTER_BYTES); + break; + case 'G': convert_ascii_to_int(&own_buf[1],registers,REGISTER_BYTES); + if(store_inferior_registers(-1)==0) + write_ok(own_buf); + else + write_enn(own_buf); + break; + case 'm': decode_m_packet(&own_buf[1],&mem_addr,&len); + read_inferior_memory(mem_addr,mem_buf,len); + convert_int_to_ascii(mem_buf,own_buf,len); + break; + case 'M': decode_M_packet(&own_buf[1],&mem_addr,&len,mem_buf); + if(write_inferior_memory(mem_addr,mem_buf,len)==0) + write_ok(own_buf); + else + write_enn(own_buf); + break; + case 'c': signal = resume(0,0,&status); + printf("\nSignal received is >: %0x \n",signal); + prepare_resume_reply(own_buf,status,signal); + break; + case 's': signal = resume(1,0,&status); + prepare_resume_reply(own_buf,status,signal); + break; + case 'k': kill_inferior(); + sprintf(own_buf,"q"); + putpkt(own_buf); + printf("\nObtained kill request...terminating\n"); + close(remote_desc); + exit(0); + case 't': try_writing_regs_command(); + own_buf[0] = '\0'; + break; + default : printf("\nUnknown option chosen by master\n"); + write_enn(own_buf); + break; + } + + putpkt(own_buf); + } while(1) ; + + close(remote_desc); + /** now get out of here**/ + printf("\nFinished reading data from serial link - Bye!\n"); + exit(0); + +} + +SHAR_EOF +cat << \SHAR_EOF > remote_utils.c +/* Remote utility routines for the remote server for GDB, the GNU debugger. + Copyright (C) 1986, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "param.h" +#include <stdio.h> +#include <signal.h> +#include <sys/wait.h> +#include <sys/ioctl.h> +#include <a.out.h> +#include <sys/file.h> +#include <sgtty.h> + +extern int remote_desc; +extern int remote_debugging; +extern int kiodebug; + +void remote_open(); +void remote_send(); +void putpkt(); +void getpkt(); + +void write_ok(); +void write_enn(); +void convert_ascii_to_int(); +void convert_int_to_ascii(); +void prepare_resume_reply(); + +/* Open a connection to a remote debugger. + NAME is the filename used for communication. */ + +void +remote_open (name, from_tty) + char *name; + int from_tty; +{ + struct sgttyb sg; + + remote_debugging = 0; + + remote_desc = open (name, O_RDWR); + if (remote_desc < 0) + printf("\ncould not open remote device\n"); + + ioctl (remote_desc, TIOCGETP, &sg); + sg.sg_flags = RAW; + ioctl (remote_desc, TIOCSETP, &sg); + + if (from_tty) + printf ("Remote debugging using %s\n", name); + remote_debugging = 1; +} + +/* Convert hex digit A to a number. */ + +static int +fromhex (a) + int a; +{ + if (a >= '0' && a <= '9') + return a - '0'; + else if (a >= 'a' && a <= 'f') + return a - 'a' + 10; + else + perror ("Reply contains invalid hex digit"); +} + +/* Convert number NIB to a hex digit. */ + +static int +tohex (nib) + int nib; +{ + if (nib < 10) + return '0'+nib; + else + return 'a'+nib-10; +} + +/* Send the command in BUF to the remote machine, + and read the reply into BUF. + Report an error if we get an error reply. */ + +void +remote_send (buf) + char *buf; +{ + putpkt (buf); + getpkt (buf); + + if (buf[0] == 'E') + perror ("Remote failure reply: %s", buf); +} + +/* Send a packet to the remote machine, with error checking. + The data of the packet is in BUF. */ + +void +putpkt (buf) + char *buf; +{ + int i; + unsigned char csum = 0; + char buf2[500]; + char buf3[1]; + int cnt = strlen (buf); + char *p; + + if (kiodebug) + fprintf (stderr, "Sending packet: %s\n", buf); + + /* Copy the packet into buffer BUF2, encapsulating it + and giving it a checksum. */ + + p = buf2; + *p++ = '$'; + + for (i = 0; i < cnt; i++) + { + csum += buf[i]; + *p++ = buf[i]; + } + *p++ = '#'; + *p++ = tohex ((csum >> 4) & 0xf); + *p++ = tohex (csum & 0xf); + + /* Send it over and over until we get a positive ack. */ + + do { + write (remote_desc, buf2, p - buf2); + read (remote_desc, buf3, 1); + } while (buf3[0] != '+'); +} + +static int +readchar () +{ + char buf[1]; + while (read (remote_desc, buf, 1) != 1) ; + return buf[0] & 0x7f; +} + +/* Read a packet from the remote machine, with error checking, + and store it in BUF. */ + +void +getpkt (buf) + char *buf; +{ + char *bp; + unsigned char csum, c, c1, c2; + extern kiodebug; + + while (1) + { + csum = 0; + while ((c = readchar()) != '$'); + + bp = buf; + while (1) + { + c = readchar (); + if (c == '#') + break; + *bp++ = c; + csum += c; + } + *bp = 0; + + c1 = fromhex (readchar ()); + c2 = fromhex (readchar ()); + if (csum == (c1 << 4) + c2) + break; + + printf ("Bad checksum, sentsum=0x%x, csum=0x%x, buf=%s\n", + (c1 << 4) + c2, csum, buf); + write (remote_desc, "-", 1); + } + + write (remote_desc, "+", 1); + + if (kiodebug) + fprintf (stderr,"Packet received :%s\n", buf); +} + + +void +write_ok(buf) + char *buf; +{ + buf[0] = 'O'; + buf[1] = 'k'; + buf[2] = '\0'; +} + +void +write_enn(buf) + char *buf; +{ + buf[0] = 'E'; + buf[1] = 'N'; + buf[2] = 'N'; + buf[3] = '\0'; +} + +void +convert_int_to_ascii(from,to,n) +char *from, *to; int n; +{ + int nib ; + char ch; + while( n-- ) + { + ch = *from++; + nib = ((ch & 0xf0) >> 4)& 0x0f; + *to++ = tohex(nib); + nib = ch & 0x0f; + *to++ = tohex(nib); + } + *to++ = 0; +} + + +void +convert_ascii_to_int(from,to,n) +char *from, *to; int n; +{ + int nib1,nib2 ; + while( n-- ) + { + nib1 = fromhex(*from++); + nib2 = fromhex(*from++); + *to++ = (((nib1 & 0x0f)<< 4)& 0xf0) | (nib2 & 0x0f); + } +} + +void +prepare_resume_reply(buf,status,signal) +char *buf ,status; +unsigned char signal; +{ + int nib; + char ch; + + *buf++ = 'S'; + *buf++ = status; + nib = ((signal & 0xf0) >> 4) ; + *buf++ = tohex(nib); + nib = signal & 0x0f; + *buf++ = tohex(nib); + *buf++ = 0; +} + +void +decode_m_packet(from,mem_addr_ptr,len_ptr) +char *from; +unsigned int *mem_addr_ptr, *len_ptr; +{ + int i = 0, j = 0 ; + char ch; + *mem_addr_ptr = *len_ptr = 0; + /************debugging begin************/ + printf("\nIn decode_m_packet"); + /************debugging end************/ + + while((ch = from[i++]) != ',') + { + *mem_addr_ptr = *mem_addr_ptr << 4; + *mem_addr_ptr |= fromhex(ch) & 0x0f; + } + /************debugging begin************/ + printf("\nFinished mem_addr part"); + /************debugging end************/ + + for(j=0; j < 4; j++) + { + if((ch = from[i++]) == 0) + break; + *len_ptr = *len_ptr << 4; + *len_ptr |= fromhex(ch) & 0x0f; + } + /************debugging begin************/ + printf("\nFinished len_ptr part"); + /************debugging end************/ +} + +void +decode_M_packet(from,mem_addr_ptr,len_ptr,to) +char *from, *to; +unsigned int *mem_addr_ptr, *len_ptr; +{ + int i = 0, j = 0 ; + char ch; + *mem_addr_ptr = *len_ptr = 0; + /************debugging begin************/ + printf("\nIn decode_M_packet"); + /************debugging end************/ + + while((ch = from[i++]) != ',') + { + *mem_addr_ptr = *mem_addr_ptr << 4; + *mem_addr_ptr |= fromhex(ch) & 0x0f; + } + /************debugging begin************/ + printf("\nFinished mem_addr part: memaddr = %x",*mem_addr_ptr); + /************debugging end************/ + + while((ch = from[i++]) != ':') + { + *len_ptr = *len_ptr << 4; + *len_ptr |= fromhex(ch) & 0x0f; + } + /************debugging begin************/ + printf("\nFinished len_ptr part: len = %d",*len_ptr); + /************debugging end************/ + + convert_ascii_to_int(&from[i++],to,*len_ptr); + + /************debugging begin************/ + printf("\nmembuf : %x",*(int *)to); + /************debugging end************/ +} + +SHAR_EOF +# End of shell archive +exit 0 diff --git a/gdb/remote-nindy.c b/gdb/remote-nindy.c new file mode 100644 index 0000000..5724f42 --- /dev/null +++ b/gdb/remote-nindy.c @@ -0,0 +1,962 @@ +/* Memory-access and commands for remote NINDY process, for GDB. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + Contributed by Intel Corporation. Modified from remote.c by Chris Benenati. + +GDB is distributed in the hope that it will be useful, but WITHOUT ANY +WARRANTY. No author or distributor accepts responsibility to anyone +for the consequences of using it or for whether it serves any +particular purpose or works at all, unless he says so in writing. +Refer to the GDB General Public License for full details. + +Everyone is granted permission to copy, modify and redistribute GDB, +but only under the conditions described in the GDB General Public +License. A copy of this license is supposed to have been given to you +along with GDB so you can know your rights and responsibilities. It +should be in a file named COPYING. Among other things, the copyright +notice and this notice must be preserved on all copies. + +In other words, go ahead and share GDB, but don't try to stop +anyone else from sharing it farther. Help stamp out software hoarding! +*/ + +/* +Except for the data cache routines, this file bears little resemblence +to remote.c. A new (although similar) protocol has been specified, and +portions of the code are entirely dependent on having an i80960 with a +NINDY ROM monitor at the other end of the line. +*/ + +/***************************************************************************** + * + * REMOTE COMMUNICATION PROTOCOL BETWEEN GDB960 AND THE NINDY ROM MONITOR. + * + * + * MODES OF OPERATION + * ----- -- --------- + * + * As far as NINDY is concerned, GDB is always in one of two modes: command + * mode or passthrough mode. + * + * In command mode (the default) pre-defined packets containing requests + * are sent by GDB to NINDY. NINDY never talks except in reponse to a request. + * + * Once the the user program is started, GDB enters passthrough mode, to give + * the user program access to the terminal. GDB remains in this mode until + * NINDY indicates that the program has stopped. + * + * + * PASSTHROUGH MODE + * ----------- ---- + * + * GDB writes all input received from the keyboard directly to NINDY, and writes + * all characters received from NINDY directly to the monitor. + * + * Keyboard input is neither buffered nor echoed to the monitor. + * + * GDB remains in passthrough mode until NINDY sends a single ^P character, + * to indicate that the user process has stopped. + * + * Note: + * GDB assumes NINDY performs a 'flushreg' when the user program stops. + * + * + * COMMAND MODE + * ------- ---- + * + * All info (except for message ack and nak) is transferred between gdb + * and the remote processor in messages of the following format: + * + * <info>#<checksum> + * + * where + * # is a literal character + * + * <info> ASCII information; all numeric information is in the + * form of hex digits ('0'-'9' and lowercase 'a'-'f'). + * + * <checksum> + * is a pair of ASCII hex digits representing an 8-bit + * checksum formed by adding together each of the + * characters in <info>. + * + * The receiver of a message always sends a single character to the sender + * to indicate that the checksum was good ('+') or bad ('-'); the sender + * re-transmits the entire message over until a '+' is received. + * + * In response to a command NINDY always sends back either data or + * a result code of the form "Xnn", where "nn" are hex digits and "X00" + * means no errors. (Exceptions: the "s" and "c" commands don't respond.) + * + * SEE THE HEADER OF THE FILE "gdb.c" IN THE NINDY MONITOR SOURCE CODE FOR A + * FULL DESCRIPTION OF LEGAL COMMANDS. + * + * SEE THE FILE "stop.h" IN THE NINDY MONITOR SOURCE CODE FOR A LIST + * OF STOP CODES. + * + ******************************************************************************/ + +#include <stdio.h> +#include <signal.h> +#include <sys/types.h> +#include <setjmp.h> + +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "target.h" +#include "gdbcore.h" +#include "command.h" +#include "bfd.h" +#include "ieee-float.h" + +#include "wait.h" +#include <sys/ioctl.h> +#include <sys/file.h> +#include <ctype.h> +#include "nindy-share/ttycntl.h" +#include "nindy-share/demux.h" +#include "nindy-share/env.h" +#include "nindy-share/stop.h" + +extern int unlink(); +extern char *getenv(); +extern char *mktemp(); + +extern char *coffstrip(); +extern void add_syms_addr_command (); +extern value call_function_by_hand (); +extern void generic_mourn_inferior (); + +extern struct target_ops nindy_ops; +extern jmp_buf to_top_level; +extern FILE *instream; +extern struct ext_format ext_format_i960[]; /* i960-tdep.c */ + +extern char ninStopWhy (); + +int nindy_initial_brk; /* nonzero if want to send an initial BREAK to nindy */ +int nindy_old_protocol; /* nonzero if want to use old protocol */ +char *nindy_ttyname; /* name of tty to talk to nindy on, or null */ + +#define DLE '\020' /* Character NINDY sends to indicate user program has + * halted. */ +#define TRUE 1 +#define FALSE 0 + +int nindy_fd = 0; /* Descriptor for I/O to NINDY */ +static int have_regs = 0; /* 1 iff regs read since i960 last halted */ +static int regs_changed = 0; /* 1 iff regs were modified since last read */ + +extern char *exists(); +static void dcache_flush (), dcache_poke (), dcache_init(); +static int dcache_fetch (); + +/* FIXME, we can probably use the normal terminal_inferior stuff here. + We have to do terminal_inferior and then set up the passthrough + settings initially. Thereafter, terminal_ours and terminal_inferior + will automatically swap the settings around for us. */ + +/* Restore TTY to normal operation */ + +static TTY_STRUCT orig_tty; /* TTY attributes before entering passthrough */ + +static void +restore_tty() +{ + ioctl( 0, TIOCSETN, &orig_tty ); +} + + +/* Recover from ^Z or ^C while remote process is running */ + +static void (*old_ctrlc)(); /* Signal handlers before entering passthrough */ + +#ifdef SIGTSTP +static void (*old_ctrlz)(); +#endif + +static +#ifdef USG +void +#endif +cleanup() +{ + restore_tty(); + signal(SIGINT, old_ctrlc); +#ifdef SIGTSTP + signal(SIGTSTP, old_ctrlz); +#endif + error("\n\nYou may need to reset the 80960 and/or reload your program.\n"); +} + +/* Clean up anything that needs cleaning when losing control. */ + +static char *savename; + +static void +nindy_close (quitting) + int quitting; +{ + if (nindy_fd) + close (nindy_fd); + nindy_fd = 0; + + if (savename) + free (savename); + savename = 0; +} + +/* Open a connection to a remote debugger. + FIXME, there should be a way to specify the various options that are + now specified with gdb command-line options. (baud_rate, old_protocol, + and initial_brk) */ +void +nindy_open (name, from_tty) + char *name; /* "/dev/ttyXX", "ttyXX", or "XX": tty to be opened */ + int from_tty; +{ + + if (!name) + error_no_arg ("serial port device name"); + + nindy_close (0); + + have_regs = regs_changed = 0; + dcache_init(); + + /* Allow user to interrupt the following -- we could hang if + * there's no NINDY at the other end of the remote tty. + */ + immediate_quit++; + nindy_fd = ninConnect( name, baud_rate? baud_rate: "9600", + nindy_initial_brk, !from_tty, nindy_old_protocol ); + immediate_quit--; + + if ( nindy_fd < 0 ){ + nindy_fd = 0; + error( "Can't open tty '%s'", name ); + } + + savename = savestring (name, strlen (name)); + push_target (&nindy_ops); + target_fetch_registers(-1); +} + +/* User-initiated quit of nindy operations. */ + +static void +nindy_detach (name, from_tty) + char *name; + int from_tty; +{ + dont_repeat (); + if (name) + error ("Too many arguments"); + pop_target (); +} + +static void +nindy_files_info () +{ + printf("\tAttached to %s at %s bps%s%s.\n", savename, + baud_rate? baud_rate: "9600", + nindy_old_protocol? " in old protocol": "", + nindy_initial_brk? " with initial break": ""); +} + +/****************************************************************************** + * remote_load: + * Download an object file to the remote system by invoking the "comm960" + * utility. We look for "comm960" in $G960BIN, $G960BASE/bin, and + * DEFAULT_BASE/bin/HOST/bin where + * DEFAULT_BASE is defined in env.h, and + * HOST must be defined on the compiler invocation line. + ******************************************************************************/ + +static void +nindy_load( filename, from_tty ) + char *filename; + int from_tty; +{ + char *tmpfile; + struct cleanup *old_chain; + char *scratch_pathname; + int scratch_chan; + + if (!filename) + filename = get_exec_file (1); + + filename = tilde_expand (filename); + make_cleanup (free, filename); + + scratch_chan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0, + &scratch_pathname); + if (scratch_chan < 0) + perror_with_name (filename); + close (scratch_chan); /* Slightly wasteful FIXME */ + + have_regs = regs_changed = 0; + mark_breakpoints_out(); + inferior_pid = 0; + dcache_flush(); + + tmpfile = coffstrip(scratch_pathname); + if ( tmpfile ){ + old_chain = make_cleanup(unlink,tmpfile); + immediate_quit++; + ninDownload( tmpfile, !from_tty ); +/* FIXME, don't we want this merged in here? */ + immediate_quit--; + do_cleanups (old_chain); + } +} + + + +/* Return the number of characters in the buffer before the first DLE character. + */ + +static +int +non_dle( buf, n ) + char *buf; /* Character buffer; NOT '\0'-terminated */ + int n; /* Number of characters in buffer */ +{ + int i; + + for ( i = 0; i < n; i++ ){ + if ( buf[i] == DLE ){ + break; + } + } + return i; +} + +/* Tell the remote machine to resume. */ + +void +nindy_resume (step, siggnal) + int step, siggnal; +{ + if (siggnal != 0 && siggnal != stop_signal) + error ("Can't send signals to remote NINDY targets."); + + dcache_flush(); + if ( regs_changed ){ + nindy_store_registers (); + regs_changed = 0; + } + have_regs = 0; + ninGo( step ); +} + +/* Wait until the remote machine stops. While waiting, operate in passthrough + * mode; i.e., pass everything NINDY sends to stdout, and everything from + * stdin to NINDY. + * + * Return to caller, storing status in 'status' just as `wait' would. + */ + +void +nindy_wait( status ) + WAITTYPE *status; +{ + DEMUX_DECL; /* OS-dependent data needed by DEMUX... macros */ + char buf[500]; /* FIXME, what is "500" here? */ + int i, n; + unsigned char stop_exit; + unsigned char stop_code; + TTY_STRUCT tty; + long ip_value, fp_value, sp_value; /* Reg values from stop */ + + + WSETEXIT( (*status), 0 ); + + /* OPERATE IN PASSTHROUGH MODE UNTIL NINDY SENDS A DLE CHARACTER */ + + /* Save current tty attributes, set up signals to restore them. + */ + ioctl( 0, TIOCGETP, &orig_tty ); + old_ctrlc = signal( SIGINT, cleanup ); +#ifdef SIGTSTP + old_ctrlz = signal( SIGTSTP, cleanup ); +#endif + + /* Pass input from keyboard to NINDY as it arrives. + * NINDY will interpret <CR> and perform echo. + */ + tty = orig_tty; + TTY_NINDYTERM( tty ); + ioctl( 0, TIOCSETN, &tty ); + + while ( 1 ){ + /* Go to sleep until there's something for us on either + * the remote port or stdin. + */ + + DEMUX_WAIT( nindy_fd ); + + /* Pass input through to correct place */ + + n = DEMUX_READ( 0, buf, sizeof(buf) ); + if ( n ){ /* Input on stdin */ + write( nindy_fd, buf, n ); + } + + n = DEMUX_READ( nindy_fd, buf, sizeof(buf) ); + if ( n ){ /* Input on remote */ + /* Write out any characters in buffer preceding DLE */ + i = non_dle( buf, n ); + if ( i > 0 ){ + write( 1, buf, i ); + } + + if ( i != n ){ + /* There *was* a DLE in the buffer */ + stop_exit = ninStopWhy( &stop_code, + &ip_value, &fp_value, &sp_value); + if ( !stop_exit && (stop_code==STOP_SRQ) ){ + immediate_quit++; + ninSrq(); + immediate_quit--; + } else { + /* Get out of loop */ + supply_register (IP_REGNUM, &ip_value); + supply_register (FP_REGNUM, &fp_value); + supply_register (SP_REGNUM, &sp_value); + break; + } + } + } + } + + signal( SIGINT, old_ctrlc ); +#ifdef SIGTSTP + signal( SIGTSTP, old_ctrlz ); +#endif + restore_tty(); + + if ( stop_exit ){ /* User program exited */ + WSETEXIT( (*status), stop_code ); + } else { /* Fault or trace */ + switch (stop_code){ + case STOP_GDB_BPT: + case TRACE_STEP: + /* Make it look like a VAX trace trap */ + stop_code = SIGTRAP; + break; + default: + /* The target is not running Unix, and its + faults/traces do not map nicely into Unix signals. + Make sure they do not get confused with Unix signals + by numbering them with values higher than the highest + legal Unix signal. code in i960_print_fault(), + called via PRINT_RANDOM_SIGNAL, will interpret the + value. */ + stop_code += NSIG; + break; + } + WSETSTOP( (*status), stop_code ); + } +} + +/* Read the remote registers into the block REGS. */ + +/* This is the block that ninRegsGet and ninRegsPut handles. */ +struct nindy_regs { + char local_regs[16 * 4]; + char global_regs[16 * 4]; + char pcw_acw[2 * 4]; + char ip[4]; + char tcw[4]; + char fp_as_double[4 * 8]; +}; + +static int +nindy_fetch_registers(regno) + int regno; +{ + struct nindy_regs nindy_regs; + int regnum, inv; + double dub; + + immediate_quit++; + ninRegsGet( (char *) &nindy_regs ); + immediate_quit--; + + bcopy (nindy_regs.local_regs, ®isters[REGISTER_BYTE (R0_REGNUM)], 16*4); + bcopy (nindy_regs.global_regs, ®isters[REGISTER_BYTE (G0_REGNUM)], 16*4); + bcopy (nindy_regs.pcw_acw, ®isters[REGISTER_BYTE (PCW_REGNUM)], 2*4); + bcopy (nindy_regs.ip, ®isters[REGISTER_BYTE (IP_REGNUM)], 1*4); + bcopy (nindy_regs.tcw, ®isters[REGISTER_BYTE (TCW_REGNUM)], 1*4); + for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) { + dub = unpack_double (builtin_type_double, + &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)], + &inv); + /* dub now in host byte order */ + double_to_ieee_extended (ext_format_i960, &dub, + ®isters[REGISTER_BYTE (regnum)]); + } + + registers_fetched (); + return 0; +} + +static void +nindy_prepare_to_store() +{ + nindy_fetch_registers(-1); +} + +static int +nindy_store_registers(regno) + int regno; +{ + struct nindy_regs nindy_regs; + int regnum, inv; + double dub; + + bcopy (®isters[REGISTER_BYTE (R0_REGNUM)], nindy_regs.local_regs, 16*4); + bcopy (®isters[REGISTER_BYTE (G0_REGNUM)], nindy_regs.global_regs, 16*4); + bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)], nindy_regs.pcw_acw, 2*4); + bcopy (®isters[REGISTER_BYTE (IP_REGNUM)], nindy_regs.ip, 1*4); + bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)], nindy_regs.tcw, 1*4); + /* Float regs. Only works on IEEE_FLOAT hosts. */ + for (regnum = FP0_REGNUM; regnum < FP0_REGNUM + 4; regnum++) { + ieee_extended_to_double (ext_format_i960, + ®isters[REGISTER_BYTE (regnum)], &dub); + /* dub now in host byte order */ + /* FIXME-someday, the arguments to unpack_double are backward. + It expects a target double and returns a host; we pass the opposite. + This mostly works but not quite. */ + dub = unpack_double (builtin_type_double, &dub, &inv); + /* dub now in target byte order */ + bcopy ((char *)&dub, &nindy_regs.fp_as_double[8 * (regnum - FP0_REGNUM)], + 8); + } + + immediate_quit++; + ninRegsPut( (char *) &nindy_regs ); + immediate_quit--; + return 0; +} + +/* Read a word from remote address ADDR and return it. + * This goes through the data cache. + */ +int +nindy_fetch_word (addr) + CORE_ADDR addr; +{ + return dcache_fetch (addr); +} + +/* Write a word WORD into remote address ADDR. + This goes through the data cache. */ + +void +nindy_store_word (addr, word) + CORE_ADDR addr; + int word; +{ + dcache_poke (addr, word); +} + +/* Copy LEN bytes to or from inferior's memory starting at MEMADDR + to debugger memory starting at MYADDR. Copy to inferior if + WRITE is nonzero. Returns the length copied. + + This is stolen almost directly from infptrace.c's child_xfer_memory, + which also deals with a word-oriented memory interface. Sometime, + FIXME, rewrite this to not use the word-oriented routines. */ + +int +nindy_xfer_inferior_memory(memaddr, myaddr, len, write) + CORE_ADDR memaddr; + char *myaddr; + int len; + int write; +{ + register int i; + /* Round starting address down to longword boundary. */ + register CORE_ADDR addr = memaddr & - sizeof (int); + /* Round ending address up; get number of longwords that makes. */ + register int count + = (((memaddr + len) - addr) + sizeof (int) - 1) / sizeof (int); + /* Allocate buffer of that many longwords. */ + register int *buffer = (int *) alloca (count * sizeof (int)); + + if (write) + { + /* Fill start and end extra bytes of buffer with existing memory data. */ + + if (addr != memaddr || len < (int)sizeof (int)) { + /* Need part of initial word -- fetch it. */ + buffer[0] = nindy_fetch_word (addr); + } + + if (count > 1) /* FIXME, avoid if even boundary */ + { + buffer[count - 1] + = nindy_fetch_word (addr + (count - 1) * sizeof (int)); + } + + /* Copy data to be written over corresponding part of buffer */ + + bcopy (myaddr, (char *) buffer + (memaddr & (sizeof (int) - 1)), len); + + /* Write the entire buffer. */ + + for (i = 0; i < count; i++, addr += sizeof (int)) + { + errno = 0; + nindy_store_word (addr, buffer[i]); + if (errno) + return 0; + } + } + else + { + /* Read all the longwords */ + for (i = 0; i < count; i++, addr += sizeof (int)) + { + errno = 0; + buffer[i] = nindy_fetch_word (addr); + if (errno) + return 0; + QUIT; + } + + /* Copy appropriate bytes out of the buffer. */ + bcopy ((char *) buffer + (memaddr & (sizeof (int) - 1)), myaddr, len); + } + return len; +} + +/* The data cache records all the data read from the remote machine + since the last time it stopped. + + Each cache block holds 16 bytes of data + starting at a multiple-of-16 address. */ + +#define DCACHE_SIZE 64 /* Number of cache blocks */ + +struct dcache_block { + struct dcache_block *next, *last; + unsigned int addr; /* Address for which data is recorded. */ + int data[4]; +}; + +struct dcache_block dcache_free, dcache_valid; + +/* Free all the data cache blocks, thus discarding all cached data. */ +static +void +dcache_flush () +{ + register struct dcache_block *db; + + while ((db = dcache_valid.next) != &dcache_valid) + { + remque (db); + insque (db, &dcache_free); + } +} + +/* + * If addr is present in the dcache, return the address of the block + * containing it. + */ +static +struct dcache_block * +dcache_hit (addr) + unsigned int addr; +{ + register struct dcache_block *db; + + if (addr & 3) + abort (); + + /* Search all cache blocks for one that is at this address. */ + db = dcache_valid.next; + while (db != &dcache_valid) + { + if ((addr & 0xfffffff0) == db->addr) + return db; + db = db->next; + } + return NULL; +} + +/* Return the int data at address ADDR in dcache block DC. */ +static +int +dcache_value (db, addr) + struct dcache_block *db; + unsigned int addr; +{ + if (addr & 3) + abort (); + return (db->data[(addr>>2)&3]); +} + +/* Get a free cache block, put or keep it on the valid list, + and return its address. The caller should store into the block + the address and data that it describes, then remque it from the + free list and insert it into the valid list. This procedure + prevents errors from creeping in if a ninMemGet is interrupted + (which used to put garbage blocks in the valid list...). */ +static +struct dcache_block * +dcache_alloc () +{ + register struct dcache_block *db; + + if ((db = dcache_free.next) == &dcache_free) + { + /* If we can't get one from the free list, take last valid and put + it on the free list. */ + db = dcache_valid.last; + remque (db); + insque (db, &dcache_free); + } + + remque (db); + insque (db, &dcache_valid); + return (db); +} + +/* Return the contents of the word at address ADDR in the remote machine, + using the data cache. */ +static +int +dcache_fetch (addr) + CORE_ADDR addr; +{ + register struct dcache_block *db; + + db = dcache_hit (addr); + if (db == 0) + { + db = dcache_alloc (); + immediate_quit++; + ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16); + immediate_quit--; + db->addr = addr & ~0xf; + remque (db); /* Off the free list */ + insque (db, &dcache_valid); /* On the valid list */ + } + return (dcache_value (db, addr)); +} + +/* Write the word at ADDR both in the data cache and in the remote machine. */ +static void +dcache_poke (addr, data) + CORE_ADDR addr; + int data; +{ + register struct dcache_block *db; + + /* First make sure the word is IN the cache. DB is its cache block. */ + db = dcache_hit (addr); + if (db == 0) + { + db = dcache_alloc (); + immediate_quit++; + ninMemGet(addr & ~0xf, (unsigned char *)db->data, 16); + immediate_quit--; + db->addr = addr & ~0xf; + remque (db); /* Off the free list */ + insque (db, &dcache_valid); /* On the valid list */ + } + + /* Modify the word in the cache. */ + db->data[(addr>>2)&3] = data; + + /* Send the changed word. */ + immediate_quit++; + ninMemPut(addr, (unsigned char *)&data, 4); + immediate_quit--; +} + +/* The cache itself. */ +struct dcache_block the_cache[DCACHE_SIZE]; + +/* Initialize the data cache. */ +static void +dcache_init () +{ + register i; + register struct dcache_block *db; + + db = the_cache; + dcache_free.next = dcache_free.last = &dcache_free; + dcache_valid.next = dcache_valid.last = &dcache_valid; + for (i=0;i<DCACHE_SIZE;i++,db++) + insque (db, &dcache_free); +} + + +static void +nindy_create_inferior (execfile, args, env) + char *execfile; + char *args; + char **env; +{ + int entry_pt; + int pid; + + if (args && *args) + error ("Can't pass arguments to remote NINDY process"); + + if (execfile == 0 || exec_bfd == 0) + error ("No exec file specified"); + + entry_pt = (int) bfd_get_start_address (exec_bfd); + + pid = 42; + +#ifdef CREATE_INFERIOR_HOOK + CREATE_INFERIOR_HOOK (pid); +#endif + +/* The "process" (board) is already stopped awaiting our commands, and + the program is already downloaded. We just set its PC and go. */ + + inferior_pid = pid; /* Needed for wait_for_inferior below */ + + clear_proceed_status (); + +#if defined (START_INFERIOR_HOOK) + START_INFERIOR_HOOK (); +#endif + + /* Tell wait_for_inferior that we've started a new process. */ + init_wait_for_inferior (); + + /* Set up the "saved terminal modes" of the inferior + based on what modes we are starting it with. */ + target_terminal_init (); + + /* Install inferior's terminal modes. */ + target_terminal_inferior (); + + /* remote_start(args); */ + /* trap_expected = 0; */ + /* insert_step_breakpoint (); FIXME, do we need this? */ + proceed ((CORE_ADDR)entry_pt, -1, 0); /* Let 'er rip... */ +} + +static void +reset_command(args, from_tty) + char *args; + int from_tty; +{ + if ( !nindy_fd ){ + error( "No target system to reset -- use 'target nindy' command."); + } + if ( query("Really reset the target system?",0,0) ){ + send_break( nindy_fd ); + tty_flush( nindy_fd ); + } +} + +void +nindy_kill (args, from_tty) + char *args; + int from_tty; +{ + return; /* Ignore attempts to kill target system */ +} + +/* Clean up when a program exits. + + The program actually lives on in the remote processor's RAM, and may be + run again without a download. Don't leave it full of breakpoint + instructions. */ + +void +nindy_mourn_inferior () +{ + remove_breakpoints (); + generic_mourn_inferior (); /* Do all the proper things now */ +} + +/* This routine is run as a hook, just before the main command loop is + entered. If gdb is configured for the i960, but has not had its + nindy target specified yet, this will loop prompting the user to do so. + + Unlike the loop provided by Intel, we actually let the user get out + of this with a RETURN. This is useful when e.g. simply examining + an i960 object file on the host system. */ + +nindy_before_main_loop () +{ + char ttyname[100]; + char *p, *p2; + + setjmp(to_top_level); + while (current_target != &nindy_ops) { /* remote tty not specified yet */ + if ( instream == stdin ){ + printf("\nAttach /dev/ttyNN -- specify NN, or \"quit\" to quit: "); + fflush( stdout ); + } + fgets( ttyname, sizeof(ttyname)-1, stdin ); + + /* Strip leading and trailing whitespace */ + for ( p = ttyname; isspace(*p); p++ ){ + ; + } + if ( *p == '\0' ){ + return; /* User just hit spaces or return, wants out */ + } + for ( p2= p; !isspace(*p2) && (*p2 != '\0'); p2++ ){ + ; + } + *p2= '\0'; + if ( !strcmp("quit",p) ){ + exit(1); + } + + nindy_open( p, 1 ); + + /* Now that we have a tty open for talking to the remote machine, + download the executable file if one was specified. */ + if ( !setjmp(to_top_level) && exec_bfd ) { + target_load (bfd_get_filename (exec_bfd), 1); + } + } +} + +/* Define the target subroutine names */ + +struct target_ops nindy_ops = { + "nindy", "Remote serial target in i960 NINDY-specific protocol", + nindy_open, nindy_close, + 0, nindy_detach, nindy_resume, nindy_wait, + nindy_fetch_registers, nindy_store_registers, + nindy_prepare_to_store, 0, 0, /* conv_from, conv_to */ + nindy_xfer_inferior_memory, nindy_files_info, + 0, 0, /* insert_breakpoint, remove_breakpoint, */ + 0, 0, 0, 0, 0, /* Terminal crud */ + nindy_kill, + nindy_load, add_syms_addr_command, + call_function_by_hand, + 0, /* lookup_symbol */ + nindy_create_inferior, + nindy_mourn_inferior, + process_stratum, 0, /* next */ + 1, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ + OPS_MAGIC, /* Always the last thing */ +}; + +void +_initialize_nindy () +{ + add_target (&nindy_ops); + add_com ("reset", class_obscure, reset_command, + "Send a 'break' to the remote target system.\n\ +Only useful if the target has been equipped with a circuit\n\ +to perform a hard reset when a break is detected."); +} diff --git a/gdb/remote-vx.c b/gdb/remote-vx.c new file mode 100644 index 0000000..63028e2 --- /dev/null +++ b/gdb/remote-vx.c @@ -0,0 +1,1775 @@ +/* Memory-access and commands for remote VxWorks processes, for GDB. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + Contributed by Wind River Systems and Cygnus Support. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "wait.h" +#include "target.h" +#include "gdbcore.h" +#include "command.h" +#include "symtab.h" +#include "symfile.h" /* for struct complaint */ + +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include <signal.h> +#include <fcntl.h> +#include <sys/types.h> +#include <sys/time.h> +#include <sys/socket.h> +#define free bogon_free /* Sun claims "int free()" not void */ +#include <rpc/rpc.h> +#undef free +#include <sys/time.h> /* UTek's <rpc/rpc.h> doesn't #incl this */ +#include <netdb.h> +#include <ptrace.h> +#include "xdr_ptrace.h" +#include "xdr_ld.h" +#include "xdr_rdb.h" +#include "dbgRpcLib.h" + +/* get rid of value.h if possible */ +#include <value.h> +#include <symtab.h> + +extern value call_function_by_hand (); +extern void symbol_file_command (); +extern void add_syms_addr_command (); +extern int stop_soon_quietly; /* for wait_for_inferior */ + +static int net_ptrace_clnt_call (); /* Forward decl */ +static enum clnt_stat net_clnt_call (); /* Forward decl */ +extern struct target_ops vx_ops, vx_run_ops; /* Forward declaration */ + +/* Saved name of target host and called function for "info files". + Both malloc'd. */ + +static char *vx_host; +static char *vx_running; /* Called function */ + +/* Nonzero means target that is being debugged remotely has a floating + point processor. */ + +static int target_has_fp; + +/* Default error message when the network is forking up. */ + +static const char rpcerr[] = "network target debugging: rpc error"; + +CLIENT *pClient; /* client used in net debugging */ +static int ptraceSock = RPC_ANYSOCK; + +enum clnt_stat net_clnt_call(); +static void parse_args (); + +static struct timeval rpcTimeout = { 10, 0 }; + +static char *skip_white_space (); +static char *find_white_space (); + +/* Tell the VxWorks target system to download a file. + The load addresses of the text, data, and bss segments are + stored in pTextAddr, pDataAddr, and *pBssAddr (respectively). + Returns 0 for success, -1 for failure. */ + +static int +net_load (filename, pTextAddr, pDataAddr, pBssAddr) + char *filename; + CORE_ADDR *pTextAddr; + CORE_ADDR *pDataAddr; + CORE_ADDR *pBssAddr; + { + enum clnt_stat status; + struct ldfile ldstruct; + struct timeval load_timeout; + + bzero ((char *) &ldstruct, sizeof (ldstruct)); + + /* We invoke clnt_call () here directly, instead of through + net_clnt_call (), because we need to set a large timeout value. + The load on the target side can take quite a while, easily + more than 10 seconds. The user can kill this call by typing + CTRL-C if there really is a problem with the load. + + Do not change the tv_sec value without checking -- select() imposes + a limit of 10**8 on it for no good reason that I can see... */ + + load_timeout.tv_sec = 99999999; /* A large number, effectively inf. */ + load_timeout.tv_usec = 0; + + status = clnt_call (pClient, VX_LOAD, xdr_wrapstring, &filename, xdr_ldfile, + &ldstruct, load_timeout); + + if (status == RPC_SUCCESS) + { + if (*ldstruct.name == NULL) /* load failed on VxWorks side */ + return -1; + *pTextAddr = ldstruct.txt_addr; + *pDataAddr = ldstruct.data_addr; + *pBssAddr = ldstruct.bss_addr; + return 0; + } + else + return -1; + } + +/* returns 0 if successful, errno if RPC failed or VxWorks complains. */ + +static int +net_break (addr, procnum) + int addr; + u_long procnum; + { + enum clnt_stat status; + int break_status; + Rptrace ptrace_in; /* XXX This is stupid. It doesn't need to be a ptrace + structure. How about something smaller? */ + + bzero ((char *) &ptrace_in, sizeof (ptrace_in)); + break_status = 0; + + ptrace_in.addr = addr; + ptrace_in.pid = inferior_pid; + + status = net_clnt_call (procnum, xdr_rptrace, &ptrace_in, xdr_int, + &break_status); + + if (status != RPC_SUCCESS) + return errno; + + if (break_status == -1) + return ENOMEM; + return break_status; /* probably (FIXME) zero */ + } + +/* returns 0 if successful, errno otherwise */ + +int +vx_insert_breakpoint (addr) + int addr; + { + return net_break (addr, VX_BREAK_ADD); + } + +/* returns 0 if successful, errno otherwise */ + +int +vx_remove_breakpoint (addr) + int addr; + { + return net_break (addr, VX_BREAK_DELETE); + } + +/* Call a function on the VxWorks target system. + ARGS is a vector of values of arguments (NARGS of them). + FUNCTION is a value, the function to be called. + Returns a struct value * representing what the function returned. + May fail to return, if a breakpoint or signal is hit + during the execution of the function. */ + +#ifdef FIXME +/* FIXME, function calls are really fried. GO back to manual method. */ +value +vx_call_function (function, nargs, args) + value function; + int nargs; + value *args; +{ + register CORE_ADDR sp; + register int i; + CORE_ADDR start_sp; + static REGISTER_TYPE dummy[] = CALL_DUMMY; + REGISTER_TYPE dummy1[sizeof dummy / sizeof (REGISTER_TYPE)]; + CORE_ADDR old_sp; + struct type *value_type; + unsigned char struct_return; + CORE_ADDR struct_addr; + struct inferior_status inf_status; + struct cleanup *old_chain; + CORE_ADDR funaddr; + int using_gcc; + + save_inferior_status (&inf_status, 1); + old_chain = make_cleanup (restore_inferior_status, &inf_status); + + /* PUSH_DUMMY_FRAME is responsible for saving the inferior registers + (and POP_FRAME for restoring them). (At least on most machines) + they are saved on the stack in the inferior. */ + PUSH_DUMMY_FRAME; + + old_sp = sp = read_register (SP_REGNUM); + +#if 1 INNER_THAN 2 /* Stack grows down */ + sp -= sizeof dummy; + start_sp = sp; +#else /* Stack grows up */ + start_sp = sp; + sp += sizeof dummy; +#endif + + funaddr = find_function_addr (function, &value_type); + + { + struct block *b = block_for_pc (funaddr); + /* If compiled without -g, assume GCC. */ + using_gcc = b == NULL || BLOCK_GCC_COMPILED (b); + } + + /* Are we returning a value using a structure return or a normal + value return? */ + + struct_return = using_struct_return (function, funaddr, value_type, + using_gcc); + + /* Create a call sequence customized for this function + and the number of arguments for it. */ + bcopy (dummy, dummy1, sizeof dummy); + FIX_CALL_DUMMY (dummy1, start_sp, funaddr, nargs, args, + value_type, using_gcc); + +#if CALL_DUMMY_LOCATION == ON_STACK + write_memory (start_sp, dummy1, sizeof dummy); + +#else /* Not on stack. */ +#if CALL_DUMMY_LOCATION == BEFORE_TEXT_END + /* Convex Unix prohibits executing in the stack segment. */ + /* Hope there is empty room at the top of the text segment. */ + { + static checked = 0; + if (!checked) + for (start_sp = text_end - sizeof dummy; start_sp < text_end; ++start_sp) + if (read_memory_integer (start_sp, 1) != 0) + error ("text segment full -- no place to put call"); + checked = 1; + sp = old_sp; + start_sp = text_end - sizeof dummy; + write_memory (start_sp, dummy1, sizeof dummy); + } +#else /* After text_end. */ + { + int errcode; + sp = old_sp; + start_sp = text_end; + errcode = target_write_memory (start_sp, dummy1, sizeof dummy); + if (errcode != 0) + error ("Cannot write text segment -- call_function failed"); + } +#endif /* After text_end. */ +#endif /* Not on stack. */ + +#ifdef STACK_ALIGN + /* If stack grows down, we must leave a hole at the top. */ + { + int len = 0; + + /* Reserve space for the return structure to be written on the + stack, if necessary */ + + if (struct_return) + len += TYPE_LENGTH (value_type); + + for (i = nargs - 1; i >= 0; i--) + len += TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args[i]))); +#ifdef CALL_DUMMY_STACK_ADJUST + len += CALL_DUMMY_STACK_ADJUST; +#endif +#if 1 INNER_THAN 2 + sp -= STACK_ALIGN (len) - len; +#else + sp += STACK_ALIGN (len) - len; +#endif + } +#endif /* STACK_ALIGN */ + + /* Reserve space for the return structure to be written on the + stack, if necessary */ + + if (struct_return) + { +#if 1 INNER_THAN 2 + sp -= TYPE_LENGTH (value_type); + struct_addr = sp; +#else + struct_addr = sp; + sp += TYPE_LENGTH (value_type); +#endif + } + +#if defined (REG_STRUCT_HAS_ADDR) + { + /* This is a machine like the sparc, where we need to pass a pointer + to the structure, not the structure itself. */ + if (REG_STRUCT_HAS_ADDR (using_gcc)) + for (i = nargs - 1; i >= 0; i--) + if (TYPE_CODE (VALUE_TYPE (args[i])) == TYPE_CODE_STRUCT) + { + CORE_ADDR addr; +#if !(1 INNER_THAN 2) + /* The stack grows up, so the address of the thing we push + is the stack pointer before we push it. */ + addr = sp; +#endif + /* Push the structure. */ + sp = value_push (sp, args[i]); +#if 1 INNER_THAN 2 + /* The stack grows down, so the address of the thing we push + is the stack pointer after we push it. */ + addr = sp; +#endif + /* The value we're going to pass is the address of the thing + we just pushed. */ + args[i] = value_from_long (builtin_type_long, (LONGEST) addr); + } + } +#endif /* REG_STRUCT_HAS_ADDR. */ + +#ifdef PUSH_ARGUMENTS + PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr); +#else /* !PUSH_ARGUMENTS */ + for (i = nargs - 1; i >= 0; i--) + sp = value_arg_push (sp, args[i]); +#endif /* !PUSH_ARGUMENTS */ + +#ifdef CALL_DUMMY_STACK_ADJUST +#if 1 INNER_THAN 2 + sp -= CALL_DUMMY_STACK_ADJUST; +#else + sp += CALL_DUMMY_STACK_ADJUST; +#endif +#endif /* CALL_DUMMY_STACK_ADJUST */ + + /* Store the address at which the structure is supposed to be + written. Note that this (and the code which reserved the space + above) assumes that gcc was used to compile this function. Since + it doesn't cost us anything but space and if the function is pcc + it will ignore this value, we will make that assumption. + + Also note that on some machines (like the sparc) pcc uses a + convention like gcc's. */ + + if (struct_return) + STORE_STRUCT_RETURN (struct_addr, sp); + + /* Write the stack pointer. This is here because the statements above + might fool with it. On SPARC, this write also stores the register + window into the right place in the new stack frame, which otherwise + wouldn't happen. (See write_inferior_registers in sparc-xdep.c.) */ + write_register (SP_REGNUM, sp); + + /* Figure out the value returned by the function. */ + { + char retbuf[REGISTER_BYTES]; + + /* Execute the stack dummy routine, calling FUNCTION. + When it is done, discard the empty frame + after storing the contents of all regs into retbuf. */ + run_stack_dummy (start_sp + CALL_DUMMY_START_OFFSET, retbuf); + + do_cleanups (old_chain); + + return value_being_returned (value_type, retbuf, struct_return); + } +} +/* should return a value of some sort */ + +value +vx_call_function (funcAddr, nargs, args, valueType) + char *funcAddr; + int nargs; + value *args; + struct type * valueType; +{ + int i; + func_call funcInfo; + arg_value *argValue; + enum clnt_stat status; + register int len; + arg_value funcReturn; + value gdbValue; + + argValue = (arg_value *) xmalloc (nargs * sizeof (arg_value)); + + bzero (argValue, nargs * sizeof (arg_value)); + bzero (&funcReturn, sizeof (funcReturn)); + + for (i = nargs - 1; i >= 0; i--) + { + len = TYPE_LENGTH (VALUE_TYPE (args [i])); + + switch (TYPE_CODE (VALUE_TYPE (args[i]))) + { + /* XXX put other types here. Where's CHAR, etc??? */ + + case TYPE_CODE_FLT: + argValue[i].type = T_FLOAT; + break; + case TYPE_CODE_INT: + case TYPE_CODE_PTR: + case TYPE_CODE_ENUM: + case TYPE_CODE_FUNC: + argValue[i].type = T_INT; + break; + + case TYPE_CODE_UNDEF: + case TYPE_CODE_ARRAY: + case TYPE_CODE_STRUCT: + case TYPE_CODE_UNION: + case TYPE_CODE_VOID: + case TYPE_CODE_SET: + case TYPE_CODE_RANGE: + case TYPE_CODE_PASCAL_ARRAY: + case TYPE_CODE_MEMBER: /* C++ */ + case TYPE_CODE_METHOD: /* C++ */ + case TYPE_CODE_REF: /* C++ */ + default: + error ("No corresponding VxWorks type for %d. CHECK IT OUT!!!\n", + TYPE_CODE(VALUE_TYPE(args[i]))); + } /* switch */ + if (TYPE_CODE(VALUE_TYPE(args[i])) == TYPE_CODE_FUNC) + argValue[i].arg_value_u.v_int = VALUE_ADDRESS(args[i]); + else + bcopy (VALUE_CONTENTS (args[i]), (char *) &argValue[i].arg_value_u, + len); + } + + /* XXX what should the type of this function addr be? + * XXX Both in gdb and vxWorks + */ + funcInfo.func_addr = (int) funcAddr; + funcInfo.args.args_len = nargs; + funcInfo.args.args_val = argValue; + + status = net_clnt_call (VX_CALL_FUNC, xdr_func_call, (char *) &funcInfo, + xdr_arg_value, &funcReturn); + + free ((char *) argValue); + + if (status == RPC_SUCCESS) + { + /* XXX this assumes that vxWorks ALWAYS returns an int, and that + * XXX gdb isn't expecting anything more + */ + + /******************* + if (funcReturn.type == T_UNKNOWN) + return YYYXXX...; + *******************/ + gdbValue = allocate_value (valueType); + bcopy (&funcReturn.arg_value_u.v_int, VALUE_CONTENTS (gdbValue), + sizeof (int)); + return gdbValue; + } + else + error (rpcerr); + } +#endif /* FIXME */ + +/* Start an inferior process and sets inferior_pid to its pid. + EXEC_FILE is the file to run. + ALLARGS is a string containing the arguments to the program. + ENV is the environment vector to pass. + Returns process id. Errors reported with error(). + On VxWorks, we ignore exec_file. */ + +void +vx_create_inferior (exec_file, args, env) + char *exec_file; + char *args; + char **env; +{ + enum clnt_stat status; + arg_array passArgs; + TASK_START taskStart; + + bzero ((char *) &passArgs, sizeof (passArgs)); + bzero ((char *) &taskStart, sizeof (taskStart)); + + /* parse arguments, put them in passArgs */ + + parse_args (args, &passArgs); + + if (passArgs.arg_array_len == 0) + error ("You must specify a function name to run, and arguments if any"); + + status = net_clnt_call (PROCESS_START, xdr_arg_array, &passArgs, + xdr_TASK_START, &taskStart); + + if ((status != RPC_SUCCESS) || (taskStart.status == -1)) + error ("Can't create process on remote target machine"); + + /* Save the name of the running function */ + vx_running = savestring (passArgs.arg_array_val[0], + strlen (passArgs.arg_array_val[0])); + +#ifdef CREATE_INFERIOR_HOOK + CREATE_INFERIOR_HOOK (pid); +#endif + + push_target (&vx_run_ops); + inferior_pid = taskStart.pid; + +#if defined (START_INFERIOR_HOOK) + START_INFERIOR_HOOK (); +#endif + + /* We will get a trace trap after one instruction. + Insert breakpoints and continue. */ + + init_wait_for_inferior (); + + /* Set up the "saved terminal modes" of the inferior + based on what modes we are starting it with. */ + target_terminal_init (); + + /* Install inferior's terminal modes. */ + target_terminal_inferior (); + + /* remote_start(args); */ + /* trap_expected = 0; */ + stop_soon_quietly = 1; + wait_for_inferior (); /* Get the task spawn event */ + stop_soon_quietly = 0; + + /* insert_step_breakpoint (); FIXME, do we need this? */ + proceed(-1, -1, 0); +} + +/* Fill ARGSTRUCT in argc/argv form with the arguments from the + argument string ARGSTRING. */ + +static void +parse_args (arg_string, arg_struct) + register char *arg_string; + arg_array *arg_struct; +{ + register int arg_count = 0; /* number of arguments */ + register int arg_index = 0; + register char *p0; + + bzero ((char *) arg_struct, sizeof (arg_array)); + + /* first count how many arguments there are */ + + p0 = arg_string; + while (*p0 != '\0') + { + if (*(p0 = skip_white_space (p0)) == '\0') + break; + p0 = find_white_space (p0); + arg_count++; + } + + arg_struct->arg_array_len = arg_count; + arg_struct->arg_array_val = (char **) xmalloc ((arg_count + 1) + * sizeof (char *)); + + /* now copy argument strings into arg_struct. */ + + while (*(arg_string = skip_white_space (arg_string))) + { + p0 = find_white_space (arg_string); + arg_struct->arg_array_val[arg_index++] = savestring (arg_string, + p0 - arg_string); + arg_string = p0; + } + + arg_struct->arg_array_val[arg_count] = NULL; +} + +/* Advance a string pointer across whitespace and return a pointer + to the first non-white character. */ + +static char * +skip_white_space (p) + register char *p; +{ + while (*p == ' ' || *p == '\t') + p++; + return p; +} + +/* Search for the first unquoted whitespace character in a string. + Returns a pointer to the character, or to the null terminator + if no whitespace is found. */ + +static char * +find_white_space (p) + register char *p; +{ + register int c; + + while ((c = *p) != ' ' && c != '\t' && c) + { + if (c == '\'' || c == '"') + { + while (*++p != c && *p) + { + if (*p == '\\') + p++; + } + if (!*p) + break; + } + p++; + } + return p; +} + +/* Poll the VxWorks target system for an event related + to the debugged task. + Returns -1 if remote wait failed, task status otherwise. */ + +int +net_wait (pEvent) + RDB_EVENT *pEvent; +{ + int pid; + enum clnt_stat status; + + bzero ((char *) pEvent, sizeof (RDB_EVENT)); + + pid = inferior_pid; + status = net_clnt_call (PROCESS_WAIT, xdr_int, &pid, xdr_RDB_EVENT, pEvent); + + return (status == RPC_SUCCESS)? pEvent->status: -1; +} + +/* Suspend the remote task. + Returns -1 if suspend fails on target system, 0 otherwise. */ + +int +net_quit () +{ + int pid; + int quit_status; + enum clnt_stat status; + + quit_status = 0; + + /* don't let rdbTask suspend itself by passing a pid of 0 */ + + if ((pid = inferior_pid) == 0) + return -1; + + status = net_clnt_call (VX_TASK_SUSPEND, xdr_int, &pid, xdr_int, + &quit_status); + + return (status == RPC_SUCCESS)? quit_status: -1; +} + +/* Read a register or registers from the remote system. */ + +int +vx_read_register (regno) + int regno; +{ + int status; + Rptrace ptrace_in; + Ptrace_return ptrace_out; + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + extern char registers[]; + + bzero ((char *) &ptrace_in, sizeof (ptrace_in)); + bzero ((char *) &ptrace_out, sizeof (ptrace_out)); + + /* FIXME, eventually only get the ones we need. */ + registers_fetched (); + + ptrace_in.pid = inferior_pid; + ptrace_out.info.more_data = (caddr_t) &inferior_registers; + status = net_ptrace_clnt_call (PTRACE_GETREGS, &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + return -1; + } + +#ifdef I80960 + + bcopy ((char *) inferior_registers.r_lreg, + ®isters[REGISTER_BYTE (R0_REGNUM)], 16 * sizeof (int)); + bcopy ((char *) inferior_registers.r_greg, + ®isters[REGISTER_BYTE (G0_REGNUM)], 16 * sizeof (int)); + + /* Don't assume that a location in registers[] is properly aligned. */ + + bcopy ((char *) &inferior_registers.r_pcw, + ®isters[REGISTER_BYTE (PCW_REGNUM)], sizeof (int)); + bcopy ((char *) &inferior_registers.r_acw, + ®isters[REGISTER_BYTE (ACW_REGNUM)], sizeof (int)); + bcopy ((char *) &inferior_registers.r_lreg[2], /* r2 (RIP) -> IP */ + ®isters[REGISTER_BYTE (IP_REGNUM)], sizeof (int)); + bcopy ((char *) &inferior_registers.r_tcw, + ®isters[REGISTER_BYTE (TCW_REGNUM)], sizeof (int)); + + /* If the target has floating point registers, fetch them. + Otherwise, zero the floating point register values in + registers[] for good measure, even though we might not + need to. */ + + if (target_has_fp) + { + ptrace_in.pid = inferior_pid; + ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers; + status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + return -1; + } + + bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], + REGISTER_RAW_SIZE (FP0_REGNUM) * 4); + } + else + { + bzero ((char *) ®isters[REGISTER_BYTE (FP0_REGNUM)], + REGISTER_RAW_SIZE (FP0_REGNUM) * 4); + } + +#else /* not 960, thus must be 68000: FIXME! */ + + bcopy (&inferior_registers, registers, 16 * 4); + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; + + if (target_has_fp) + { + ptrace_in.pid = inferior_pid; + ptrace_out.info.more_data = (caddr_t) &inferior_fp_registers; + status = net_ptrace_clnt_call (PTRACE_GETFPREGS, &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + return -1; + } + + bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.fps_regs); + bcopy (&inferior_fp_registers.fps_control, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + } + else + { + bzero (®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.fps_regs); + bzero (®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + } +#endif /* various architectures */ + + return 0; +} + +/* Prepare to store registers. Since we will store all of them, + read out their current values now. */ + +void +vx_prepare_to_store () +{ + vx_read_register (-1); +} + + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + /* FIXME, look at REGNO to save time here */ + +vx_write_register (regno) + int regno; +{ + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + extern char registers[]; + int status; + Rptrace ptrace_in; + Ptrace_return ptrace_out; + + bzero ((char *) &ptrace_in, sizeof (ptrace_in)); + bzero ((char *) &ptrace_out, sizeof (ptrace_out)); + +#ifdef I80960 + + bcopy (®isters[REGISTER_BYTE (R0_REGNUM)], + (char *) inferior_registers.r_lreg, 16 * sizeof (int)); + bcopy (®isters[REGISTER_BYTE (G0_REGNUM)], + (char *) inferior_registers.r_greg, 16 * sizeof (int)); + + /* Don't assume that a location in registers[] is properly aligned. */ + + bcopy (®isters[REGISTER_BYTE (PCW_REGNUM)], + (char *) &inferior_registers.r_pcw, sizeof (int)); + bcopy (®isters[REGISTER_BYTE (ACW_REGNUM)], + (char *) &inferior_registers.r_acw, sizeof (int)); + bcopy (®isters[REGISTER_BYTE (TCW_REGNUM)], + (char *) &inferior_registers.r_tcw, sizeof (int)); + +#else /* not 960 -- assume 68k -- FIXME */ + + bcopy (registers, &inferior_registers, 16 * 4); + inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; + inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; + +#endif /* Different register sets */ + + ptrace_in.pid = inferior_pid; + ptrace_in.info.ttype = REGS; + ptrace_in.info.more_data = (caddr_t) &inferior_registers; + + /* XXX change second param to be a proc number */ + status = net_ptrace_clnt_call (PTRACE_SETREGS, &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + return -1; + } + + /* Store floating point registers if the target has them. */ + + if (target_has_fp) + { +#ifdef I80960 + + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, + sizeof inferior_fp_registers.fps_regs); + +#else /* not 960 -- assume 68k -- FIXME */ + + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, + sizeof inferior_fp_registers.fps_regs); + bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], + &inferior_fp_registers.fps_control, + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); + +#endif /* Different register sets */ + + ptrace_in.pid = inferior_pid; + ptrace_in.info.ttype = FPREGS; + ptrace_in.info.more_data = (caddr_t) &inferior_fp_registers; + + status = net_ptrace_clnt_call (PTRACE_SETFPREGS, &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + return -1; + } + } + return 0; +} + +/* Copy LEN bytes to or from remote inferior's memory starting at MEMADDR + to debugger memory starting at MYADDR. WRITE is true if writing to the + inferior. + Result is the number of bytes written or read (zero if error). The + protocol allows us to return a negative count, indicating that we can't + handle the current address but can handle one N bytes further, but + vxworks doesn't give us that information. */ + +int +vx_xfer_memory (memaddr, myaddr, len, write) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + int status; + Rptrace ptrace_in; + Ptrace_return ptrace_out; + C_bytes data; + + bzero ((char *) &ptrace_in, sizeof (ptrace_in)); + bzero ((char *) &ptrace_out, sizeof (ptrace_out)); + + ptrace_in.pid = inferior_pid; /* XXX pid unnecessary for READDATA */ + ptrace_in.addr = (int) memaddr; /* Where from */ + ptrace_in.data = len; /* How many bytes */ + + if (write) + { + ptrace_in.info.ttype = DATA; + ptrace_in.info.more_data = (caddr_t) &data; + + data.bytes = (caddr_t) myaddr; /* Where from */ + data.len = len; /* How many bytes (again, for XDR) */ + + /* XXX change second param to be a proc number */ + status = net_ptrace_clnt_call (PTRACE_WRITEDATA, &ptrace_in, &ptrace_out); + } + else + { + ptrace_out.info.more_data = (caddr_t) &data; + data.bytes = myaddr; /* Where to */ + data.len = len; /* How many (again, for XDR) */ + + /* XXX change second param to be a proc number */ + status = net_ptrace_clnt_call (PTRACE_READDATA, &ptrace_in, &ptrace_out); + } + + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + return 0; /* No bytes moved */ + } + return len; /* Moved *all* the bytes */ +} + +void +vx_files_info () +{ + printf ("\tAttached to host `%s'", vx_host); + printf (", which has %sfloating point", target_has_fp? "": "no "); + printf (".\n"); +} + +void +vx_run_files_info () +{ + printf ("\tRunning %s VxWorks process 0x%x", + vx_running? "child": "attached", + inferior_pid); + if (vx_running) + printf (", function `%s'", vx_running); + printf(".\n"); +} + +void +vx_resume (step, siggnal) + int step; + int siggnal; +{ + int status; + Rptrace ptrace_in; + Ptrace_return ptrace_out; + + if (siggnal != 0 && siggnal != stop_signal) + error ("Cannot send signals to VxWorks processes"); + + bzero ((char *) &ptrace_in, sizeof (ptrace_in)); + bzero ((char *) &ptrace_out, sizeof (ptrace_out)); + + ptrace_in.pid = inferior_pid; + ptrace_in.addr = 1; /* Target side insists on this, or it panics. */ + + /* XXX change second param to be a proc number */ + status = net_ptrace_clnt_call (step? PTRACE_SINGLESTEP: PTRACE_CONT, + &ptrace_in, &ptrace_out); + if (status) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + perror_with_name ("Resuming remote process"); + } +} + +void +vx_mourn_inferior () +{ + pop_target (); /* Pop back to no-child state */ + generic_mourn_inferior (); +} + + +/* This function allows the addition of incrementally linked object files. */ + +void +vx_load_command (arg_string, from_tty) + char* arg_string; + int from_tty; +{ + CORE_ADDR text_addr; + CORE_ADDR data_addr; + CORE_ADDR bss_addr; + + if (arg_string == 0) + error ("The load command takes a file name"); + + arg_string = tilde_expand (arg_string); + make_cleanup (free, arg_string); + + dont_repeat (); + + QUIT; + immediate_quit++; + if (net_load (arg_string, &text_addr, &data_addr, &bss_addr) == -1) + error ("Load failed on target machine"); + immediate_quit--; + + /* FIXME, for now we ignore data_addr and bss_addr. */ + symbol_file_add (arg_string, from_tty, text_addr, 0); +} + +#ifdef FIXME /* Not ready for prime time */ +/* Single step the target program at the source or machine level. + Takes an error exit if rpc fails. + Returns -1 if remote single-step operation fails, else 0. */ + +static int +net_step () +{ + enum clnt_stat status; + int step_status; + SOURCE_STEP source_step; + + source_step.taskId = inferior_pid; + + if (step_range_end) + { + source_step.startAddr = step_range_start; + source_step.endAddr = step_range_end; + } + else + { + source_step.startAddr = 0; + source_step.endAddr = 0; + } + + status = net_clnt_call (VX_SOURCE_STEP, xdr_SOURCE_STEP, &source_step, + xdr_int, &step_status); + + if (status == RPC_SUCCESS) + return step_status; + else + error (rpcerr); +} +#endif + +/* Emulate ptrace using RPC calls to the VxWorks target system. + Returns nonzero (-1) if RPC status to VxWorks is bad, 0 otherwise. */ + +static int +net_ptrace_clnt_call (request, pPtraceIn, pPtraceOut) + enum ptracereq request; + Rptrace *pPtraceIn; + Ptrace_return *pPtraceOut; +{ + enum clnt_stat status; + + status = net_clnt_call (request, xdr_rptrace, pPtraceIn, xdr_ptrace_return, + pPtraceOut); + + if (status != RPC_SUCCESS) + return -1; + + return 0; +} + +/* Query the target for the name of the file from which VxWorks was + booted. pBootFile is the address of a pointer to the buffer to + receive the file name; if the pointer pointed to by pBootFile is + NULL, memory for the buffer will be allocated by XDR. + Returns -1 if rpc failed, 0 otherwise. */ + +int +net_get_boot_file (pBootFile) + char **pBootFile; +{ + enum clnt_stat status; + + status = net_clnt_call (VX_BOOT_FILE_INQ, xdr_void, (char *) 0, + xdr_wrapstring, pBootFile); + return (status == RPC_SUCCESS) ? 0 : -1; +} + +/* Fetch a list of loaded object modules from the VxWorks target. + Returns -1 if rpc failed, 0 otherwise + There's no way to check if the returned loadTable is correct. + VxWorks doesn't check it. */ + +int +net_get_symbols (pLoadTable) + ldtabl *pLoadTable; /* return pointer to ldtabl here */ +{ + enum clnt_stat status; + + bzero ((char *) pLoadTable, sizeof (struct ldtabl)); + + status = net_clnt_call (VX_STATE_INQ, xdr_void, 0, xdr_ldtabl, pLoadTable); + return (status == RPC_SUCCESS) ? 0 : -1; +} + +/* Look up a symbol in the VxWorks target's symbol table. + Returns status of symbol read on target side (0=success, -1=fail) + Returns -1 and complain()s if rpc fails. */ + +struct complaint cant_contact_target = + {"Lost contact with VxWorks target", 0, 0}; + +int +vx_lookup_symbol (name, pAddr) + char *name; /* symbol name */ + CORE_ADDR *pAddr; +{ + enum clnt_stat status; + SYMBOL_ADDR symbolAddr; + + *pAddr = 0; + bzero ((char *) &symbolAddr, sizeof (symbolAddr)); + + status = net_clnt_call (VX_SYMBOL_INQ, xdr_wrapstring, &name, + xdr_SYMBOL_ADDR, &symbolAddr); + if (status != RPC_SUCCESS) { + complain (&cant_contact_target, 0); + return -1; + } + + *pAddr = symbolAddr.addr; + return symbolAddr.status; +} + +/* Check to see if the VxWorks target has a floating point coprocessor. + Returns 1 if target has floating point processor, 0 otherwise. + Calls error() if rpc fails. */ + +int +net_check_for_fp () +{ + enum clnt_stat status; + bool_t fp = 0; /* true if fp processor is present on target board */ + + status = net_clnt_call (VX_FP_INQUIRE, xdr_void, 0, xdr_bool, &fp); + if (status != RPC_SUCCESS) + error (rpcerr); + + return (int) fp; +} + +/* Establish an RPC connection with the VxWorks target system. + Calls error () if unable to establish connection. */ + +void +net_connect (host) + char *host; +{ + struct sockaddr_in destAddr; + struct hostent *destHost; + + /* get the internet address for the given host */ + + if ((destHost = (struct hostent *) gethostbyname (host)) == NULL) + error ("Invalid hostname. Couldn't find remote host address."); + + bzero (&destAddr, sizeof (destAddr)); + + destAddr.sin_addr.s_addr = * (u_long *) destHost->h_addr; + destAddr.sin_family = AF_INET; + destAddr.sin_port = 0; /* set to actual port that remote + ptrace is listening on. */ + + /* Create a tcp client transport on which to issue + calls to the remote ptrace server. */ + + ptraceSock = RPC_ANYSOCK; + pClient = clnttcp_create (&destAddr, RDBPROG, RDBVERS, &ptraceSock, 0, 0); + /* FIXME, here is where we deal with different version numbers of the proto */ + + if (pClient == NULL) + { + clnt_pcreateerror ("\tnet_connect"); + error ("Couldn't connect to remote target."); + } +} + +/* Sleep for the specified number of milliseconds + * (assumed to be less than 1000). + * If select () is interrupted, returns immediately; + * takes an error exit if select () fails for some other reason. + */ + +static void +sleep_ms (ms) + long ms; +{ + struct timeval select_timeout; + int status; + + select_timeout.tv_sec = 0; + select_timeout.tv_usec = ms * 1000; + + status = select (0, (fd_set *) 0, (fd_set *) 0, (fd_set *) 0, &select_timeout); + + if (status < 0 && errno != EINTR) + perror_with_name ("select"); +} + +/* Wait for control to return from inferior to debugger. + If inferior gets a signal, we may decide to start it up again + instead of returning. That is why there is a loop in this function. + When this function actually returns it means the inferior + should be left stopped and GDB should read more commands. */ + +/* For network debugging with VxWorks. + * VxWorks knows when tasks hit breakpoints, receive signals, exit, etc, + * so vx_wait() receives this information directly from + * VxWorks instead of trying to figure out what happenned via a wait() call. + */ + +static int +vx_wait (status) + int *status; +{ + register int pid; + WAITTYPE w; + RDB_EVENT rdbEvent; + int quit_failed; + + do + { + /* If CTRL-C is hit during this loop, + suspend the inferior process. */ + + quit_failed = 0; + if (quit_flag) + { + quit_failed = (net_quit () == -1); + quit_flag = 0; + } + + /* If a net_quit () or net_wait () call has failed, + allow the user to break the connection with the target. + We can't simply error () out of this loop, since the + data structures representing the state of the inferior + are in an inconsistent state. */ + + if (quit_failed || net_wait (&rdbEvent) == -1) + { + terminal_ours (); + if (query ("Can't %s. Disconnect from target system? ", + (quit_failed) ? "suspend remote task" + : "get status of remote task")) + { + target_mourn_inferior(); + error ("Use the \"target\" command to reconnect."); + } + else + { + terminal_inferior (); + continue; + } + } + + pid = rdbEvent.taskId; + if (pid == 0) + { + sleep_ms (200); /* FIXME Don't kill the network too badly */ + } + else if (pid != inferior_pid) + fatal ("Bad pid for debugged task: 0x%x\n", pid); + } while (pid == 0); + + /* FIXME, eventually do more then SIGTRAP on everything... */ + switch (rdbEvent.eventType) + { + case EVENT_EXIT: + WSETEXIT (w, 0); + /* FIXME is it possible to distinguish between a + XXX normal vs abnormal exit in VxWorks? */ + break; + + case EVENT_START: /* Task was just started. */ + WSETSTOP (w, SIGTRAP); + break; + + case EVENT_STOP: + WSETSTOP (w, SIGTRAP); + /* XXX was it stopped by a signal? act accordingly */ + break; + + case EVENT_BREAK: /* Breakpoint was hit. */ + WSETSTOP (w, SIGTRAP); + break; + + case EVENT_SUSPEND: /* Task was suspended, probably by ^C. */ + WSETSTOP (w, SIGINT); + break; + + case EVENT_BUS_ERR: /* Task made evil nasty reference. */ + WSETSTOP (w, SIGBUS); + break; + + case EVENT_ZERO_DIV: /* Division by zero */ + WSETSTOP (w, SIGFPE); /* Like Unix, call it a float exception. */ + + case EVENT_SIGNAL: + /* The target is not running Unix, and its + faults/traces do not map nicely into Unix signals. + Make sure they do not get confused with Unix signals + by numbering them with values higher than the highest + legal Unix signal. code in the arch-dependent PRINT_RANDOM_SIGNAL + routine will interpret the value for wait_for_inferior. */ + WSETSTOP (w, rdbEvent.sigType + NSIG); + break; + } /* switch */ + *status = *(int *)&w; /* Grumble union wait crap Grumble */ + return pid; +} + +static int +symbol_stub (arg) + int arg; +{ + char *bootFile = (char *)arg; + symbol_file_command (bootFile, 0); + return 1; +} + +static int +add_symbol_stub (arg) + int arg; +{ + struct ldfile *pLoadFile = (struct ldfile *)arg; + + printf("\t%s: ", pLoadFile->name); + symbol_file_add (pLoadFile->name, 0, pLoadFile->txt_addr, 0); + printf ("ok\n"); + return 1; +} +/* Target command for VxWorks target systems. + + Used in vxgdb. Takes the name of a remote target machine + running vxWorks and connects to it to initialize remote network + debugging. */ + +static void +vx_open (args, from_tty) + char *args; + int from_tty; +{ + extern int close (); + char *bootFile; + extern char *source_path; + struct ldtabl loadTable; + struct ldfile *pLoadFile; + int i; + extern CLIENT *pClient; + + if (!args) + error_no_arg ("target machine name"); + + unpush_target (&vx_ops); + printf ("Attaching remote machine across net...\n"); + fflush (stdout); + + /* Allow the user to kill the connect attempt by typing ^C. + Wait until the call to target_has_fp () completes before + disallowing an immediate quit, since even if net_connect () + is successful, the remote debug server might be hung. */ + + immediate_quit++; + + net_connect (args); + target_has_fp = net_check_for_fp (); + printf_filtered ("Connected to %s.\n", args); + + immediate_quit--; + + push_target (&vx_ops); + + /* Save a copy of the target host's name. */ + vx_host = savestring (args, strlen (args)); + + /* Find out the name of the file from which the target was booted + and load its symbol table. */ + + printf_filtered ("Looking in Unix path for all loaded modules:\n"); + bootFile = NULL; + if (!net_get_boot_file (&bootFile)) + { + if (*bootFile) { + printf_filtered ("\t%s: ", bootFile); + if (catch_errors (symbol_stub, (int)bootFile, + "Error reading symbols from boot file")) + puts_filtered ("ok\n"); + } else if (from_tty) + printf ("VxWorks kernel symbols not loaded.\n"); + } + else + error ("Can't retrieve boot file name from target machine."); + + clnt_freeres (pClient, xdr_wrapstring, &bootFile); + + if (net_get_symbols (&loadTable) != 0) + error ("Can't read loaded modules from target machine"); + + i = 0-1; + while (++i < loadTable.tbl_size) + { + QUIT; /* FIXME, avoids clnt_freeres below: mem leak */ + pLoadFile = &loadTable.tbl_ent [i]; +#ifdef WRS_ORIG + { + register int desc; + struct cleanup *old_chain; + char *fullname = NULL; + + desc = openp (source_path, 0, pLoadFile->name, O_RDONLY, 0, &fullname); + if (desc < 0) + perror_with_name (pLoadFile->name); + old_chain = make_cleanup (close, desc); + add_file_at_addr (fullname, desc, pLoadFile->txt_addr, pLoadFile->data_addr, + pLoadFile->bss_addr); + do_cleanups (old_chain); + } +#else + /* Botches, FIXME: + (1) Searches the PATH, not the source path. + (2) data and bss are assumed to be at the usual offsets from text. */ + catch_errors (add_symbol_stub, (int)pLoadFile, (char *)0); +#endif + } + printf_filtered ("Done.\n"); + + clnt_freeres (pClient, xdr_ldtabl, &loadTable); +} + +/* attach_command -- + takes a task started up outside of gdb and ``attaches'' to it. + This stops it cold in its tracks and allows us to start tracing it. */ + +static void +vx_attach (args, from_tty) + char *args; + int from_tty; +{ + int pid; + char *cptr = 0; + Rptrace ptrace_in; + Ptrace_return ptrace_out; + int status; + + dont_repeat(); + + if (!args) + error_no_arg ("process-id to attach"); + + pid = strtol (args, &cptr, 0); + if ((cptr == args) || (*cptr != '\0')) + error ("Invalid process-id -- give a single number in decimal or 0xhex"); + + if (from_tty) + printf ("Attaching pid 0x%x.\n", pid); + + bzero ((char *)&ptrace_in, sizeof (ptrace_in)); + bzero ((char *)&ptrace_out, sizeof (ptrace_out)); + ptrace_in.pid = pid; + + status = net_ptrace_clnt_call (PTRACE_ATTACH, &ptrace_in, &ptrace_out); + if (status == -1) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + perror_with_name ("Attaching remote process"); + } + + /* It worked... */ + push_target (&vx_run_ops); + inferior_pid = pid; + vx_running = 0; + +#if defined (START_INFERIOR_HOOK) + START_INFERIOR_HOOK (); +#endif + + mark_breakpoints_out (); + + /* Set up the "saved terminal modes" of the inferior + based on what modes we are starting it with. */ + target_terminal_init (); + + /* Install inferior's terminal modes. */ + target_terminal_inferior (); + + /* We will get a task spawn event immediately. */ + init_wait_for_inferior (); + clear_proceed_status (); + stop_soon_quietly = 1; + wait_for_inferior (); + stop_soon_quietly = 0; + normal_stop (); +} + + +/* detach_command -- + takes a program previously attached to and detaches it. + The program resumes execution and will no longer stop + on signals, etc. We better not have left any breakpoints + in the program or it'll die when it hits one. For this + to work, it may be necessary for the process to have been + previously attached. It *might* work if the program was + started via the normal ptrace (PTRACE_TRACEME). */ + +static void +vx_detach (args, from_tty) + char *args; + int from_tty; +{ + Rptrace ptrace_in; + Ptrace_return ptrace_out; + int signal = 0; + int status; + + if (args) + error ("Argument given to VxWorks \"detach\"."); + + if (from_tty) + printf ("Detaching pid 0x%x.\n", inferior_pid); + + if (args) /* FIXME, should be possible to leave suspended */ + signal = atoi (args); + + bzero ((char *)&ptrace_in, sizeof (ptrace_in)); + bzero ((char *)&ptrace_out, sizeof (ptrace_out)); + ptrace_in.pid = inferior_pid; + + status = net_ptrace_clnt_call (PTRACE_DETACH, &ptrace_in, &ptrace_out); + if (status == -1) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + perror_with_name ("Detaching VxWorks process"); + } + + inferior_pid = 0; + pop_target (); /* go back to non-executing VxWorks connection */ +} + +/* vx_kill -- takes a running task and wipes it out. */ + +static void +vx_kill (args, from_tty) + char *args; + int from_tty; +{ + Rptrace ptrace_in; + Ptrace_return ptrace_out; + int status; + + if (args) + error ("Argument given to VxWorks \"kill\"."); + + if (from_tty) + printf ("Killing pid 0x%x.\n", inferior_pid); + + bzero ((char *)&ptrace_in, sizeof (ptrace_in)); + bzero ((char *)&ptrace_out, sizeof (ptrace_out)); + ptrace_in.pid = inferior_pid; + + status = net_ptrace_clnt_call (PTRACE_KILL, &ptrace_in, &ptrace_out); + if (status == -1) + error (rpcerr); + if (ptrace_out.status == -1) + { + errno = ptrace_out.errno; + perror_with_name ("Killing VxWorks process"); + } + + /* If it gives good status, the process is *gone*, no events remain. */ + inferior_pid = 0; + pop_target (); /* go back to non-executing VxWorks connection */ +} + +/* Clean up from the VxWorks process target as it goes away. */ + +void +vx_proc_close (quitting) + int quitting; +{ + inferior_pid = 0; /* No longer have a process. */ + if (vx_running) + free (vx_running); + vx_running = 0; +} + +/* Cross-net conversion of floats to and from extended form. + (This is needed because different target machines have different + extended floating point formats.) */ + +/* Convert from an extended float to a double. + + The extended float is stored as raw data pointed to by FROM. + Return the converted value as raw data in the double pointed to by TO. +*/ + +static void +vx_convert_to_virtual (regno, from, to) + int regno; + char *from; + char *to; +{ + enum clnt_stat status; + + if (REGISTER_CONVERTIBLE (regno)) + { + if (!target_has_fp) { + *(double *)to = 0.0; /* Skip the trouble if no float anyway */ + return; + } + + status = net_clnt_call (VX_CONV_FROM_68881, xdr_ext_fp, from, + xdr_double, to); + + if (status == RPC_SUCCESS) + return; + else + error (rpcerr); + } + else + bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno)); +} + + +/* The converse: convert from a double to an extended float. + + The double is stored as raw data pointed to by FROM. + Return the converted value as raw data in the extended + float pointed to by TO. +*/ + +static void +vx_convert_from_virtual (regno, from, to) + int regno; + char *from; + char *to; +{ + enum clnt_stat status; + + if (REGISTER_CONVERTIBLE (regno)) + { + if (!target_has_fp) { + bzero (to, REGISTER_RAW_SIZE (FP0_REGNUM)); /* Shrug */ + return; + } + + status = net_clnt_call (VX_CONV_TO_68881, xdr_double, from, + xdr_ext_fp, to); + if (status == RPC_SUCCESS) + return; + else + error (rpcerr); + } + else + bcopy (from, to, REGISTER_VIRTUAL_SIZE (regno)); +} + +/* Make an RPC call to the VxWorks target. + Returns RPC status. */ + +static enum clnt_stat +net_clnt_call (procNum, inProc, in, outProc, out) + enum ptracereq procNum; + xdrproc_t inProc; + char *in; + xdrproc_t outProc; + char *out; +{ + enum clnt_stat status; + + status = clnt_call (pClient, procNum, inProc, in, outProc, out, rpcTimeout); + + if (status != RPC_SUCCESS) + clnt_perrno (status); + + return status; +} + +/* Clean up before losing control. */ + +void +vx_close (quitting) + int quitting; +{ + if (pClient) + clnt_destroy (pClient); /* The net connection */ + pClient = 0; + + if (vx_host) + free (vx_host); /* The hostname */ + vx_host = 0; +} + + +/* Target ops structure for accessing memory and such over the net */ + +struct target_ops vx_ops = { + "vxworks", "VxWorks target memory via RPC over TCP/IP", + vx_open, vx_close, vx_attach, 0, /* vx_detach, */ + 0, 0, /* resume, wait */ + 0, 0, /* read_reg, write_reg */ + 0, vx_convert_to_virtual, vx_convert_from_virtual, /* prep_to_store, */ + vx_xfer_memory, vx_files_info, + 0, 0, /* insert_breakpoint, remove_breakpoint */ + 0, 0, 0, 0, 0, /* terminal stuff */ + 0, /* vx_kill, */ + vx_load_command, add_syms_addr_command, + 0, /* call_function */ + vx_lookup_symbol, + vx_create_inferior, 0, /* mourn_inferior */ + core_stratum, 0, /* next */ + 1, 1, 0, 0, 0, /* all mem, mem, stack, regs, exec */ + OPS_MAGIC, /* Always the last thing */ +}; + +/* Target ops structure for accessing VxWorks child processes over the net */ + +struct target_ops vx_run_ops = { + "vxprocess", "VxWorks process", + vx_open, vx_proc_close, 0, vx_detach, /* vx_attach */ + vx_resume, vx_wait, + vx_read_register, vx_write_register, + vx_prepare_to_store, vx_convert_to_virtual, vx_convert_from_virtual, + vx_xfer_memory, vx_run_files_info, + vx_insert_breakpoint, vx_remove_breakpoint, + 0, 0, 0, 0, 0, /* terminal stuff */ + vx_kill, + vx_load_command, add_syms_addr_command, + call_function_by_hand, /* FIXME, calling fns is maybe botched? */ + vx_lookup_symbol, + 0, vx_mourn_inferior, + process_stratum, 0, /* next */ + 0, 1, 1, 1, 1, /* all mem, mem, stack, regs, exec */ + /* all_mem is off to avoid spurious msg in "i files" */ + OPS_MAGIC, /* Always the last thing */ +}; +/* ==> Remember when reading at end of file, there are two "ops" structs here. */ + +void +_initialize_vx () +{ + add_target (&vx_ops); + add_target (&vx_run_ops); +} diff --git a/gdb/saber.suppress b/gdb/saber.suppress new file mode 100644 index 0000000..19fac4d --- /dev/null +++ b/gdb/saber.suppress @@ -0,0 +1,411 @@ + + +/* Options for project */ +unsetopt ansi +setopt auto_compile +unsetopt auto_reload +setopt auto_replace +unsetopt batch_load +unsetopt batch_run +unsetopt cc_prog +setopt ccargs -g +unsetopt create_file +unsetopt debug_child +unsetopt echo +setopt edit_jobs 5 +unsetopt eight_bit +setopt line_edit +setopt line_meta +setopt lint_load 2 +setopt lint_run 2 +setopt list_action +setopt load_flags -I. -g -I.. -I../vx-share +unsetopt long_not_int +unsetopt make_args +setopt make_hfiles +unsetopt make_offset +unsetopt make_prog +setopt make_symbol # +setopt mem_config 16384 +unsetopt mem_trace +setopt num_proc 1 +unsetopt page_cmds +setopt page_list 19 +unsetopt page_load +unsetopt path +setopt proto_path . /s2/saber_dir30/sun4-40/proto /s2/saber_dir30/sun4-40/../common/proto +unsetopt preprocessor +setopt program_name a.out +unsetopt print_custom +setopt print_pointer +setopt print_string 20 +unsetopt save_memory +setopt sbrk_size 1048576 +setopt src_err 3 +setopt src_step 1 +setopt src_stop 3 +setopt sys_load_flags -L/lib -L/usr/lib -L/usr/local/lib -I/usr/include -Dunix -Dsun -Dsparc +unsetopt tab_stop +unsetopt terse_suppress +unsetopt terse_where +setopt unset_value 191 +unsetopt win_fork_nodup +setopt win_no_raise +unsetopt win_message_list +unsetopt win_project_list +/* Suppressions for project */ +suppress 6 in read_huge_number +/* Over/underflow <plus> */ +suppress 8 in read_huge_number +/* Over/underflow <multiply> */ +suppress 22 +/* Pointer subtraction */ +suppress 22 in free_all_psymtabs +/* Pointer subtraction */ +suppress 22 in free_all_symtabs +/* Pointer subtraction */ +suppress 56 in print_string +/* Information lost <function> */ +suppress 65 "../bfd/bfd.c":379 +/* Too many function arguments */ +suppress 65 on printf_filtered +/* Too many function arguments */ +suppress 65 on fprintf_filtered +/* Too many function arguments */ +suppress 65 on vfprintf_filtered +/* Too many function arguments */ +suppress 65 on query +/* Too many function arguments */ +suppress 65 on fatal_dump_core +/* Too many function arguments */ +suppress 65 on fatal +/* Too many function arguments */ +suppress 65 on error +/* Too many function arguments */ +suppress 65 on noprocess +/* Too many function arguments */ +suppress 65 +/* Too many function arguments */ +suppress 66 on say +/* Too few function arguments */ +suppress 66 on printf_filtered +/* Too few function arguments */ +suppress 66 on fprintf_filtered +/* Too few function arguments */ +suppress 66 on vfprintf_filtered +/* Too few function arguments */ +suppress 66 on query +/* Too few function arguments */ +suppress 66 on fatal_dump_core +/* Too few function arguments */ +suppress 66 on fatal +/* Too few function arguments */ +suppress 66 on error +/* Too few function arguments */ +suppress 67 on printf_filtered +/* Signed/unsigned argument mismatch */ +suppress 67 on fprintf_filtered +/* Signed/unsigned argument mismatch */ +suppress 67 on vfprintf_filtered +/* Signed/unsigned argument mismatch */ +suppress 67 on query +/* Signed/unsigned argument mismatch */ +suppress 67 on fatal_dump_core +/* Signed/unsigned argument mismatch */ +suppress 67 on fatal +/* Signed/unsigned argument mismatch */ +suppress 67 on error +/* Signed/unsigned argument mismatch */ +suppress 67 +/* Signed/unsigned argument mismatch */ +suppress 68 on bfd_get_section_contents +/* Benign argument mismatch */ +suppress 68 on _do_getblong +/* Benign argument mismatch */ +suppress 68 on supply_register +/* Benign argument mismatch */ +suppress 68 on target_write_memory +/* Benign argument mismatch */ +suppress 68 on write_register_bytes +/* Benign argument mismatch */ +suppress 68 on read_register_bytes +/* Benign argument mismatch */ +suppress 68 on read_memory +/* Benign argument mismatch */ +suppress 68 on say +/* Benign argument mismatch */ +suppress 68 on printf_filtered +/* Benign argument mismatch */ +suppress 68 on fprintf_filtered +/* Benign argument mismatch */ +suppress 68 on vfprintf_filtered +/* Benign argument mismatch */ +suppress 68 on query +/* Benign argument mismatch */ +suppress 68 on fatal_dump_core +/* Benign argument mismatch */ +suppress 68 on fatal +/* Benign argument mismatch */ +suppress 68 on error +/* Benign argument mismatch */ +suppress 68 in find_solib +/* Benign argument mismatch */ +suppress 68 on child_wait +/* Benign argument mismatch */ +suppress 68 on xrealloc +/* Benign argument mismatch */ +suppress 68 on myread +/* Benign argument mismatch */ +suppress 68 in do_cleanups +/* Benign argument mismatch */ +suppress 68 on make_cleanup +/* Benign argument mismatch */ +suppress 68 on target_read_memory +/* Benign argument mismatch */ +suppress 69 on printf_filtered +/* Serious argument mismatch */ +suppress 69 on fprintf_filtered +/* Serious argument mismatch */ +suppress 69 on vfprintf_filtered +/* Serious argument mismatch */ +suppress 69 on query +/* Serious argument mismatch */ +suppress 69 on fatal_dump_core +/* Serious argument mismatch */ +suppress 69 on fatal +/* Serious argument mismatch */ +suppress 69 on error +/* Serious argument mismatch */ +suppress 70 on printf_filtered +/* Passing illegal enumeration value */ +suppress 70 on fprintf_filtered +/* Passing illegal enumeration value */ +suppress 70 on vfprintf_filtered +/* Passing illegal enumeration value */ +suppress 70 on query +/* Passing illegal enumeration value */ +suppress 70 on fatal_dump_core +/* Passing illegal enumeration value */ +suppress 70 on fatal +/* Passing illegal enumeration value */ +suppress 70 on error +/* Passing illegal enumeration value */ +suppress 110 in printf_filtered +/* Signed/unsigned memory retrieval */ +suppress 110 in fprintf_filtered +/* Signed/unsigned memory retrieval */ +suppress 110 in vfprintf_filtered +/* Signed/unsigned memory retrieval */ +suppress 110 in query +/* Signed/unsigned memory retrieval */ +suppress 110 in fatal_dump_core +/* Signed/unsigned memory retrieval */ +suppress 110 in fatal +/* Signed/unsigned memory retrieval */ +suppress 110 in error +/* Signed/unsigned memory retrieval */ +suppress 112 in printf_filtered +/* Memory retrieval */ +suppress 112 in fprintf_filtered +/* Memory retrieval */ +suppress 112 in vfprintf_filtered +/* Memory retrieval */ +suppress 112 in query +/* Memory retrieval */ +suppress 112 in fatal_dump_core +/* Memory retrieval */ +suppress 112 in fatal +/* Memory retrieval */ +suppress 112 in error +/* Memory retrieval */ +suppress 112 +/* Memory retrieval */ +suppress 112 ../symtab.c +/* Memory retrieval */ +suppress 112 in child_xfer_memory +/* Memory retrieval */ +suppress 165 in frame_saved_pc +/* Dereference */ +suppress 165 in get_prev_frame_info +/* Dereference */ +suppress 167 in get_prev_frame_info +/* Selection */ +suppress 167 in frame_saved_pc +/* Selection */ +suppress 442 in try_baudrate +/* Escape has null value */ +suppress 529 in read_range_type +/* Statement not reached */ +suppress 529 in process_one_symbol +/* Statement not reached */ +suppress 529 in unpack_double +/* Statement not reached */ +suppress 529 in wait_for_inferior +/* Statement not reached */ +suppress 529 in do_registers_info +/* Statement not reached */ +suppress 529 in value_from_register +/* Statement not reached */ +suppress 530 "../environ.c":69 +/* Empty body of statement */ +suppress 530 "../remote-eb.c":333 +/* Empty body of statement */ +suppress 530 "../remote-eb.c":331 +/* Empty body of statement */ +suppress 530 "../remote-eb.c":324 +/* Empty body of statement */ +suppress 530 "../dbxread.c":792 +/* Empty body of statement */ +suppress 530 +/* Empty body of statement */ +suppress 530 "../dbxread.c":796 +/* Empty body of statement */ +suppress 546 in net_quit +/* Function exits through bottom */ +suppress 546 in net_wait +/* Function exits through bottom */ +suppress 546 in vx_remove_breakpoint +/* Function exits through bottom */ +suppress 546 in vx_insert_breakpoint +/* Function exits through bottom */ +suppress 546 in value_less +/* Function exits through bottom */ +suppress 546 in value_equal +/* Function exits through bottom */ +suppress 546 in unpack_long +/* Function exits through bottom */ +suppress 558 in read_range_type +/* Constant in conditional */ +suppress 558 in process_one_symbol +/* Constant in conditional */ +suppress 558 in read_dbx_symtab +/* Constant in conditional */ +suppress 558 in vx_write_register +/* Constant in conditional */ +suppress 558 in vx_read_register +/* Constant in conditional */ +suppress 558 in unpack_double +/* Constant in conditional */ +suppress 558 in wait_for_inferior +/* Constant in conditional */ +suppress 558 in do_registers_info +/* Constant in conditional */ +suppress 558 in value_from_register +/* Constant in conditional */ +suppress 560 in solib_address +/* Assignment within conditional */ +suppress 560 in solib_info +/* Assignment within conditional */ +suppress 560 in solib_add +/* Assignment within conditional */ +suppress 560 in read_type +/* Assignment within conditional */ +suppress 560 in type_print_base +/* Assignment within conditional */ +suppress 560 in type_print_derivation_info +/* Assignment within conditional */ +suppress 560 in block_depth +/* Assignment within conditional */ +suppress 560 in select_source_symtab +/* Assignment within conditional */ +suppress 560 in clear_value_history +/* Assignment within conditional */ +suppress 560 in clear_displays +/* Assignment within conditional */ +suppress 560 in initialize_main +/* Assignment within conditional */ +suppress 560 in echo_command +/* Assignment within conditional */ +suppress 560 in unset_in_environ +/* Assignment within conditional */ +suppress 560 in set_in_environ +/* Assignment within conditional */ +suppress 560 in get_in_environ +/* Assignment within conditional */ +suppress 560 in do_setshow_command +/* Assignment within conditional */ +suppress 560 in breakpoint_1 +/* Assignment within conditional */ +suppress 590 on sig +/* Unused formal parameter */ +suppress 590 in nindy_create_inferior +/* Unused formal parameter */ +suppress 590 in add_to_section_table +/* Unused formal parameter */ +suppress 590 in vx_create_inferior +/* Unused formal parameter */ +suppress 590 in host_convert_from_virtual +/* Unused formal parameter */ +suppress 590 in host_convert_to_virtual +/* Unused formal parameter */ +suppress 590 on siggnal +/* Unused formal parameter */ +suppress 590 in init_sig +/* Unused formal parameter */ +suppress 590 in nindy_resume +/* Unused formal parameter */ +suppress 590 in set_history_size_command +/* Unused formal parameter */ +suppress 590 in not_just_help_class_command +/* Unused formal parameter */ +suppress 590 on regno +/* Unused formal parameter */ +suppress 590 on from_tty +/* Unused formal parameter */ +suppress 590 on args +/* Unused formal parameter */ +suppress 590 in process_symbol_pair +/* Unused formal parameter */ +suppress 591 in print_scalar_formatted +/* Unused automatic variable */ +suppress 592 on rcsid +/* Unused static */ +suppress 592 on check_break_insn_size +/* Unused static */ +suppress 594 in call_function_by_hand +/* Set but not used */ +suppress 594 in record_latest_value +/* Set but not used */ +suppress 594 in bpstat_stop_status +/* Set but not used */ +suppress 595 in coffstrip +/* Used before set */ +suppress 652 ../bfd.h +/* Declaration has no effect */ +suppress 652 /usr/include/machine/reg.h +/* Declaration has no effect */ + +/* Signals caught and ignored */ +catch HUP +catch QUIT +catch ILL +catch TRAP +catch IOT +catch EMT +catch FPE +catch KILL +catch BUS +catch SEGV +catch SYS +catch PIPE +catch TERM +catch URG +catch STOP +catch TSTP +catch TTIN +catch TTOU +catch IO +catch XCPU +catch XFSZ +catch VTALRM +catch PROF +catch LOST +catch USR1 +catch USR2 +ignore INT +ignore ALRM +ignore CONT +ignore CHLD +ignore WINCH + +/* Status of project */ diff --git a/gdb/signals.h b/gdb/signals.h new file mode 100644 index 0000000..a6218d9 --- /dev/null +++ b/gdb/signals.h @@ -0,0 +1,34 @@ +/* Signal handler definitions for GDB, the GNU Debugger. + Copyright (C) 1986, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + + +/* This file is almost the same as including <signal.h> except that it + eliminates certain signal names when job control is not supported, + (or, on some systems, when job control is there but doesn't work + the way GDB expects it to work). */ + +#include <signal.h> + +#ifdef NO_JOB_CONTROL +# undef SIGTSTP +# undef SIGSTOP +# undef SIGCONT +# undef SIGTTIN +# undef SIGTTOU +#endif diff --git a/gdb/signame.c b/gdb/signame.c new file mode 100755 index 0000000..740da40 --- /dev/null +++ b/gdb/signame.c @@ -0,0 +1,246 @@ +/* Convert between signal names and numbers. + Copyright (C) 1990 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <signal.h> +#include "signame.h" + +#ifdef __STDC__ +#define CONST const +#else +#define CONST +#endif + +#ifdef SYS_SIGLIST_MISSING +/* There is too much variation in Sys V signal numbers and names, so + we must initialize them at runtime. */ + +static CONST char undoc[] = "unknown signal"; + +CONST char *sys_siglist[NSIG]; +#endif /* SYS_SIGLIST_MISSING */ + +/* Table of abbreviations for signals. Note: A given number can + appear more than once with different abbreviations. */ +typedef struct + { + int number; + CONST char *abbrev; + } num_abbrev; +static num_abbrev sig_table[NSIG*2]; +/* Number of elements of sig_table used. */ +static int sig_table_nelts = 0; + +/* Enter signal number NUMBER into the tables with ABBREV and NAME. */ +static void +init_sig (number, abbrev, name) + int number; + CONST char *abbrev; + CONST char *name; +{ +#ifdef SYS_SIGLIST_MISSING + sys_siglist[number] = name; +#endif + sig_table[sig_table_nelts].number = number; + sig_table[sig_table_nelts++].abbrev = abbrev; +} + +static void init_sigs () +{ +#ifdef SYS_SIGLIST_MISSING + /* Initialize signal names. */ + for (i = 0; i < NSIG; i++) + sys_siglist[i] = undoc; +#endif /* SYS_SIGLIST_MISSING */ + + /* Initialize signal names. */ +#if defined (SIGHUP) + init_sig (SIGHUP, "HUP", "Hangup"); +#endif +#if defined (SIGINT) + init_sig (SIGINT, "INT", "Interrupt"); +#endif +#if defined (SIGQUIT) + init_sig (SIGQUIT, "QUIT", "Quit"); +#endif +#if defined (SIGILL) + init_sig (SIGILL, "ILL", "Illegal Instruction"); +#endif +#if defined (SIGTRAP) + init_sig (SIGTRAP, "TRAP", "Trace/breakpoint trap"); +#endif + /* If SIGIOT == SIGABRT, we want to print it as SIGABRT because + SIGABRT is in ANSI and POSIX.1 and SIGIOT isn't. */ +#if defined (SIGABRT) + init_sig (SIGABRT, "ABRT", "Aborted"); +#endif +#if defined (SIGIOT) + init_sig (SIGIOT, "IOT", "IOT trap"); +#endif +#if defined (SIGEMT) + init_sig (SIGEMT, "EMT", "EMT trap"); +#endif +#if defined (SIGFPE) + init_sig (SIGFPE, "FPE", "Floating point exception"); +#endif +#if defined (SIGKILL) + init_sig (SIGKILL, "KILL", "Killed"); +#endif +#if defined (SIGBUS) + init_sig (SIGBUS, "BUS", "Bus error"); +#endif +#if defined (SIGSEGV) + init_sig (SIGSEGV, "SEGV", "Segmentation fault"); +#endif +#if defined (SIGSYS) + init_sig (SIGSYS, "SYS", "Bad system call"); +#endif +#if defined (SIGPIPE) + init_sig (SIGPIPE, "PIPE", "Broken pipe"); +#endif +#if defined (SIGALRM) + init_sig (SIGALRM, "ALRM", "Alarm clock"); +#endif +#if defined (SIGTERM) + init_sig (SIGTERM, "TERM", "Terminated"); +#endif +#if defined (SIGUSR1) + init_sig (SIGUSR1, "USR1", "User defined signal 1"); +#endif +#if defined (SIGUSR2) + init_sig (SIGUSR2, "USR2", "User defined signal 2"); +#endif + /* If SIGCLD == SIGCHLD, we want to print it as SIGCHLD because that + is what is in POSIX.1. */ +#if defined (SIGCHLD) + init_sig (SIGCHLD, "CHLD", "Child exited"); +#endif +#if defined (SIGCLD) + init_sig (SIGCLD, "CLD", "Child exited"); +#endif +#if defined (SIGPWR) + init_sig (SIGPWR, "PWR", "Power failure"); +#endif +#if defined (SIGTSTP) + init_sig (SIGTSTP, "TSTP", "Stopped"); +#endif +#if defined (SIGTTIN) + init_sig (SIGTTIN, "TTIN", "Stopped (tty input)"); +#endif +#if defined (SIGTTOU) + init_sig (SIGTTOU, "TTOU", "Stopped (tty output)"); +#endif +#if defined (SIGSTOP) + init_sig (SIGSTOP, "STOP", "Stopped (signal)"); +#endif +#if defined (SIGXCPU) + init_sig (SIGXCPU, "XCPU", "CPU time limit exceeded"); +#endif +#if defined (SIGXFSZ) + init_sig (SIGXFSZ, "XFSZ", "File size limit exceeded"); +#endif +#if defined (SIGVTALRM) + init_sig (SIGVTALRM, "VTALRM", "Virtual timer expired"); +#endif +#if defined (SIGPROF) + init_sig (SIGPROF, "PROF", "Profiling timer expired"); +#endif +#if defined (SIGWINCH) + /* "Window size changed" might be more accurate, but even if that + is all that it means now, perhaps in the future it will be + extended to cover other kinds of window changes. */ + init_sig (SIGWINCH, "WINCH", "Window changed"); +#endif +#if defined (SIGCONT) + init_sig (SIGCONT, "CONT", "Continued"); +#endif +#if defined (SIGURG) + init_sig (SIGURG, "URG", "Urgent I/O condition"); +#endif +#if defined (SIGIO) + /* "I/O pending" has also been suggested. A disadvantage is + that signal only happens when the process has + asked for it, not everytime I/O is pending. Another disadvantage + is the confusion from giving it a different name than under Unix. */ + init_sig (SIGIO, "IO", "I/O possible"); +#endif +#if defined (SIGWIND) + init_sig (SIGWIND, "WIND", "SIGWIND"); +#endif +#if defined (SIGPHONE) + init_sig (SIGPHONE, "PHONE", "SIGPHONE"); +#endif +#if defined (SIGPOLL) + init_sig (SIGPOLL, "POLL", "I/O possible"); +#endif +#if defined (SIGLOST) + init_sig (SIGLOST, "LOST", "Resource lost"); +#endif +} + +/* Return the abbreviation for signal NUMBER. */ +char * +sig_abbrev (number) + int number; +{ + int i; + + for (i = 0; i < sig_table_nelts; i++) + if (sig_table[i].number == number) + return (char *)sig_table[i].abbrev; + return NULL; +} + +/* Return the signal number for an ABBREV, or -1 if there is no + signal by that name. */ +int +sig_number (abbrev) + CONST char *abbrev; +{ + int i; + + /* Skip over "SIG" if present. */ + if (abbrev[0] == 'S' && abbrev[1] == 'I' && abbrev[2] == 'G') + abbrev += 3; + + for (i = 0; i < sig_table_nelts; i++) + if (abbrev[0] == sig_table[i].abbrev[0] + && strcmp (abbrev, sig_table[i].abbrev) == 0) + return sig_table[i].number; + return -1; +} + +#if defined (SYS_SIGLIST_MISSING) +/* Print to standard error the name of SIGNAL, preceded by MESSAGE and + a colon, and followed by a newline. */ +void +psignal (signal, message) + unsigned signal; + CONST char *message; +{ + if (signal <= 0 || signal >= NSIG) + fprintf (stderr, "%s: unknown signal", message); + else + fprintf (stderr, "%s: %s\n", message, sys_siglist[signal]); +} +#endif + +void +_initialize_signame () +{ + init_sigs (); +} diff --git a/gdb/signame.h b/gdb/signame.h new file mode 100755 index 0000000..83edfa8 --- /dev/null +++ b/gdb/signame.h @@ -0,0 +1,41 @@ +/* Convert between signal names and numbers. + Copyright (C) 1990 Free Software Foundation, Inc. + +This program is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +This program is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with this program; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Names for signals from 0 to NSIG-1. */ +extern char *sys_siglist[]; + +#ifdef __STDC__ +/* Return the abbreviation (e.g. ABRT, FPE, etc.) for signal NUMBER. + Do not return this as a const char *. The caller might want to + assign it to a char *. */ +char *sig_abbrev (int number); + +/* Return the signal number for an ABBREV, or -1 if there is no + signal by that name. */ +int sig_number (const char *abbrev); + +/* Print to standard error the name of SIGNAL, preceded by MESSAGE and + a colon, and followed by a newline. */ +void psignal (unsigned signal, const char *message); + +#else + +char *sig_abbrev (); +int sig_number (); +void psignal (); + +#endif diff --git a/gdb/sparc-opcode.h b/gdb/sparc-opcode.h new file mode 100755 index 0000000..473ab6f --- /dev/null +++ b/gdb/sparc-opcode.h @@ -0,0 +1,641 @@ +/* Table of opcodes for the sparc. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GAS, the GNU Assembler, and GDB, the GNU disassembler. + +GAS/GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GAS/GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GAS or GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#if !defined(__STDC__) && !defined(const) +#define const +#endif + +/* + * Structure of an opcode table entry. + */ +struct sparc_opcode +{ + const char *name; + unsigned long int match; /* Bits that must be set. */ + unsigned long int lose; /* Bits that must not be set. */ + const char *args; + char flags; +}; + +#define F_DELAYED 1 /* Delayed branch */ +#define F_ALIAS 2 /* Alias for a "real" instruction */ + +/* + All sparc opcodes are 32 bits, except for the `set' instruction (really + a macro), which is 64 bits. It is handled as a special case. + + The match component is a mask saying which bits must match a + particular opcode in order for an instruction to be an instance + of that opcode. + + The args component is a string containing one character + for each operand of the instruction. + +Kinds of operands: + # Number used by optimizer. It is ignored. + 1 rs1 register. + 2 rs2 register. + d rd register. + e frs1 floating point register. + f frs2 floating point register. + g frsd floating point register. + b crs1 coprocessor register + c crs2 coprocessor register + D crsd coprocessor register + h 22 high bits. + i 13 bit Immediate. + l 22 bit PC relative immediate. + L 30 bit PC relative immediate. + a Annul. The annul bit is set. + A Alternate address space. Stored as 8 bits. + C Coprocessor state register. + F floating point state register. + p Processor state register. + q Floating point queue. + r Single register that is both rs1 and rsd. + Q Coprocessor queue. + S Special case. + t Trap base register. + w Window invalid mask register. + y Y register. + +*/ + +/* The order of the opcodes in this table is significant: + + * The assembler requires that all instances of the same mnemonic must be + consecutive. If they aren't, the assembler will bomb at runtime. + + * The disassembler should not care about the order of the opcodes. */ + +static struct sparc_opcode sparc_opcodes[] = +{ + +{ "ldd", 0xc1980000, 0x0060201f, "[1],D", 0 }, /* ldd [rs1+%g0],d */ +{ "ldd", 0xc1982000, 0x00601fff, "[1],D", 0 }, /* ldd [rs1+0],d */ +{ "ldd", 0xc1982000, 0x00600000, "[1+i],D", 0 }, +{ "ldd", 0xc1982000, 0x00600000, "[i+1],D", 0 }, +{ "ldd", 0xc1980000, 0x00602000, "[1+2],D", 0 }, +{ "ldd", 0xc1180000, 0x00e0201f, "[1],g", 0 }, /* ldd [rs1+%g0],d */ +{ "ldd", 0xc1182000, 0x00e01fff, "[1],g", 0 }, /* ldd [rs1+0],d */ +{ "ldd", 0xc1182000, 0x00e00000, "[1+i],g", 0 }, +{ "ldd", 0xc1182000, 0x00e00000, "[i+1],g", 0 }, +{ "ldd", 0xc1180000, 0x00e02000, "[1+2],g", 0 }, +{ "ldd", 0xc0180000, 0x01e0201f, "[1],d", 0 }, /* ldd [rs1+%g0],d */ +{ "ldd", 0xc0182000, 0x01e01fff, "[1],d", 0 }, /* ldd [rs1+0],d */ +{ "ldd", 0xc0182000, 0x01e00000, "[1+i],d", 0 }, +{ "ldd", 0xc0182000, 0x01e00000, "[i+1],d", 0 }, +{ "ldd", 0xc0180000, 0x01e02000, "[1+2],d", 0 }, +{ "ld", 0xc1880000, 0x0070201f, "[1],C", 0 }, /* ld [rs1+%g0],d */ +{ "ld", 0xc1882000, 0x00701fff, "[1],C", 0 }, /* ld [rs1+0],d */ +{ "ld", 0xc1882000, 0x00700000, "[1+i],C", 0 }, +{ "ld", 0xc1882000, 0x00700000, "[i+1],C", 0 }, +{ "ld", 0xc1880000, 0x00702000, "[1+2],C", 0 }, +{ "ld", 0xc1800000, 0x0078201f, "[1],D", 0 }, /* ld [rs1+%g0],d */ +{ "ld", 0xc1802000, 0x00781fff, "[1],D", 0 }, /* ld [rs1+0],d */ +{ "ld", 0xc1802000, 0x00780000, "[1+i],D", 0 }, +{ "ld", 0xc1802000, 0x00780000, "[i+1],D", 0 }, +{ "ld", 0xc1800000, 0x00782000, "[1+2],D", 0 }, +{ "ld", 0xc1080000, 0x00f0201f, "[1],F", 0 }, /* ld [rs1+%g0],d */ +{ "ld", 0xc1082000, 0x00f01fff, "[1],F", 0 }, /* ld [rs1+0],d */ +{ "ld", 0xc1082000, 0x00f00000, "[1+i],F", 0 }, +{ "ld", 0xc1082000, 0x00f00000, "[i+1],F", 0 }, +{ "ld", 0xc1080000, 0x00f02000, "[1+2],F", 0 }, +{ "ld", 0xc1000000, 0x00f8201f, "[1],g", 0 }, /* ld [rs1+%g0],d */ +{ "ld", 0xc1002000, 0x00f81fff, "[1],g", 0 }, /* ld [rs1+0],d */ +{ "ld", 0xc1002000, 0x00f80000, "[1+i],g", 0 }, +{ "ld", 0xc1002000, 0x00f80000, "[i+1],g", 0 }, +{ "ld", 0xc1000000, 0x00f82000, "[1+2],g", 0 }, +{ "ld", 0xc0000000, 0x01f8201f, "[1],d", 0 }, /* ld [rs1+%g0],d */ +{ "ld", 0xc0002000, 0x01f81fff, "[1],d", 0 }, /* ld [rs1+0],d */ +{ "ld", 0xc0002000, 0x01f80000, "[1+i],d", 0 }, +{ "ld", 0xc0002000, 0x01f80000, "[i+1],d", 0 }, +{ "ld", 0xc0000000, 0x01f82000, "[1+2],d", 0 }, +{ "ldstuba", 0xc0d80000, 0x0100201f, "[1]A,d", 0 }, /* ldstuba [rs1+%g0],d */ +{ "ldstuba", 0xc0d80000, 0x01002000, "[1+2]A,d", 0 }, +{ "ldsha", 0xc0d00000, 0x0128201f, "[1]A,d", 0 }, /* ldsha [rs1+%g0],d */ +{ "ldsha", 0xc0d00000, 0x01282000, "[1+2]A,d", 0 }, +{ "ldsba", 0xc0c80000, 0x0130201f, "[1]A,d", 0 }, /* ldsba [rs1+%g0],d */ +{ "ldsba", 0xc0c80000, 0x01302000, "[1+2]A,d", 0 }, +{ "ldda", 0xc0980000, 0x0160201f, "[1]A,d", 0 }, /* ldda [rs1+%g0],d */ +{ "ldda", 0xc0980000, 0x01602000, "[1+2]A,d", 0 }, +{ "lduha", 0xc0900000, 0x0168201f, "[1]A,d", 0 }, /* lduha [rs1+%g0],d */ +{ "lduha", 0xc0900000, 0x01682000, "[1+2]A,d", 0 }, +{ "ldstub", 0xc0680000, 0x0190201f, "[1],d", 0 }, /* ldstub [rs1+%g0],d */ +{ "ldstub", 0xc0682000, 0x01900000, "[1+i],d", 0 }, +{ "ldstub", 0xc0682000, 0x01900000, "[i+1],d", 0 }, +{ "ldstub", 0xc0680000, 0x01902000, "[1+2],d", 0 }, +{ "lda", 0xc0800000, 0x0178201f, "[1]A,d", 0 }, /* lda [rs1+%g0],d */ +{ "lda", 0xc0800000, 0x01782000, "[1+2]A,d", 0 }, +{ "ldsh", 0xc0500000, 0x0000000d, "[1],d", 0 }, /* ldsh [rs1+%g0],d */ +{ "ldsh", 0xc0502000, 0x01a81fff, "[1],d", 0 }, /* ldsh [rs1+0],d */ +{ "ldsh", 0xc0502000, 0x01a80000, "[1+i],d", 0 }, +{ "ldsh", 0xc0502000, 0x01a80000, "[i+1],d", 0 }, +{ "ldsh", 0xc0500000, 0x01a82000, "[1+2],d", 0 }, +{ "ldsb", 0xc0480000, 0x01b0201f, "[1],d", 0 }, /* ldsb [rs1+%g0],d */ +{ "ldsb", 0xc0482000, 0x01b01fff, "[1],d", 0 }, /* ldsb [rs1+0],d */ +{ "ldsb", 0xc0482000, 0x01b00000, "[1+i],d", 0 }, +{ "ldsb", 0xc0482000, 0x01b00000, "[i+1],d", 0 }, +{ "ldsb", 0xc0480000, 0x01b02000, "[1+2],d", 0 }, +{ "ldub", 0xc0080000, 0x01f0201f, "[1],d", 0 }, /* ldub [rs1+%g0],d */ +{ "ldub", 0xc0082000, 0x01f01fff, "[1],d", 0 }, /* ldub [rs1+0],d */ +{ "ldub", 0xc0082000, 0x01f00000, "[1+i],d", 0 }, +{ "ldub", 0xc0082000, 0x01f00000, "[i+1],d", 0 }, +{ "ldub", 0xc0080000, 0x01f02000, "[1+2],d", 0 }, +{ "lduba", 0xc0880000, 0x0170201f, "[1]A,d", 0 }, /* lduba [rs1+%g0],d */ +{ "lduba", 0xc0880000, 0x01702000, "[1+2]A,d", 0 }, +{ "lduh", 0xc0102000, 0x01e80000, "[1+i],d", 0 }, +{ "lduh", 0xc0102000, 0x01e80000, "[i+1],d", 0 }, +{ "lduh", 0xc0100000, 0x01e8201f, "[1],d", 0 }, /* lduh [rs1+%g0],d */ +{ "lduh", 0xc0102000, 0x01e81fff, "[1],d", 0 }, /* lduh [rs1+0],d */ +{ "lduh", 0xc0100000, 0x01e82000, "[1+2],d", 0 }, + +{ "st", 0xc0200000, 0x01d8201f, "d,[1]", 0 }, /* st d,[rs1+%g0] */ +{ "st", 0xc0202000, 0x01d81fff, "d,[1]", 0 }, /* st d,[rs1+0] */ +{ "st", 0xc0202000, 0x01d80000, "d,[1+i]", 0 }, +{ "st", 0xc0202000, 0x01d80000, "d,[i+1]", 0 }, +{ "st", 0xc0200000, 0x01d82000, "d,[1+2]", 0 }, +{ "st", 0xc1200000, 0x00d8201f, "g,[1]", 0 }, /* st d[rs1+%g0] */ +{ "st", 0xc1202000, 0x00d81fff, "g,[1]", 0 }, /* st d,[rs1+0] */ +{ "st", 0xc1202000, 0x00d80000, "g,[1+i]", 0 }, +{ "st", 0xc1202000, 0x00d80000, "g,[i+1]", 0 }, +{ "st", 0xc1200000, 0x00d82000, "g,[1+2]", 0 }, +{ "st", 0xc1280000, 0x00d0201f, "F,[1]", 0 }, /* st %fsr,[rs1+%g0] */ +{ "st", 0xc1282000, 0x00d01fff, "F,[1]", 0 }, /* st %fsr,[rs1+0] */ +{ "st", 0xc1282000, 0x00d00000, "F,[1+i]", 0 }, +{ "st", 0xc1282000, 0x00d00000, "F,[i+1]", 0 }, +{ "st", 0xc1280000, 0x00d02000, "F,[1+2]", 0 }, +{ "st", 0xc1a00000, 0x0058201f, "D,[1]", 0 }, /* st d,[rs1+%g0] */ +{ "st", 0xc1a02000, 0x00581fff, "D,[1]", 0 }, /* st d,[rs1+0] */ +{ "st", 0xc1a02000, 0x00580000, "D,[1+i]", 0 }, +{ "st", 0xc1a02000, 0x00580000, "D,[i+1]", 0 }, +{ "st", 0xc1a00000, 0x00582000, "D,[1+2]", 0 }, +{ "st", 0xc1a80000, 0x0050201f, "C,[1]", 0 }, /* st d,[rs1+%g0] */ +{ "st", 0xc1a82000, 0x00501fff, "C,[1]", 0 }, /* st d,[rs1+0] */ +{ "st", 0xc1a82000, 0x00500000, "C,[1+i]", 0 }, +{ "st", 0xc1a82000, 0x00500000, "C,[i+1]", 0 }, +{ "st", 0xc1a80000, 0x00502000, "C,[1+2]", 0 }, +{ "sta", 0xc0a00000, 0x0108201f, "d,[1]A", 0 }, /* sta d,[rs1+%g0] */ +{ "sta", 0xc0a00000, 0x01082000, "d,[1+2]A", 0 }, + +{ "stb", 0xc0280000, 0x01d0201f, "d,[1]", 0 }, /* stb d,[rs1+%g0] */ +{ "stb", 0xc0282000, 0x01d01fff, "d,[1]", 0 }, /* stb d,[rs1+0] */ +{ "stb", 0xc0282000, 0x01d00000, "d,[1+i]", 0 }, +{ "stb", 0xc0282000, 0x01d00000, "d,[i+1]", 0 }, +{ "stb", 0xc0280000, 0x01d02000, "d,[1+2]", 0 }, +{ "stba", 0xc0a80000, 0x01002000, "d,[1+2]A", 0 }, +{ "stba", 0xc0a80000, 0x0100201f, "d,[1]A", 0 }, /* stba d,[rs1+%g0] */ + +{ "std", 0xc0380000, 0x01c0201f, "d,[1]", 0 }, /* std d,[rs1+%g0] */ +{ "std", 0xc0382000, 0x01c01fff, "d,[1]", 0 }, /* std d,[rs1+0] */ +{ "std", 0xc0382000, 0x01c00000, "d,[1+i]", 0 }, +{ "std", 0xc0382000, 0x01c00000, "d,[i+1]", 0 }, +{ "std", 0xc0380000, 0x01c02000, "d,[1+2]", 0 }, +{ "std", 0xc1380000, 0x00c0201f, "g,[1]", 0 }, /* std d,[rs1+%g0] */ +{ "std", 0xc1382000, 0x00c01fff, "g,[1]", 0 }, /* std d,[rs1+0] */ +{ "std", 0xc1382000, 0x00c00000, "g,[1+i]", 0 }, +{ "std", 0xc1382000, 0x00c00000, "g,[i+1]", 0 }, +{ "std", 0xc1380000, 0x00c02000, "g,[1+2]", 0 }, +{ "std", 0xc1300000, 0x00c8201f, "q,[1]", 0 }, /* std d,[rs1+%g0] */ +{ "std", 0xc1302000, 0x00c81fff, "q,[1]", 0 }, /* std d,[rs1+0] */ +{ "std", 0xc1302000, 0x00c80000, "q,[1+i]", 0 }, +{ "std", 0xc1302000, 0x00c80000, "q,[i+1]", 0 }, +{ "std", 0xc1300000, 0x00c82000, "q,[1+2]", 0 }, +{ "std", 0xc1b80000, 0x0040201f, "D,[1]", 0 }, /* std d,[rs1+%g0] */ +{ "std", 0xc1b82000, 0x00401fff, "D,[1]", 0 }, /* std d,[rs1+0] */ +{ "std", 0xc1b82000, 0x00400000, "D,[1+i]", 0 }, +{ "std", 0xc1b82000, 0x00400000, "D,[i+1]", 0 }, +{ "std", 0xc1b80000, 0x00402000, "D,[1+2]", 0 }, +{ "std", 0xc1b00000, 0x0048201f, "Q,[1]", 0 }, /* std d,[rs1+%g0] */ +{ "std", 0xc1b02000, 0x00481fff, "Q,[1]", 0 }, /* std d,[rs1+0] */ +{ "std", 0xc1b02000, 0x00480000, "Q,[1+i]", 0 }, +{ "std", 0xc1b02000, 0x00480000, "Q,[i+1]", 0 }, +{ "std", 0xc1b00000, 0x00482000, "Q,[1+2]", 0 }, +{ "stda", 0xc0b80000, 0x01402000, "d,[1+2]A", 0 }, +{ "stda", 0xc0b80000, 0x0140201f, "d,[1]A", 0 }, /* stda d,[rs1+%g0] */ + +{ "sth", 0xc0300000, 0x01c8201f, "d,[1]", 0 }, /* sth d,[rs1+%g0] */ +{ "sth", 0xc0302000, 0x01c81fff, "d,[1]", 0 }, /* sth d,[rs1+0] */ +{ "sth", 0xc0300000, 0x01c82000, "d,[1+2]", 0 }, +{ "sth", 0xc0302000, 0x01c80000, "d,[1+i]", 0 }, +{ "sth", 0xc0302000, 0x01c80000, "d,[i+1]", 0 }, +{ "stha", 0xc0b00000, 0x0148201f, "d,[1]A", 0 }, /* stha d,[rs1+%g0] */ +{ "stha", 0xc0b00000, 0x01482000, "d,[1+2]A", 0 }, + +{ "swap", 0xc0780000, 0x0180201f, "[1],d", 0 }, /* swap [rs1+%g0],d */ +{ "swap", 0xc0782000, 0x01801fff, "[1],d", 0 }, /* swap [rs1+0],d */ +{ "swap", 0xc0782000, 0x01800000, "[1+i],d", 0 }, +{ "swap", 0xc0782000, 0x01800000, "[i+1],d", 0 }, +{ "swap", 0xc0780000, 0x01802000, "[1+2],d", 0 }, +{ "swapa", 0xc0f80000, 0x01002000, "[1+2]A,d", 0 }, +{ "swapa", 0xc0f80000, 0x0100201f, "[1]A,d", 0 }, /* swapa [rs1+%g0],d */ + +{ "restore", 0x81e80000, 0x7e17e01f, "", 0 }, /* restore %g0,%g0,%g0 */ +{ "restore", 0x81e82000, 0x7e14dfff, "", 0 }, /* restore %g0,0,%g0 */ +{ "restore", 0x81e82000, 0x00000000, "1,i,d", 0 }, +{ "restore", 0x81e80000, 0x00000000, "1,2,d", 0 }, +{ "rett", 0x81c82000, 0x40300000, "1+i", F_DELAYED }, +{ "rett", 0x81c82000, 0x40300000, "i+1", F_DELAYED }, +{ "rett", 0x81c80000, 0x40302000, "1+2", F_DELAYED }, +{ "rett", 0x81c82000, 0x40301fff, "1", F_DELAYED}, /* rett X,0 */ +{ "rett", 0x81c80000, 0x4030201f, "1", F_DELAYED}, /* rett X,%g0 */ +{ "save", 0x81e02000, 0x40180000, "1,i,d", 0 }, +{ "save", 0x81e00000, 0x40180000, "1,2,d", 0 }, + +{ "ret", 0x81c7e008, 0x00001ff7, "", F_DELAYED }, /* jmpl %i7+8,%g0 */ +{ "retl", 0x81c3e008, 0x00001ff7, "", F_DELAYED }, /* jmpl %o7+8,%g0 */ + +{ "jmpl", 0x81c00000, 0x4038201f, "1,d", F_DELAYED }, /* jmpl rs1+%g0,d */ +{ "jmpl", 0x81c02000, 0x4037c000, "i,d", F_DELAYED }, /* jmpl %g0+i,d */ +{ "jmpl", 0x81c02000, 0x40380000, "1+i,d", F_DELAYED }, +{ "jmpl", 0x81c02000, 0x40380000, "i+1,d", F_DELAYED }, +{ "jmpl", 0x81c00000, 0x40382000, "1+2,d", F_DELAYED }, +{ "wr", 0x81982000, 0x40600000, "1,i,t", 0 }, +{ "wr", 0x81980000, 0x40600000, "1,2,t", 0 }, +{ "wr", 0x81902000, 0x40680000, "1,i,w", 0 }, +{ "wr", 0x81900000, 0x40680000, "1,2,w", 0 }, +{ "wr", 0x81882000, 0x40700000, "1,i,p", 0 }, +{ "wr", 0x81880000, 0x40700000, "1,2,p", 0 }, +{ "wr", 0x81802000, 0x40780000, "1,i,y", 0 }, +{ "wr", 0x81800000, 0x40780000, "1,2,y", 0 }, + +{ "rd", 0x81580000, 0x40a00000, "t,d", 0 }, +{ "rd", 0x81500000, 0x40a80000, "w,d", 0 }, +{ "rd", 0x81480000, 0x40b00000, "p,d", 0 }, +{ "rd", 0x81400000, 0x40b80000, "y,d", 0 }, + +{ "sra", 0x81382000, 0x00000000, "1,i,d", 0 }, +{ "sra", 0x81380000, 0x00000000, "1,2,d", 0 }, +{ "srl", 0x81302000, 0x40c80000, "1,i,d", 0 }, +{ "srl", 0x81300000, 0x40c80000, "1,2,d", 0 }, +{ "sll", 0x81282000, 0x40d00000, "1,i,d", 0 }, +{ "sll", 0x81280000, 0x40d00000, "1,2,d", 0 }, + +{ "mulscc", 0x81202000, 0x40d80000, "1,i,d", 0 }, +{ "mulscc", 0x81200000, 0x40d80000, "1,2,d", 0 }, + +{ "clr", 0x80100000, 0x4e87e01f, "d", F_ALIAS }, /* or %g0,%g0,d */ +{ "clr", 0x80102000, 0x41efdfff, "d", F_ALIAS }, /* or %g0,0,d */ +{ "clr", 0xc0200000, 0x3fd8001f, "[1]", F_ALIAS }, /* st %g0,[rs1+%g0] */ +{ "clr", 0xc0202000, 0x3fd81fff, "[1]", F_ALIAS }, /* st %g0,[rs1+0] */ +{ "clr", 0xc0202000, 0x3fd80000, "[1+i]", F_ALIAS }, +{ "clr", 0xc0202000, 0x3fd80000, "[i+1]", F_ALIAS }, +{ "clr", 0xc0200000, 0x3fd80000, "[1+2]", F_ALIAS }, + +{ "clrb", 0xc0280000, 0x3fd0001f, "[1]", F_ALIAS },/* stb %g0,[rs1+%g0] */ +{ "clrb", 0xc0282000, 0x3fd00000, "[1+i]", F_ALIAS }, +{ "clrb", 0xc0282000, 0x3fd00000, "[i+1]", F_ALIAS }, +{ "clrb", 0xc0280000, 0x3fd00000, "[1+2]", F_ALIAS }, + +{ "clrh", 0xc0300000, 0x3fc8001f, "[1]", F_ALIAS },/* sth %g0,[rs1+%g0] */ +{ "clrh", 0xc0300000, 0x3fc80000, "[1+2]", F_ALIAS }, +{ "clrh", 0xc0302000, 0x3fc80000, "[1+i]", F_ALIAS }, +{ "clrh", 0xc0302000, 0x3fc80000, "[i+1]", F_ALIAS }, + +{ "orncc", 0x80b02000, 0x04048000, "1,i,d", 0 }, +{ "orncc", 0x80b00000, 0x04048000, "1,2,d", 0 }, + +{ "tst", 0x80900000, 0x7f6fe000, "2", 0 }, /* orcc %g0, rs2, %g0 */ +{ "tst", 0x80900000, 0x7f68201f, "1", 0 }, /* orcc rs1, %g0, %g0 */ +{ "tst", 0x80902000, 0x7f681fff, "1", 0 }, /* orcc rs1, 0, %g0 */ + +{ "orcc", 0x80902000, 0x41680000, "1,i,d", 0 }, +{ "orcc", 0x80902000, 0x41680000, "i,1,d", 0 }, +{ "orcc", 0x80900000, 0x41680000, "1,2,d", 0 }, +{ "orn", 0x80302000, 0x41c80000, "1,i,d", 0 }, +{ "orn", 0x80300000, 0x41c80000, "1,2,d", 0 }, + +{ "mov", 0x81800000, 0x4078201f, "1,y", F_ALIAS }, /* wr rs1,%g0,%y */ +{ "mov", 0x81802000, 0x40781fff, "1,y", F_ALIAS }, /* wr rs1,0,%y */ +{ "mov", 0x81802000, 0x40780000, "i,y", F_ALIAS }, +{ "mov", 0x81400000, 0x40b80000, "y,d", F_ALIAS }, /* rd %y,d */ +{ "mov", 0x81980000, 0x4060201f, "1,t", F_ALIAS }, /* wr rs1,%g0,%tbr */ +{ "mov", 0x81982000, 0x40601fff, "1,t", F_ALIAS }, /* wr rs1,0,%tbr */ +{ "mov", 0x81982000, 0x40600000, "i,t", F_ALIAS }, +{ "mov", 0x81580000, 0x40a00000, "t,d", F_ALIAS }, /* rd %tbr,d */ +{ "mov", 0x81900000, 0x4068201f, "1,w", F_ALIAS }, /* wr rs1,%g0,%wim */ +{ "mov", 0x81902000, 0x40681fff, "1,w", F_ALIAS }, /* wr rs1,0,%wim */ +{ "mov", 0x81902000, 0x40680000, "i,w", F_ALIAS }, +{ "mov", 0x81500000, 0x40a80000, "w,d", F_ALIAS }, /* rd %wim,d */ +{ "mov", 0x81880000, 0x4070201f, "1,p", F_ALIAS }, /* wr rs1,%g0,%psr */ +{ "mov", 0x81882000, 0x40701fff, "1,p", F_ALIAS }, /* wr rs1,0,%psr */ +{ "mov", 0x81882000, 0x40700000, "i,p", F_ALIAS }, +{ "mov", 0x81480000, 0x40b00000, "p,d", F_ALIAS }, /* rd %psr,d */ + +{ "mov", 0x80102000, 0x41efc000, "i,d", 0 }, /* or %g0,i,d */ +{ "mov", 0x80100000, 0x41efe000, "2,d", 0 }, /* or %g0,rs2,d */ +{ "mov", 0x80102000, 0x41e81fff, "1,d", 0 }, /* or rs1,0,d */ +{ "mov", 0x80100000, 0x41e8201f, "1,d", 0 }, /* or rs1,%g0,d */ + +{ "or", 0x80102000, 0x40800000, "1,i,d", 0 }, +{ "or", 0x80102000, 0x40800000, "i,1,d", 0 }, +{ "or", 0x80100000, 0x40800000, "1,2,d", 0 }, + +{ "bset", 0x80102000, 0x40800000, "i,r", F_ALIAS },/* or rd,i,rd */ +{ "bset", 0x80100000, 0x40800000, "2,r", F_ALIAS },/* or rd,rs2,rd */ + +{ "andncc", 0x80a82000, 0x41500000, "1,i,d", 0 }, +{ "andncc", 0x80a80000, 0x41500000, "1,2,d", 0 }, +{ "andn", 0x80282000, 0x41d00000, "1,i,d", 0 }, +{ "andn", 0x80280000, 0x41d00000, "1,2,d", 0 }, + +{ "bclr", 0x80282000, 0x41d00000, "i,r", F_ALIAS },/* andn rd,i,rd */ +{ "bclr", 0x80280000, 0x41d00000, "2,r", F_ALIAS },/* andn rd,rs2,rd */ + +{ "cmp", 0x80a02000, 0x7d580000, "1,i", 0 }, /* subcc rs1,i,%g0 */ +{ "cmp", 0x80a00000, 0x7d580000, "1,2", 0 }, /* subcc rs1,rs2,%g0 */ + +{ "subcc", 0x80a02000, 0x41580000, "1,i,d", 0 }, +{ "subcc", 0x80a00000, 0x41580000, "1,2,d", 0 }, +{ "sub", 0x80202000, 0x41d80000, "1,i,d", 0 }, +{ "sub", 0x80200000, 0x41d80000, "1,2,d", 0 }, +{ "subx", 0x80602000, 0x41980000, "1,i,d", 0 }, +{ "subx", 0x80600000, 0x41980000, "1,2,d", 0 }, +{ "subxcc", 0x80e02000, 0x41180000, "1,i,d", 0 }, +{ "subxcc", 0x80e00000, 0x41180000, "1,2,d", 0 }, + +{ "andcc", 0x80882000, 0x41700000, "1,i,d", 0 }, +{ "andcc", 0x80882000, 0x41700000, "i,1,d", 0 }, +{ "andcc", 0x80880000, 0x41700000, "1,2,d", 0 }, +{ "and", 0x80082000, 0x41f00000, "1,i,d", 0 }, +{ "and", 0x80082000, 0x41f00000, "i,1,d", 0 }, +{ "and", 0x80080000, 0x41f00000, "1,2,d", 0 }, + +{ "inc", 0x80002001, 0x41f81ffe, "r", F_ALIAS }, /* add rs1,1,rsd */ +{ "inccc", 0x80802001, 0x41781ffe, "r", F_ALIAS }, /* addcc rd,1,rd */ +{ "dec", 0x80202001, 0x41d81ffe, "r", F_ALIAS }, /* sub rd,1,rd */ +{ "deccc", 0x80a02001, 0x41581ffe, "r", F_ALIAS }, /* subcc rd,1,rd */ + +{ "btst", 0x80882000, 0x41700000, "i,1", F_ALIAS },/* andcc rs1,i,%g0 */ +{ "btst", 0x80880000, 0x41700000, "1,2", F_ALIAS },/* andcc rs1,rs2,%0 */ + +{ "neg", 0x80200000, 0x41d80000, "r", F_ALIAS }, /* sub %0,rd,rd */ +{ "neg", 0x80200000, 0x41d80000, "2,d", F_ALIAS }, /* sub %0,rs2,rd */ + +{ "addxcc", 0x80c02000, 0x41380000, "1,i,d", 0 }, +{ "addxcc", 0x80c02000, 0x41380000, "i,1,d", 0 }, +{ "addxcc", 0x80c00000, 0x41380000, "1,2,d", 0 }, +{ "addcc", 0x80802000, 0x41780000, "1,i,d", 0 }, +{ "addcc", 0x80802000, 0x41780000, "i,1,d", 0 }, +{ "addcc", 0x80800000, 0x41780000, "1,2,d", 0 }, +{ "addx", 0x80402000, 0x41b80000, "1,i,d", 0 }, +{ "addx", 0x80402000, 0x41b80000, "i,1,d", 0 }, +{ "addx", 0x80400000, 0x41b80000, "1,2,d", 0 }, +{ "add", 0x80002000, 0x41f80000, "1,i,d", 0 }, +{ "add", 0x80002000, 0x41f80000, "i,1,d", 0 }, +{ "add", 0x80000000, 0x41f80000, "1,2,d", 0 }, + +{ "call", 0x9fc00000, 0x4038201f, "1", F_DELAYED }, /* jmpl rs1+%g0, %o7 */ +{ "call", 0x9fc00000, 0x4038201f, "1,#", F_DELAYED }, +{ "call", 0x40000000, 0x80000000, "L", F_DELAYED }, +{ "call", 0x40000000, 0x80000000, "L,#", F_DELAYED }, + +{ "jmp", 0x81c00000, 0x7e38201f, "1", F_DELAYED }, /* jmpl rs1+%g0,%g0 */ +{ "jmp", 0x81c02000, 0x7e3fc000, "i", F_DELAYED }, /* jmpl %g0+i,%g0 */ +{ "jmp", 0x81c00000, 0x7e382000, "1+2", F_DELAYED }, /* jmpl rs1+rs2,%g0 */ +{ "jmp", 0x81c02000, 0x7e380000, "1+i", F_DELAYED }, /* jmpl rs1+i,%g0 */ +{ "jmp", 0x81c02000, 0x7e380000, "i+1", F_DELAYED }, /* jmpl i+rs1,%g0 */ + +{ "nop", 0x01000000, 0xfeffffff, "", 0 }, /* sethi 0, %g0 */ + +{ "set", 0x01000000, 0xc0c00000, "Sh,d", F_ALIAS }, + +{ "sethi", 0x01000000, 0xc0c00000, "h,d", 0 }, + +{ "taddcctv", 0x81102000, 0x40e00000, "1,i,d", 0 }, +{ "taddcctv", 0x81100000, 0x40e00000, "1,2,d", 0 }, +{ "taddcc", 0x81002000, 0x40f80000, "1,i,d", 0 }, +{ "taddcc", 0x81000000, 0x40f80000, "1,2,d", 0 }, + +/* Conditional instructions. + + Because this part of the table was such a mess earlier, I have + macrofied it so that all the branches and traps are generated from + a single-line description of each condition value. */ + +#define ANNUL 0x20000000 +#define IMMED 0x00002000 +#define RS1_G0 0x0007C000 +#define RS2_G0 0x0000001F + +/* Define two branches -- one annulled, one without */ +#define br(opcode, mask, lose, flags) \ + { opcode, mask+ANNUL, lose, ",al", flags }, \ + { opcode, mask , lose, "l", flags } + +/* Define four traps: reg+reg, reg + immediate, immediate alone, reg alone. */ +#define tr(opcode, mask, lose, flags) \ + {opcode, mask+IMMED, lose+RS1_G0 , "i", flags }, /* %g0 + imm */ \ + {opcode, mask+IMMED, lose , "1+i", flags }, /* rs1 + imm */ \ + {opcode, mask , lose+IMMED , "1+2", flags }, /* rs1 + rs2 */ \ + {opcode, mask , lose+IMMED+RS2_G0, "1", flags } /* rs1 + %g0 */ + +/* Define both branches and traps based on condition mask */ +#ifdef __STDC__ +#define cond(bop, top, mask, flags) \ + br(#bop, 0x00800000+(mask << 25), 0xC1400000, F_DELAYED|flags), \ + tr(#top, 0x81d00000+(mask << 25), 0x40280000, flags) +#else +#define cond(bop, top, mask, flags) \ + br("bop", 0x00800000+(mask << 25), 0xC1400000, F_DELAYED|flags), \ + tr("top", 0x81d00000+(mask << 25), 0x40280000, flags) +#endif + +/* Define all the conditions, all the branches, all the traps. */ +cond (bvc, tvc, 0xF, 0), +cond (bvs, tvs, 0x7, 0), +cond (bpos, tpos, 0xE, 0), +cond (bneg, tneg, 0x6, 0), +cond (bcc, tcc, 0xD, 0), +cond (bcs, tcs, 0x5, 0), +cond (blu, tlu, 0x5, F_ALIAS), /* for cs */ +cond (bgeu, tgeu, 0xD, F_ALIAS), /* for cc */ +cond (bgu, tgu, 0xC, 0), +cond (bleu, tleu, 0x4, 0), +cond (bge, tge, 0xB, 0), +cond (bl, tl, 0x3, 0), +cond (bg, tg, 0xA, 0), +cond (ble, tle, 0x2, 0), +cond (be, te, 0x1, 0), +cond (bz, tz, 0x1, F_ALIAS), /* for e */ +cond (bne, tne, 0x9, 0), +cond (bnz, tnz, 0x9, F_ALIAS), /* for ne */ +cond (b, t, 0x8, 0), +cond (ba, ta, 0x8, F_ALIAS), /* for nothing */ +cond (bn, tn, 0x0, 0), + +#undef cond +#undef br +#undef tr + +{ "tsubcc", 0x81080000, 0x40f00000, "1,2,d", 0 }, +{ "tsubcc", 0x81082000, 0x40f00000, "1,i,d", 0 }, +{ "tsubcctv", 0x80580000, 0x40a00000, "1,2,d", 0 }, +{ "tsubcctv", 0x80582000, 0x40a00000, "1,i,d", 0 }, + +{ "unimp", 0x00000000, 0xFFFFFFFF, "l", 0 }, + +{ "iflush", 0x81d80000, 0x40202000, "1+2", 0 }, +{ "iflush", 0x81d82000, 0x40200000, "1+i", 0 }, + +{ "xnorcc", 0x80b80000, 0x41400000, "1,2,d", 0 }, +{ "xnorcc", 0x80b82000, 0x41400000, "1,i,d", 0 }, +{ "xnorcc", 0x80b82000, 0x41400000, "i,1,d", 0 }, +{ "xorcc", 0x80980000, 0x41600000, "1,2,d", 0 }, +{ "xorcc", 0x80982000, 0x41600000, "1,i,d", 0 }, +{ "xorcc", 0x80982000, 0x41600000, "i,1,d", 0 }, +{ "xnor", 0x80380000, 0x41c00000, "1,2,d", 0 }, +{ "xnor", 0x80382000, 0x41c00000, "1,i,d", 0 }, +{ "xnor", 0x80382000, 0x41c00000, "i,1,d", 0 }, +{ "xor", 0x80180000, 0x41e00000, "1,2,d", 0 }, +{ "xor", 0x80182000, 0x41e00000, "1,i,d", 0 }, +{ "xor", 0x80182000, 0x41e00000, "i,1,d", 0 }, + +{ "not", 0x80380000, 0x41c00000, "r", F_ALIAS }, /* xnor rd,%0,rd */ +{ "not", 0x80380000, 0x41c00000, "1,d", F_ALIAS }, /* xnor rs1,%0,rd */ + +{ "btog", 0x80180000, 0x41e02000, "2,r", F_ALIAS }, /* xor rd,rs2,rd */ +{ "btog", 0x80182000, 0x41e00000, "i,r", F_ALIAS }, /* xor rd,i,rd */ + +{ "fpop1", 0x81a00000, 0x40580000, "[1+2],d", 0 }, +{ "fpop2", 0x81a80000, 0x40500000, "[1+2],d", 0 }, + +/* Someday somebody should give these the same treatment as the branches + above. FIXME someday. */ + +{ "fb", 0x31800000, 0xc0400000, ",al", F_DELAYED }, +{ "fb", 0x11800000, 0xc0400000, "l", F_DELAYED }, +{ "fba", 0x31800000, 0xc0400000, ",al", F_DELAYED|F_ALIAS }, +{ "fba", 0x11800000, 0xc0400000, "l", F_DELAYED|F_ALIAS }, +{ "fbn", 0x21800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbn", 0x01800000, 0xc0400000, "l", F_DELAYED }, +{ "fbu", 0x2f800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbu", 0x0f800000, 0xc0400000, "l", F_DELAYED }, +{ "fbg", 0x2d800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbg", 0x0d800000, 0xc0400000, "l", F_DELAYED }, +{ "fbug", 0x2b800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbug", 0x0b800000, 0xc0400000, "l", F_DELAYED }, +{ "fbl", 0x29800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbl", 0x09800000, 0xc0400000, "l", F_DELAYED }, +{ "fbul", 0x27800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbul", 0x07800000, 0xc0400000, "l", F_DELAYED }, +{ "fblg", 0x25800000, 0xc0400000, ",al", F_DELAYED }, +{ "fblg", 0x05800000, 0xc0400000, "l", F_DELAYED }, +{ "fbne", 0x23800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbne", 0x03800000, 0xc0400000, "l", F_DELAYED }, +{ "fbe", 0x33800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbe", 0x13800000, 0xc0400000, "l", F_DELAYED }, +{ "fbue", 0x35800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbue", 0x15800000, 0xc0400000, "l", F_DELAYED }, +{ "fbge", 0x37800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbge", 0x17800000, 0xc0400000, "l", F_DELAYED }, +{ "fbuge", 0x39800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbuge", 0x19800000, 0xc0400000, "l", F_DELAYED }, +{ "fble", 0x3b800000, 0xc0400000, ",al", F_DELAYED }, +{ "fble", 0x1b800000, 0xc0400000, "l", F_DELAYED }, +{ "fbule", 0x3d800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbule", 0x1d800000, 0xc0400000, "l", F_DELAYED }, +{ "fbo", 0x3f800000, 0xc0400000, ",al", F_DELAYED }, +{ "fbo", 0x1f800000, 0xc0400000, "l", F_DELAYED }, + +{ "cba", 0x31c00000, 0xce000000, ",al", F_DELAYED }, +{ "cba", 0x11c00000, 0xce000000, "l", F_DELAYED }, +{ "cbn", 0x21c00000, 0xde000000, ",al", F_DELAYED }, +{ "cbn", 0x01c00000, 0xde000000, "l", F_DELAYED }, +{ "cb3", 0x2fc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb3", 0x0fc00000, 0xc0000000, "l", F_DELAYED }, +{ "cb2", 0x2dc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb2", 0x0dc00000, 0xc0000000, "l", F_DELAYED }, +{ "cb23", 0x2bc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb23", 0x0bc00000, 0xc0000000, "l", F_DELAYED }, +{ "cb1", 0x29c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb1", 0x09c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb13", 0x27c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb13", 0x07c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb12", 0x25c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb12", 0x05c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb123", 0x23c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb123", 0x03c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb0", 0x33c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb0", 0x13c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb03", 0x35c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb03", 0x15c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb02", 0x37c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb02", 0x17c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb023", 0x39c00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb023", 0x19c00000, 0xc0000000, "l", F_DELAYED }, +{ "cb01", 0x3bc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb01", 0x1bc00000, 0xc0000000, "l", F_DELAYED }, +{ "cb013", 0x3dc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb013", 0x1dc00000, 0xc0000000, "l", F_DELAYED }, +{ "cb012", 0x3fc00000, 0xc0000000, ",al", F_DELAYED }, +{ "cb012", 0x1fc00000, 0xc0000000, "l", F_DELAYED }, + +{ "fstoi", 0x81a01a20, 0x400025c0, "f,g", 0 }, +{ "fdtoi", 0x81a01a40, 0x400025a0, "f,g", 0 }, +{ "fxtoi", 0x81a01a60, 0x40002580, "f,g", 0 }, + +{ "fitox", 0x81a01980, 0x40002660, "f,g", 0 }, +{ "fitod", 0x81a01900, 0x400026e0, "f,g", 0 }, +{ "fitos", 0x81a01880, 0x40002660, "f,g", 0 }, + +{ "fstod", 0x81a01920, 0x400026c0, "f,g", 0 }, +{ "fstox", 0x81a019a0, 0x40002640, "f,g", 0 }, +{ "fdtos", 0x81a018c0, 0x40002720, "f,g", 0 }, +{ "fdtox", 0x81a019c0, 0x40002620, "f,g", 0 }, +{ "fxtos", 0x81a018e0, 0x40002700, "f,g", 0 }, +{ "fxtod", 0x81a01960, 0x40002680, "f,g", 0 }, + +{ "fdivx", 0x81a009e0, 0x40083600, "e,f,g", 0 }, +{ "fdivd", 0x81a009c0, 0x40003620, "e,f,g", 0 }, +{ "fdivs", 0x81a009a0, 0x40003640, "e,f,g", 0 }, + +{ "fmuls", 0x81a00920, 0x400036c0, "e,f,g", 0 }, +{ "fmuld", 0x81a00940, 0x400036a0, "e,f,g", 0 }, +{ "fmulx", 0x81a00960, 0x40003680, "e,f,g", 0 }, + +{ "fsqrts", 0x81a00520, 0x40003ac0, "f,g", 0 }, +{ "fsqrtd", 0x81a00540, 0x40003aa8, "f,g", 0 }, +{ "fsqrtx", 0x81a00560, 0x40003a80, "f,g", 0 }, + +{ "fabss", 0x81a00120, 0x40003ec0, "f,g", 0 }, +{ "fnegs", 0x81a000a0, 0x40003f40, "f,g", 0 }, +{ "fmovs", 0x81a00020, 0x40003fc0, "f,g", 0 }, + +{ "fsubx", 0x81a008e0, 0x40003700, "e,f,g", 0 }, +{ "fsubd", 0x81a008c0, 0x40003720, "e,f,g", 0 }, +{ "fsubs", 0x81a008a0, 0x40003740, "e,f,g", 0 }, + +{ "faddx", 0x81a00860, 0x40003780, "e,f,g", 0 }, +{ "faddd", 0x81a00840, 0x400037a0, "e,f,g", 0 }, +{ "fadds", 0x81a00820, 0x400037c0, "e,f,g", 0 }, + +{ "fcmpex", 0x81a80ae0, 0x40003500, "e,f", 0 }, +{ "fcmped", 0x81a80ac0, 0x40003520, "e,f", 0 }, +{ "fcmpes", 0x81a80aa0, 0x40003540, "e,f", 0 }, +{ "fcmpx", 0x81a80a60, 0x40003580, "e,f", 0 }, +{ "fcmpd", 0x81a80a40, 0x400035a0, "e,f", 0 }, +{ "fcmps", 0x81a80a20, 0x400035c0, "e,f", 0 }, + +{ "cpop1", 0x81b00000, 0x40480000, "[1+2],d", 0 }, +{ "cpop2", 0x81b80000, 0x40400000, "[1+2],d", 0 }, +}; + +#define NUMOPCODES ((sizeof sparc_opcodes)/(sizeof sparc_opcodes[0])) + diff --git a/gdb/sparc-pinsn.c b/gdb/sparc-pinsn.c new file mode 100644 index 0000000..39d62af --- /dev/null +++ b/gdb/sparc-pinsn.c @@ -0,0 +1,465 @@ +/* Disassembler for the sparc. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB, the GNU disassembler. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "sparc-opcode.h" +#include "gdbcore.h" +#include "string.h" +#include "target.h" + +extern void qsort (); + + +extern char *reg_names[]; +#define freg_names (®_names[4 * 8]) + +union sparc_insn + { + unsigned long int code; + struct + { + unsigned int OP:2; +#define op ldst.OP + unsigned int RD:5; +#define rd ldst.RD + unsigned int op3:6; + unsigned int RS1:5; +#define rs1 ldst.RS1 + unsigned int i:1; + unsigned int ASI:8; +#define asi ldst.ASI + unsigned int RS2:5; +#define rs2 ldst.RS2 +#define shcnt rs2 + } ldst; + struct + { + unsigned int OP:2, RD:5, op3:6, RS1:5, i:1; + unsigned int IMM13:13; +#define imm13 IMM13.IMM13 + } IMM13; + struct + { + unsigned int OP:2; + unsigned int a:1; + unsigned int cond:4; + unsigned int op2:3; + unsigned int DISP22:22; +#define disp22 branch.DISP22 + } branch; +#define imm22 disp22 + struct + { + unsigned int OP:2; + unsigned int DISP30:30; +#define disp30 call.DISP30 + } call; + }; + +/* Nonzero if INSN is the opcode for a delayed branch. */ +static int +is_delayed_branch (insn) + union sparc_insn insn; +{ + unsigned int i; + + for (i = 0; i < NUMOPCODES; ++i) + { + const struct sparc_opcode *opcode = &sparc_opcodes[i]; + if ((opcode->match & insn.code) == opcode->match + && (opcode->lose & insn.code) == 0) + return (opcode->flags & F_DELAYED); + } + return 0; +} + +static int opcodes_sorted = 0; + +/* Print one instruction from MEMADDR on STREAM. */ +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + union sparc_insn insn; + + register unsigned int i; + + if (!opcodes_sorted) + { + static int compare_opcodes (); + qsort ((char *) sparc_opcodes, NUMOPCODES, + sizeof (sparc_opcodes[0]), compare_opcodes); + opcodes_sorted = 1; + } + + read_memory (memaddr, &insn, sizeof (insn)); + + for (i = 0; i < NUMOPCODES; ++i) + { + const struct sparc_opcode *opcode = &sparc_opcodes[i]; + if ((opcode->match & insn.code) == opcode->match + && (opcode->lose & insn.code) == 0) + { + /* Nonzero means that we have found an instruction which has + the effect of adding or or'ing the imm13 field to rs1. */ + int imm_added_to_rs1 = 0; + + /* Nonzero means that we have found a plus sign in the args + field of the opcode table. */ + int found_plus = 0; + + /* Do we have an 'or' instruction where rs1 is the same + as rsd, and which has the i bit set? */ + if (opcode->match == 0x80102000 + && insn.rs1 == insn.rd) + imm_added_to_rs1 = 1; + + if (insn.rs1 != insn.rd + && strchr (opcode->args, 'r') != 0) + /* Can't do simple format if source and dest are different. */ + continue; + + fputs_filtered (opcode->name, stream); + + { + register const char *s; + + if (opcode->args[0] != ',') + fputs_filtered (" ", stream); + for (s = opcode->args; *s != '\0'; ++s) + { + if (*s == ',') + { + fputs_filtered (",", stream); + ++s; + if (*s == 'a') + { + fputs_filtered ("a", stream); + ++s; + } + fputs_filtered (" ", stream); + } + + switch (*s) + { + case '+': + found_plus = 1; + + /* note fall-through */ + default: + fprintf_filtered (stream, "%c", *s); + break; + + case '#': + fputs_filtered ("0", stream); + break; + +#define reg(n) fprintf_filtered (stream, "%%%s", reg_names[n]) + case '1': + case 'r': + reg (insn.rs1); + break; + + case '2': + reg (insn.rs2); + break; + + case 'd': + reg (insn.rd); + break; +#undef reg + +#define freg(n) fprintf_filtered (stream, "%%%s", freg_names[n]) + case 'e': + freg (insn.rs1); + break; + + case 'f': + freg (insn.rs2); + break; + + case 'g': + freg (insn.rd); + break; +#undef freg + +#define creg(n) fprintf_filtered (stream, "%%c%u", (unsigned int) (n)) + case 'b': + creg (insn.rs1); + break; + + case 'c': + creg (insn.rs2); + break; + + case 'D': + creg (insn.rd); + break; +#undef creg + + case 'h': + fprintf_filtered (stream, "%%hi(%#x)", + (int) insn.imm22 << 10); + break; + + case 'i': + { + /* We cannot trust the compiler to sign-extend + when extracting the bitfield, hence the shifts. */ + int imm = ((int) insn.imm13 << 19) >> 19; + + /* Check to see whether we have a 1+i, and take + note of that fact. + + Note: because of the way we sort the table, + we will be matching 1+i rather than i+1, + so it is OK to assume that i is after +, + not before it. */ + if (found_plus) + imm_added_to_rs1 = 1; + + if (imm <= 9) + fprintf_filtered (stream, "%d", imm); + else + fprintf_filtered (stream, "%#x", imm); + } + break; + + case 'L': + print_address ((CORE_ADDR) memaddr + insn.disp30 * 4, + stream); + break; + + case 'l': + if ((insn.code >> 22) == 0) + /* Special case for `unimp'. Don't try to turn + it's operand into a function offset. */ + fprintf_filtered (stream, "%#x", + (int) (((int) insn.disp22 << 10) >> 10)); + else + /* We cannot trust the compiler to sign-extend + when extracting the bitfield, hence the shifts. */ + print_address ((CORE_ADDR) + (memaddr + + (((int) insn.disp22 << 10) >> 10) * 4), + stream); + break; + + case 'A': + fprintf_filtered (stream, "(%d)", (int) insn.asi); + break; + + case 'C': + fputs_filtered ("%csr", stream); + break; + + case 'F': + fputs_filtered ("%fsr", stream); + break; + + case 'p': + fputs_filtered ("%psr", stream); + break; + + case 'q': + fputs_filtered ("%fq", stream); + break; + + case 'Q': + fputs_filtered ("%cq", stream); + break; + + case 't': + fputs_filtered ("%tbr", stream); + break; + + case 'w': + fputs_filtered ("%wim", stream); + break; + + case 'y': + fputs_filtered ("%y", stream); + break; + } + } + } + + /* If we are adding or or'ing something to rs1, then + check to see whether the previous instruction was + a sethi to the same register as in the sethi. + If so, attempt to print the result of the add or + or (in this context add and or do the same thing) + and its symbolic value. */ + if (imm_added_to_rs1) + { + union sparc_insn prev_insn; + int errcode; + + errcode = target_read_memory (memaddr - 4, + (char *)&prev_insn, sizeof (prev_insn)); + + if (errcode == 0) + { + /* If it is a delayed branch, we need to look at the + instruction before the delayed branch. This handles + sequences such as + + sethi %o1, %hi(_foo), %o1 + call _printf + or %o1, %lo(_foo), %o1 + */ + + if (is_delayed_branch (prev_insn)) + errcode = target_read_memory + (memaddr - 8, (char *)&prev_insn, sizeof (prev_insn)); + } + + /* If there was a problem reading memory, then assume + the previous instruction was not sethi. */ + if (errcode == 0) + { + /* Is it sethi to the same register? */ + if ((prev_insn.code & 0xc1c00000) == 0x01000000 + && prev_insn.rd == insn.rs1) + { + fprintf_filtered (stream, "\t! "); + /* We cannot trust the compiler to sign-extend + when extracting the bitfield, hence the shifts. */ + print_address (((int) prev_insn.imm22 << 10) + | (insn.imm13 << 19) >> 19, stream); + } + } + } + + return sizeof (insn); + } + } + + printf_filtered ("%#8x", insn.code); + return sizeof (insn); +} + + +/* Compare opcodes A and B. */ + +static int +compare_opcodes (a, b) + char *a, *b; +{ + struct sparc_opcode *op0 = (struct sparc_opcode *) a; + struct sparc_opcode *op1 = (struct sparc_opcode *) b; + unsigned long int match0 = op0->match, match1 = op1->match; + unsigned long int lose0 = op0->lose, lose1 = op1->lose; + register unsigned int i; + + /* If a bit is set in both match and lose, there is something + wrong with the opcode table. */ + if (match0 & lose0) + { + fprintf (stderr, "Internal error: bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n", + op0->name, match0, lose0); + op0->lose &= ~op0->match; + lose0 = op0->lose; + } + + if (match1 & lose1) + { + fprintf (stderr, "Internal error: bad sparc-opcode.h: \"%s\", %#.8lx, %#.8lx\n", + op1->name, match1, lose1); + op1->lose &= ~op1->match; + lose1 = op1->lose; + } + + /* Because the bits that are variable in one opcode are constant in + another, it is important to order the opcodes in the right order. */ + for (i = 0; i < 32; ++i) + { + unsigned long int x = 1 << i; + int x0 = (match0 & x) != 0; + int x1 = (match1 & x) != 0; + + if (x0 != x1) + return x1 - x0; + } + + for (i = 0; i < 32; ++i) + { + unsigned long int x = 1 << i; + int x0 = (lose0 & x) != 0; + int x1 = (lose1 & x) != 0; + + if (x0 != x1) + return x1 - x0; + } + + /* They are functionally equal. So as long as the opcode table is + valid, we can put whichever one first we want, on aesthetic grounds. */ + + /* Our first aesthetic ground is that aliases defer to real insns. */ + { + int alias_diff = (op0->flags & F_ALIAS) - (op1->flags & F_ALIAS); + if (alias_diff != 0) + /* Put the one that isn't an alias first. */ + return alias_diff; + } + + /* Except for the above aliases, two "identical" instructions had + better have the same opcode. This is a sanity check on the table. */ + if (0 != strcmp (op0->name, op1->name)) + fprintf (stderr, "Internal error: bad sparc-opcode.h: \"%s\" == \"%s\"\n", + op0->name, op1->name); + + /* Fewer arguments are preferred. */ + { + int length_diff = strlen (op0->args) - strlen (op1->args); + if (length_diff != 0) + /* Put the one with fewer arguments first. */ + return length_diff; + } + + /* Put 1+i before i+1. */ + { + char *p0 = (char *) strchr(op0->args, '+'); + char *p1 = (char *) strchr(op1->args, '+'); + + if (p0 && p1) + { + /* There is a plus in both operands. Note that a plus + sign cannot be the first character in args, + so the following [-1]'s are valid. */ + if (p0[-1] == 'i' && p1[1] == 'i') + /* op0 is i+1 and op1 is 1+i, so op1 goes first. */ + return 1; + if (p0[1] == 'i' && p1[-1] == 'i') + /* op0 is 1+i and op1 is i+1, so op0 goes first. */ + return -1; + } + } + + /* They are, as far as we can tell, identical. + Since qsort may have rearranged the table partially, there is + no way to tell which one was first in the opcode table as + written, so just say there are equal. */ + return 0; +} diff --git a/gdb/sparc-xdep.c b/gdb/sparc-xdep.c new file mode 100644 index 0000000..89fcb8d --- /dev/null +++ b/gdb/sparc-xdep.c @@ -0,0 +1,298 @@ +/* Machine-dependent code which would otherwise be in inflow.c and core.c, + for GDB, the GNU debugger, for SPARC host systems. + + Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "tm-sparc.h" +#include "param-no-tm.h" +#include "inferior.h" +#include "target.h" + +#include <sys/param.h> +#include <sys/file.h> /* For L_SET */ + +#include <sys/ptrace.h> +#include <machine/reg.h> + +#include "gdbcore.h" +#include <sys/core.h> + +extern char register_valid[]; + +/* Fetch one or more registers from the inferior. REGNO == -1 to get + them all. We actually fetch more than requested, when convenient, + marking them as valid so we won't fetch them again. */ +void +fetch_inferior_registers (regno) + int regno; +{ + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + int i; + + /* We should never be called with deferred stores, because a prerequisite + for writing regs is to have fetched them all (PREPARE_TO_STORE), sigh. */ + if (deferred_stores) abort(); + + DO_DEFERRED_STORES; + + /* Global and Out regs are fetched directly, as well as the control + registers. If we're getting one of the in or local regs, + and the stack pointer has not yet been fetched, + we have to do that first, since they're found in memory relative + to the stack pointer. */ + if (regno < O7_REGNUM /* including -1 */ + || regno >= Y_REGNUM + || (!register_valid[SP_REGNUM] && regno < I7_REGNUM)) + { + if (0 != ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers)) + perror("ptrace_getregs"); + + registers[REGISTER_BYTE (0)] = 0; + bcopy (&inferior_registers.r_g1, ®isters[REGISTER_BYTE (1)], 15 * REGISTER_RAW_SIZE (G0_REGNUM)); + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; + *(int *)®isters[REGISTER_BYTE (NPC_REGNUM)] = inferior_registers.r_npc; + *(int *)®isters[REGISTER_BYTE (Y_REGNUM)] = inferior_registers.r_y; + + for (i = G0_REGNUM; i <= O7_REGNUM; i++) + register_valid[i] = 1; + register_valid[Y_REGNUM] = 1; + register_valid[PS_REGNUM] = 1; + register_valid[PC_REGNUM] = 1; + register_valid[NPC_REGNUM] = 1; + /* If we don't set these valid, read_register_bytes() rereads + all the regs every time it is called! FIXME. */ + register_valid[WIM_REGNUM] = 1; /* Not true yet, FIXME */ + register_valid[TBR_REGNUM] = 1; /* Not true yet, FIXME */ + register_valid[FPS_REGNUM] = 1; /* Not true yet, FIXME */ + register_valid[CPS_REGNUM] = 1; /* Not true yet, FIXME */ + } + + /* Floating point registers */ + if (regno == -1 || (regno >= FP0_REGNUM && regno <= FP0_REGNUM + 31)) + { + if (0 != ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers)) + perror("ptrace_getfpregs"); + bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.fpu_fr); + /* bcopy (&inferior_fp_registers.Fpu_fsr, + ®isters[REGISTER_BYTE (FPS_REGNUM)], + sizeof (FPU_FSR_TYPE)); FIXME??? -- gnu@cyg */ + for (i = FP0_REGNUM; i <= FP0_REGNUM+31; i++) + register_valid[i] = 1; + register_valid[FPS_REGNUM] = 1; + } + + /* These regs are saved on the stack by the kernel. Only read them + all (16 ptrace calls!) if we really need them. */ + if (regno == -1) + { + target_xfer_memory (*(CORE_ADDR*)®isters[REGISTER_BYTE (SP_REGNUM)], + ®isters[REGISTER_BYTE (L0_REGNUM)], + 16*REGISTER_RAW_SIZE (L0_REGNUM), 0); + for (i = L0_REGNUM; i <= I7_REGNUM; i++) + register_valid[i] = 1; + } + else if (regno >= L0_REGNUM && regno <= I7_REGNUM) + { + CORE_ADDR sp = *(CORE_ADDR*)®isters[REGISTER_BYTE (SP_REGNUM)]; + i = REGISTER_BYTE (regno); + if (register_valid[regno]) + printf("register %d valid and read\n", regno); + target_xfer_memory (sp + i - REGISTER_BYTE (L0_REGNUM), + ®isters[i], REGISTER_RAW_SIZE (regno), 0); + register_valid[regno] = 1; + } +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +#define INT_REGS 1 +#define STACK_REGS 2 +#define FP_REGS 4 +int deferred_stores = 0; /* Cumulates stores we want to do eventually. */ + +int +store_inferior_registers (regno) + int regno; +{ + struct regs inferior_registers; + struct fp_status inferior_fp_registers; + int wanna_store = INT_REGS + STACK_REGS + FP_REGS; + + /* First decide which pieces of machine-state we need to modify. + Default for regno == -1 case is all pieces. */ + if (regno >= 0) + if (FP0_REGNUM <= regno && regno < FP0_REGNUM + 32) + { + wanna_store = FP_REGS; + } + else + { + if (regno == SP_REGNUM) + wanna_store = INT_REGS + STACK_REGS; + else if (regno < L0_REGNUM || regno > I7_REGNUM) + wanna_store = INT_REGS; + else + wanna_store = STACK_REGS; + } + + /* See if we're forcing the stores to happen now, or deferring. */ + if (regno == -2) + { + wanna_store = deferred_stores; + deferred_stores = 0; + } + else + { + if (wanna_store == STACK_REGS) + { + /* Fall through and just store one stack reg. If we deferred + it, we'd have to store them all, or remember more info. */ + } + else + { + deferred_stores |= wanna_store; + return 0; + } + } + + if (wanna_store & STACK_REGS) + { + CORE_ADDR sp = *(CORE_ADDR *)®isters[REGISTER_BYTE (SP_REGNUM)]; + + if (regno < 0 || regno == SP_REGNUM) + { + if (!register_valid[L0_REGNUM+5]) abort(); + target_xfer_memory (sp, + ®isters[REGISTER_BYTE (L0_REGNUM)], + 16*REGISTER_RAW_SIZE (L0_REGNUM), 1); + } + else + { + if (!register_valid[regno]) abort(); + target_xfer_memory (sp + REGISTER_BYTE (regno) - REGISTER_BYTE (L0_REGNUM), + ®isters[REGISTER_BYTE (regno)], + REGISTER_RAW_SIZE (regno), 1); + } + + } + + if (wanna_store & INT_REGS) + { + if (!register_valid[G1_REGNUM]) abort(); + + bcopy (®isters[REGISTER_BYTE (G1_REGNUM)], + &inferior_registers.r_g1, 15 * REGISTER_RAW_SIZE (G1_REGNUM)); + + inferior_registers.r_ps = + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; + inferior_registers.r_pc = + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; + inferior_registers.r_npc = + *(int *)®isters[REGISTER_BYTE (NPC_REGNUM)]; + inferior_registers.r_y = + *(int *)®isters[REGISTER_BYTE (Y_REGNUM)]; + + if (0 != ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers)) + perror("ptrace_setregs"); + } + + if (wanna_store & FP_REGS) + { + if (!register_valid[FP0_REGNUM+9]) abort(); + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], + &inferior_fp_registers, + sizeof inferior_fp_registers.fpu_fr); + +/* bcopy (®isters[REGISTER_BYTE (FPS_REGNUM)], + &inferior_fp_registers.Fpu_fsr, + sizeof (FPU_FSR_TYPE)); +****/ + if (0 != + ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers)) + perror("ptrace_setfpregs"); + } + return 0; +} + +void +fetch_core_registers (core_reg_sect, core_reg_size, which) + char *core_reg_sect; + unsigned core_reg_size; + int which; +{ + + if (which == 0) { + + /* Integer registers */ + +#define gregs ((struct regs *)core_reg_sect) + /* G0 *always* holds 0. */ + *(int *)®isters[REGISTER_BYTE (0)] = 0; + + /* The globals and output registers. */ + bcopy (&gregs->r_g1, + ®isters[REGISTER_BYTE (G1_REGNUM)], + 15 * REGISTER_RAW_SIZE (G1_REGNUM)); + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = gregs->r_ps; + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = gregs->r_pc; + *(int *)®isters[REGISTER_BYTE (NPC_REGNUM)] = gregs->r_npc; + *(int *)®isters[REGISTER_BYTE (Y_REGNUM)] = gregs->r_y; + + /* My best guess at where to get the locals and input + registers is exactly where they usually are, right above + the stack pointer. If the core dump was caused by a bus error + from blowing away the stack pointer (as is possible) then this + won't work, but it's worth the try. */ + { + int sp; + + sp = *(int *)®isters[REGISTER_BYTE (SP_REGNUM)]; + if (0 != target_read_memory (sp, ®isters[REGISTER_BYTE (L0_REGNUM)], + 16 * REGISTER_RAW_SIZE (L0_REGNUM))) + { + /* fprintf so user can still use gdb */ + fprintf (stderr, + "Couldn't read input and local registers from core file\n"); + } + } + } else if (which == 2) { + + /* Floating point registers */ + +#define fpuregs ((struct fpu *) core_reg_sect) + if (core_reg_size >= sizeof (struct fpu)) + { + bcopy (fpuregs->fpu_regs, + ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof (fpuregs->fpu_regs)); + bcopy (&fpuregs->fpu_fsr, + ®isters[REGISTER_BYTE (FPS_REGNUM)], + sizeof (FPU_FSR_TYPE)); + } + else + fprintf (stderr, "Couldn't read float regs from core file\n"); + } +} diff --git a/gdb/stab.def b/gdb/stab.def new file mode 100755 index 0000000..58364e1 --- /dev/null +++ b/gdb/stab.def @@ -0,0 +1,182 @@ +/* Table of DBX symbol codes for the GNU system. + Copyright (C) 1988 Free Software Foundation, Inc. + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 1, or (at your option) + any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Global variable. Only the name is significant. + To find the address, look in the corresponding external symbol. */ +__define_stab (N_GSYM, 0x20, "GSYM") + +/* Function name for BSD Fortran. Only the name is significant. + To find the address, look in the corresponding external symbol. */ +__define_stab (N_FNAME, 0x22, "FNAME") + +/* Function name or text-segment variable for C. Value is its address. + Desc is supposedly starting line number, but GCC doesn't set it + and DBX seems not to miss it. */ +__define_stab (N_FUN, 0x24, "FUN") + +/* Data-segment variable with internal linkage. Value is its address. */ +__define_stab (N_STSYM, 0x26, "STSYM") + +/* BSS-segment variable with internal linkage. Value is its address. */ +__define_stab (N_LCSYM, 0x28, "LCSYM") + +/* Name of main routine. Only the name is significant. + This is not used in C. */ +__define_stab (N_MAIN, 0x2a, "MAIN") + +/* Register variable. Value is number of register. */ +__define_stab (N_RSYM, 0x40, "RSYM") + +/* Structure or union element. Value is offset in the structure. */ +__define_stab (N_SSYM, 0x60, "SSYM") + +/* Parameter variable. Value is offset from argument pointer. + (On most machines the argument pointer is the same as the frame pointer. */ +__define_stab (N_PSYM, 0xa0, "PSYM") + +/* Automatic variable in the stack. Value is offset from frame pointer. + Also used for type descriptions. */ +__define_stab (N_LSYM, 0x80, "LSYM") + +/* Alternate entry point. Value is its address. */ +__define_stab (N_ENTRY, 0xa4, "ENTRY") + +/* Name of main source file. + Value is starting text address of the compilation. */ +__define_stab (N_SO, 0x64, "SO") + +/* Name of sub-source file. + Value is starting text address of the compilation. */ +__define_stab (N_SOL, 0x84, "SOL") + +/* Line number in text segment. Desc is the line number; + value is corresponding address. */ +__define_stab (N_SLINE, 0x44, "SLINE") +/* Similar, for data segment. */ +__define_stab (N_DSLINE, 0x66, "DSLINE") +/* Similar, for bss segment. */ +__define_stab (N_BSLINE, 0x68, "BSLINE") + +/* Beginning of an include file. Only Sun uses this. + In an object file, only the name is significant. + The Sun linker puts data into some of the other fields. */ +__define_stab (N_BINCL, 0x82, "BINCL") +/* End of an include file. No name. + These two act as brackets around the file's output. + In an object file, there is no significant data in this entry. + The Sun linker puts data into some of the fields. */ +__define_stab (N_EINCL, 0xa2, "EINCL") +/* Place holder for deleted include file. + This appears only in output from the Sun linker. */ +__define_stab (N_EXCL, 0xc2, "EXCL") + +/* Beginning of lexical block. + The desc is the nesting level in lexical blocks. + The value is the address of the start of the text for the block. + The variables declared inside the block *precede* the N_LBRAC symbol. */ +__define_stab (N_LBRAC, 0xc0, "LBRAC") +/* End of a lexical block. Desc matches the N_LBRAC's desc. + The value is the address of the end of the text for the block. */ +__define_stab (N_RBRAC, 0xe0, "RBRAC") + +/* Begin named common block. Only the name is significant. */ +__define_stab (N_BCOMM, 0xe2, "BCOMM") +/* Begin named common block. Only the name is significant + (and it should match the N_BCOMM). */ +__define_stab (N_ECOMM, 0xe4, "ECOMM") +/* End common (local name): value is address. + I'm not sure how this is used. */ +__define_stab (N_ECOML, 0xe8, "ECOML") +/* Second symbol entry containing a length-value for the preceding entry. + The value is the length. */ +__define_stab (N_LENG, 0xfe, "LENG") + +/* Global symbol in Pascal. + Supposedly the value is its line number; I'm skeptical. */ +__define_stab (N_PC, 0x30, "PC") + +/* Modula-2 compilation unit. Can someone say what info it contains? */ +__define_stab (N_M2C, 0x42, "M2C") +/* Modula-2 scope information. Can someone say what info it contains? */ +__define_stab (N_SCOPE, 0xc4, "SCOPE") + +/* Sun's source-code browser stabs. ?? Don't know what the fields are. + Supposedly the field is "path to associated .cb file". */ +__define_stab (N_BROWS, 0x48, "BROWS") + +/* GNU C++ exception stabs. */ + +/* GNU C++ exception variable. Name is variable name. */ +__define_stab (N_EHDECL, 0x50, "EHDECL") + +/* GNU C++ `catch' clause. Value is its address. Desc is nonzero if + this entry is immediately followed by a CAUGHT stab saying what exception + was caught. Multiple CAUGHT stabs means that multiple exceptions + can be caught here. If Desc is 0, it means all exceptions are caught + here. */ +__define_stab (N_CATCH, 0x54, "CATCH") + +/* These STAB's are used on Gould systems for Non-Base register symbols + or something like that. FIXME. I have assigned the values at random + since I don't have a Gould here. Fixups from Gould folk welcome... */ +__define_stab (N_NBTEXT, 0xF0, "NBTEXT") +__define_stab (N_NBDATA, 0xF2, "NBDATA") +__define_stab (N_NBBSS, 0xF4, "NBBSS") +__define_stab (N_NBSTS, 0xF6, "NBSTS") +__define_stab (N_NBLCS, 0xF8, "NBLCS") +__define_stab (N_NSYMS, 0xFA, "NSYMS") + +/* The above information, in matrix format. + + STAB MATRIX + _________________________________________________ + | 00 - 1F are not dbx stab symbols | + | Entries with bits 01 set are external symbols | + | N_UNDEF | N_ABS | N_TEXT | N_DATA | + | N_BSS | N_COMM | | N_FN | + |_______________________________________________| + | 20 GSYM | 22 FNAME | 24 FUN | 26 STSYM | + | 28 LCSYM | 2A MAIN | 2C | 2E | + | 30 PC | 32 | 34 | 36 | + | 38 | 3A | 3C | 3E | + | 40 RSYM | 42 M2C | 44 SLINE | 46 | + | 48 BROWS | 4A | 4C | 4E | + | 50 EHDECL | 52 | 54 CATCH | 56 | + | 58 | 5A | 5C | 5E | + | 60 SSYM | 62 | 64 SO | 66 DSLINE | + | 68 BSLINE | 6A | 6C | 6E | + | 70 | 72 | 74 | 76 | + | 78 | 7A | 7C | 7E | + | 80 LSYM | 82 BINCL | 84 SOL | 86 | + | 88 | 8A | 8C | 8E | + | 90 | 92 | 94 | 96 | + | 98 | 9A | 9C | 9E | + | A0 PSYM | A2 EINCL | A4 ENTRY | A6 | + | A8 | AA | AC | AE | + | B0 | B2 | B4 | B6 | + | B8 | BA | BC | BE | + | C0 LBRAC | C2 EXCL | C4 SCOPE | C6 | + | C8 | CA | CC | CE | + | D0 | D2 | D4 | D6 | + | D8 | DA | DC | DE | + | E0 RBRAC | E2 BCOMM | E4 ECOMM | E6 | + | E8 ECOML | EA | EC | EE | + | F0 | F2 | F4 | F6 | + | F8 | FA | FC | FE LENG | + +-----------------------------------------------+ + +*/ diff --git a/gdb/standalone.c b/gdb/standalone.c new file mode 100644 index 0000000..fcb6e7e --- /dev/null +++ b/gdb/standalone.c @@ -0,0 +1,594 @@ +/* Interface to bare machine for GDB running as kernel debugger. + Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <sys/ioctl.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/stat.h> + +#if defined (SIGTSTP) && defined (SIGIO) +#include <sys/time.h> +#include <sys/resource.h> +#endif /* SIGTSTP and SIGIO defined (must be 4.2) */ + +#include "defs.h" +#include "param.h" +#include "signals.h" +#include "symtab.h" +#include "frame.h" +#include "inferior.h" +#include "wait.h" + + +/* Random system calls, mostly no-ops to prevent link problems */ + +ioctl (desc, code, arg) +{} + +int (* signal ()) () +{} + +kill () +{} + +getpid () +{ + return 0; +} + +sigsetmask () +{} + +chdir () +{} + +char * +getwd (buf) + char *buf; +{ + buf[0] = '/'; + buf[1] = 0; + return buf; +} + +/* Used to check for existence of .gdbinit. Say no. */ + +access () +{ + return -1; +} + +exit () +{ + error ("Fatal error; restarting."); +} + +/* Reading "files". The contents of some files are written into kdb's + data area before it is run. These files are used to contain the + symbol table for kdb to load, and the source files (in case the + kdb user wants to print them). The symbols are stored in a file + named "kdb-symbols" in a.out format (except that all the text and + data have been stripped to save room). + + The files are stored in the following format: + int number of bytes of data for this file, including these four. + char[] name of the file, ending with a null. + padding to multiple of 4 boundary. + char[] file contents. The length can be deduced from what was + specified before. There is no terminating null here. + + If the int at the front is zero, it means there are no more files. + + Opening a file in kdb returns a nonzero value to indicate success, + but the value does not matter. Only one file can be open, and only + for reading. All the primitives for input from the file know + which file is open and ignore what is specified for the descriptor + or for the stdio stream. + + Input with fgetc can be done either on the file that is open + or on stdin (which reads from the terminal through tty_input () */ + +/* Address of data for the files stored in format described above. */ +char *files_start; + +/* The file stream currently open: */ + +char *sourcebeg; /* beginning of contents */ +int sourcesize; /* size of contents */ +char *sourceptr; /* current read pointer */ +int sourceleft; /* number of bytes to eof */ + +/* "descriptor" for the file now open. + Incremented at each close. + If specified descriptor does not match this, + it means the program is trying to use a closed descriptor. + We report an error for that. */ + +int sourcedesc; + +open (filename, modes) + char *filename; + int modes; +{ + register char *next; + + if (modes) + { + errno = EROFS; + return -1; + } + + if (sourceptr) + { + errno = EMFILE; + return -1; + } + + for (next - files_start; * (int *) next; + next += * (int *) next) + { + if (!strcmp (next + 4, filename)) + { + sourcebeg = next + 4 + strlen (next + 4) + 1; + sourcebeg = (char *) (((int) sourcebeg + 3) & (-4)); + sourceptr = sourcebeg; + sourcesize = next + * (int *) next - sourceptr; + sourceleft = sourcesize; + return sourcedesc; + } + } + return 0; +} + +close (desc) + int desc; +{ + sourceptr = 0; + sourcedesc++; + /* Don't let sourcedesc get big enough to be confused with stdin. */ + if (sourcedesc == 100) + sourcedesc = 5; +} + +FILE * +fopen (filename, modes) + char *filename; + char *modes; +{ + return (FILE *) open (filename, *modes == 'w'); +} + +FILE * +fdopen (desc) + int desc; +{ + return (FILE *) desc; +} + +fclose (desc) + int desc; +{ + close (desc); +} + +fstat (desc, statbuf) + struct stat *statbuf; +{ + if (desc != sourcedesc) + { + errno = EBADF; + return -1; + } + statbuf->st_size = sourcesize; +} + +myread (desc, destptr, size, filename) + int desc; + char *destptr; + int size; + char *filename; +{ + int len = min (sourceleft, size); + + if (desc != sourcedesc) + { + errno = EBADF; + return -1; + } + + bcopy (sourceptr, destptr, len); + sourceleft -= len; + return len; +} + +int +fread (bufp, numelts, eltsize, stream) +{ + register int elts = min (numelts, sourceleft / eltsize); + register int len = elts * eltsize; + + if (stream != sourcedesc) + { + errno = EBADF; + return -1; + } + + bcopy (sourceptr, bufp, len); + sourceleft -= len; + return elts; +} + +int +fgetc (desc) + int desc; +{ + + if (desc == (int) stdin) + return tty_input (); + + if (desc != sourcedesc) + { + errno = EBADF; + return -1; + } + + if (sourceleft-- <= 0) + return EOF; + return *sourceptr++; +} + +lseek (desc, pos) + int desc; + int pos; +{ + + if (desc != sourcedesc) + { + errno = EBADF; + return -1; + } + + if (pos < 0 || pos > sourcesize) + { + errno = EINVAL; + return -1; + } + + sourceptr = sourcebeg + pos; + sourceleft = sourcesize - pos; +} + +/* Output in kdb can go only to the terminal, so the stream + specified may be ignored. */ + +printf (a1, a2, a3, a4, a5, a6, a7, a8, a9) +{ + char buffer[1024]; + sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9); + display_string (buffer); +} + +fprintf (ign, a1, a2, a3, a4, a5, a6, a7, a8, a9) +{ + char buffer[1024]; + sprintf (buffer, a1, a2, a3, a4, a5, a6, a7, a8, a9); + display_string (buffer); +} + +fwrite (buf, numelts, size, stream) + register char *buf; + int numelts, size; +{ + register int i = numelts * size; + while (i-- > 0) + fputc (*buf++, stream); +} + +fputc (c, ign) +{ + char buf[2]; + buf[0] = c; + buf[1] = 0; + display_string (buf); +} + +/* sprintf refers to this, but loading this from the + library would cause fflush to be loaded from it too. + In fact there should be no need to call this (I hope). */ + +_flsbuf () +{ + error ("_flsbuf was actually called."); +} + +fflush (ign) +{ +} + +/* Entries into core and inflow, needed only to make things link ok. */ + +exec_file_command () +{} + +core_file_command () +{} + +char * +get_exec_file (err) + int err; +{ + /* Makes one printout look reasonable; value does not matter otherwise. */ + return "run"; +} + +have_core_file_p () +{ + return 0; +} + +kill_command () +{ + inferior_pid = 0; +} + +terminal_inferior () +{} + +terminal_ours () +{} + +terminal_init_inferior () +{} + +write_inferior_register () +{} + +read_inferior_register () +{} + +read_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + bcopy (memaddr, myaddr, len); +} + +/* Always return 0 indicating success. */ + +write_memory (memaddr, myaddr, len) + CORE_ADDR memaddr; + char *myaddr; + int len; +{ + bcopy (myaddr, memaddr, len); + return 0; +} + +static REGISTER_TYPE saved_regs[NUM_REGS]; + +REGISTER_TYPE +read_register (regno) + int regno; +{ + if (regno < 0 || regno >= NUM_REGS) + error ("Register number %d out of range.", regno); + return saved_regs[regno]; +} + +void +write_register (regno, value) + int regno; + REGISTER_TYPE value; +{ + if (regno < 0 || regno >= NUM_REGS) + error ("Register number %d out of range.", regno); + saved_regs[regno] = value; +} + +/* System calls needed in relation to running the "inferior". */ + +vfork () +{ + /* Just appear to "succeed". Say the inferior's pid is 1. */ + return 1; +} + +/* These are called by code that normally runs in the inferior + that has just been forked. That code never runs, when standalone, + and these definitions are so it will link without errors. */ + +ptrace () +{} + +setpgrp () +{} + +execle () +{} + +_exit () +{} + +/* Malloc calls these. */ + +malloc_warning (str) + char *str; +{ + printf ("\n%s.\n\n", str); +} + +char *next_free; +char *memory_limit; + +char * +sbrk (amount) + int amount; +{ + if (next_free + amount > memory_limit) + return (char *) -1; + next_free += amount; + return next_free - amount; +} + +/* Various ways malloc might ask where end of memory is. */ + +char * +ulimit () +{ + return memory_limit; +} + +int +vlimit () +{ + return memory_limit - next_free; +} + +getrlimit (addr) + struct rlimit *addr; +{ + addr->rlim_cur = memory_limit - next_free; +} + +/* Context switching to and from program being debugged. */ + +/* GDB calls here to run the user program. + The frame pointer for this function is saved in + gdb_stack by save_frame_pointer; then we restore + all of the user program's registers, including PC and PS. */ + +static int fault_code; +static REGISTER_TYPE gdb_stack; + +resume () +{ + REGISTER_TYPE restore[NUM_REGS]; + + PUSH_FRAME_PTR; + save_frame_pointer (); + + bcopy (saved_regs, restore, sizeof restore); + POP_REGISTERS; + /* Control does not drop through here! */ +} + +save_frame_pointer (val) + CORE_ADDR val; +{ + gdb_stack = val; +} + +/* Fault handlers call here, running in the user program stack. + They must first push a fault code, + old PC, old PS, and any other info about the fault. + The exact format is machine-dependent and is known only + in the definition of PUSH_REGISTERS. */ + +fault () +{ + /* Transfer all registers and fault code to the stack + in canonical order: registers in order of GDB register number, + followed by fault code. */ + PUSH_REGISTERS; + + /* Transfer them to saved_regs and fault_code. */ + save_registers (); + + restore_gdb (); + /* Control does not reach here */ +} + +restore_gdb () +{ + CORE_ADDR new_fp = gdb_stack; + /* Switch to GDB's stack */ + POP_FRAME_PTR; + /* Return from the function `resume'. */ +} + +/* Assuming register contents and fault code have been pushed on the stack as + arguments to this function, copy them into the standard place + for the program's registers while GDB is running. */ + +save_registers (firstreg) + int firstreg; +{ + bcopy (&firstreg, saved_regs, sizeof saved_regs); + fault_code = (&firstreg)[NUM_REGS]; +} + +/* Store into the structure such as `wait' would return + the information on why the program faulted, + converted into a machine-independent signal number. */ + +static int fault_table[] = FAULT_TABLE; + +int +wait (w) + WAITTYPE *w; +{ + WSETSTOP (*w, fault_table[fault_code / FAULT_CODE_UNITS]); + return inferior_pid; +} + +/* Allocate a big space in which files for kdb to read will be stored. + Whatever is left is where malloc can allocate storage. + + Initialize it, so that there will be space in the executable file + for it. Then the files can be put into kdb by writing them into + kdb's executable file. */ + +/* The default size is as much space as we expect to be available + for kdb to use! */ + +#ifndef HEAP_SIZE +#define HEAP_SIZE 400000 +#endif + +char heap[HEAP_SIZE] = {0}; + +#ifndef STACK_SIZE +#define STACK_SIZE 100000 +#endif + +int kdb_stack_beg[STACK_SIZE / sizeof (int)]; +int kdb_stack_end; + +_initialize_standalone () +{ + register char *next; + + /* Find start of data on files. */ + + files_start = heap; + + /* Find the end of the data on files. */ + + for (next - files_start; * (int *) next; + next += * (int *) next) + {} + + /* That is where free storage starts for sbrk to give out. */ + next_free = next; + + memory_limit = heap + sizeof heap; +} + diff --git a/gdb/stddef.h b/gdb/stddef.h new file mode 100755 index 0000000..d95a815 --- /dev/null +++ b/gdb/stddef.h @@ -0,0 +1,24 @@ +#ifndef _STDDEF_H +#define _STDDEF_H + +/* Signed type of difference of two pointers. */ + +typedef long ptrdiff_t; + +/* Unsigned type of `sizeof' something. */ + +#ifndef _SIZE_T /* in case <sys/types.h> has defined it. */ +#define _SIZE_T +typedef unsigned long size_t; +#endif /* _SIZE_T */ + +/* A null pointer constant. */ + +#undef NULL /* in case <stdio.h> has defined it. */ +#define NULL 0 + +/* Offset of member MEMBER in a struct of type TYPE. */ + +#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER) + +#endif /* _STDDEF_H */ diff --git a/gdb/stdlib.h b/gdb/stdlib.h new file mode 100755 index 0000000..40ce167 --- /dev/null +++ b/gdb/stdlib.h @@ -0,0 +1,10 @@ +/* Fake stdlib.h supplying the stuff needed by malloc. */ + +#ifndef __ONEFILE +#include <stddef.h> +#endif + +extern void EXFUN(abort, (void)); +extern void EXFUN(free, (PTR)); +extern PTR EXFUN(malloc, (size_t)); +extern PTR EXFUN(realloc, (PTR, size_t)); diff --git a/gdb/stuff.c b/gdb/stuff.c new file mode 100644 index 0000000..2ffdc97 --- /dev/null +++ b/gdb/stuff.c @@ -0,0 +1,174 @@ +/* Program to stuff files into a specially prepared space in kdb. + Copyright (C) 1986, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Written 13-Mar-86 by David Bridgham. */ + +#include <stdio.h> +#include <a.out.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <sys/file.h> +#include <varargs.h> + +extern char *sys_errlist[]; + +main (argc, argv) + int argc; + char *argv[]; +{ + register char *cp; + char *outfile; + register int i; + int offset; + int out_fd, in_fd; + struct stat stat_buf; + int size, pad; + char buf[1024]; + static char zeros[4] = {0}; + + if (argc < 4) + err("Not enough arguments\nUsage: %s -o kdb file1 file2 ...\n", + argv[0]); + + outfile = 0; + for (i = 1; i < argc; i++) + { + if (strcmp (argv[i], "-o") == 0) + outfile = argv[++i]; + } + if (outfile == 0) + err("Output file not specified\n"); + + offset = get_offset (outfile, "_heap"); + + out_fd = open (outfile, O_WRONLY); + if (out_fd < 0) + err ("Error opening %s for write: %s\n", outfile, sys_errlist[errno]); + if (lseek (out_fd, offset, 0) < 0) + err ("Error seeking to heap in %s: %s\n", outfile, sys_errlist[errno]); + + /* For each file listed on the command line, write it into the + * 'heap' of the output file. Make sure to skip the arguments + * that name the output file. */ + for (i = 1; i < argc; i++) + { + if (strcmp (argv[i], "-o") == 0) + continue; + if ((in_fd = open (argv[i], O_RDONLY)) < 0) + err ("Error opening %s for read: %s\n", argv[i], sys_errlist[errno]); + if (fstat (in_fd, &stat_buf) < 0) + err ("Error stat'ing %s: %s\n", argv[i], sys_errlist[errno]); + size = strlen (argv[i]); + pad = 4 - (size & 3); + size += pad + stat_buf.st_size + sizeof (int); + write (out_fd, &size, sizeof (int)); + write (out_fd, argv[i], strlen (argv[i])); + write (out_fd, zeros, pad); + while ((size = read (in_fd, buf, sizeof (buf))) > 0) + write (out_fd, buf, size); + close (in_fd); + } + size = 0; + write (out_fd, &size, sizeof (int)); + close (out_fd); + return (0); +} + +/* Read symbol table from file and returns the offset into the file + * where symbol sym_name is located. If error, print message and + * exit. */ +get_offset (file, sym_name) + char *file; + char *sym_name; +{ + int f; + struct exec file_hdr; + struct nlist *symbol_table; + int size; + char *strings; + + f = open (file, O_RDONLY); + if (f < 0) + err ("Error opening %s: %s\n", file, sys_errlist[errno]); + if (read (f, &file_hdr, sizeof (file_hdr)) < 0) + err ("Error reading exec structure: %s\n", sys_errlist[errno]); + if (N_BADMAG (file_hdr)) + err ("File %s not an a.out file\n", file); + + /* read in symbol table */ + if ((symbol_table = (struct nlist *)malloc (file_hdr.a_syms)) == 0) + err ("Couldn't allocate space for symbol table\n"); + if (lseek (f, N_SYMOFF (file_hdr), 0) == -1) + err ("lseek error: %s\n", sys_errlist[errno]); + if (read (f, symbol_table, file_hdr.a_syms) == -1) + err ("Error reading symbol table from %s: %s\n", file, sys_errlist[errno]); + + /* read in string table */ + if (read (f, &size, 4) == -1) + err ("reading string table size: %s\n", sys_errlist[errno]); + if ((strings = (char *)malloc (size)) == 0) + err ("Couldn't allocate memory for string table\n"); + if (read (f, strings, size - 4) == -1) + err ("reading string table: %s\n", sys_errlist[errno]); + + /* Find the core address at which the first byte of kdb text segment + should be loaded into core when kdb is run. */ + origin = find_symbol ("_etext", symbol_table, file_hdr.a_syms, strings) + - file_hdr.a_text; + /* Find the core address at which the heap will appear. */ + coreaddr = find_symbol (sym_name, symbol_table, file_hdr.a_syms, strings); + /* Return address in file of the heap data space. */ + return (N_TXTOFF (file_hdr) + core_addr - origin); +} + +find_symbol (sym_name, symbol_table, length, strings) + char *sym_name; + struct nlist *symbol_table; + int length; + char *strings; +{ + register struct nlist *sym; + + /* Find symbol in question */ + for (sym = symbol_table; + sym != (struct nlist *)((char *)symbol_table + length); + sym++) + { + if ((sym->n_type & N_TYPE) != N_DATA) continue; + if (sym->n_un.n_strx == 0) continue; + if (strcmp (sym_name, strings + sym->n_un.n_strx - 4) == 0) + return sym->n_value; + } + err ("Data symbol %s not found in %s\n", sym_name, file); +} + +/* VARARGS */ +void +err (va_alist) + va_dcl +{ + va_list args; + char *string; + + va_start (args); + string = va_arg (args, char *); + vfprintf (stderr, string, args); + va_end (args); + exit (-1); +} diff --git a/gdb/sun3-xdep.c b/gdb/sun3-xdep.c new file mode 100644 index 0000000..6789cd6 --- /dev/null +++ b/gdb/sun3-xdep.c @@ -0,0 +1,133 @@ +/* Sun-3 Machine-dependent code which would otherwise be in inflow.c and core.c, + for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "inferior.h" + +#include <sys/ptrace.h> +#define KERNEL /* To get floating point reg definitions */ +#include <machine/reg.h> + +#include "gdbcore.h" + +extern int errno; + +void +fetch_inferior_registers () +{ + struct regs inferior_registers; +#ifdef FP0_REGNUM + struct fp_status inferior_fp_registers; +#endif + extern char registers[]; + + registers_fetched (); + + ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers); +#ifdef FP0_REGNUM + ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers); +#endif + + bcopy (&inferior_registers, registers, 16 * 4); +#ifdef FP0_REGNUM + bcopy (&inferior_fp_registers, ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.fps_regs); +#endif + *(int *)®isters[REGISTER_BYTE (PS_REGNUM)] = inferior_registers.r_ps; + *(int *)®isters[REGISTER_BYTE (PC_REGNUM)] = inferior_registers.r_pc; +#ifdef FP0_REGNUM + bcopy (&inferior_fp_registers.fps_control, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); +#endif +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + struct regs inferior_registers; +#ifdef FP0_REGNUM + struct fp_status inferior_fp_registers; +#endif + extern char registers[]; + + bcopy (registers, &inferior_registers, 16 * 4); +#ifdef FP0_REGNUM + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)], &inferior_fp_registers, + sizeof inferior_fp_registers.fps_regs); +#endif + inferior_registers.r_ps = *(int *)®isters[REGISTER_BYTE (PS_REGNUM)]; + inferior_registers.r_pc = *(int *)®isters[REGISTER_BYTE (PC_REGNUM)]; + +#ifdef FP0_REGNUM + bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], + &inferior_fp_registers.fps_control, + sizeof inferior_fp_registers - sizeof inferior_fp_registers.fps_regs); +#endif + + ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers); +#if FP0_REGNUM + ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers); +#endif +} + +/* Machine-dependent code for pulling registers out of a Sun-3 core file. */ + +void +fetch_core_registers (core_reg_sect, core_reg_size, which) + char *core_reg_sect; + unsigned core_reg_size; + int which; +{ + extern char registers[]; + struct regs *regs = (struct regs *) core_reg_sect; + + if (which == 0) { + if (core_reg_size < sizeof (struct regs)) + error ("Can't find registers in core file"); + + bcopy ((char *)regs, registers, 16 * 4); + supply_register (PS_REGNUM, ®s->r_ps); + supply_register (PC_REGNUM, ®s->r_pc); + + } else if (which == 2) { + +#define fpustruct ((struct fpu *) core_reg_sect) + + if (core_reg_size >= sizeof (struct fpu)) + { + bcopy (fpustruct->f_fpstatus.fps_regs, + ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof fpustruct->f_fpstatus.fps_regs); + bcopy (&fpustruct->f_fpstatus.fps_control, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof fpustruct->f_fpstatus - + sizeof fpustruct->f_fpstatus.fps_regs); + } + else + fprintf (stderr, "Couldn't read float regs from core file\n"); + } +} diff --git a/gdb/sun386-xdep.c b/gdb/sun386-xdep.c new file mode 100644 index 0000000..d9f1cb5 --- /dev/null +++ b/gdb/sun386-xdep.c @@ -0,0 +1,252 @@ +/* Machine-dependent code for host Sun 386i's for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + Changes for sun386i by Jean Daniel Fekete (jdf@litp.univ-p6-7.fr), + C2V Paris, April 89. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "signame.h" +#include "gdbcore.h" + +#include <sys/param.h> +#include <sys/dir.h> +#include <sys/user.h> +#include <signal.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#include <sys/ptrace.h> +#include <machine/reg.h> + +#include <sys/file.h> +#include <sys/stat.h> +#include <sys/core.h> + +void +fetch_inferior_registers () +{ + struct regs inferior_registers; + struct fp_state inferior_fp_registers; + extern char registers[]; + + registers_fetched (); + + ptrace (PTRACE_GETREGS, inferior_pid, &inferior_registers); + ptrace (PTRACE_GETFPREGS, inferior_pid, &inferior_fp_registers); + + bcopy (&inferior_registers, registers, sizeof inferior_registers); + + bcopy (inferior_fp_registers.f_st,®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof inferior_fp_registers.f_st); + bcopy (&inferior_fp_registers.f_ctrl, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st); +} + +/* Store our register values back into the inferior. + If REGNO is -1, do this for all registers. + Otherwise, REGNO specifies which register (so we can save time). */ + +store_inferior_registers (regno) + int regno; +{ + struct regs inferior_registers; + struct fp_state inferior_fp_registers; + extern char registers[]; + + bcopy (registers, &inferior_registers, 20 * 4); + + bcopy (®isters[REGISTER_BYTE (FP0_REGNUM)],inferior_fp_registers.f_st, + sizeof inferior_fp_registers.f_st); + bcopy (®isters[REGISTER_BYTE (FPC_REGNUM)], + &inferior_fp_registers.f_ctrl, + sizeof inferior_fp_registers - sizeof inferior_fp_registers.f_st); + +#ifdef PTRACE_FP_BUG + if (regno == FP_REGNUM || regno == -1) + /* Storing the frame pointer requires a gross hack, in which an + instruction that moves eax into ebp gets single-stepped. */ + { + int stack = inferior_registers.r_reg[SP_REGNUM]; + int stuff = ptrace (PTRACE_PEEKDATA, inferior_pid, stack); + int reg = inferior_registers.r_reg[EAX]; + inferior_registers.r_reg[EAX] = + inferior_registers.r_reg[FP_REGNUM]; + ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers); + ptrace (PTRACE_POKEDATA, inferior_pid, stack, 0xc589); + ptrace (PTRACE_SINGLESTEP, inferior_pid, stack, 0); + wait (0); + ptrace (PTRACE_POKEDATA, inferior_pid, stack, stuff); + inferior_registers.r_reg[EAX] = reg; + } +#endif + ptrace (PTRACE_SETREGS, inferior_pid, &inferior_registers); + ptrace (PTRACE_SETFPREGS, inferior_pid, &inferior_fp_registers); +} + +/* Machine-dependent code which would otherwise be in core.c */ +/* Work with core files, for GDB. */ + + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + + { + struct core corestr; + + val = myread (corechan, &corestr, sizeof corestr); + if (val < 0) + perror_with_name (filename); + if (corestr.c_magic != CORE_MAGIC) + error ("\"%s\" does not appear to be a core dump file (magic 0x%x, expected 0x%x)", + filename, corestr.c_magic, (int) CORE_MAGIC); + else if (sizeof (struct core) != corestr.c_len) + error ("\"%s\" has an invalid struct core length (%d, expected %d)", + filename, corestr.c_len, (int) sizeof (struct core)); + + data_start = exec_data_start; + data_end = data_start + corestr.c_dsize; + stack_start = stack_end - corestr.c_ssize; + data_offset = sizeof corestr; + stack_offset = sizeof corestr + corestr.c_dsize; + + bcopy (&corestr.c_regs, registers, sizeof corestr.c_regs); + + bcopy (corestr.c_fpu.f_fpstatus.f_st, + ®isters[REGISTER_BYTE (FP0_REGNUM)], + sizeof corestr.c_fpu.f_fpstatus.f_st); + bcopy (&corestr.c_fpu.f_fpstatus.f_ctrl, + ®isters[REGISTER_BYTE (FPC_REGNUM)], + sizeof corestr.c_fpu.f_fpstatus - + sizeof corestr.c_fpu.f_fpstatus.f_st); + + /* the struct aouthdr of sun coff is not the struct exec stored + in the core file. */ + bcopy (&corestr.c_aouthdr, &core_aouthdr, sizeof (struct exec)); +#ifndef COFF_ENCAPSULATE + core_aouthdr.magic = corestr.c_aouthdr.a_info; + core_aouthdr.vstamp = /*SUNVERSION*/ 31252; +#endif + printf ("Core file is from \"%s\".\n", corestr.c_cmdname); + if (corestr.c_signo > 0) + printf ("Program terminated with signal %d, %s.\n", + corestr.c_signo, + corestr.c_signo < NSIG + ? sys_siglist[corestr.c_signo] + : "(undocumented)"); + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} + +i387_to_double (from, to) + char *from; + char *to; +{ + long *lp; + /* push extended mode on 387 stack, then pop in double mode + * + * first, set exception masks so no error is generated - + * number will be rounded to inf or 0, if necessary + */ + asm ("pushl %eax"); /* grab a stack slot */ + asm ("fstcw (%esp)"); /* get 387 control word */ + asm ("movl (%esp),%eax"); /* save old value */ + asm ("orl $0x3f,%eax"); /* mask all exceptions */ + asm ("pushl %eax"); + asm ("fldcw (%esp)"); /* load new value into 387 */ + + asm ("movl 8(%ebp),%eax"); + asm ("fldt (%eax)"); /* push extended number on 387 stack */ + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpl (%eax)"); /* pop double */ + asm ("fwait"); + + asm ("popl %eax"); /* flush modified control word */ + asm ("fnclex"); /* clear exceptions */ + asm ("fldcw (%esp)"); /* restore original control word */ + asm ("popl %eax"); /* flush saved copy */ +} + +double_to_i387 (from, to) + char *from; + char *to; +{ + /* push double mode on 387 stack, then pop in extended mode + * no errors are possible because every 64-bit pattern + * can be converted to an extended + */ + asm ("movl 8(%ebp),%eax"); + asm ("fldl (%eax)"); + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpt (%eax)"); + asm ("fwait"); +} diff --git a/gdb/symmetry-tdep.c b/gdb/symmetry-tdep.c new file mode 100755 index 0000000..aba21c3 --- /dev/null +++ b/gdb/symmetry-tdep.c @@ -0,0 +1,494 @@ +/* Sequent Symmetry target interface, for GDB when running under Unix. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* many 387-specific items of use taken from i386-dep.c */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "symtab.h" + +#include <signal.h> +#include <sys/param.h> +#include <sys/user.h> +#include <sys/dir.h> +#include <sys/ioctl.h> +#include <sys/stat.h> +#include "gdbcore.h" +#include <fcntl.h> + +static long i386_get_frame_setup (); +static i386_follow_jump (); + +#include <sgtty.h> +#define TERMINAL struct sgttyb + +exec_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + + /* Eliminate all traces of old exec file. + Mark text segment as empty. */ + + if (execfile) + free (execfile); + execfile = 0; + data_start = 0; + data_end -= exec_data_start; + text_start = 0; + text_end = 0; + exec_data_start = 0; + exec_data_end = 0; + if (execchan >= 0) + close (execchan); + execchan = -1; + + /* Now open and digest the file the user requested, if any. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + execchan = openp (getenv ("PATH"), 1, filename, O_RDONLY, 0, + &execfile); + if (execchan < 0) + perror_with_name (filename); + +#ifdef COFF_FORMAT + { + int aout_hdrsize; + int num_sections; + + if (read_file_hdr (execchan, &file_hdr) < 0) + error ("\"%s\": not in executable format.", execfile); + + aout_hdrsize = file_hdr.f_opthdr; + num_sections = file_hdr.f_nscns; + + if (read_aout_hdr (execchan, &exec_aouthdr, aout_hdrsize) < 0) + error ("\"%s\": can't read optional aouthdr", execfile); + + if (read_section_hdr (execchan, _TEXT, &text_hdr, num_sections, + aout_hdrsize) < 0) + error ("\"%s\": can't read text section header", execfile); + + if (read_section_hdr (execchan, _DATA, &data_hdr, num_sections, + aout_hdrsize) < 0) + error ("\"%s\": can't read data section header", execfile); + + text_start = exec_aouthdr.text_start; + text_end = text_start + exec_aouthdr.tsize; + text_offset = text_hdr.s_scnptr; + exec_data_start = exec_aouthdr.data_start; + exec_data_end = exec_data_start + exec_aouthdr.dsize; + exec_data_offset = data_hdr.s_scnptr; + data_start = exec_data_start; + data_end += exec_data_start; + exec_mtime = file_hdr.f_timdat; + } +#else /* not COFF_FORMAT */ + { + struct stat st_exec; + + val = myread (execchan, &exec_aouthdr, sizeof (AOUTHDR)); + + if (val < 0) + perror_with_name (filename); + + text_start = N_ADDRADJ(exec_aouthdr); + exec_data_start = round(exec_aouthdr.a_text, NBPG*CLSIZE); + text_offset = N_TXTOFF (exec_aouthdr); + exec_data_offset = N_TXTOFF (exec_aouthdr) + exec_aouthdr.a_text; + text_end = exec_aouthdr.a_text; + exec_data_end = exec_data_start + exec_aouthdr.a_data; + data_start = exec_data_start; + data_end = data_start + exec_aouthdr.a_data; + exec_data_offset = N_TXTOFF(exec_aouthdr); + fstat (execchan, &st_exec); + exec_mtime = st_exec.st_mtime; + } +#endif /* not COFF_FORMAT */ + + validate_files (); + } + else if (from_tty) + printf ("No exec file now.\n"); + + /* Tell display code (if any) about the changed file name. */ + if (exec_file_display_hook) + (*exec_file_display_hook) (filename); +} + +/* rounds 'one' up to divide evenly by 'two' */ + +int +round(one,two) +register int one, two; + +{ + register int temp; + temp = (one/two)*two; + if (one != temp) { + temp += two; + } + return temp; +} + + +static CORE_ADDR codestream_next_addr; +static CORE_ADDR codestream_addr; +static unsigned char codestream_buf[sizeof (int)]; +static int codestream_off; +static int codestream_cnt; + +#define codestream_tell() (codestream_addr + codestream_off) +#define codestream_peek() (codestream_cnt == 0 ? \ + codestream_fill(1): codestream_buf[codestream_off]) +#define codestream_get() (codestream_cnt-- == 0 ? \ + codestream_fill(0) : codestream_buf[codestream_off++]) + + +static unsigned char +codestream_fill (peek_flag) +{ + codestream_addr = codestream_next_addr; + codestream_next_addr += sizeof (int); + codestream_off = 0; + codestream_cnt = sizeof (int); + read_memory (codestream_addr, + (unsigned char *)codestream_buf, + sizeof (int)); + + if (peek_flag) + return (codestream_peek()); + else + return (codestream_get()); +} + +static void +codestream_seek (place) +{ + codestream_next_addr = place & -sizeof (int); + codestream_cnt = 0; + codestream_fill (1); + while (codestream_tell() != place) + codestream_get (); +} + +static void +codestream_read (buf, count) + unsigned char *buf; +{ + unsigned char *p; + int i; + p = buf; + for (i = 0; i < count; i++) + *p++ = codestream_get (); +} + +/* + * Following macro translates i386 opcode register numbers to Symmetry + * register numbers. This is used by FRAME_FIND_SAVED_REGS. + * + * %eax %ecx %edx %ebx %esp %ebp %esi %edi + * i386 0 1 2 3 4 5 6 7 + * Symmetry 0 2 1 5 14 15 6 7 + * + */ +#define I386_REGNO_TO_SYMMETRY(n) \ +((n)==0?0 :(n)==1?2 :(n)==2?1 :(n)==3?5 :(n)==4?14 :(n)==5?15 :(n)) + +/* from i386-dep.c */ +i386_frame_find_saved_regs (fip, fsrp) + struct frame_info *fip; + struct frame_saved_regs *fsrp; +{ + unsigned long locals; + unsigned char *p; + unsigned char op; + CORE_ADDR dummy_bottom; + CORE_ADDR adr; + int i; + + bzero (fsrp, sizeof *fsrp); + + /* if frame is the end of a dummy, compute where the + * beginning would be + */ + dummy_bottom = fip->frame - 4 - NUM_REGS*4 - CALL_DUMMY_LENGTH; + + /* check if the PC is in the stack, in a dummy frame */ + if (dummy_bottom <= fip->pc && fip->pc <= fip->frame) + { + /* all regs were saved by push_call_dummy () */ + adr = fip->frame - 4; + for (i = 0; i < NUM_REGS; i++) + { + fsrp->regs[i] = adr; + adr -= 4; + } + return; + } + + locals = i386_get_frame_setup (get_pc_function_start (fip->pc)); + + if (locals >= 0) + { + adr = fip->frame - 4 - locals; + for (i = 0; i < 8; i++) + { + op = codestream_get (); + if (op < 0x50 || op > 0x57) + break; + fsrp->regs[I386_REGNO_TO_SYMMETRY(op - 0x50)] = adr; + adr -= 4; + } + } + + fsrp->regs[PC_REGNUM] = fip->frame + 4; + fsrp->regs[FP_REGNUM] = fip->frame; +} + +static long +i386_get_frame_setup (pc) +{ + unsigned char op; + + codestream_seek (pc); + + i386_follow_jump (); + + op = codestream_get (); + + if (op == 0x58) /* popl %eax */ + { + /* + * this function must start with + * + * popl %eax 0x58 + * xchgl %eax, (%esp) 0x87 0x04 0x24 + * or xchgl %eax, 0(%esp) 0x87 0x44 0x24 0x00 + * + * (the system 5 compiler puts out the second xchg + * inst, and the assembler doesn't try to optimize it, + * so the 'sib' form gets generated) + * + * this sequence is used to get the address of the return + * buffer for a function that returns a structure + */ + int pos; + unsigned char buf[4]; + static unsigned char proto1[3] = { 0x87,0x04,0x24 }; + static unsigned char proto2[4] = { 0x87,0x44,0x24,0x00 }; + pos = codestream_tell (); + codestream_read (buf, 4); + if (bcmp (buf, proto1, 3) == 0) + pos += 3; + else if (bcmp (buf, proto2, 4) == 0) + pos += 4; + + codestream_seek (pos); + op = codestream_get (); /* update next opcode */ + } + + if (op == 0x55) /* pushl %esp */ + { + if (codestream_get () != 0x8b) /* movl %esp, %ebp (2bytes) */ + return (-1); + if (codestream_get () != 0xec) + return (-1); + /* + * check for stack adjustment + * + * subl $XXX, %esp + * + * note: you can't subtract a 16 bit immediate + * from a 32 bit reg, so we don't have to worry + * about a data16 prefix + */ + op = codestream_peek (); + if (op == 0x83) /* subl with 8 bit immed */ + { + codestream_get (); + if (codestream_get () != 0xec) + return (-1); + /* subl with signed byte immediate + * (though it wouldn't make sense to be negative) + */ + return (codestream_get()); + } + else if (op == 0x81) /* subl with 32 bit immed */ + { + int locals; + if (codestream_get () != 0xec) + return (-1); + /* subl with 32 bit immediate */ + codestream_read ((unsigned char *)&locals, 4); + return (locals); + } + else + { + return (0); + } + } + else if (op == 0xc8) + { + /* enter instruction: arg is 16 unsigned immed */ + unsigned short slocals; + codestream_read ((unsigned char *)&slocals, 2); + codestream_get (); /* flush final byte of enter instruction */ + return (slocals); + } + return (-1); +} + +/* next instruction is a jump, move to target */ +static +i386_follow_jump () +{ + int long_delta; + short short_delta; + char byte_delta; + int data16; + int pos; + + pos = codestream_tell (); + + data16 = 0; + if (codestream_peek () == 0x66) + { + codestream_get (); + data16 = 1; + } + + switch (codestream_get ()) + { + case 0xe9: + /* relative jump: if data16 == 0, disp32, else disp16 */ + if (data16) + { + codestream_read ((unsigned char *)&short_delta, 2); + pos += short_delta + 3; /* include size of jmp inst */ + } + else + { + codestream_read ((unsigned char *)&long_delta, 4); + pos += long_delta + 5; + } + break; + case 0xeb: + /* relative jump, disp8 (ignore data16) */ + codestream_read ((unsigned char *)&byte_delta, 1); + pos += byte_delta + 2; + break; + } + codestream_seek (pos + data16); +} + +/* return pc of first real instruction */ +/* from i386-dep.c */ + +i386_skip_prologue (pc) +{ + unsigned char op; + int i; + + if (i386_get_frame_setup (pc) < 0) + return (pc); + + /* found valid frame setup - codestream now points to + * start of push instructions for saving registers + */ + + /* skip over register saves */ + for (i = 0; i < 8; i++) + { + op = codestream_peek (); + /* break if not pushl inst */ + if (op < 0x50 || op > 0x57) + break; + codestream_get (); + } + + i386_follow_jump (); + + return (codestream_tell ()); +} + +symmetry_extract_return_value(type, regbuf, valbuf) + struct type *type; + char *regbuf; + char *valbuf; +{ + union { + double d; + int l[2]; + } xd; + int i; + float f; + + if (TYPE_CODE_FLT == TYPE_CODE(type)) { + for (i = 0; i < misc_function_count; i++) { + if (!strcmp(misc_function_vector[i].name, "1167_flt")) + break; + } + if (i < misc_function_count) { + /* found "1167_flt" means 1167, %fp2-%fp3 */ + /* float & double; 19= %fp2, 20= %fp3 */ + /* no single precision on 1167 */ + xd.l[1] = *((int *)®buf[REGISTER_BYTE(19)]); + xd.l[0] = *((int *)®buf[REGISTER_BYTE(20)]); + switch (TYPE_LENGTH(type)) { + case 4: + f = (float) xd.d; + bcopy(&f, valbuf, TYPE_LENGTH(type)); + break; + case 8: + bcopy(&xd.d, valbuf, TYPE_LENGTH(type)); + break; + default: + error("Unknown floating point size"); + break; + } + } else { + /* 387 %st(0), gcc uses this */ + i387_to_double(((int *)®buf[REGISTER_BYTE(3)]), + &xd.d); + switch (TYPE_LENGTH(type)) { + case 4: /* float */ + f = (float) xd.d; + bcopy(&f, valbuf, 4); + break; + case 8: /* double */ + bcopy(&xd.d, valbuf, 8); + break; + default: + error("Unknown floating point size"); + break; + } + } + } else { + bcopy (regbuf, valbuf, TYPE_LENGTH (type)); + } +} diff --git a/gdb/symmetry-xdep.c b/gdb/symmetry-xdep.c new file mode 100755 index 0000000..3449678 --- /dev/null +++ b/gdb/symmetry-xdep.c @@ -0,0 +1,557 @@ +/* Sequent Symmetry host interface, for GDB when running under Unix. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* many 387-specific items of use taken from i386-dep.c */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" +#include "symtab.h" + +#include <signal.h> +#include <sys/param.h> +#include <sys/user.h> +#include <sys/dir.h> +#include <sys/ioctl.h> +#include <sys/stat.h> +#include "gdbcore.h" +#include <fcntl.h> + +static long i386_get_frame_setup (); +static i386_follow_jump (); + +#include <sgtty.h> +#define TERMINAL struct sgttyb + +store_inferior_registers(regno) +int regno; +{ + struct pt_regset regs; + int reg_tmp, i; + extern char registers[]; + +#if 0 + /* PREPARE_TO_STORE deals with this. */ + if (-1 == regno) + { +#endif + regs.pr_eax = *(int *)®isters[REGISTER_BYTE(0)]; + regs.pr_ebx = *(int *)®isters[REGISTER_BYTE(5)]; + regs.pr_ecx = *(int *)®isters[REGISTER_BYTE(2)]; + regs.pr_edx = *(int *)®isters[REGISTER_BYTE(1)]; + regs.pr_esi = *(int *)®isters[REGISTER_BYTE(6)]; + regs.pr_edi = *(int *)®isters[REGISTER_BYTE(7)]; + regs.pr_esp = *(int *)®isters[REGISTER_BYTE(14)]; + regs.pr_ebp = *(int *)®isters[REGISTER_BYTE(15)]; + regs.pr_eip = *(int *)®isters[REGISTER_BYTE(16)]; + regs.pr_flags = *(int *)®isters[REGISTER_BYTE(17)]; + for (i = 0; i < 31; i++) { + regs.pr_fpa.fpa_regs[i] = + *(int *)®isters[REGISTER_BYTE(FP1_REGNUM+i)]; + } +#if 0 + } + else + { + reg_tmp = *(int *)®isters[REGISTER_BYTE(regno)]; + ptrace(XPT_RREGS, inferior_pid, ®s, 0); + switch (regno) + { + case 0: + regs.pr_eax = *(int *)®isters[REGISTER_BYTE(0)]; + break; + case 5: + regs.pr_ebx = *(int *)®isters[REGISTER_BYTE(5)]; + break; + case 2: + regs.pr_ecx = *(int *)®isters[REGISTER_BYTE(2)]; + break; + case 1: + regs.pr_edx = *(int *)®isters[REGISTER_BYTE(1)]; + break; + case 6: + regs.pr_esi = *(int *)®isters[REGISTER_BYTE(6)]; + break; + case 7: + regs.pr_edi = *(int *)®isters[REGISTER_BYTE(7)]; + break; + case 15: + regs.pr_ebp = *(int *)®isters[REGISTER_BYTE(15)]; + break; + case 14: + regs.pr_esp = *(int *)®isters[REGISTER_BYTE(14)]; + break; + case 16: + regs.pr_eip = *(int *)®isters[REGISTER_BYTE(16)]; + break; + case 17: + regs.pr_flags = *(int *)®isters[REGISTER_BYTE(17)]; + break; + } + } +#endif /* 0 */ + ptrace(XPT_WREGS, inferior_pid, ®s, 0); +} + +void +fetch_inferior_registers() +{ + int i; + struct pt_regset regs; + extern char registers[]; + + registers_fetched (); + + ptrace(XPT_RREGS, inferior_pid, ®s, 0); + *(int *)®isters[REGISTER_BYTE(0)] = regs.pr_eax; + *(int *)®isters[REGISTER_BYTE(5)] = regs.pr_ebx; + *(int *)®isters[REGISTER_BYTE(2)] = regs.pr_ecx; + *(int *)®isters[REGISTER_BYTE(1)] = regs.pr_edx; + *(int *)®isters[REGISTER_BYTE(6)] = regs.pr_esi; + *(int *)®isters[REGISTER_BYTE(7)] = regs.pr_edi; + *(int *)®isters[REGISTER_BYTE(15)] = regs.pr_ebp; + *(int *)®isters[REGISTER_BYTE(14)] = regs.pr_esp; + *(int *)®isters[REGISTER_BYTE(16)] = regs.pr_eip; + *(int *)®isters[REGISTER_BYTE(17)] = regs.pr_flags; + for (i = 0; i < FPA_NREGS; i++) { + *(int *)®isters[REGISTER_BYTE(FP1_REGNUM+i)] = regs.pr_fpa.fpa_regs[i]; + } + bcopy(regs.pr_fpu.fpu_stack[0], ®isters[REGISTER_BYTE(3)], 10); + bcopy(regs.pr_fpu.fpu_stack[1], ®isters[REGISTER_BYTE(4)], 10); + bcopy(regs.pr_fpu.fpu_stack[2], ®isters[REGISTER_BYTE(8)], 10); + bcopy(regs.pr_fpu.fpu_stack[3], ®isters[REGISTER_BYTE(9)], 10); + bcopy(regs.pr_fpu.fpu_stack[4], ®isters[REGISTER_BYTE(10)], 10); + bcopy(regs.pr_fpu.fpu_stack[5], ®isters[REGISTER_BYTE(11)], 10); + bcopy(regs.pr_fpu.fpu_stack[6], ®isters[REGISTER_BYTE(12)], 10); + bcopy(regs.pr_fpu.fpu_stack[7], ®isters[REGISTER_BYTE(13)], 10); +} + + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +#include "gdbcore.h" + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct user u; + int reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name (filename); + data_start = exec_data_start; + + data_end = data_start + NBPG * (u.u_dsize - u.u_tsize); + stack_start = stack_end - NBPG * u.u_ssize; + data_offset = NBPG * UPAGES; + stack_offset = ctob(UPAGES + u.u_dsize - u.u_tsize); + reg_offset = (int) u.u_ar0 - KERNEL_U_ADDR; +printf("u.u_tsize= %#x, u.u_dsize= %#x, u.u_ssize= %#x, stack_off= %#x\n", + u.u_tsize, u.u_dsize, u.u_ssize, stack_offset); + + core_aouthdr.a_magic = 0; + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = lseek (corechan, register_addr (regno, reg_offset), 0); + if (val < 0) + perror_with_name (filename); + + val = myread (corechan, buf, sizeof buf); + if (val < 0) + perror_with_name (filename); + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame(create_new_frame(read_register(FP_REGNUM), + read_pc())); +/* set_current_frame (read_register (FP_REGNUM));*/ + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} + +/* from i386-dep.c */ +static +print_387_control_word (control) +unsigned short control; +{ + printf ("control 0x%04x: ", control); + printf ("compute to "); + switch ((control >> 8) & 3) + { + case 0: printf ("24 bits; "); break; + case 1: printf ("(bad); "); break; + case 2: printf ("53 bits; "); break; + case 3: printf ("64 bits; "); break; + } + printf ("round "); + switch ((control >> 10) & 3) + { + case 0: printf ("NEAREST; "); break; + case 1: printf ("DOWN; "); break; + case 2: printf ("UP; "); break; + case 3: printf ("CHOP; "); break; + } + if (control & 0x3f) + { + printf ("mask:"); + if (control & 0x0001) printf (" INVALID"); + if (control & 0x0002) printf (" DENORM"); + if (control & 0x0004) printf (" DIVZ"); + if (control & 0x0008) printf (" OVERF"); + if (control & 0x0010) printf (" UNDERF"); + if (control & 0x0020) printf (" LOS"); + printf (";"); + } + printf ("\n"); + if (control & 0xe080) printf ("warning: reserved bits on 0x%x\n", + control & 0xe080); +} + +static +print_387_status_word (status) + unsigned short status; +{ + printf ("status %#04x: ", status); + if (status & 0xff) { + printf ("exceptions:"); /* exception names match <machine/fpu.h> */ + if (status & 0x0001) printf (" FLTINV"); + if (status & 0x0002) printf (" FLTDEN"); + if (status & 0x0004) printf (" FLTDIV"); + if (status & 0x0008) printf (" FLTOVF"); + if (status & 0x0010) printf (" FLTUND"); + if (status & 0x0020) printf (" FLTPRE"); + if (status & 0x0040) printf (" FLTSTK"); + printf ("; "); + } + printf ("flags: %d%d%d%d; ", + (status & 0x4000) != 0, + (status & 0x0400) != 0, + (status & 0x0200) != 0, + (status & 0x0100) != 0); + + printf ("top %d\n", (status >> 11) & 7); +} + +static +print_fpu_status(ep) +struct pt_regset ep; + +{ + int i; + int bothstatus; + int top; + int fpreg; + unsigned char *p; + + printf("80387:"); + if (ep.pr_fpu.fpu_ip == 0) { + printf(" not in use.\n"); + return; + } else { + printf("\n"); + } + if (ep.pr_fpu.fpu_status != 0) { + print_387_status_word (ep.pr_fpu.fpu_status); + } + print_387_control_word (ep.pr_fpu.fpu_control); + printf ("last exception: "); + printf ("opcode 0x%x; ", ep.pr_fpu.fpu_rsvd4); + printf ("pc 0x%x:0x%x; ", ep.pr_fpu.fpu_cs, ep.pr_fpu.fpu_ip); + printf ("operand 0x%x:0x%x\n", ep.pr_fpu.fpu_data_offset, ep.pr_fpu.fpu_op_sel); + + top = (ep.pr_fpu.fpu_status >> 11) & 7; + + printf ("regno tag msb lsb value\n"); + for (fpreg = 7; fpreg >= 0; fpreg--) + { + double val; + + printf ("%s %d: ", fpreg == top ? "=>" : " ", fpreg); + + switch ((ep.pr_fpu.fpu_tag >> (fpreg * 2)) & 3) + { + case 0: printf ("valid "); break; + case 1: printf ("zero "); break; + case 2: printf ("trap "); break; + case 3: printf ("empty "); break; + } + for (i = 9; i >= 0; i--) + printf ("%02x", ep.pr_fpu.fpu_stack[fpreg][i]); + + i387_to_double (ep.pr_fpu.fpu_stack[fpreg], (char *)&val); + printf (" %g\n", val); + } + if (ep.pr_fpu.fpu_rsvd1) + printf ("warning: rsvd1 is 0x%x\n", ep.pr_fpu.fpu_rsvd1); + if (ep.pr_fpu.fpu_rsvd2) + printf ("warning: rsvd2 is 0x%x\n", ep.pr_fpu.fpu_rsvd2); + if (ep.pr_fpu.fpu_rsvd3) + printf ("warning: rsvd3 is 0x%x\n", ep.pr_fpu.fpu_rsvd3); + if (ep.pr_fpu.fpu_rsvd5) + printf ("warning: rsvd5 is 0x%x\n", ep.pr_fpu.fpu_rsvd5); +} + + +print_1167_control_word(pcr) +unsigned int pcr; + +{ + int pcr_tmp; + + pcr_tmp = pcr & FPA_PCR_MODE; + printf("\tMODE= %#x; RND= %#x ", pcr_tmp, pcr_tmp & 12); + switch (pcr_tmp & 12) { + case 0: + printf("RN (Nearest Value)"); + break; + case 1: + printf("RZ (Zero)"); + break; + case 2: + printf("RP (Positive Infinity)"); + break; + case 3: + printf("RM (Negative Infinity)"); + break; + } + printf("; IRND= %d ", pcr_tmp & 2); + if (0 == pcr_tmp & 2) { + printf("(same as RND)\n"); + } else { + printf("(toward zero)\n"); + } + pcr_tmp = pcr & FPA_PCR_EM; + printf("\tEM= %#x", pcr_tmp); + if (pcr_tmp & FPA_PCR_EM_DM) printf(" DM"); + if (pcr_tmp & FPA_PCR_EM_UOM) printf(" UOM"); + if (pcr_tmp & FPA_PCR_EM_PM) printf(" PM"); + if (pcr_tmp & FPA_PCR_EM_UM) printf(" UM"); + if (pcr_tmp & FPA_PCR_EM_OM) printf(" OM"); + if (pcr_tmp & FPA_PCR_EM_ZM) printf(" ZM"); + if (pcr_tmp & FPA_PCR_EM_IM) printf(" IM"); + printf("\n"); + pcr_tmp = FPA_PCR_CC; + printf("\tCC= %#x", pcr_tmp); + if (pcr_tmp & FPA_PCR_20MHZ) printf(" 20MHZ"); + if (pcr_tmp & FPA_PCR_CC_Z) printf(" Z"); + if (pcr_tmp & FPA_PCR_CC_C2) printf(" C2"); + if (pcr_tmp & FPA_PCR_CC_C1) printf(" C1"); + switch (pcr_tmp) { + case FPA_PCR_CC_Z: + printf(" (Equal)"); + break; + case FPA_PCR_CC_C1: + printf(" (Less than)"); + break; + case 0: + printf(" (Greater than)"); + break; + case FPA_PCR_CC_Z | FPA_PCR_CC_C1 | FPA_PCR_CC_C2: + printf(" (Unordered)"); + break; + default: + printf(" (Undefined)"); + break; + } + printf("\n"); + pcr_tmp = pcr & FPA_PCR_AE; + printf("\tAE= %#x", pcr_tmp); + if (pcr_tmp & FPA_PCR_AE_DE) printf(" DE"); + if (pcr_tmp & FPA_PCR_AE_UOE) printf(" UOE"); + if (pcr_tmp & FPA_PCR_AE_PE) printf(" PE"); + if (pcr_tmp & FPA_PCR_AE_UE) printf(" UE"); + if (pcr_tmp & FPA_PCR_AE_OE) printf(" OE"); + if (pcr_tmp & FPA_PCR_AE_ZE) printf(" ZE"); + if (pcr_tmp & FPA_PCR_AE_EE) printf(" EE"); + if (pcr_tmp & FPA_PCR_AE_IE) printf(" IE"); + printf("\n"); +} + +print_1167_regs(regs) +long regs[FPA_NREGS]; + +{ + int i; + + union { + double d; + long l[2]; + } xd; + union { + float f; + long l; + } xf; + + + for (i = 0; i < FPA_NREGS; i++) { + xf.l = regs[i]; + printf("%%fp%d: raw= %#x, single= %f", i+1, regs[i], xf.f); + if (!(i & 1)) { + printf("\n"); + } else { + xd.l[1] = regs[i]; + xd.l[0] = regs[i+1]; + printf(", double= %f\n", xd.d); + } + } +} + +print_fpa_status(ep) +struct pt_regset ep; + +{ + + printf("WTL 1167:"); + if (ep.pr_fpa.fpa_pcr !=0) { + printf("\n"); + print_1167_control_word(ep.pr_fpa.fpa_pcr); + print_1167_regs(ep.pr_fpa.fpa_regs); + } else { + printf(" not in use.\n"); + } +} + +i386_float_info () + +{ + char ubuf[UPAGES*NBPG]; + struct pt_regset regset; + extern int corechan; + + if (have_inferior_p()) { + call_ptrace(XPT_RREGS, inferior_pid, ®set, 0); + } else { + if (lseek (corechan, 0, 0) < 0) { + perror ("seek on core file"); + } + if (myread (corechan, ubuf, UPAGES*NBPG) < 0) { + perror ("read on core file"); + } + /* only interested in the floating point registers */ + regset.pr_fpu = ((struct user *) ubuf)->u_fpusave; + regset.pr_fpa = ((struct user *) ubuf)->u_fpasave; + } + print_fpu_status(regset); + print_fpa_status(regset); +} + +i387_to_double (from, to) + char *from; + char *to; +{ + long *lp; + /* push extended mode on 387 stack, then pop in double mode + * + * first, set exception masks so no error is generated - + * number will be rounded to inf or 0, if necessary + */ + asm ("pushl %eax"); /* grab a stack slot */ + asm ("fstcw (%esp)"); /* get 387 control word */ + asm ("movl (%esp),%eax"); /* save old value */ + asm ("orl $0x3f,%eax"); /* mask all exceptions */ + asm ("pushl %eax"); + asm ("fldcw (%esp)"); /* load new value into 387 */ + + asm ("movl 8(%ebp),%eax"); + asm ("fldt (%eax)"); /* push extended number on 387 stack */ + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpl (%eax)"); /* pop double */ + asm ("fwait"); + + asm ("popl %eax"); /* flush modified control word */ + asm ("fnclex"); /* clear exceptions */ + asm ("fldcw (%esp)"); /* restore original control word */ + asm ("popl %eax"); /* flush saved copy */ +} + +double_to_i387 (from, to) + char *from; + char *to; +{ + /* push double mode on 387 stack, then pop in extended mode + * no errors are possible because every 64-bit pattern + * can be converted to an extended + */ + asm ("movl 8(%ebp),%eax"); + asm ("fldl (%eax)"); + asm ("fwait"); + asm ("movl 12(%ebp),%eax"); + asm ("fstpt (%eax)"); + asm ("fwait"); +} diff --git a/gdb/tdesc.c b/gdb/tdesc.c new file mode 100755 index 0000000..9a632e3 --- /dev/null +++ b/gdb/tdesc.c @@ -0,0 +1,1650 @@ +/* This file has been modified by Data General Corporation, November 1989. */ + +/* +This file provides an abstract interface to "tdesc" information. + It is designed to be used in a uniform manner by several kinds + of debuggers: + (1) code in live debugged process (e.g., a traceback routine) + (2) a separate-process debugger debugging a live process + (3) a separate-process debugger debugging a memory dump + + Dcontext model notes + * captures machine context + * partial: excludes memory + * frames + * kinds + * make one for starters, chain in reverse order to previous ones + * representation: pointer to opaque + * alloc/free protocol + + Overall model + * access functions + * handle + * error handling +*/ + + + +typedef int dc_boolean_t; /* range 0 .. 1 */ +#define DC_FALSE 0 +#define DC_TRUE 1 + + +typedef int dc_tristate_t; /* range 0 .. 2 */ +#define DC_NO 0 +#define DC_YES 1 +#define DC_MAYBE 2 + + +/* + A word is 32 bits of information. In memory, a word is word-aligned. + + A common and important use of dc_word_t is to represent values in the + target process, including (byte) addresses in the target process. + In this case, C arithmetic can be used to simulate machine address + arithmetic on the target. (Unsigned arithmetic is actually modulus + arithmetic.) +*/ +typedef unsigned int dc_word_t; + + +/* These bit operations number bits from 0 at the least significant end. */ +#define bit_test(word,bit) ((word) & (1 << (bit))) /* returns 0 or other */ +#define bit_value(word,bit) (((word) >> (bit)) & 1) /* returns 0 or 1 */ +#define bit_set(word,bit) ((word) |= (1 << (bit))) +#define bit_clear(word,bit) ((word) &= ~(1 << (bit))) +#define bit_assign(word, bit, bool) \ + if (bool) bit_set(word, bit); else bit_clear(word, bit) + + +/*----------------*/ + + +/* The exactness of locations may not be certainly known. */ +typedef dc_tristate_t dc_exactness_t; + + +/* + The model includes five kinds of contexts. Because each context + has an associated region and frame, these describe region kinds + and frame kinds as well. + [more description needed] + Currently, only call contexts exist. +*/ + +typedef int dc_kind_t; /* range 0 .. 4 */ +#define DC_CALL_KIND 0 +#define DC_SAVE_KIND 1 +#define DC_EXCEPTION_KIND 2 +#define DC_PROTECTION_KIND 3 +#define DC_SPECIAL_KIND 4 +#define DC_NUM_KINDS 5 + +#define DC_MIO_ENTRY_POINT (1<< 0) +#define DC_MIO_PROLOGUE_END (1<< 1) +#define DC_MIO_EPILOGUE_START (1<< 2) +#define DC_MIO_IMPLICIT_PROLOGUE_END (1<<16) +#define DC_MIO_LITERAL_ENTRY_POINT (1<<17) +#define DC_MIO_LITERAL_EPILOGUE_START (1<<18) + +#define DC_MII_PRECEDING_TDESC_END (1<<0) +#define DC_MII_FOLLOWING_TDESC_START (1<<1) + +typedef struct dc_debug_info { + unsigned int protocol; /* 1 for this structure */ + dc_word_t tdesc_ptr; + unsigned int text_words_count; + dc_word_t text_words_ptr; + unsigned int data_words_count; + dc_word_t data_words_ptr; +} dc_debug_info_t; + + +typedef struct tdesc_hdr { + unsigned int map_protocol; /* 1 for this structure */ + unsigned int end; /* address beyond end */ +} tdesc_hdr_t; + + +typedef struct tdesc_chunk_hdr { + int zeroes : 8; + int info_length : 22; + int info_alignment : 2; + unsigned int info_protocol; + dc_word_t start_address; + dc_word_t end_address; +} tdesc_chunk_hdr_t; + + +typedef struct tdesc_chunk_info1 { + int variant : 8; /* 1 for this structure */ + int register_save_mask : 17; + int pad1 : 1; + int return_address_info_discriminant : 1; + int frame_address_register : 5; + unsigned int frame_address_offset; + unsigned int return_address_info; + unsigned int register_save_offset; +} tdesc_chunk_info1_t; + + +typedef struct tdesc_chunk1 { + tdesc_chunk_hdr_t hdr; + tdesc_chunk_info1_t info; +} tdesc_chunk1_t; + + +typedef struct dc_mstate { + dc_word_t reg[32]; /* general registers */ + dc_word_t xip; + dc_word_t nip; + dc_word_t fip; + dc_word_t fpsr; + dc_word_t fpcr; + dc_word_t psr; +} dc_mstate_t; + + +typedef struct dc_map_info_in { + dc_word_t flags; + dc_word_t preceding_tdesc_end; + dc_word_t following_tdesc_start; +} dc_map_info_in_t; + + +typedef struct dc_map_info_out { + dc_word_t flags; + dc_word_t entry_point; + dc_word_t prologue_end; + dc_word_t epilogue_start; +} dc_map_info_out_t; + + +#if 0 + + void error_fcn (env, continuable, message) + dc_word_t env; /* environment (arbitrary datum) */ + dc_boolean_t continuable; /* whether error function may return */ + char *message; /* string (no trailing newline) */ + + /* In the future, we probably want the error_fcn to be: */ + void error_fcn (env, continuable, code, ...) + dc_word_t env; /* environment (arbitrary datum) */ + dc_boolean_t continuable; /* whether error function may return */ + int code; /* error code */ + ... /* parameters to message associated + with the code */ + + void read_fcn (env, memory, length, buffer) + dc_word_t env; /* environment (arbitrary datum) */ + dc_word_t memory; /* start address in image */ + int length; /* in bytes */ + char *buffer; /* start address of buffer */ + /* There are no alignment assumptions for the read function. */ + + void write_fcn (env, memory, length, buffer) + dc_word_t env; /* environment (arbitrary datum) */ + dc_word_t memory; /* start address in image */ + int length; /* in bytes */ + char *buffer; /* start address of buffer */ + /* There are no alignment assumptions for the write function. */ + /* The write function is optional. It must be provided if changes + to writable registers are to be made. */ + + void exec_fcn (env, mstate) + dc_word_t env; /* environment (arbitrary datum) */ + dc_mstate_t *mstate; /* machine state (read-write) */ + /* The execute function is optional. It would be used (in the future) + by the implementation of a procedurally specified tdesc mechanism. */ + +#endif + +/*----------------*/ + + +#ifndef NULL +#define NULL ((void *) 0) +#endif + +extern char *malloc(); +extern char *calloc(); +extern void qsort(); + + +/* + At initialization, create a tdesc table from the tdesc info. + A tdesc table is simply a sorted array of tdesc elements. + A tdesc element is the last 6 words of the tdesc chunk. + We require that all tdesc chunks have info protocol 1. +*/ + +typedef struct tdesc_elem { + dc_word_t start_address; + dc_word_t end_address; + tdesc_chunk_info1_t info; +} tdesc_elem_t; + +typedef tdesc_elem_t *tdesc_table_t; + +void dc_correct_cr_data(); + +int dc_compare_tdesc_elems (elem1, elem2) + char *elem1, *elem2; +{ + dc_word_t s1, s2, e1, e2; + s1 = ((tdesc_elem_t *) elem1)->start_address; + s2 = ((tdesc_elem_t *) elem2)->start_address; + if (s1 < s2) return -1; + if (s1 > s2) return +1; + e1 = ((tdesc_elem_t *) elem1)->end_address; + e2 = ((tdesc_elem_t *) elem2)->end_address; + if (e1 < e2) return -1; + if (e1 > e2) return +1; + return 0; +} + + +typedef struct handle_info { + dc_word_t debug_info_ptr; + void (*error_fcn)(); + dc_word_t error_env; + void (*read_fcn)(); + dc_word_t read_env; + void (*write_fcn)(); /* NULL => absent */ + dc_word_t write_env; + void (*exec_fcn)(); /* NULL => absent */ + dc_word_t exec_env; + void (*map_fcn)(); /* NULL => absent */ + dc_word_t map_env; + tdesc_table_t tdesc_table; + int tdesc_table_size; +} handle_info_t; + +typedef handle_info_t *dc_handle_t; + + +/* + Errors detected in this module are funnelled through dc_error or dc_warn, + as appropriate. Both routines call dc_exception, which invokes the error + handler supplied by the user. + + Currently, dc_exception substitutes parameters into the message given + it and passes the resulting string to the user error handler. + In the future, dc_exception should simply pass an error code and + the parameters on to the user error handler. +*/ + +#include <varargs.h> +extern int vsprintf(); + +/* Exit status for exception-processing machinery failure */ +#define DC_EXCEPTION_FAILURE 250 + +void dc_exception(continuable, args) + dc_boolean_t continuable; + va_list args; +{ + dc_handle_t handle; + char *format; + char buffer[1024]; + + handle = va_arg(args, dc_handle_t); + format = va_arg(args, char *); + (void) vsprintf(buffer, format, args); + (*(handle->error_fcn)) (handle->error_env, continuable, buffer); + if (!continuable) + exit(DC_EXCEPTION_FAILURE); /* User error handler should never return in this case. */ +} + + +void dc_error(va_alist) /* (handle, format, args... ) */ + va_dcl +{ + va_list args; + + va_start(args); + dc_exception(DC_FALSE, args); + va_end(args); +} + + +void dc_warn(va_alist) /* (handle, format, args... ) */ + va_dcl +{ + va_list args; + + va_start(args); + dc_exception(DC_TRUE, args); + va_end(args); +} + + + +#define MALLOC_FAILURE_MESSAGE "Heap space exhausted (malloc failed)." +#define CALLOC_FAILURE_MESSAGE "Heap space exhausted (Calloc failed)." + + +/* Commonize memory allocation call so failure diagnosis is easier */ + +char* dc_malloc( handle, size ) + dc_handle_t handle; + int size; +{ + char* space = malloc( size ); + if (space == (char *)NULL) + dc_error( handle, MALLOC_FAILURE_MESSAGE ); + + return space; +} + + +/* Commonize memory allocation call so failure diagnosis is easier */ + +char* dc_calloc( handle,nelem, size ) + dc_handle_t handle; + int nelem; + int size; +{ + char* space = calloc( nelem, size ); + if (space == (char *)NULL) + dc_error( handle, CALLOC_FAILURE_MESSAGE ); + + return space; +} + + +dc_word_t dc_read_word (handle, address) + dc_handle_t handle; + dc_word_t address; +{ + dc_word_t word; + (*(handle->read_fcn)) (handle->read_env, address, + sizeof(dc_word_t), (char *)(&(word))); + return word; +} + + +void dc_write_word (handle, address, value) + dc_handle_t handle; + dc_word_t address; + dc_word_t value; +{ + dc_word_t word; + word = value; + if (handle->write_fcn) { + (*(handle->write_fcn)) (handle->write_env, address, + sizeof(dc_word_t), (char *)(&(word))); + } else { + dc_error (handle, "Writing is disabled."); + } +} + + +void dc_write_masked_word (handle, address, mask, value) + dc_handle_t handle; + dc_word_t address; + dc_word_t mask; + dc_word_t value; +{ + dc_write_word (handle, address, + (value & mask) | (dc_read_word(handle, address) & ~mask)); +} + + +dc_handle_t dc_initiate (debug_info_ptr, + error_fcn, error_env, + read_fcn, read_env, + write_fcn, write_env, + exec_fcn, exec_env, + map_fcn, map_env) + dc_word_t debug_info_ptr; + void (*error_fcn)(); + dc_word_t error_env; + void (*read_fcn)(); + dc_word_t read_env; + void (*write_fcn)(); /* NULL => absent */ + dc_word_t write_env; + void (*exec_fcn)(); /* NULL => absent */ + dc_word_t exec_env; + void (*map_fcn)(); /* NULL => absent */ + dc_word_t map_env; + /* write_fcn may be given as NULL if no writing is required. */ + /* exec_fcn may be given as NULL if no execution is required. + Currently, no execution is required. It would be if the + implementation needed to invoke procedures in the debugged process. */ +{ + dc_handle_t handle; + unsigned int debug_info_protocol; + dc_debug_info_t debug_info; + unsigned int tdesc_map_protocol; + tdesc_hdr_t tdesc_hdr; + dc_word_t tdesc_info_start; + dc_word_t tdesc_info_end; + dc_word_t tdesc_info_length; + + /* Set up handle enough for dc_error. */ + handle = (dc_handle_t) malloc(sizeof(handle_info_t)); + /* Cant use dc_malloc() as handle is being created ... */ + /* if (handle == NULL) (*error_fcn)( error_env, MALLOC_FAILURE_MESSAGE ) */ + handle->error_fcn = error_fcn; + handle->error_env = error_env; + handle->read_fcn = read_fcn; + handle->read_env = read_env; + handle->write_fcn = write_fcn; + handle->write_env = write_env; + handle->exec_fcn = exec_fcn; + handle->exec_env = exec_env; +/****************************************************************/ +/* BUG 9/19/89 Found by hls. Map functions not initialized. */ +/****************************************************************/ + handle->map_fcn = map_fcn; + handle->map_env = map_env; + handle->debug_info_ptr = debug_info_ptr; + handle->tdesc_table = (tdesc_table_t)NULL; + + /* Find tdesc info. */ + if (debug_info_ptr) { + (*read_fcn) (read_env, debug_info_ptr, sizeof(unsigned int), + (char *)(&debug_info_protocol)); + if (debug_info_protocol != 1) + dc_error (handle, "Unrecognized debug info protocol: %d", + debug_info_protocol); + (*read_fcn) (read_env, debug_info_ptr, sizeof(dc_debug_info_t), + (char *)(&debug_info)); + (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(unsigned int), + (char *)(&tdesc_map_protocol)); + if (tdesc_map_protocol != 1) + dc_error (handle, "Unrecognized tdesc map protocol: %d", + tdesc_map_protocol); + (*read_fcn) (read_env, debug_info.tdesc_ptr, sizeof(tdesc_hdr_t), + (char *)(&tdesc_hdr)); + tdesc_info_start = debug_info.tdesc_ptr + sizeof(tdesc_hdr_t); + tdesc_info_end = tdesc_hdr.end; + tdesc_info_length = tdesc_info_end - tdesc_info_start; + + /* Create tdesc table from tdesc info. */ + { + /* Over-allocate in order to avoid second pass over tdesc info. */ + tdesc_table_t tt = (tdesc_table_t) dc_malloc(handle, tdesc_info_length); + dc_word_t p = tdesc_info_start; + dc_word_t q = tdesc_info_end - sizeof(tdesc_chunk1_t); + int n = 0; + tdesc_chunk1_t chunk; + dc_word_t start_address, end_address; + int i; + + for (; p <= q; ) { + (*read_fcn) (read_env, p, sizeof(tdesc_chunk1_t), (char *)(&chunk)); + if (chunk.hdr.zeroes != 0) { + /* Skip padding. */ + p += sizeof(dc_word_t); + continue; + } + if (chunk.hdr.info_protocol != 1) { + dc_warn (handle, "Unrecognized tdesc info protocol: %d", + chunk.hdr.info_protocol); + goto next_chunk; + } + if (chunk.hdr.info_length != 16) { + dc_warn (handle, "Incorrect tdesc info length: %d", + chunk.hdr.info_length); + goto next_chunk; + } + if (chunk.hdr.info_alignment > 2) { + dc_warn (handle, "Incorrect tdesc info alignment: %d", + chunk.hdr.info_alignment); + goto next_chunk; + } + start_address = chunk.hdr.start_address; + end_address = chunk.hdr.end_address; + if ((start_address&3)!=0) { + dc_warn (handle, + "Tdesc start address is not word-aligned: %#.8X", + start_address); + goto next_chunk; + } + if ((end_address&3)!=0) { + dc_warn (handle, + "Tdesc end address is not word-aligned: %#.8X", + end_address); + goto next_chunk; + } + if (start_address > end_address) { + /* Note that the range may be null. */ + dc_warn (handle, + "Tdesc start address (%#.8X) follows end address (%#.8X).", + start_address, end_address); + goto next_chunk; + } + if (chunk.info.variant != 1) { + dc_warn (handle, "Invalid tdesc chunk variant: %d", + chunk.info.variant); + goto next_chunk; + } + if (chunk.info.pad1 != 0) { + dc_warn (handle, "Tdesc chunk padding is not zero."); + goto next_chunk; + } + if (chunk.info.return_address_info_discriminant != 0) { + if ((chunk.info.return_address_info & 3) != 0) { + dc_warn (handle, + "Tdesc return address offset is not word-aligned: %#.8X", + chunk.info.return_address_info); + goto next_chunk; + } + } else { + if ((chunk.info.return_address_info & ~31) != 0) { + dc_warn (handle, + "Invalid tdesc return address register: %d", + chunk.info.return_address_info); + goto next_chunk; + } + } + if ((chunk.info.register_save_offset & 3) != 0) { + dc_warn (handle, + "Tdesc register save offset is not word-aligned: %#.8X", + chunk.info.register_save_offset); + goto next_chunk; + } + + tt[n].start_address = start_address; + tt[n].end_address = end_address; + tt[n].info = chunk.info; + n++; + + next_chunk: + p += sizeof(tdesc_chunk1_t); + } + /* Leftover (less than a tdesc_chunk1_t in size) is padding or + in error. Ignore it in either case. */ + + if (n != 0) { + + /* Sort table by start address. */ + qsort ((char *)tt, n, sizeof(tdesc_elem_t), dc_compare_tdesc_elems); + + /* Check for overlap among tdesc chunks. */ + for (i=0; i<(n-1); i++) { + if (tt[i].end_address > tt[i+1].start_address) + dc_error (handle, "Text chunks overlap."); + } + } + + /* Finish setting up handle. */ + handle->tdesc_table = tt; + handle->tdesc_table_size = n; + } + } else { + handle->tdesc_table_size = 0; + } + + return (dc_handle_t) handle; +} + + +void dc_terminate (handle) + dc_handle_t handle; +{ + if (((dc_handle_t)handle)->tdesc_table) { + free((char *)(((dc_handle_t)handle)->tdesc_table)); + } + free((char *)handle); +} + + + +/* + + Dcontext Model + + For each interesting register (word-sized piece of machine state), + a word of value information is kept. This word may + be either the value of the register, or the address in + subject memory where the value can be found (and changed). In + addition, the register may be invalid (in which case the value + information is undefined). These three cases are encoded for + a given register in the same-numbered bit of two words of flags: + + flags[0] bit flags[1] bit meaning + ------------ ------------ ------- + 0 0 register is invalid; info is undefined + 0 1 register is readable; info is value + 1 0 register is writable; info is address + 1 1 (reserved) + + The general registers (r0-r31) are handled by reg_info and + reg_flags. The bit number for a register is that register's number. + The other registers are grouped together for convenience and are + handled by aux_info and aux_flags. The bit numbers for these + registers are: + + bit number register + ---------- -------- + 0 location + 1 SXIP + 2 SNIP + 3 SFIP + 4 FPSR + 5 FPCR + + The SXIP, SNIP, and SFIP are the exception-time values of the + XIP, NIP, and FIP registers. They are valid only in the topmost frame. + (That is, in any context obtained from dc_previous_context, they + are invalid.) + + "location" is a pseudo-register of this model and represents the + location of the context. It is always valid. It also has an + exactness associated with it. The location and its exactness of a + context obtained from dc_previous_context are taken from the + return address and its exactness of the context given as an argument + to dc_previous_context. + + The following model is recommended for dealing with the partial + redundancy between location and the SXIP, SNIP, and SFIP values + in the topmost frame. The location should be set to either the + SNIP or SXIP value, and its exactness should be set to DC_NO. A + change to the register whose value the location is set to should + be accompanied by an identical change to the location. + + The PSR is handled separately, because it is a diverse collection + of flags. The PSR, as a whole, is always valid. A separate + psr_ind flag tells whether the psr_info data is a value or + an address. Each bit of the PSR has its own pair of flag bits to + mark validity and writability. + +*/ + + +/* The following value means "other", because state is stored in 2 bits. */ +#define DC_RESERVED 3 + + +#define RSTATE(flags, bit) \ + ((bit_value((flags)[0], bit) << 1) + bit_value((flags)[1], bit)) + +#define REG_STATE(dcontext, reg) RSTATE(dcontext->reg_flags, reg) +#define AUX_STATE(dcontext, reg) RSTATE(dcontext->aux_flags, reg) +#define PSR_STATE(dcontext, reg) RSTATE(dcontext->psr_flags, reg) + + +#define SET_INVALID(flags, bit) \ + { bit_clear ((flags)[0], bit); bit_clear ((flags)[1], bit); } + +#define SET_READABLE(flags, bit) \ + { bit_clear ((flags)[0], bit); bit_set ((flags)[1], bit); } + +#define SET_WRITABLE(flags, bit) \ + { bit_set ((flags)[0], bit); bit_clear ((flags)[1], bit); } + +#define ASSIGN_RSTATE(to_flags, to_bit, from_flags, from_bit) \ + { bit_assign ((to_flags)[0], to_bit, bit_value((from_flags)[0], from_bit));\ + bit_assign ((to_flags)[1], to_bit, bit_value((from_flags)[1], from_bit));} + + +#define CHECK_REG_READ(dcontext, reg) \ + if (REG_STATE(dcontext, reg) == DC_INVALID) \ + dc_error (dcontext->handle, \ + "General register %d is not readable.", reg) + +#define CHECK_REG_WRITE(dcontext, reg) \ + if (REG_STATE(dcontext, reg) != DC_WRITABLE) \ + dc_error (dcontext->handle, \ + "General register %d is not writable.", reg) + +#define CHECK_AUX_READ(dcontext, reg) \ + if (AUX_STATE(dcontext, reg) == DC_INVALID) \ + dc_error (dcontext->handle, \ + "Auxiliary register %d is not readable.", reg) + +#define CHECK_AUX_WRITE(dcontext, reg) \ + if (AUX_STATE(dcontext, reg) != DC_WRITABLE) \ + dc_error (dcontext->handle, \ + "Auxiliary register %d is not writable.", reg) + + + +#define DC_REG_RA 1 +#define DC_REG_FP 30 +#define DC_REG_SP 31 +#define DC_NUM_REG 32 + +#define DC_AUX_LOC 0 + /* DC_AUX_LOC must be first, with value 0 */ +#define DC_AUX_SXIP 1 +#define DC_AUX_SNIP 2 +#define DC_AUX_SFIP 3 +#define DC_AUX_FPSR 4 +#define DC_AUX_FPCR 5 +#define DC_NUM_AUX 6 + + + +#define CHECK_REG(dcontext, reg) \ + if ((reg < 0) || (reg >= DC_NUM_REG)) \ + dc_error (dcontext->handle, \ + "Bad general register number: %d", reg) + +#define CHECK_AUX(dcontext, reg) \ + if ((reg < 1) || (reg >= DC_NUM_AUX)) \ + dc_error (dcontext->handle, \ + "Bad auxiliary register number: %d", reg) + /* CHECK_AUX is not used for location pseudo-register. */ + +#define CHECK_BIT(dcontext, bit) \ + if ((bit < 0) || (bit >= 32)) \ + dc_error (dcontext->handle, \ + "Bad bit number: %d", bit) + + + +typedef struct cr_value { + int reg; + unsigned int off; + } dc_cr_value_t; + +#define DC_UNDEF 32 + +/* + A "dc_cr_value" represents an execution-time value symbolically, in + terms of the initial value of a register (the value on entry to + the procedure being analyzed) and a known offset. A value with + a 'reg' field value of 0 through 31 represents the value obtained + by summing (using 32-bit modulus arithmetic) the initial value of + register 'reg' and the value 'off'. Note that the value (0,k) + represents the constant value k, that (31,0) represents the CFA, and + that (1,0) represents the return address. A value with a 'reg' field + of DC_UNDEF represents an indeterminable value; in this case the + 'off' field is undefined. Other values of 'reg' are erroneous. +*/ + +typedef struct cr_data { + dc_cr_value_t reg_val[DC_NUM_REG]; + dc_word_t saved; + dc_word_t how; + unsigned int where[DC_NUM_REG]; +} dc_cr_data_t; + +/* + 'cr_data' collects all the information needed to represent the + symbolic machine state during code reading. + + The 'reg_val' array gives the current dc_cr_value for each register. + + The 'saved', 'how', and 'where' fields combine to describe what + registers have been saved, and where. The 'saved' and 'how' fields + are implicitly bit arrays over 0..31, where the numbering is from + 0 on the right. (Hence, 1<<r gives the mask for register r.) + If saved[r] is 0, the register is not saved, and how[r] and where[r] + are undefined. If saved[r] is 1, then how[r] tells whether register r + was saved in another register (how[r]==0) or in the frame (how[r]==1). + In the former case, where[r] gives the register number; in the latter + case, where[r] gives the frame position. +*/ + + +typedef int dc_register_state_t; /* range 0 to 2 */ + +#define DC_INVALID 0 +#define DC_READABLE 1 +#define DC_WRITABLE 2 + + + + +typedef struct dcontext_info { + dc_handle_t handle; /* environment of context */ + dc_word_t reg_info[DC_NUM_REG]; + dc_word_t reg_flags[2]; + dc_word_t aux_info[DC_NUM_AUX]; + dc_word_t aux_flags[2]; + dc_exactness_t loc_exact; + dc_word_t psr_info; /* value or address */ + dc_word_t psr_ind; /* DC_TRUE iff address */ + dc_word_t psr_flags[2]; /* per-PSR-bit flags */ + unsigned int code_reading; /* no tdesc therefore must read code*/ + union { + tdesc_elem_t *tdesc_elem_ptr; /* locates tdesc chunk */ + dc_cr_data_t *cr_data_ptr; /* or code reading data */ + } info_ptr; +} dcontext_info_t; + +typedef dcontext_info_t *dc_dcontext_t; + +dc_word_t dc_get_value (handle, info, flags, pos) + dc_handle_t handle; + dc_word_t info[]; + dc_word_t flags[2]; + int pos; + /* Assumes either DC_READABLE or DC_WRITABLE. */ +{ + if (bit_test(flags[0], pos)) { + /* DC_WRITABLE case */ + return dc_read_word(handle, info[pos]); + } else { + /* DC_READABLE case */ + return info[pos]; + } +} + +void dc_set_value (handle, info, flags, pos, value) + dc_handle_t handle; + dc_word_t info[]; + dc_word_t flags[2]; + int pos; + dc_word_t value; + /* Assumes DC_WRITABLE. */ +{ + dc_write_word(handle, info[pos], value); +} + + +#define GET_REG_VALUE(dcontext, reg) \ + dc_get_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg) + +#define SET_REG_VALUE(dcontext, reg, value) \ + dc_set_value(dcontext->handle, dcontext->reg_info, dcontext->reg_flags, reg, \ + value) + +#define GET_AUX_VALUE(dcontext, reg) \ + dc_get_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg) + +#define SET_AUX_VALUE(dcontext, reg, value) \ + dc_set_value(dcontext->handle, dcontext->aux_info, dcontext->aux_flags, reg, \ + value) + + + +void dc_check_dcontext (dc) + dc_dcontext_t dc; + /* Check consistency of information supplied to make a dcontext. */ +{ + int i; + + if ((REG_STATE(dc, 0) != DC_READABLE) || (dc->reg_info[0] != 0)) + dc_error (dc->handle, "Register 0 is misspecified"); + for (i = 1; i < DC_NUM_REG; i++) + if (REG_STATE(dc, i) == DC_RESERVED) + dc_error (dc->handle, + "State for general register %d is incorrect", i); + for (i = 0; i < DC_NUM_AUX; i++) + if (AUX_STATE(dc, i) == DC_RESERVED) + dc_error (dc->handle, + "State for auxiliary register %d is incorrect", i); + if (AUX_STATE(dc, DC_AUX_LOC) == DC_INVALID) + dc_error (dc->handle, "Location is specified as invalid"); + if (GET_AUX_VALUE(dc, DC_AUX_LOC) == 0) + dc_error (dc->handle, "Location is zero."); + if (dc->loc_exact >= 3) + dc_error (dc->handle, "Location exactness is incorrectly specified: %d", + dc->loc_exact); + if (dc->psr_ind >= 2) + dc_error (dc->handle, + "PSR indirection flag is incorrectly specified: %d", + dc->psr_ind); + for (i = 0; i < 32; i++) + if (PSR_STATE(dc, i) == DC_RESERVED) + dc_error (dc->handle, "State for PSR bit %d is incorrect", i); +} + + + +tdesc_elem_t * dc_tdesc_lookup (loc, tt, tt_size, map_info_in_ptr) + dc_word_t loc; + tdesc_table_t tt; + int tt_size; + dc_map_info_in_t *map_info_in_ptr; + /* Return address of tdesc_elem_t for given location, or NULL if + there is no tdesc chunk for the location. + */ +{ + int l = 0; + int h = tt_size; + int m; + + if (tt_size == 0) { + map_info_in_ptr->flags = 0; + return (tdesc_elem_t *)NULL; + } + for (;;) { + m = (l + h) / 2; + if (m == l) break; + if (loc >= tt[m].start_address) + l = m; + else + h = m; + } + if (loc >= tt[m].end_address) { + map_info_in_ptr->preceding_tdesc_end = tt[m].end_address; + if (m+1 < tt_size) { + map_info_in_ptr->following_tdesc_start = tt[m+1].start_address; + map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END | + DC_MII_FOLLOWING_TDESC_START; + } else { + map_info_in_ptr->flags = DC_MII_PRECEDING_TDESC_END; + } + return (tdesc_elem_t *)NULL; + } else if (loc < tt[m].start_address) { + map_info_in_ptr->following_tdesc_start = tt[m].start_address; + map_info_in_ptr->flags = DC_MII_FOLLOWING_TDESC_START; + return (tdesc_elem_t *)NULL; + } else { + return (&tt[m]); + } +} + + + +dc_dcontext_t dc_make_dcontext (handle, + reg_info, reg_flags, + aux_info, aux_flags, loc_exact, + psr_info, psr_ind, psr_flags) + dc_handle_t handle; + dc_word_t reg_info[DC_NUM_REG]; + dc_word_t reg_flags[2]; + dc_word_t aux_info[DC_NUM_AUX]; + dc_word_t aux_flags[2]; + dc_exactness_t loc_exact; + dc_word_t psr_info; + dc_boolean_t psr_ind; + dc_word_t psr_flags[2]; +{ + dc_dcontext_t dc = (dc_dcontext_t) dc_malloc (handle, sizeof(dcontext_info_t)); + int i; + dc_map_info_in_t map_info_in; + + /* Fill in supplied content. */ + dc->handle = ((dc_handle_t)handle); + for (i = 0; i < DC_NUM_REG; i++) dc->reg_info[i] = reg_info[i]; + for (i = 0; i < 2; i++) dc->reg_flags[i] = reg_flags[i]; + for (i = 0; i < DC_NUM_AUX; i++) dc->aux_info[i] = aux_info[i]; + for (i = 0; i < 2; i++) dc->aux_flags[i] = aux_flags[i]; + dc->loc_exact = loc_exact; + dc->psr_info = psr_info; + dc->psr_ind = psr_ind; + for (i = 0; i < 2; i++) dc->psr_flags[i] = psr_flags[i]; + + dc_check_dcontext(dc); + + /* Find tdesc information for the text chunk. */ + { +/***************************************************************/ +/* BUG 8/16/89 Found by hls. Not zeroing EV bits of location. */ +/* SHOULD USE dc_location()! */ +/* dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC); */ +/***************************************************************/ + dc_word_t loc = GET_AUX_VALUE(dc, DC_AUX_LOC) & ~3; + tdesc_elem_t *tep = + dc_tdesc_lookup(loc, ((dc_handle_t)handle)->tdesc_table, + ((dc_handle_t)handle)->tdesc_table_size,&map_info_in); + if (tep) { + dc->code_reading = 0; + dc->info_ptr.tdesc_elem_ptr = tep; + } else { + dc->code_reading = 1; + if (!dc->handle->map_fcn) { + dc_error (dc->handle, "No tdesc information for %#.8X and no map function supplied.",loc); + } +/****************************************************************/ +/* BUG 9/18/89 Found by hls. Not using dc_malloc() */ +/* dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)malloc(sizeof(dc_cr_data_t )); */ +/****************************************************************/ + dc->info_ptr.cr_data_ptr= (dc_cr_data_t *)dc_calloc(dc->handle,1,sizeof(dc_cr_data_t )); + dc_read_code(loc,dc,map_info_in,dc->info_ptr.cr_data_ptr); + } + } + + return (dc_dcontext_t) dc; +} + + + +void dc_free_dcontext (dcontext) + dc_dcontext_t dcontext; +{ +/****************************************************************/ +/* BUG 9/19/89 Found by hls. Freeing non-pointer value. */ +/* free((char *)dcontext->code_reading); */ +/****************************************************************/ + if (dcontext->code_reading) + free((char *)dcontext->info_ptr.cr_data_ptr); + free((char *)dcontext); +} + + + +dc_register_state_t dc_location_state (dcontext) + dc_dcontext_t dcontext; +{ + return AUX_STATE(((dc_dcontext_t)dcontext), DC_AUX_LOC); +} + + +dc_exactness_t dc_location_exactness (dcontext) + dc_dcontext_t dcontext; +{ + return ((dc_dcontext_t)dcontext)->loc_exact; +} + + +dc_word_t dc_location (dcontext) + dc_dcontext_t dcontext; + /* Return high 30 bits only. */ +{ + /* Don't need: CHECK_AUX_READ (((dc_dcontext_t)dcontext), DC_AUX_LOC); */ + return GET_AUX_VALUE (((dc_dcontext_t)dcontext), DC_AUX_LOC) & ~3; +} + + +dc_boolean_t dc_location_in_text_chunk( dcontext, value ) + dc_dcontext_t dcontext; + dc_word_t value; +{ + /* Check that new location is still within same text chunk. */ + tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr; +/********************************************************************/ +/* Bug in predicate -- LS adjusted according to OCS documentation.. */ +/* if ((value < tep->start_address) || (value >= tep->end_address))*/ +/********************************************************************/ + if ((value >= tep->start_address) && (value < tep->end_address)) + return DC_TRUE; + else + return DC_FALSE; + +} + + +void dc_set_location (dcontext, value) + dc_dcontext_t dcontext; + dc_word_t value; + /* Set high 30 bits only. */ +{ + if (dc_location_in_text_chunk( dcontext, value ) != DC_TRUE) + dc_warn (((dc_dcontext_t)dcontext)->handle, + "New location is not in same text chunk."); + + CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), DC_AUX_LOC); + dc_write_masked_word (((dc_dcontext_t)dcontext)->handle, + ((dc_dcontext_t)dcontext)->aux_info[DC_AUX_LOC], ~3, value); +} + + + +dc_register_state_t dc_general_register_state (dcontext, reg) + dc_dcontext_t dcontext; + int reg; +{ + CHECK_REG (((dc_dcontext_t)dcontext), reg); + return REG_STATE(((dc_dcontext_t)dcontext), reg); +} + + +dc_word_t dc_general_register (dcontext, reg) + dc_dcontext_t dcontext; + int reg; +{ + CHECK_REG (((dc_dcontext_t)dcontext), reg); + CHECK_REG_READ (((dc_dcontext_t)dcontext), reg); + return GET_REG_VALUE(((dc_dcontext_t)dcontext), reg); +} + + +void dc_set_general_register (dcontext, reg, value) + dc_dcontext_t dcontext; + int reg; + dc_word_t value; +{ + CHECK_REG (((dc_dcontext_t)dcontext), reg); + CHECK_REG_WRITE (((dc_dcontext_t)dcontext), reg); + SET_REG_VALUE (((dc_dcontext_t)dcontext), reg, value); +} + + + +dc_register_state_t dc_auxiliary_register_state (dcontext, reg) + dc_dcontext_t dcontext; + int reg; +{ + CHECK_AUX (((dc_dcontext_t)dcontext), reg); + return AUX_STATE(((dc_dcontext_t)dcontext), reg); +} + + +dc_word_t dc_auxiliary_register (dcontext, reg) + dc_dcontext_t dcontext; + int reg; +{ + CHECK_AUX (((dc_dcontext_t)dcontext), reg); + CHECK_AUX_READ (((dc_dcontext_t)dcontext), reg); + return GET_AUX_VALUE(((dc_dcontext_t)dcontext), reg); +} + + +void dc_set_auxiliary_register (dcontext, reg, value) + dc_dcontext_t dcontext; + int reg; + dc_word_t value; +{ + CHECK_AUX (((dc_dcontext_t)dcontext), reg); + CHECK_AUX_WRITE (((dc_dcontext_t)dcontext), reg); + SET_AUX_VALUE (((dc_dcontext_t)dcontext), reg, value); +} + + + +dc_register_state_t dc_psr_register_bit_state (dcontext, bit) + dc_dcontext_t dcontext; + int bit; +{ + CHECK_BIT (((dc_dcontext_t)dcontext), bit); + return PSR_STATE(((dc_dcontext_t)dcontext), bit); +} + + +dc_word_t dc_psr_register (dcontext) + dc_dcontext_t dcontext; +{ + if (((dc_dcontext_t)dcontext)->psr_ind) { + return dc_read_word(((dc_dcontext_t)dcontext)->handle, + ((dc_dcontext_t)dcontext)->psr_info); + } else { + return ((dc_dcontext_t)dcontext)->psr_info; + } +} + + +void dc_set_psr_register (dcontext, mask, value) + dc_dcontext_t dcontext; + dc_word_t mask; + dc_word_t value; + /* Set bits of PSR corresponding to 1 bits in mask. */ +{ + if (((dc_dcontext_t)dcontext)->psr_ind) { + if (((((dc_dcontext_t)dcontext)->psr_flags[0] & mask) != mask) || + ((((dc_dcontext_t)dcontext)->psr_flags[1] & mask) != 0)) + dc_error (((dc_dcontext_t)dcontext)->handle, + "Some PSR bits specified are not writable."); + dc_write_masked_word (((dc_dcontext_t)dcontext)->handle, + ((dc_dcontext_t)dcontext)->psr_info, mask, value); + } else { + dc_error (((dc_dcontext_t)dcontext)->handle, "PSR is not writable."); + } +} + + + +dc_word_t dc_frame_address (dcontext) + dc_dcontext_t dcontext; +{ + if (!dcontext->code_reading) { + tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr; + return dc_general_register(dcontext, + tep->info.frame_address_register) + tep->info.frame_address_offset; + } else { + if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].reg == DC_REG_SP) { + return (dc_general_register(dcontext,DC_REG_FP) + - dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_FP].off); + } + if (dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].reg == DC_REG_SP) { + return (dc_general_register(dcontext,DC_REG_SP) + - dcontext->info_ptr.cr_data_ptr->reg_val[DC_REG_SP].off); + } + dc_error (((dc_dcontext_t)dcontext)->handle, "Cannot locate frame pointer."); + } +} + + + +dc_kind_t dc_context_kind (dcontext) + dc_dcontext_t dcontext; +{ + return DC_CALL_KIND; +} + + + + +/* operations valid for call contexts only */ + + +dc_register_state_t dc_return_address_state (dcontext) + dc_dcontext_t dcontext; +{ + tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr; + int reg; + + if (!dcontext->code_reading) { + if (tep->info.return_address_info_discriminant) { + return DC_WRITABLE; + } else { + return REG_STATE(((dc_dcontext_t)dcontext), tep->info.return_address_info); + } + } else { + reg= DC_REG_RA; + if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) { + if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) { + return DC_WRITABLE; + } else { + reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]; + } + } + return REG_STATE(((dc_dcontext_t)dcontext),reg); + + + } +} + + +dc_exactness_t dc_return_address_exactness (dcontext) + dc_dcontext_t dcontext; +{ + return DC_MAYBE; +} + + +dc_word_t dc_return_address (dcontext) + dc_dcontext_t dcontext; + /* Return high 30 bits only. */ +{ + tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr; + dc_word_t rai = tep->info.return_address_info; + dc_word_t val; + int reg; + + if (!dcontext->code_reading) { + if (tep->info.return_address_info_discriminant) { + val = dc_read_word (((dc_dcontext_t)dcontext)->handle, + dc_frame_address(dcontext) + rai); + } else { + val = dc_general_register (dcontext, rai); + } + } else { + reg=DC_REG_RA; + if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,reg)) { + if (bit_test(dcontext->info_ptr.cr_data_ptr->how,reg)) { + val = dc_read_word (((dc_dcontext_t)dcontext)->handle, + dc_frame_address(dcontext) + + (dcontext->info_ptr.cr_data_ptr->where[reg])); + } else { + reg= dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]; + val = dc_general_register (dcontext, reg); + } + } else { + val = dc_general_register (dcontext, reg); + } + } + return val & ~3; +} + + +void dc_set_return_address (dcontext, value) + dc_dcontext_t dcontext; + dc_word_t value; + /* Set high 30 bits only. */ +{ + if (!dcontext->code_reading) { + tdesc_elem_t *tep = ((dc_dcontext_t)dcontext)->info_ptr.tdesc_elem_ptr; + dc_word_t rai = tep->info.return_address_info; + + if (tep->info.return_address_info_discriminant) { + dc_write_masked_word (((dc_dcontext_t)dcontext)->handle, + dc_frame_address(dcontext) + rai, ~3, value); + } else { + dc_set_general_register (dcontext, rai, + (value & ~3) | (dc_general_register(dcontext, rai) & 3)); + } + } else { + if (bit_test(dcontext->info_ptr.cr_data_ptr->saved,DC_REG_RA)) { + if (bit_test(dcontext->info_ptr.cr_data_ptr->how,DC_REG_RA)) { + dc_write_masked_word (((dc_dcontext_t)dcontext)->handle, + dc_frame_address(dcontext) + + dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA], ~3, value); + } else { + dc_set_general_register( dcontext, + dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]); + } + } else { + dc_set_general_register( dcontext, + dcontext->info_ptr.cr_data_ptr->where[DC_REG_RA]); + } + } +} + + + +/* operations valid for save contexts only */ + +/* (none) */ + + + +/* operations valid for exception contexts only */ + + +void dc_get_exception_info (dcontext, handler, datum) + dc_dcontext_t dcontext; + dc_word_t *handler; + dc_word_t *datum; +{ + dc_error (((dc_dcontext_t)dcontext)->handle, + "dc_get_exception_info is not yet implemented."); +} + + + +/* operations valid for protection contexts only */ + + +void dc_get_protection_info (dcontext, handler, datum) + dc_dcontext_t dcontext; + dc_word_t *handler; + dc_word_t *datum; +{ + dc_error (((dc_dcontext_t)dcontext)->handle, + "dc_get_protection_info is not yet implemented."); +} + + + +/* operations valid for special contexts only */ + + +void dc_get_special_info (dcontext, kind, datum) + dc_dcontext_t dcontext; + dc_word_t *kind; + dc_word_t *datum; +{ + dc_error (((dc_dcontext_t)dcontext)->handle, + "dc_get_special_info is not yet implemented."); +} + + + +/* operations valid for all contexts (again) */ + + +dc_dcontext_t dc_previous_dcontext (dcontext) + dc_dcontext_t dcontext; + /* Return NULL if there is no previous context. */ +{ + dc_dcontext_t old = (dc_dcontext_t) dcontext; + dcontext_info_t new; /* to serve as temporary storage only */ + tdesc_elem_t *tep; + dc_cr_data_t *cdp; + dc_word_t cfa; + int rsm; + dc_word_t offset; + dc_word_t rai; + int r; + + if (dc_return_address_state((dc_dcontext_t)old) == DC_INVALID) + dc_error (old->handle, "Return address is invalid."); + + if (dc_return_address((dc_dcontext_t)old) == 0) + return (dc_dcontext_t)NULL; /* end of the chain */ + + /* Copy over old contents. */ + new = *old; + + cfa = dc_frame_address(old); + /* Restore stack pointer. */ + new.reg_info[DC_REG_SP] = cfa; + SET_READABLE (new.reg_flags, DC_REG_SP); + + /* Invalidate temporary registers. */ + for (r = 1; r <= 13; r++) SET_INVALID (new.reg_flags, r); + + if (!old->code_reading) { + tep = old->info_ptr.tdesc_elem_ptr; + /* Restore preserved registers. */ + rsm = tep->info.register_save_mask; + offset = cfa + tep->info.register_save_offset; + for (r = 14; r <= 30; r++) { + if (bit_test(rsm, 30-r)) { + new.reg_info[r] = offset; + SET_WRITABLE (new.reg_flags, r); + offset += sizeof(dc_word_t); + } + } + + /* Set location from old return address. */ + rai = tep->info.return_address_info; + if (tep->info.return_address_info_discriminant) { + new.aux_info[DC_AUX_LOC] = cfa + rai; + SET_WRITABLE (new.aux_flags, DC_AUX_LOC); + } else { + new.aux_info[DC_AUX_LOC] = old->reg_info[rai]; + ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, old->reg_flags, rai); + } + } else { + cdp = old->info_ptr.cr_data_ptr; + + /* Restore preserved registers. */ + for (r = 14; r <= 30; r++) { + if (bit_test(cdp->saved,r)) { + if (bit_test(cdp->how,r)){ /* saved in the frame */ + new.reg_info[r] = cfa+cdp->where[r]; + SET_WRITABLE (new.reg_flags, r); + } else { /* saved in the in a register */ + new.reg_info[r] = dc_general_register(old,cdp->where[r]); + ASSIGN_RSTATE (new.aux_flags, r, old->reg_flags, cdp->where[r]); + } + } /* not saved, therefore, already valid , no else*/ + } + + /* Set location from old return address. */ + if (bit_test(cdp->saved,DC_REG_RA)) { + if (bit_test(cdp->how,DC_REG_RA)){ /* saved in the frame */ + new.aux_info[DC_AUX_LOC] = + new.reg_info[DC_REG_RA] = cfa+cdp->where[DC_REG_RA]; + SET_WRITABLE (new.reg_flags, DC_REG_RA); + SET_WRITABLE (new.aux_flags, DC_AUX_LOC); + } else { /* saved in the in a register */ + new.reg_info[DC_REG_RA] = + new.aux_info[DC_AUX_LOC] = + dc_general_register(old,cdp->where[DC_REG_RA]); + ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, + old->reg_flags, cdp->where[DC_REG_RA]); + } + } else { /* not saved, therefore, already valid , set DC_AUX_LOC only*/ + new.aux_info[DC_AUX_LOC] = + dc_general_register(old,DC_REG_RA); + ASSIGN_RSTATE (new.aux_flags, DC_AUX_LOC, + old->reg_flags, DC_REG_RA); + } + } + + /* Invalidate instruction pointers. */ + SET_INVALID (new.aux_flags, DC_AUX_SXIP); + SET_INVALID (new.aux_flags, DC_AUX_SNIP); + SET_INVALID (new.aux_flags, DC_AUX_SFIP); + + /* No change to FCR registers. */ + + /* No change to PSR register. */ + + return dc_make_dcontext ((dc_handle_t)new.handle, + new.reg_info, new.reg_flags, + new.aux_info, new.aux_flags, new.loc_exact, + new.psr_info, new.psr_ind, new.psr_flags); +} + + + +/* extensions for nonlocal goto */ + +#if 0 + +typedef + struct label { + ??? + } label_t; + + +label_t dc_make_label (dcontext, location) + dc_dcontext_t dcontext; + dc_word_t location; +{ +} + +#endif + +/* procedure for reading code */ + +dc_read_code(loc,dc,map_info_in,cdp) +dc_word_t loc; +dc_dcontext_t dc; +dc_cr_data_t *cdp; +dc_map_info_in_t map_info_in; +{ +dc_map_info_out_t map_info_out; +dc_word_t pc; +dc_boolean_t found_branch=DC_FALSE; +dc_word_t instr; + + (*dc->handle->map_fcn)(dc->handle->map_env,loc,map_info_in,&map_info_out); + if (map_info_out.flags & DC_MIO_ENTRY_POINT + && (!(map_info_in.flags & DC_MII_PRECEDING_TDESC_END) + || map_info_out.entry_point >= map_info_in.preceding_tdesc_end + || map_info_out.flags & DC_MIO_LITERAL_ENTRY_POINT)) { + dc_init_cr_data(cdp,(tdesc_elem_t *)NULL); + pc= map_info_out.entry_point; + } else if (map_info_in.flags & DC_MII_PRECEDING_TDESC_END) { + /**/ + /* tdesc_lookup gets the tep for the preceeding tdesc information + /* so we call it with one less than the preceding tdesc end since + /* tdesc information is exclusive of the ending address + /**/ + dc_init_cr_data(cdp, + dc_tdesc_lookup(map_info_in.preceding_tdesc_end-1, + ((dc_handle_t)dc->handle)->tdesc_table, + ((dc_handle_t)dc->handle)->tdesc_table_size, + &map_info_in)); + pc= map_info_in.preceding_tdesc_end; + } else { + dc_error (dc->handle, "Insufficient information for code reading."); + } + for (;;pc+=4) { + if (pc==loc) { + return (DC_TRUE); + } + instr= dc_read_word(dc->handle,pc); + found_branch= dc_decode_finds_branch(dc,instr); + if ((map_info_out.flags & DC_MIO_PROLOGUE_END) + && (pc==map_info_out.prologue_end)) { + break; + } + if (found_branch) { + if (DC_MIO_IMPLICIT_PROLOGUE_END & map_info_out.flags) { + break; + } else { + dc_error (dc->handle, "Found branch before end of prologue."); + } + } + } + if (!(map_info_out.flags & DC_MIO_LITERAL_EPILOGUE_START) + && (map_info_out.epilogue_start >= loc + || !(map_info_out.flags & DC_MIO_EPILOGUE_START))) { + return (DC_TRUE); + } + dc_correct_cr_data(cdp,dc->handle); + for (pc=map_info_out.epilogue_start;pc<loc;pc+=4) { + instr= dc_read_word(dc->handle,pc); + if (dc_decode_finds_branch(dc,instr)) { + return (DC_FALSE); + } + } + return (DC_TRUE); + +} + + + +dc_init_cr_data(cdp,tep) +dc_cr_data_t *cdp; +tdesc_elem_t *tep; +{ +int reg; +dc_word_t rai; +dc_word_t raid; +dc_word_t rsm; +dc_word_t frpos; + + if (tep){ + + /* Start off with all registers undefined and none saved. */ + for (reg = 0; reg < DC_NUM_REG; reg++) { + cdp->reg_val[reg].reg = DC_UNDEF; + } + cdp->saved = 0; + + /* Overwrite with what tdesc element says. */ + + cdp->reg_val[tep->info.frame_address_register].reg = DC_REG_SP; + cdp->reg_val[tep->info.frame_address_register].off = + - tep->info.frame_address_offset; + + rai = tep->info.return_address_info; + raid = tep->info.return_address_info_discriminant; + if (raid || rai != DC_REG_RA) { + bit_set(cdp->saved,DC_REG_RA); + bit_assign(cdp->how,DC_REG_RA,raid); + cdp->where[DC_REG_RA] = rai; + } + + rsm = tep->info.register_save_mask; + frpos = tep->info.register_save_offset; + for (reg = 14; reg <= 30; reg++) { + if (bit_test(rsm, 30-reg)) { + bit_set(cdp->saved,reg); + bit_set(cdp->how,reg); + cdp->where[reg] = frpos; + frpos += sizeof(dc_word_t); + } else { + cdp->reg_val[reg].reg = reg; + cdp->reg_val[reg].off = 0; + } + } + + cdp->reg_val[0].reg = 0; /* guarantee what hardware does */ + cdp->reg_val[0].off = 0; + + } else { + /* Each register has its own initial value. */ + for (reg = 0; reg < DC_NUM_REG; reg++) { + cdp->reg_val[reg].reg = reg; + cdp->reg_val[reg].off = 0; + } + /* No register is yet saved. */ + cdp->saved = 0; + cdp->how = 0; + } +} +void dc_correct_cr_data(cdp,handle) +dc_cr_data_t *cdp; +dc_handle_t handle; +{ +long sr,r; +dc_word_t save_regs = 0; /* registers used to save others */ + for (r = 1; r < DC_REG_SP; r++) { + if (bit_test(cdp->saved,r) && !bit_test(cdp->how,r)) { + sr = cdp->where[r]; + if (bit_test(save_regs,sr)) { + dc_error(handle, "Same register used to save two others."); + } + bit_set(save_regs,sr); + } + } + for (r = 1; r < DC_REG_FP; r++) { + if ((r < 14 || bit_test(cdp->saved,r)) && !bit_test(save_regs,r)) { + cdp->reg_val[r].reg = DC_UNDEF; + } + } + if (bit_test(cdp->saved,DC_REG_FP) && + cdp->reg_val[DC_REG_FP].reg == DC_REG_SP) { /* is r30 the far? */ + cdp->reg_val[DC_REG_SP].reg = DC_UNDEF; /* trash sp */ + } else if (cdp->reg_val[DC_REG_SP].reg == DC_REG_SP) { /* is r31 the far? */ + if (bit_test(cdp->saved,DC_REG_FP) && !bit_test(save_regs,DC_REG_FP)) { + cdp->reg_val[DC_REG_FP].reg = DC_UNDEF; /* trash r30 */ + } + } +} diff --git a/gdb/tdesc.h b/gdb/tdesc.h new file mode 100755 index 0000000..3936330 --- /dev/null +++ b/gdb/tdesc.h @@ -0,0 +1,329 @@ +/* This file has been modified by Data General Corporation, November 1989. */ + +#ifndef _tdesc_h +#define _tdesc_h +#ifdef __STDC__ +#define _ARGS(x) x +#else +#define _ARGS(x) () +#endif + +/* + This file provides an abstract interface to "tdesc" information. + It is designed to be used in a uniform manner by several kinds + of debuggers: + (1) code in live debugged process (e.g., a traceback routine) + (2) a separate-process debugger debugging a live process + (3) a separate-process debugger debugging a memory dump + + Dcontext model notes + * captures machine context + * partial: excludes memory + * frames + * kinds + * make one for starters, chain in reverse order to previous ones + * representation: pointer to opaque + * alloc/free protocol + + Overall model + * access functions + * handle + * error handling +*/ + + + +typedef int dc_boolean_t; /* range 0 .. 1 */ +#define DC_FALSE 0 +#define DC_TRUE 1 + + +typedef int dc_tristate_t; /* range 0 .. 2 */ +#define DC_NO 0 +#define DC_YES 1 +#define DC_MAYBE 2 + + +#define DC_MII_PRECEDING_TDESC_END (1<<0) +#define DC_MII_FOLLOWING_TDESC_START (1<<1) + +#define DC_MIO_ENTRY_POINT (1<< 0) +#define DC_MIO_PROLOGUE_END (1<< 1) +#define DC_MIO_EPILOGUE_START (1<< 2) +#define DC_MIO_IMPLICIT_PROLOGUE_END (1<<16) +#define DC_MIO_LITERAL_ENTRY_POINT (1<<17) +#define DC_MIO_LITERAL_EPILOGUE_START (1<<18) + + +/* + A word is 32 bits of information. In memory, a word is word-aligned. + + A common and important use of word_t is to represent values in the + target process, including (byte) addresses in the target process. + In this case, C arithmetic can be used to simulate machine address + arithmetic on the target. (Unsigned arithmetic is actually modulus + arithmetic.) +*/ +typedef unsigned int dc_word_t; + + +/*----------------*/ + + +/* The exactness of locations may not be certainly known. */ +typedef dc_tristate_t dc_exactness_t; + + +/* + The model includes five kinds of contexts. Because each context + has an associated region and frame, these describe region kinds + and frame kinds as well. + [more description needed] + Currently, only call contexts exist. +*/ + +typedef int dc_kind_t; /* range 0 .. 4 */ +#define DC_CALL_KIND 0 +#define DC_SAVE_KIND 1 +#define DC_EXCEPTION_KIND 2 +#define DC_PROTECTION_KIND 3 +#define DC_SPECIAL_KIND 4 +#define DC_NUM_KINDS 5 + + +typedef struct dc_debug_info { + unsigned int protocol; /* 1 for this structure */ + dc_word_t tdesc_ptr; + unsigned int text_words_count; + dc_word_t text_words_ptr; + unsigned int data_words_count; + dc_word_t data_words_ptr; +} dc_debug_info_t; + + +typedef struct dc_mstate { + dc_word_t reg[32]; /* general registers */ + dc_word_t xip; + dc_word_t nip; + dc_word_t fip; + dc_word_t fpsr; + dc_word_t fpcr; + dc_word_t psr; +} dc_mstate_t; + + + +#if 0 + + void error_fcn (env, continuable, message) + dc_word_t env; /* environment (arbitrary datum) */ + boolean_t continuable; /* whether error function may return */ + char *message; /* string (no trailing newline) */ + + /* In the future, we probably want the error_fcn to be: */ + void error_fcn (env, continuable, code, ...) + dc_word_t env; /* environment (arbitrary datum) */ + boolean_t continuable; /* whether error function may return */ + int code; /* error code */ + ... /* parameters to message associated + with the code */ + + void read_fcn (env, memory, length, buffer) + dc_word_t env; /* environment (arbitrary datum) */ + dc_word_t memory; /* start address in image */ + int length; /* in bytes */ + char *buffer; /* start address of buffer */ + /* There are no alignment assumptions for the read function. */ + + void write_fcn (env, memory, length, buffer) + dc_word_t env; /* environment (arbitrary datum) */ + dc_word_t memory; /* start address in image */ + int length; /* in bytes */ + char *buffer; /* start address of buffer */ + /* There are no alignment assumptions for the write function. */ + /* The write function is optional. It must be provided if changes + to writable registers are to be made. */ + + void exec_fcn (env, mstate) + dc_word_t env; /* environment (arbitrary datum) */ + dc_mstate_t *mstate; /* machine state (read-write) */ + /* The execute function is optional. It would be used (in the future) + by the implementation of a procedurally specified tdesc mechanism. */ + +#endif + +/*----------------*/ + + +typedef struct dc_map_info_in { + dc_word_t flags; + dc_word_t preceding_tdesc_end; + dc_word_t following_tdesc_start; +} dc_map_info_in_t; + + +typedef struct dc_map_info_out { + dc_word_t flags; + dc_word_t entry_point; + dc_word_t prologue_end; + dc_word_t epilogue_start; +} dc_map_info_out_t; + + +typedef void *dc_handle_t; + +typedef void (*tdesc_error_fcn_type) _ARGS(( + dc_word_t env, /* environment (arbitrary datum) */ + dc_boolean_t continuable, /* whether error function may return */ + const char *message /* string (no trailing newline) */ +)); +typedef void (*tdesc_io_fcn_type) _ARGS(( + dc_word_t env, /* environment (arbitrary datum) */ + dc_word_t memory, /* start address in image */ + int length, /* in bytes */ + void *buffer /* start address of buffer */ +)); +typedef void (*tdesc_exec_fcn_type) _ARGS(( + dc_word_t env, /* environment (arbitrary datum) */ + dc_mstate_t *mstate /* machine state (read-write) */ +)); +typedef void (*tdesc_map_fcn_type) _ARGS(( + dc_word_t map_env, + dc_word_t loc, + dc_map_info_in_t map_info_in, + dc_map_info_out_t *map_info_out +)); + + +extern dc_handle_t dc_initiate _ARGS(( + dc_word_t debug_info_ptr, + tdesc_error_fcn_type error_fcn, + dc_word_t error_env, + tdesc_io_fcn_type read_fcn, + dc_word_t read_env, + tdesc_io_fcn_type write_fcn, /* NULL => absent */ + dc_word_t write_env, + tdesc_exec_fcn_type exec_fcn, /* NULL => absent */ + dc_word_t exec_env, + tdesc_map_fcn_type map_fcn, /* NULL => absent */ + dc_word_t map_env +)); +extern void dc_terminate _ARGS(( + dc_handle_t handle +)); + +typedef int dc_register_state_t; /* range 0 to 2 */ + +#define DC_INVALID 0 +#define DC_READABLE 1 +#define DC_WRITABLE 2 + +#define DC_NUM_REG 32 + +#define DC_AUX_LOC 0 +#define DC_AUX_SXIP 1 +#define DC_AUX_SNIP 2 +#define DC_AUX_SFIP 3 +#define DC_AUX_FPSR 4 +#define DC_AUX_FPCR 5 +#define DC_NUM_AUX 6 + + +typedef void *dc_dcontext_t; + +extern dc_dcontext_t dc_make_dcontext _ARGS(( + dc_handle_t handle, + dc_word_t reg_info[DC_NUM_REG], + dc_word_t reg_flags[2], + dc_word_t aux_info[DC_NUM_AUX], + dc_word_t aux_flags[2], + dc_exactness_t loc_exact, + dc_word_t psr_info, + dc_boolean_t psr_ind, + dc_word_t psr_flags[2] +)); +extern void dc_free_dcontext _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_register_state_t dc_location_state _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_exactness_t dc_location_exactness _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_word_t dc_location _ARGS(( + dc_dcontext_t dcontext +)); +extern void dc_set_location _ARGS(( + dc_dcontext_t dcontext, + dc_word_t value +)); +extern dc_register_state_t dc_general_register_state _ARGS(( + dc_dcontext_t dcontext, + int reg +)); +extern dc_word_t dc_general_register _ARGS(( + dc_dcontext_t dcontext, + int reg +)); +extern void dc_set_general_register _ARGS(( + dc_dcontext_t dcontext, + int reg, + dc_word_t value +)); +extern dc_register_state_t dc_auxiliary_register_state _ARGS(( + dc_dcontext_t dcontext, + int reg +)); +extern dc_word_t dc_auxiliary_register _ARGS(( + dc_dcontext_t dcontext, + int reg +)); +extern void dc_set_auxiliary_register _ARGS(( + dc_dcontext_t dcontext, + int reg, + dc_word_t value +)); +extern dc_register_state_t dc_psr_register_bit_state _ARGS(( + dc_dcontext_t dcontext, + int bit +)); +extern dc_word_t dc_psr_register _ARGS(( + dc_dcontext_t dcontext +)); +extern void dc_set_psr_register _ARGS(( + dc_dcontext_t dcontext, + dc_word_t mask, + dc_word_t value +)); +extern dc_word_t dc_frame_address _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_kind_t dc_context_kind _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_register_state_t dc_return_address_state _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_exactness_t dc_return_address_exactness _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_word_t dc_return_address _ARGS(( + dc_dcontext_t dcontext +)); +extern void dc_set_return_address _ARGS(( + dc_dcontext_t dcontext, + dc_word_t value +)); +extern void dc_get_exception_info(); +extern void dc_get_protection_info(); +extern void dc_get_special_info(); +extern dc_dcontext_t dc_previous_dcontext _ARGS(( + dc_dcontext_t dcontext +)); +extern dc_boolean_t dc_location_in_text_chunk _ARGS(( + dc_dcontext_t dcontext, + dc_word_t value +)); + +#endif diff --git a/gdb/tm-29k.h b/gdb/tm-29k.h new file mode 100644 index 0000000..4594622 --- /dev/null +++ b/gdb/tm-29k.h @@ -0,0 +1,653 @@ +/* Parameters for target machine of AMD 29000, for GDB, the GNU debugger. + Copyright 1990, 1991 Free Software Foundation, Inc. + Contributed by Cygnus Support. Written by Jim Kingdon. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Parameters for an EB29K (a board which plugs into a PC and is + accessed through EBMON software running on the PC, which we + use as we'd use a remote stub (see remote-eb.c). + + If gdb is ported to other 29k machines/systems, the + machine/system-specific parts should be removed from this file (a + la tm-68k.h). */ + +/* Byte order is configurable, but this machine runs big-endian. */ +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* Floating point uses IEEE representations. */ +#define IEEE_FLOAT + +/* We can either use a.out, encapsulated, or can use COFF */ +#ifndef COFF_ENCAPSULATE +#define COFF_FORMAT +/* This just has to do with what coff header files are in use. */ +#define COFF_CHECK_X_ZEROES +#endif + +/* Recognize our magic number. */ +#define BADMAG(x) ((x)->f_magic != 0572) + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ + { pc = skip_prologue (pc); } +CORE_ADDR skip_prologue (); + +/* Immediately after a function call, return the saved pc. + Can't go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) (read_register (LR0_REGNUM)) + +/* I'm not sure about the exact value of this, but based on looking + at the stack pointer when we get to main this seems to be right. + + This is the register stack; We call it "CONTROL" in GDB for consistency + with Pyramid. */ +#define CONTROL_END_ADDR 0x80200000 + +/* Memory stack. This is for the default register stack size, which is + only 0x800 bytes. Perhaps we should let the user specify stack sizes + (and tell EBMON with the "ZS" command). */ +#define STACK_END_ADDR 0x801ff800 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Stack must be aligned on 32-bit word boundaries. */ +#define STACK_ALIGN(ADDR) (((ADDR) + 3) & ~3) + +/* Sequence of bytes for breakpoint instruction. */ +/* ASNEQ 0x50, gr1, gr1 + The trap number 0x50 is chosen arbitrarily. */ +#if TARGET_BYTE_ORDER == BIG_ENDIAN +#define BREAKPOINT {0x72, 0x50, 0x01, 0x01} +#else /* Target is little-endian. */ +#define BREAKPOINT {0x01, 0x01, 0x50, 0x72} +#endif /* Target is little-endian. */ + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 4 + +/* Nonzero if instruction at PC is a return instruction. + On the 29k, this is a "jmpi l0" instruction. */ + +#define ABOUT_TO_RETURN(pc) \ + ((read_memory_integer (pc, 4) & 0xff0000ff) == 0xc0000080) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */ + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 205 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. + + FIXME, add floating point registers and support here. + + Also note that this list does not attempt to deal with kernel + debugging (in which the first 32 registers are gr64-gr95). */ + +#define REGISTER_NAMES \ +{"gr96", "gr97", "gr98", "gr99", "gr100", "gr101", "gr102", "gr103", "gr104", \ + "gr105", "gr106", "gr107", "gr108", "gr109", "gr110", "gr111", "gr112", \ + "gr113", "gr114", "gr115", "gr116", "gr117", "gr118", "gr119", "gr120", \ + "gr121", "gr122", "gr123", "gr124", "gr125", "gr126", "gr127", \ + "lr0", "lr1", "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", "lr8", "lr9", \ + "lr10", "lr11", "lr12", "lr13", "lr14", "lr15", "lr16", "lr17", "lr18", \ + "lr19", "lr20", "lr21", "lr22", "lr23", "lr24", "lr25", "lr26", "lr27", \ + "lr28", "lr29", "lr30", "lr31", "lr32", "lr33", "lr34", "lr35", "lr36", \ + "lr37", "lr38", "lr39", "lr40", "lr41", "lr42", "lr43", "lr44", "lr45", \ + "lr46", "lr47", "lr48", "lr49", "lr50", "lr51", "lr52", "lr53", "lr54", \ + "lr55", "lr56", "lr57", "lr58", "lr59", "lr60", "lr61", "lr62", "lr63", \ + "lr64", "lr65", "lr66", "lr67", "lr68", "lr69", "lr70", "lr71", "lr72", \ + "lr73", "lr74", "lr75", "lr76", "lr77", "lr78", "lr79", "lr80", "lr81", \ + "lr82", "lr83", "lr84", "lr85", "lr86", "lr87", "lr88", "lr89", "lr90", \ + "lr91", "lr92", "lr93", "lr94", "lr95", "lr96", "lr97", "lr98", "lr99", \ + "lr100", "lr101", "lr102", "lr103", "lr104", "lr105", "lr106", "lr107", \ + "lr108", "lr109", "lr110", "lr111", "lr112", "lr113", "lr114", "lr115", \ + "lr116", "lr117", "lr118", "lr119", "lr120", "lr121", "lr122", "lr123", \ + "lr124", "lr125", "lr126", "lr127", \ + "AI0", "AI1", "AI2", "AI3", "AI4", "AI5", "AI6", "AI7", "AI8", "AI9", \ + "AI10", "AI11", "AI12", "AI13", "AI14", "AI15", "FP", \ + "bp", "fc", "cr", "q", \ + "vab", "ops", "cps", "cfg", "cha", "chd", "chc", "rbp", "tmc", "tmr", \ + "pc0", "pc1", "pc2", "mmu", "lru", "fpe", "int", "fps", "exo", "gr1", \ + "alu", "ipc", "ipa", "ipb" } + +/* Special register #x. */ +#define SR_REGNUM(x) \ + ((x) < 15 ? VAB_REGNUM + (x) \ + : (x) >= 128 && (x) < 131 ? IPC_REGNUM + (x) \ + : (x) == 131 ? Q_REGNUM \ + : (x) == 132 ? ALU_REGNUM \ + : (x) >= 133 && (x) < 136 ? BP_REGNUM + (x) \ + : (x) >= 160 && (x) < 163 ? FPE_REGNUM + (x) \ + : (x) == 164 ? EXO_REGNUM \ + : (error ("Internal error in SR_REGNUM"), 0)) +#define GR96_REGNUM 0 +#define GR1_REGNUM 200 +/* This needs to be the memory stack pointer, not the register stack pointer, + to make call_function work right. */ +#define SP_REGNUM MSP_REGNUM +#define FP_REGNUM 33 /* lr1 */ +/* Large Return Pointer (gr123). */ +#define LRP_REGNUM (123 - 96 + GR96_REGNUM) +/* Static link pointer (gr124). */ +#define SLP_REGNUM (124 - 96 + GR96_REGNUM) +/* Memory Stack Pointer (gr125). */ +#define MSP_REGNUM (125 - 96 + GR96_REGNUM) +/* Register allocate bound (gr126). */ +#define RAB_REGNUM (126 - 96 + GR96_REGNUM) +/* Register Free Bound (gr127). */ +#define RFB_REGNUM (127 - 96 + GR96_REGNUM) +/* Register Stack Pointer. */ +#define RSP_REGNUM GR1_REGNUM +#define LR0_REGNUM 32 +#define PC_REGNUM 192 /* pc1 */ +#define NPC_REGNUM 191 /* pc0 */ +#define PC2_REGNUM 193 +#define BP_REGNUM 177 +#define FC_REGNUM 178 +#define CR_REGNUM 179 +#define Q_REGNUM 180 +#define VAB_REGNUM 181 +#define LRU_REGNUM 195 +#define FPE_REGNUM 196 +#define INT_REGNUM 197 +#define FPS_REGNUM 198 +#define EXO_REGNUM 199 +#define PS_REGNUM 201 +#define ALU_REGNUM 201 +#define IPC_REGNUM 202 +#define IPB_REGNUM 204 + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (NUM_REGS * 4) + +/* Index within `registers' of the first byte of the space for + register N. */ +#define REGISTER_BYTE(N) ((N)*4) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +/* All regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) (4) + +/* Number of bytes of storage in the program's representation + for register N. */ + +/* All regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) (4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE (4) + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE (4) + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +{ bcopy ((FROM), (TO), 4); } + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +{ bcopy ((FROM), (TO), 4); } + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + (((N) == PC_REGNUM || (N) == LRP_REGNUM || (N) == SLP_REGNUM \ + || (N) == MSP_REGNUM || (N) == RAB_REGNUM || (N) == RFB_REGNUM \ + || (N) == GR1_REGNUM || (N) == FP_REGNUM || (N) == LR0_REGNUM \ + || (N) == NPC_REGNUM || (N) == PC2_REGNUM) \ + ? lookup_pointer_type (builtin_type_void) : builtin_type_int) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ +/* On the 29k the LRP points to the part of the structure beyond the first + 16 words. */ +#define STORE_STRUCT_RETURN(ADDR, SP) \ + write_register (LRP_REGNUM, (ADDR) + 16 * 4); + +/* Should call_function allocate stack space for a struct return? */ +/* On the 29k objects over 16 words require the caller to allocate space. */ +#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > 16 * 4) + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + { \ + int reg_length = TYPE_LENGTH (TYPE); \ + if (reg_length > 16 * 4) \ + { \ + reg_length = 16 * 4; \ + read_memory (*((int *)(REGBUF) + LRP_REGNUM), (VALBUF) + 16 * 4, \ + TYPE_LENGTH (TYPE) - 16 * 4); \ + } \ + bcopy (((int *)(REGBUF))+GR96_REGNUM, (VALBUF), reg_length); \ + } + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + { \ + int reg_length = TYPE_LENGTH (TYPE); \ + if (reg_length > 16 * 4) \ + { \ + reg_length = 16 * 4; \ + write_memory (read_register (LRP_REGNUM), \ + (char *)(VALBUF) + 16 * 4, \ + TYPE_LENGTH (TYPE) - 16 * 4); \ + } \ + write_register_bytes (REGISTER_BYTE (GR96_REGNUM), (char *)(VALBUF), \ + TYPE_LENGTH (TYPE)); \ + } + +/* The am29k user's guide documents well what the stacks look like. + But what isn't so clear there is how this interracts with the + symbols, or with GDB. + In the following saved_msp, saved memory stack pointer (which functions + as a memory frame pointer), means either + a register containing the memory frame pointer or, in the case of + functions with fixed size memory frames (i.e. those who don't use + alloca()), the result of the calculation msp + msize. + + LOC_ARG, LOC_LOCAL - For GCC, these are relative to saved_msp. + For high C, these are relative to msp (making alloca impossible). + LOC_REGISTER, LOC_REGPARM - The register number is the number at the + time the function is running (after the prologue), or in the case + of LOC_REGPARM, may be a register number in the range 160-175. + + The compilers do things like store an argument into memory, and then put out + a LOC_ARG for it, or put it into global registers and put out a + LOC_REGPARM. Thus is it important to execute the first line of + code (i.e. the line of the open brace, i.e. the prologue) of a function + before trying to print arguments or anything. + + The following diagram attempts to depict what is going on in memory + (see also the _am29k user's guide_) and also how that interacts with + GDB frames. We arbitrarily pick fci->frame to point the same place + as the register stack pointer; since we set it ourself in + INIT_EXTRA_FRAME_INFO, and access it only through the FRAME_* + macros, it doesn't really matter exactly how we + do it. However, note that FRAME_FP is used in two ways in GDB: + (1) as a "magic cookie" which uniquely identifies frames (even over + calls to the inferior), (2) (in PC_IN_CALL_DUMMY [!CANNOT_EXECUTE_STACK]) + as the value of SP_REGNUM before the dummy frame was pushed. These + two meanings would be incompatible for the 29k if we didn't define + CANNOT_EXECUTE_STACK (but we do, so don't worry about it). + Also note that "lr1" below, while called a frame pointer + in the user's guide, has only one function: To determine whether + registers need to be filled in the function epilogue. + + Consider the code: + < call bar> + loc1: . . . + bar: sub gr1,gr1,rsize_b + . . . + add mfp,msp,0 + sub msp,msp,msize_b + . . . + < call foo > + loc2: . . . + foo: sub gr1,gr1,rsize_f + . . . + add mfp,msp,0 + sub msp,msp,msize_f + . . . + loc3: < suppose the inferior stops here > + + memory stack register stack + | | |____________| + | | |____loc1____| + +------->|___________| | | ^ + | | ^ | | locals_b | | + | | | | |____________| | + | | | | | | | rsize_b + | | | msize_b | | args_to_f | | + | | | | |____________| | + | | | | |____lr1_____| V + | | V | |____loc2____|<----------------+ + | +--->|___________|<---------mfp | ^ | + | | | ^ | | locals_f | | | + | | | | msize_f | |____________| | | + | | | | | | | | rsize_f | + | | | V | | args | | | + | | |___________|<msp |____________| | | + | | |_____lr1____| V | + | | |___garbage__| <- gr1 <----+ | + | | | | + | | | | + | | pc=loc3 | | + | | | | + | | | | + | | frame cache | | + | | |_________________| | | + | | |rsize=rsize_b | | | + | | |msize=msize_b | | | + +---|--------saved_msp | | | + | |frame------------------------------------|---+ + | |pc=loc2 | | + | |_________________| | + | |rsize=rsize_f | | + | |msize=msize_f | | + +--------saved_msp | | + |frame------------------------------------+ + |pc=loc3 | + |_________________| + + So, is that sufficiently confusing? Welcome to the 29000. + Notes: + * The frame for foo uses a memory frame pointer but the frame for + bar does not. In the latter case the saved_msp is + computed by adding msize to the saved_msp of the + next frame. + * msize is in the frame cache only for high C's sake. */ + +void read_register_stack (); +long read_register_stack_integer (); + +#define EXTRA_FRAME_INFO \ + CORE_ADDR saved_msp; \ + unsigned int rsize; \ + unsigned int msize; + +/* Because INIT_FRAME_PC gets passed fromleaf, that's where we init + not only ->pc and ->frame, but all the extra stuff, when called from + get_prev_frame_info, that is. */ +#define INIT_EXTRA_FRAME_INFO(fci) \ + init_extra_frame_info(fci); +void init_extra_frame_info (); +#define INIT_FRAME_PC(fromleaf, fci) \ + init_frame_pc(fromleaf, fci); +void init_frame_pc (); + +/* FRAME_CHAIN takes a FRAME + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* On the 29k, the nominal address of a frame is the address on the + register stack of the return address (the one next to the incoming + arguments, not down at the bottom so nominal address == stack pointer). + + GDB expects "nominal address" to equal contents of FP_REGNUM, + at least when it comes time to create the innermost frame. + However, that doesn't work for us, so when creating the innermost + frame we set ->frame ourselves in INIT_EXTRA_FRAME_INFO. */ + +/* These are mostly dummies for the 29k because INIT_FRAME_PC + sets prev->frame instead. */ +#define FRAME_CHAIN(thisframe) (0) + +/* Not sure how to figure out where the bottom frame is. There is + no frame for start. In my tests so far the + pc has been outside the text segment, though, so check for that. + However, allow a pc in a call dummy. */ +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (outside_startup_file (FRAME_SAVED_PC (thisframe)) \ + && FRAME_SAVED_PC (thisframe) >= text_start \ + && FRAME_SAVED_PC (thisframe) < text_end + CALL_DUMMY_LENGTH) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (0) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + (FRAMELESS) = frameless_look_for_prologue(FI) + +/* Saved pc (i.e. return address). */ +#define FRAME_SAVED_PC(fraim) \ + (read_register_stack_integer ((fraim)->frame + (fraim)->rsize, 4)) + +/* Local variables (i.e. LOC_LOCAL) are on the memory stack, with their + offsets being relative to the memory stack pointer (high C) or + saved_msp (gcc). */ + +#define FRAME_LOCALS_ADDRESS(fi) frame_locals_address (fi) +extern CORE_ADDR frame_locals_address (); + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ +/* While we could go the effort of finding the tags word and getting + the argcount field from it, + (1) It only counts arguments in registers, i.e. the first 16 words + of arguments + (2) It gives the number of arguments the function was declared with + not how many it was called with (or some variation, like all 16 + words for varadic functions). This makes argcount pretty much + redundant with -g info, even for varadic functions. + So don't bother. */ +#define FRAME_NUM_ARGS(numargs, fi) ((numargs) = -1) + +#define FRAME_ARGS_ADDRESS(fi) FRAME_LOCALS_ADDRESS (fi) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Provide our own get_saved_register. HAVE_REGISTER_WINDOWS is insufficient + because registers get renumbered on the 29k without getting saved. */ + +#define GET_SAVED_REGISTER + +/* Call function stuff. */ + +/* The dummy frame looks like this (see also the general frame picture + above): + + register stack + + | | frame for function + | locals_sproc | executing at time + |________________| of call_function. + | | We must not disturb + | args_out_sproc | it. + memory stack |________________| + |____lr1_sproc___| + | | |__retaddr_sproc_| <- gr1 (at start) + |____________|<-msp 0 <-----------mfp_dummy_____| + | | (at start) | | + | arg_slop | | saved regs | + | (16 words) | | gr96-gr124 | + |____________|<-msp 1--after | sr128-sr135 | + | | PUSH_DUMMY_FRAME| | + | struct ret | |________________| + | 17+ | | | + |____________|<- lrp | args_out_dummy | + | struct ret | | (16 words) | + | 16 | |________________| + | (16 words) | |____lr1_dummy___| + |____________|<- msp 2--after |_retaddr_dummy__|<- gr1 after + | | struct ret | | PUSH_DUMMY_FRAME + | margs17+ | area allocated | locals_inf | + | | |________________| called + |____________|<- msp 4--when | | function's + | | inf called | args_out_inf | frame (set up + | margs16 | |________________| by called + | (16 words) | |_____lr1_inf____| function). + |____________|<- msp 3--after | . | + | | args pushed | . | + | | | . | + | | + + arg_slop: This area is so that when the call dummy adds 16 words to + the msp, it won't end up larger than mfp_dummy (it is needed in the + case where margs and struct_ret do not add up to at least 16 words). + struct ret: This area is allocated by GDB if the return value is more + than 16 words. struct ret_16 is not used on the 29k. + margs: Pushed by GDB. The call dummy copies the first 16 words to + args_out_dummy. + retaddr_sproc: Contains the PC at the time we call the function. + set by PUSH_DUMMY_FRAME and read by POP_FRAME. + retaddr_dummy: This points to a breakpoint instruction in the dummy. */ + +/* Rsize for dummy frame, in bytes. */ + +/* Bytes for outgoing args, lr1, and retaddr. */ +#define DUMMY_ARG (2 * 4 + 16 * 4) + +/* Number of special registers (sr128-) to save. */ +#define DUMMY_SAVE_SR128 8 +/* Number of general (gr96-) registers to save. */ +#define DUMMY_SAVE_GR96 29 + +#define DUMMY_FRAME_RSIZE \ +(4 /* mfp_dummy */ \ + + DUMMY_SAVE_GR96 * 4 \ + + DUMMY_SAVE_SR128 * 4 \ + + DUMMY_ARG \ + ) + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME push_dummy_frame(); +extern void push_dummy_frame (); + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME pop_frame (); +extern void pop_frame (); + +/* This sequence of words is the instructions + mtsrim cr, 15 + loadm 0, 0, lr2, msp ; load first 16 words of arguments into registers + add msp, msp, 16 * 4 ; point to the remaining arguments + CONST_INSN: + const gr96,inf + consth gr96,inf + calli lr0, gr96 + aseq 0x40,gr1,gr1 ; nop + asneq 0x50,gr1,gr1 ; breakpoint + */ + +/* Position of the "const" instruction within CALL_DUMMY in bytes. */ +#define CONST_INSN (3 * 4) +#if TARGET_BYTE_ORDER == HOST_BYTE_ORDER +#define CALL_DUMMY {0x0400870f, 0x3600827d, 0x157d7d40, 0x03ff60ff, \ + 0x02ff60ff, 0xc8008060, 0x70400101, 0x72500101} +#else /* Byte order differs. */ + you lose +#endif /* Byte order differs. */ +#define CALL_DUMMY_LENGTH (8 * 4) + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Helper macro for FIX_CALL_DUMMY. WORDP is a long * which points to a + word in target byte order; bits 0-7 and 16-23 of *WORDP are replaced with + bits 0-7 and 8-15 of DATA (which is in host byte order). */ + +#if TARGET_BYTE_ORDER == BIG_ENDIAN +#define STUFF_I16(WORDP, DATA) \ + { \ + *((char *)(WORDP) + 3) = ((DATA) & 0xff);\ + *((char *)(WORDP) + 1) = (((DATA) >> 8) & 0xff);\ + } +#else /* Target is little endian. */ +#define STUFF_I16(WORDP, DATA) \ + { + *(char *)(WORDP) = ((DATA) & 0xff); + *((char *)(WORDP) + 2) = (((DATA) >> 8) & 0xff); + } +#endif /* Target is little endian. */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +/* Currently this stuffs in the address of the function that we are calling. + If different 29k systems use different breakpoint instructions, it + could also stuff BREAKPOINT in the right place (to avoid having to + duplicate CALL_DUMMY in each tm-*.h file). */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ + {\ + STUFF_I16((char *)dummyname + CONST_INSN, fun);\ + STUFF_I16((char *)dummyname + CONST_INSN + 4, fun >> 16);\ + } + +/* At least our 29k board has separate data & instruction memories and can't + execute the data memory. Also, there should be space after text_end; + we won't get a SIGSEGV or scribble on data space. */ + +#define CALL_DUMMY_LOCATION AFTER_TEXT_END + +/* How to translate register numbers in the .stab's into gdb's internal register + numbers. We don't translate them, but we warn if an invalid register + number is seen. Note that FIXME, we use the value "sym" as an implicit + argument in printing the error message. It happens to be available where + this macro is used. (This macro definition appeared in a late revision + of gdb-3.91.6 and is not well tested. Also, it should be a "complaint".) */ + +#define STAB_REG_TO_REGNUM(num) \ + (((num) > LR0_REGNUM + 127) \ + ? fprintf(stderr, \ + "Invalid register number %d in symbol table entry for %s\n", \ + (num), SYMBOL_NAME (sym)), (num) \ + : (num)) diff --git a/gdb/tm-3b1.h b/gdb/tm-3b1.h new file mode 100644 index 0000000..65143a9 --- /dev/null +++ b/gdb/tm-3b1.h @@ -0,0 +1,108 @@ +/* Parameters for targeting to a 3b1. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define BREAKPOINT { 0x4e, 0x41 } +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in COFF format. */ + +#define COFF_FORMAT +#define COFF_NO_LONG_FILE_NAMES + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0x300000 + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM);\ + register int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame ( create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + bpt + nop +Note this is 24 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 24 + +#define CALL_DUMMY_START_OFFSET 8 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, type) \ +{ *(int *)((char *) dummyname + 16) = nargs * 4; \ + *(int *)((char *) dummyname + 10) = fun; } + +#include "tm-68k.h" diff --git a/gdb/tm-68k.h b/gdb/tm-68k.h new file mode 100644 index 0000000..120ea08 --- /dev/null +++ b/gdb/tm-68k.h @@ -0,0 +1,473 @@ +/* Parameters for execution on a 68000 series machine. + Copyright (C) 1986, 1987, 1989, 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Generic 68000 stuff, to be included by other m-*.h files. + Define HAVE_68881 if that is the case. */ + +#if defined (HAVE_68881) +#define IEEE_FLOAT 1 +#endif + +/* Define the bit, byte, and word ordering of the machine. */ +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ +{ register int op = read_memory_integer (pc, 2); \ + if (op == 0047126) \ + pc += 4; /* Skip link #word */ \ + else if (op == 0044016) \ + pc += 6; /* Skip link #long */ \ + /* Not sure why branches are here. */ \ + /* From m-isi.h, m-altos.h */ \ + else if (op == 0060000) \ + pc += 4; /* Skip bra #word */ \ + else if (op == 00600377) \ + pc += 6; /* skip bra #long */ \ + else if ((op & 0177400) == 0060000) \ + pc += 2; /* skip bra #char */ \ +} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ +read_memory_integer (read_register (SP_REGNUM), 4) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. + This is a TRAP instruction. The last 4 bits (0xf below) is the + vector. Systems which don't use 0xf should define BREAKPOINT + themselves before including this file. */ + +#if !defined (BREAKPOINT) +#define BREAKPOINT {0x4e, 0x4f} +#endif + +/* If your kernel resets the pc after the trap happens you may need to + define this in m-68k.h. */ + +#if !defined (DECR_PC_AFTER_BREAK) +#define DECR_PC_AFTER_BREAK 2 +#endif + +/* Nonzero if instruction at PC is a return instruction. */ +/* Allow any of the return instructions, including a trapv and a return + from interupt. */ + +#define ABOUT_TO_RETURN(pc) ((read_memory_integer (pc, 2) & ~0x3) == 0x4e74) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */ + +/* Say how long registers are. */ + +#define REGISTER_TYPE long + +#if defined (HAVE_68881) +# if defined (sun) + /* Sun3 status includes fpflags, which shows whether the FPU has been used + by the process, and whether the FPU was done with an instruction or + was interrupted in the middle of a long instruction. See + <machine/reg.h>. */ + /* a&d, pc,sr, fp, fpstat, fpflags */ +# define NUM_REGS 31 +# define REGISTER_BYTES (16*4 + 8 + 8*12 + 3*4 + 4) +# else /* Not sun3. */ +# define NUM_REGS 29 +# define REGISTER_BYTES (16*4 + 8 + 8*12 + 3*4) +# endif /* Not sun3. */ +#else /* No 68881. */ +# define NUM_REGS 18 +# define REGISTER_BYTES (16*4 + 8) +#endif /* No 68881. */ + +/* Index within `registers' of the first byte of the space for + register N. */ + +#if defined (HAVE_68881) +#define REGISTER_BYTE(N) \ + ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 168 \ + : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 12) + 72 \ + : (N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the 68000, all regs are 4 bytes + except the floating point regs which are 12 bytes. */ +/* Note that the unsigned cast here forces the result of the + subtraction to very high positive values if N < FP0_REGNUM */ + +#define REGISTER_RAW_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 12 : 4) + +/* Number of bytes of storage in the program's representation + for register N. On the 68000, all regs are 4 bytes + except the floating point regs which are 8-byte doubles. */ + +#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)(N) - FP0_REGNUM) < 8 ? 8 : 4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 12 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (((unsigned)(N) - FP0_REGNUM) < 8) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +{ \ + extern struct ext_format ext_format_68881 []; \ + \ + if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \ + ieee_extended_to_double (ext_format_68881, (FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); \ +} + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +{ \ + extern struct ext_format ext_format_68881 []; \ + \ + if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \ + double_to_ieee_extended (ext_format_68881, (FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); \ +} + +/* Return the GDB type object for the "standard" data type + of data in register N. */ +/* Note, for registers which contain addresses return + pointer to void, not pointer to char, because we don't + want to attempt to print the string after printing the address. */ +#define REGISTER_VIRTUAL_TYPE(N) \ + (((unsigned)(N) - FP0_REGNUM) < 8 ? builtin_type_double : \ + (N) == PC_REGNUM || (N) == FP_REGNUM || (N) == SP_REGNUM ? \ + lookup_pointer_type (builtin_type_void) : builtin_type_int) + +#else /* no 68881. */ +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the 68000, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) 4 + +/* Number of bytes of storage in the program's representation + for register N. On the 68000, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) 4 + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 4 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) bcopy ((FROM), (TO), 4); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) bcopy ((FROM), (TO), 4); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int + +#endif /* No 68881. */ + +/* Initializer for an array of names of registers. + Entries beyond the first NUM_REGS are ignored. */ + +#define REGISTER_NAMES \ + {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", \ + "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", \ + "ps", "pc", \ + "fp0", "fp1", "fp2", "fp3", "fp4", "fp5", "fp6", "fp7", \ + "fpcontrol", "fpstatus", "fpiaddr", "fpcode", "fpflags" } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define A1_REGNUM 9 +#define FP_REGNUM 14 /* Contains address of executing stack frame */ +#define SP_REGNUM 15 /* Contains address of top of stack */ +#define PS_REGNUM 16 /* Contains processor status */ +#define PC_REGNUM 17 /* Contains program counter */ +#if defined (HAVE_68881) +#define FP0_REGNUM 18 /* Floating point register 0 */ +#define FPC_REGNUM 26 /* 68881 control register */ +#define FPS_REGNUM 27 /* 68881 status register */ +#endif /* 68881. */ + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { write_register (A1_REGNUM, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. This is assuming that floating point values are returned + as doubles in d0/d1. */ + +#if !defined (EXTRACT_RETURN_VALUE) +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) +#endif + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. Assumes floats are passed + in d0/d1. */ + +#if !defined (STORE_RETURN_VALUE) +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) +#endif + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the 68000, the frame's nominal address + is the address of a 4-byte word containing the calling frame's address. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && outside_startup_file (FRAME_SAVED_PC (thisframe))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + (FRAMELESS) = frameless_look_for_prologue(FI) + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4)) + +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Set VAL to the number of args passed to frame described by FI. + Can set VAL to -1, meaning no way to tell. */ + +/* We can't tell how many args there are + now that the C compiler delays popping them. */ +#if !defined (FRAME_NUM_ARGS) +#define FRAME_NUM_ARGS(val,fi) (val = -1) +#endif + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#if !defined (FRAME_FIND_SAVED_REGS) +#if defined (HAVE_68881) +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ register int regnum; \ + register int regmask; \ + register CORE_ADDR next_addr; \ + register CORE_ADDR pc; \ + int nextinsn; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + if ((frame_info)->pc >= (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \ + && (frame_info)->pc <= (frame_info)->frame) \ + { next_addr = (frame_info)->frame; \ + pc = (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\ + else \ + { pc = get_pc_function_start ((frame_info)->pc); \ + /* Verify we have a link a6 instruction next; \ + if not we lose. If we win, find the address above the saved \ + regs using the amount of storage from the link instruction. */\ + if (044016 == read_memory_integer (pc, 2)) \ + next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 4), pc+=4; \ + else if (047126 == read_memory_integer (pc, 2)) \ + next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 2), pc+=2; \ + else goto lose; \ + /* If have an addal #-n, sp next, adjust next_addr. */ \ + if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \ + next_addr += read_memory_integer (pc += 2, 4), pc += 4; \ + } \ + /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \ + regmask = read_memory_integer (pc + 2, 2); \ + /* But before that can come an fmovem. Check for it. */ \ + nextinsn = 0xffff & read_memory_integer (pc, 2); \ + if (0xf227 == nextinsn \ + && (regmask & 0xff00) == 0xe000) \ + { pc += 4; /* Regmask's low bit is for register fp7, the first pushed */ \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr -= 12); \ + regmask = read_memory_integer (pc + 2, 2); } \ + if (0044327 == read_memory_integer (pc, 2)) \ + { pc += 4; /* Regmask's low bit is for register 0, the first written */ \ + for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; } \ + else if (0044347 == read_memory_integer (pc, 2)) \ + { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \ + for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \ + else if (0x2f00 == (0xfff0 & read_memory_integer (pc, 2))) \ + { regnum = 0xf & read_memory_integer (pc, 2); pc += 2; \ + (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \ + /* fmovemx to index of sp may follow. */ \ + regmask = read_memory_integer (pc + 2, 2); \ + nextinsn = 0xffff & read_memory_integer (pc, 2); \ + if (0xf236 == nextinsn \ + && (regmask & 0xff00) == 0xf000) \ + { pc += 10; /* Regmask's low bit is for register fp0, the first written */ \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr += 12) - 12; \ + regmask = read_memory_integer (pc + 2, 2); } \ + /* clrw -(sp); movw ccr,-(sp) may follow. */ \ + if (0x426742e7 == read_memory_integer (pc, 4)) \ + (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \ + lose: ; \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame; \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4; \ +} +#else /* no 68881. */ +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ register int regnum; \ + register int regmask; \ + register CORE_ADDR next_addr; \ + register CORE_ADDR pc; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + if ((frame_info)->pc >= (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 4 \ + && (frame_info)->pc <= (frame_info)->frame) \ + { next_addr = (frame_info)->frame; \ + pc = (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 4; }\ + else \ + { pc = get_pc_function_start ((frame_info)->pc); \ + /* Verify we have a link a6 instruction next; \ + if not we lose. If we win, find the address above the saved \ + regs using the amount of storage from the link instruction. */\ + if (044016 == read_memory_integer (pc, 2)) \ + next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 4), pc+=4; \ + else if (047126 == read_memory_integer (pc, 2)) \ + next_addr = (frame_info)->frame + read_memory_integer (pc += 2, 2), pc+=2; \ + else goto lose; \ + /* If have an addal #-n, sp next, adjust next_addr. */ \ + if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \ + next_addr += read_memory_integer (pc += 2, 4), pc += 4; \ + } \ + /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \ + regmask = read_memory_integer (pc + 2, 2); \ + if (0044327 == read_memory_integer (pc, 2)) \ + { pc += 4; /* Regmask's low bit is for register 0, the first written */ \ + for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr += 4) - 4; } \ + else if (0044347 == read_memory_integer (pc, 2)) \ + { pc += 4; /* Regmask's low bit is for register 15, the first pushed */ \ + for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \ + else if (0x2f00 == 0xfff0 & read_memory_integer (pc, 2)) \ + { regnum = 0xf & read_memory_integer (pc, 2); pc += 2; \ + (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \ + /* clrw -(sp); movw ccr,-(sp) may follow. */ \ + if (0x426742e7 == read_memory_integer (pc, 4)) \ + (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \ + lose: ; \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame; \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4; \ +} +#endif /* no 68881. */ +#endif /* no FIND_FRAME_SAVED_REGS. */ + +/* Note that stuff for calling inferior functions is not in this file + because the call dummy is different for different breakpoint + instructions, which are different on different systems. Perhaps + they could be merged, but I haven't bothered. */ diff --git a/gdb/tm-altos.h b/gdb/tm-altos.h new file mode 100644 index 0000000..ea92f8b --- /dev/null +++ b/gdb/tm-altos.h @@ -0,0 +1,130 @@ +/* Definitions to make GDB run on an Altos 3068 (m68k running SVR2) + Copyright (C) 1987,1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0x4e, 0x4e} + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#undef NAMES_HAVE_UNDERSCORE + +/* Exec files and symbol tables are in COFF format */ + +#define COFF_FORMAT +#define COFF_NO_LONG_FILE_NAMES + +/* Address of end of stack space. */ + +/*#define STACK_END_ADDR (0xffffff)*/ +#define STACK_END_ADDR (0x1000000) + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. + On the Altos, the kernel resets the pc to the trap instr */ + +#define DECR_PC_AFTER_BREAK 0 + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); } + +/* This sequence of words is the instructions + fmovem 0xff,-(sp) + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + bpt + nop +Note this is 28 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4e4e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } + +#include "tm-68k.h" diff --git a/gdb/tm-altosgas.h b/gdb/tm-altosgas.h new file mode 100644 index 0000000..eb342ea --- /dev/null +++ b/gdb/tm-altosgas.h @@ -0,0 +1,28 @@ +/* Definitions to make GDB run on an Altos 3068 using COFF encapsulation. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define COFF_ENCAPSULATE + +#include "m-altos.h" + +#undef COFF_FORMAT +#undef COFF_NO_LONG_FILE_NAMES +#define NAMES_HAVE_UNDERSCORE + +#define READ_DBX_FORMAT diff --git a/gdb/tm-arm.h b/gdb/tm-arm.h new file mode 100644 index 0000000..c061399 --- /dev/null +++ b/gdb/tm-arm.h @@ -0,0 +1,415 @@ +/* Definitions to make GDB target for an ARM under RISCiX (4.3bsd). + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* IEEE format floating point */ + +#define IEEE_FLOAT + +/* I provide my own xfer_core_file to cope with shared libraries */ + +#define XFER_CORE_FILE + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) pc = skip_prologue(pc) + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) (read_register (LR_REGNUM) & 0x03fffffc) + +/* I don't know the real values for these. */ +#define TARGET_UPAGES UPAGES +#define TARGET_NBPG NBPG + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0x01000000 - (TARGET_UPAGES * TARGET_NBPG)) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0x00,0x00,0x18,0xef} /* BKPT_SWI from <sys/ptrace.h> */ + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) \ + ((read_memory_integer(pc, 4) & 0x0fffffff == 0x01b0f00e) || \ + (read_memory_integer(pc, 4) & 0x0ffff800 == 0x09eba800)) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes. */ + +#define INVALID_FLOAT(p, len) 0 + +/* code to execute to print interesting information about the + * floating point processor (if any) + * No need to define if there is nothing to do. + */ +#define FLOAT_INFO { arm_float_info (); } + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +/* Note: I make a fake copy of the pc in register 25 (calling it ps) so + that I can clear the status bits from pc (register 15) */ + +#define NUM_REGS 26 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES \ + { "a1", "a2", "a3", "a4", \ + "v1", "v2", "v3", "v4", "v5", "v6", \ + "sl", "fp", "ip", "sp", "lr", "pc", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", "fps", "ps" } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define AP_REGNUM 11 +#define FP_REGNUM 11 /* Contains address of executing stack frame */ +#define SP_REGNUM 13 /* Contains address of top of stack */ +#define LR_REGNUM 14 /* address to return to from a function call */ +#define PC_REGNUM 15 /* Contains program counter */ +#define F0_REGNUM 16 /* first floating point register */ +#define FPS_REGNUM 24 /* floating point status register */ +#define PS_REGNUM 25 /* Contains processor status */ + + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (16*4 + 12*8 + 4 + 4) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) (((N) < F0_REGNUM) ? (N)*4 : \ + (((N) < PS_REGNUM) ? 16*4 + ((N) - 16)*12 : \ + 16*4 + 8*12 + ((N) - FPS_REGNUM) * 4)) + +/* Number of bytes of storage in the actual machine representation + for register N. On the vax, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) (((N) < F0_REGNUM || (N) >= FPS_REGNUM) ? 4 : 12) + +/* Number of bytes of storage in the program's representation + for register N. On the vax, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) (((N) < F0_REGNUM || (N) >= FPS_REGNUM) ? 4 : 8) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 12 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) ((unsigned)(N) - F0_REGNUM < 8) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + if (REGISTER_CONVERTIBLE(REGNUM)) \ + convert_from_extended((FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + if (REGISTER_CONVERTIBLE(REGNUM)) \ + convert_to_extended((FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + (((unsigned)(N) - F0_REGNUM) < 8 ? builtin_type_double : builtin_type_int) + +/* The system C compiler uses a similar structure return convention to gcc */ + +#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > 4) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { write_register (0, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + convert_from_extended(REGBUF + REGISTER_BYTE (F0_REGNUM), VALBUF); \ + else \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) { \ + char _buf[MAX_REGISTER_RAW_SIZE]; \ + convert_to_extended(VALBUF, _buf); \ + write_register_bytes (REGISTER_BYTE (F0_REGNUM), _buf, MAX_REGISTER_RAW_SIZE); \ + } else \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Specify that for the native compiler variables for a particular + lexical context are listed after the beginning LBRAC instead of + before in the executables list of symbols. */ +#define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (!(gcc_p)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the ARM, the frame's nominal address is the FP value, + and 12 bytes before comes the saved previous FP value as a 4-byte word. */ + +#define FRAME_CHAIN(thisframe) \ + ((thisframe)->pc >= first_object_file_end ? \ + read_memory_integer ((thisframe)->frame - 12, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (FRAME_SAVED_PC (thisframe) >= first_object_file_end)) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ +{ \ + CORE_ADDR func_start, after_prologue; \ + func_start = (get_pc_function_start ((FI)->pc) + \ + FUNCTION_START_OFFSET); \ + after_prologue = func_start; \ + SKIP_PROLOGUE (after_prologue); \ + (FRAMELESS) = (after_prologue == func_start); \ +} + +/* Saved Pc. */ + +#define FRAME_SAVED_PC(FRAME) \ + (read_memory_integer ((FRAME)->frame - 4, 4) & 0x03fffffc) + +#define FRAME_ARGS_ADDRESS(fi) (fi->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) (numargs = -1) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ \ + register int regnum; \ + register int frame; \ + register int next_addr; \ + register int return_data_save; \ + register int saved_register_mask; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + frame = (frame_info)->frame; \ + return_data_save = read_memory_integer(frame, 4) & 0x03fffffc - 12; \ + saved_register_mask = \ + read_memory_integer(return_data_save, 4); \ + next_addr = frame - 12; \ + for (regnum = 4; regnum < 10; regnum++) \ + if (saved_register_mask & (1<<regnum)) { \ + next_addr -= 4; \ + (frame_saved_regs).regs[regnum] = next_addr; \ + } \ + if (read_memory_integer(return_data_save + 4, 4) == 0xed6d7103) { \ + next_addr -= 12; \ + (frame_saved_regs).regs[F0_REGNUM + 7] = next_addr; \ + } \ + if (read_memory_integer(return_data_save + 8, 4) == 0xed6d6103) { \ + next_addr -= 12; \ + (frame_saved_regs).regs[F0_REGNUM + 6] = next_addr; \ + } \ + if (read_memory_integer(return_data_save + 12, 4) == 0xed6d5103) { \ + next_addr -= 12; \ + (frame_saved_regs).regs[F0_REGNUM + 5] = next_addr; \ + } \ + if (read_memory_integer(return_data_save + 16, 4) == 0xed6d4103) { \ + next_addr -= 12; \ + (frame_saved_regs).regs[F0_REGNUM + 4] = next_addr; \ + } \ + (frame_saved_regs).regs[SP_REGNUM] = next_addr; \ + (frame_saved_regs).regs[PC_REGNUM] = frame - 4; \ + (frame_saved_regs).regs[PS_REGNUM] = frame - 4; \ + (frame_saved_regs).regs[FP_REGNUM] = frame - 12; \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ \ + register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + /* opcode for ldmdb fp,{v1-v6,fp,ip,lr,pc}^ */ \ + sp = push_word(sp, 0xe92dbf0); /* dummy return_data_save ins */ \ + /* push a pointer to the dummy instruction minus 12 */ \ + sp = push_word(sp, read_register (SP_REGNUM) - 16); \ + sp = push_word(sp, read_register (PS_REGNUM)); \ + sp = push_word(sp, read_register (SP_REGNUM)); \ + sp = push_word(sp, read_register (FP_REGNUM)); \ + for (regnum = 9; regnum >= 4; regnum --) \ + sp = push_word(sp, read_register (regnum)); \ + write_register (FP_REGNUM, read_register (SP_REGNUM) - 8); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ \ + register CORE_ADDR fp = read_register (FP_REGNUM); \ + register unsigned long return_data_save = \ + read_memory_integer ( (read_memory_integer (fp, 4) & \ + 0x03fffffc) - 12, 4); \ + register int regnum; \ + write_register (PS_REGNUM, read_memory_integer (fp - 4, 4)); \ + write_register (PC_REGNUM, read_register (PS_REGNUM) & 0x03fffffc); \ + write_register (SP_REGNUM, read_memory_integer (fp - 8, 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp - 12, 4)); \ + fp -= 12; \ + for (regnum = 9; regnum >= 4; regnum--) \ + if (return_data_save & (1<<regnum)) { \ + fp -= 4; \ + write_register (regnum, read_memory_integer(fp, 4)); \ + } \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); \ +} + +/* This sequence of words is the instructions + + ldmia sp!,{a1-a4} + mov lk,pc + bl *+8 + swi bkpt_swi + + Note this is 16 bytes. */ + +#define CALL_DUMMY {0xe8bd000f, 0xe1a0e00f, 0xeb000000, 0xef180000} + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + register enum type_code code = TYPE_CODE (type); \ + register nargs_in_registers, struct_return = 0; \ + /* fix the load-arguments mask to move the first 4 or less arguments \ + into a1-a4 but make sure the structure return address in a1 is \ + not disturbed if the function is returning a structure */ \ + if ((code == TYPE_CODE_STRUCT || \ + code == TYPE_CODE_UNION || \ + code == TYPE_CODE_ARRAY) && \ + TYPE_LENGTH (type) > 4) { \ + nargs_in_registers = min(nargs + 1, 4); \ + struct_return = 1; \ + } else \ + nargs_in_registers = min(nargs, 4); \ + *(char *) dummyname = (1 << nargs_in_registers) - 1 - struct_return; \ + *(int *)((char *) dummyname + 8) = \ + (((fun - (pc + 16)) / 4) & 0x00ffffff) | 0xeb000000; } diff --git a/gdb/tm-bigmips.h b/gdb/tm-bigmips.h new file mode 100644 index 0000000..7d6bae5 --- /dev/null +++ b/gdb/tm-bigmips.h @@ -0,0 +1,21 @@ +/* Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +#include "tm-mips.h" diff --git a/gdb/tm-convex.h b/gdb/tm-convex.h new file mode 100644 index 0000000..5a001f1 --- /dev/null +++ b/gdb/tm-convex.h @@ -0,0 +1,563 @@ +/* Definitions to make GDB run on Convex Unix (4bsd) + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* I don't know if this will work for cross-debugging, even if you do get + the right files. */ +/* Include certain files for dbxread.c */ +#include <convex/filehdr.h> +#include <convex/opthdr.h> +#include <convex/scnhdr.h> +#include <nlist.h> + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* There is come problem with the debugging symbols generated by the + compiler such that the debugging symbol for the first line of a + function overlap with the function prologue. */ +#define PROLOGUE_FIRSTLINE_OVERLAP + +/* When convex pcc says CHAR or SHORT, it provides the correct address. */ + +#define BELIEVE_PCC_PROMOTION 1 + +/* Symbol types to ignore. */ +/* 0xc4 is N_MONPT. Use the numeric value for the benefit of people + with (rather) old OS's. */ +#define IGNORE_SYMBOL(TYPE) \ + (((TYPE) & ~N_EXT) == N_TBSS \ + || ((TYPE) & ~N_EXT) == N_TDATA \ + || ((TYPE) & ~N_EXT) == 0xc4) + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. + Convex prolog is: + [sub.w #-,sp] in one of 3 possible sizes + [mov psw,- fc/vc main program prolog + and #-,- (skip it because the "mov psw" saves the + mov -,psw] T bit, so continue gets a surprise trap) + [and #-,sp] fc/vc O2 main program prolog + [ld.- -(ap),-] pcc/gcc register arg loads +*/ + +#define SKIP_PROLOGUE(pc) \ +{ int op, ix; \ + op = read_memory_integer (pc, 2); \ + if ((op & 0xffc7) == 0x5ac0) pc += 2; \ + else if (op == 0x1580) pc += 4; \ + else if (op == 0x15c0) pc += 6; \ + if ((read_memory_integer (pc, 2) & 0xfff8) == 0x7c40 \ + && (read_memory_integer (pc + 2, 2) & 0xfff8) == 0x1240 \ + && (read_memory_integer (pc + 8, 2) & 0xfff8) == 0x7c48) \ + pc += 10; \ + if (read_memory_integer (pc, 2) == 0x1240) pc += 6; \ + for (;;) { \ + op = read_memory_integer (pc, 2); \ + ix = (op >> 3) & 7; \ + if (ix != 6) break; \ + if ((op & 0xfcc0) == 0x3000) pc += 4; \ + else if ((op & 0xfcc0) == 0x3040) pc += 6; \ + else if ((op & 0xfcc0) == 0x2800) pc += 4; \ + else if ((op & 0xfcc0) == 0x2840) pc += 6; \ + else break;}} + +/* Immediately after a function call, return the saved pc. + (ignore frame and return *$sp so we can handle both calls and callq) */ + +#define SAVED_PC_AFTER_CALL(frame) \ + read_memory_integer (read_register (SP_REGNUM), 4) + +/* Address of end of stack space. + This is ((USRSTACK + 0xfff) & -0x1000)) from <convex/vmparam.h> but + that expression depends on the kernel version; instead, fetch a + page-zero pointer and get it from that. This will be invalid if + they ever change the way bkpt signals are delivered. */ + +#define STACK_END_ADDR (0xfffff000 & *(unsigned *) 0x80000050) + +/* User-mode traps push an extended rtn block, + then fault with one of the following PCs */ + +#define is_trace_pc(pc) ((unsigned) ((pc) - (*(int *) 0x80000040)) <= 4) +#define is_arith_pc(pc) ((unsigned) ((pc) - (*(int *) 0x80000044)) <= 4) +#define is_break_pc(pc) ((unsigned) ((pc) - (*(int *) 0x80000050)) <= 4) + +/* We need to manipulate trap bits in the psw */ + +#define PSW_TRAP_FLAGS 0x69670000 +#define PSW_T_BIT 0x08000000 +#define PSW_S_BIT 0x01000000 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. (bkpt) */ + +#define BREAKPOINT {0x7d,0x50} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT but not always. + (The break PC needs to be decremented by 2, but we do it when the + break frame is recognized and popped. That way gdb can tell breaks + from trace traps with certainty.) */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. (rtn or rtnq) */ + +#define ABOUT_TO_RETURN(pc) \ + ((read_memory_integer (pc, 2) & 0xffe0) == 0x7c80) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p,len) 0 + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long long + +/* Number of machine registers */ + +#define NUM_REGS 26 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES {"pc","psw","fp","ap","a5","a4","a3","a2","a1","sp",\ + "s7","s6","s5","s4","s3","s2","s1","s0",\ + "S7","S6","S5","S4","S3","S2","S1","S0"} + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define S0_REGNUM 25 /* the real S regs */ +#define S7_REGNUM 18 +#define s0_REGNUM 17 /* low-order halves of S regs */ +#define s7_REGNUM 10 +#define SP_REGNUM 9 /* A regs */ +#define A1_REGNUM 8 +#define A5_REGNUM 4 +#define AP_REGNUM 3 +#define FP_REGNUM 2 /* Contains address of executing stack frame */ +#define PS_REGNUM 1 /* Contains processor status */ +#define PC_REGNUM 0 /* Contains program counter */ + +/* convert dbx stab register number (from `r' declaration) to a gdb REGNUM */ + +#define STAB_REG_TO_REGNUM(value) \ + ((value) < 8 ? S0_REGNUM - (value) : SP_REGNUM - ((value) - 8)) + +/* Vector register numbers, not handled as ordinary regs. + They are treated as convenience variables whose values are read + from the inferior when needed. */ + +#define V0_REGNUM 0 +#define V7_REGNUM 7 +#define VM_REGNUM 8 +#define VS_REGNUM 9 +#define VL_REGNUM 10 + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (4*10 + 8*8) + +/* Index within `registers' of the first byte of the space for + register N. + NB: must match structure of struct syscall_context for correct operation */ + +#define REGISTER_BYTE(N) ((N) < s7_REGNUM ? 4*(N) : \ + (N) < S7_REGNUM ? 44 + 8 * ((N)-s7_REGNUM) : \ + 40 + 8 * ((N)-S7_REGNUM)) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +#define REGISTER_RAW_SIZE(N) ((N) < S7_REGNUM ? 4 : 8) + +/* Number of bytes of storage in the program's representation + for register N. */ + +#define REGISTER_VIRTUAL_SIZE(N) REGISTER_RAW_SIZE(N) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 8 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM)); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_RAW_SIZE (REGNUM)); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + ((N) < S7_REGNUM ? builtin_type_int : builtin_type_long_long) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { write_register (A1_REGNUM, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (&((char *) REGBUF) [REGISTER_BYTE (S0_REGNUM) + \ + 8 - TYPE_LENGTH (TYPE)],\ + VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE (S0_REGNUM), VALBUF, 8) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ + (*(int *) & ((char *) REGBUF) [REGISTER_BYTE (s0_REGNUM)]) + +/* Define trapped internal variable hooks to read and write + vector and communication registers. */ + +#define IS_TRAPPED_INTERNALVAR is_trapped_internalvar +#define VALUE_OF_TRAPPED_INTERNALVAR value_of_trapped_internalvar +#define SET_TRAPPED_INTERNALVAR set_trapped_internalvar + +extern struct value *value_of_trapped_internalvar (); + +/* Hooks to read data from soff exec and core files, + and to describe the files. */ + +#define XFER_CORE_FILE +#define FILES_INFO_HOOK print_maps + +/* Hook to call to print a typeless integer value, normally printed in decimal. + For convex, use hex instead if the number looks like an address. */ + +#define PRINT_TYPELESS_INTEGER decout + +/* For the native compiler, variables for a particular lexical context + are listed after the beginning LBRAC instead of before in the + executables list of symbols. Using "gcc_compiled." to distinguish + between GCC and native compiler doesn't work on Convex because the + linker sorts the symbols to put "gcc_compiled." in the wrong place. + desc is nonzero for native, zero for gcc. */ +#define VARIABLES_INSIDE_BLOCK(desc, gcc_p) (desc != 0) + +/* Pcc occaisionally puts an SO where there should be an SOL. */ +#define PCC_SOL_BROKEN + +/* Cannot execute with pc on the stack. */ +#define CANNOT_EXECUTE_STACK + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame_info with a frame's nominal address in fi->frame, + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* (caller fp is saved at 8(fp)) */ + +#define FRAME_CHAIN(fi) (read_memory_integer ((fi)->frame + 8, 4)) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. + On convex, check at the return address for `callq' -- if so, frameless, + otherwise, not. */ + +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ +{ \ + extern CORE_ADDR text_start, text_end; \ + CORE_ADDR call_addr = SAVED_PC_AFTER_CALL (FI); \ + (FRAMELESS) = (call_addr >= text_start && call_addr < text_end \ + && read_memory_integer (call_addr - 6, 1) == 0x22); \ +} + +#define FRAME_SAVED_PC(fi) (read_memory_integer ((fi)->frame, 4)) + +#define FRAME_ARGS_ADDRESS(fi) (read_memory_integer ((fi)->frame + 12, 4)) + +#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) \ +{ numargs = read_memory_integer (FRAME_ARGS_ADDRESS (fi) - 4, 4); \ + if (numargs < 0 || numargs >= 256) numargs = -1;} + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +/* Normal (short) frames save only PC, FP, (callee's) AP. To reasonably + handle gcc and pcc register variables, scan the code following the + call for the instructions the compiler inserts to reload register + variables from stack slots and record the stack slots as the saved + locations of those registers. This will occasionally identify some + random load as a saved register; this is harmless. vc does not + declare its register allocation actions in the stabs. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ register int regnum; \ + register int frame_length = /* 3 short, 2 long, 1 extended, 0 context */\ + (read_memory_integer ((frame_info)->frame + 4, 4) >> 25) & 3; \ + register CORE_ADDR frame_fp = \ + read_memory_integer ((frame_info)->frame + 8, 4); \ + register CORE_ADDR next_addr; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 0; \ + (frame_saved_regs).regs[PS_REGNUM] = (frame_info)->frame + 4; \ + (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[AP_REGNUM] = frame_fp + 12; \ + next_addr = (frame_info)->frame + 12; \ + if (frame_length < 3) \ + for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum) \ + (frame_saved_regs).regs[regnum] = (next_addr += 4); \ + if (frame_length < 2) \ + (frame_saved_regs).regs[SP_REGNUM] = (next_addr += 4); \ + next_addr -= 4; \ + if (frame_length < 3) \ + for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum) \ + (frame_saved_regs).regs[regnum] = (next_addr += 8); \ + if (frame_length < 2) \ + (frame_saved_regs).regs[S0_REGNUM] = (next_addr += 8); \ + else \ + (frame_saved_regs).regs[SP_REGNUM] = next_addr + 8; \ + if (frame_length == 3) { \ + CORE_ADDR pc = read_memory_integer ((frame_info)->frame, 4); \ + int op, ix, disp; \ + op = read_memory_integer (pc, 2); \ + if ((op & 0xffc7) == 0x1480) pc += 4; /* add.w #-,sp */ \ + else if ((op & 0xffc7) == 0x58c0) pc += 2; /* add.w #-,sp */ \ + op = read_memory_integer (pc, 2); \ + if ((op & 0xffc7) == 0x2a06) pc += 4; /* ld.w -,ap */ \ + for (;;) { \ + op = read_memory_integer (pc, 2); \ + ix = (op >> 3) & 7; \ + if ((op & 0xfcc0) == 0x2800) { /* ld.- -,ak */ \ + regnum = SP_REGNUM - (op & 7); \ + disp = read_memory_integer (pc + 2, 2); \ + pc += 4;} \ + else if ((op & 0xfcc0) == 0x2840) { /* ld.- -,ak */ \ + regnum = SP_REGNUM - (op & 7); \ + disp = read_memory_integer (pc + 2, 4); \ + pc += 6;} \ + if ((op & 0xfcc0) == 0x3000) { /* ld.- -,sk */ \ + regnum = S0_REGNUM - (op & 7); \ + disp = read_memory_integer (pc + 2, 2); \ + pc += 4;} \ + else if ((op & 0xfcc0) == 0x3040) { /* ld.- -,sk */ \ + regnum = S0_REGNUM - (op & 7); \ + disp = read_memory_integer (pc + 2, 4); \ + pc += 6;} \ + else if ((op & 0xff00) == 0x7100) { /* br crossjump */ \ + pc += 2 * (char) op; \ + continue;} \ + else if (op == 0x0140) { /* jmp crossjump */ \ + pc = read_memory_integer (pc + 2, 4); \ + continue;} \ + else break; \ + if ((frame_saved_regs).regs[regnum]) \ + break; \ + if (ix == 7) disp += frame_fp; \ + else if (ix == 6) disp += read_memory_integer (frame_fp + 12, 4); \ + else if (ix != 0) break; \ + (frame_saved_regs).regs[regnum] = \ + disp - 8 + (1 << ((op >> 8) & 3)); \ + if (regnum >= S7_REGNUM) \ + (frame_saved_regs).regs[regnum - S0_REGNUM + s0_REGNUM] = \ + disp - 4 + (1 << ((op >> 8) & 3)); \ + } \ + } \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char buf[8]; \ + long word; \ + for (regnum = S0_REGNUM; regnum >= S7_REGNUM; --regnum) { \ + read_register_bytes (REGISTER_BYTE (regnum), buf, 8); \ + sp = push_bytes (sp, buf, 8);} \ + for (regnum = SP_REGNUM; regnum >= FP_REGNUM; --regnum) { \ + word = read_register (regnum); \ + sp = push_bytes (sp, &word, 4);} \ + word = (read_register (PS_REGNUM) &~ (3<<25)) | (1<<25); \ + sp = push_bytes (sp, &word, 4); \ + word = read_register (PC_REGNUM); \ + sp = push_bytes (sp, &word, 4); \ + write_register (SP_REGNUM, sp); \ + write_register (FP_REGNUM, sp); \ + write_register (AP_REGNUM, sp);} + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME do {\ + register CORE_ADDR fp = read_register (FP_REGNUM); \ + register int regnum; \ + register int frame_length = /* 3 short, 2 long, 1 extended, 0 context */ \ + (read_memory_integer (fp + 4, 4) >> 25) & 3; \ + char buf[8]; \ + write_register (PC_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PS_REGNUM, read_memory_integer (fp += 4, 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp += 4, 4)); \ + write_register (AP_REGNUM, read_memory_integer (fp += 4, 4)); \ + if (frame_length < 3) \ + for (regnum = A5_REGNUM; regnum < SP_REGNUM; ++regnum) \ + write_register (regnum, read_memory_integer (fp += 4, 4)); \ + if (frame_length < 2) \ + write_register (SP_REGNUM, read_memory_integer (fp += 4, 4)); \ + fp -= 4; \ + if (frame_length < 3) \ + for (regnum = S7_REGNUM; regnum < S0_REGNUM; ++regnum) { \ + read_memory (fp += 8, buf, 8); \ + write_register_bytes (REGISTER_BYTE (regnum), buf, 8);} \ + if (frame_length < 2) { \ + read_memory (fp += 8, buf, 8); \ + write_register_bytes (REGISTER_BYTE (regnum), buf, 8);} \ + else write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); \ +} while (0) + +/* This sequence of words is the instructions + mov sp,ap + pshea 69696969 + calls 32323232 + bkpt + Note this is 16 bytes. */ + +#define CALL_DUMMY {0x50860d4069696969LL,0x2140323232327d50LL} + +#define CALL_DUMMY_LENGTH 16 + +#define CALL_DUMMY_START_OFFSET 0 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 4) = nargs; \ + *(int *)((char *) dummyname + 10) = fun; } + +/* Defs to read soff symbol tables, see dbxread.c */ + +#define NUMBER_OF_SYMBOLS ((long) opthdr.o_nsyms) +#define STRING_TABLE_OFFSET ((long) filehdr.h_strptr) +#define SYMBOL_TABLE_OFFSET ((long) opthdr.o_symptr) +#define STRING_TABLE_SIZE ((long) filehdr.h_strsiz) +#define SIZE_OF_TEXT_SEGMENT ((long) txthdr.s_size) +#define ENTRY_POINT ((long) opthdr.o_entry) + +#define READ_STRING_TABLE_SIZE(BUFFER) \ + (BUFFER = STRING_TABLE_SIZE) + +#define DECLARE_FILE_HEADERS \ + FILEHDR filehdr; \ + OPTHDR opthdr; \ + SCNHDR txthdr + +#define READ_FILE_HEADERS(DESC,NAME) \ +{ \ + int n; \ + val = myread (DESC, &filehdr, sizeof filehdr); \ + if (val < 0) \ + perror_with_name (NAME); \ + if (! IS_SOFF_MAGIC (filehdr.h_magic)) \ + error ("%s: not an executable file.", NAME); \ + lseek (DESC, 0L, 0); \ + if (myread (DESC, &filehdr, sizeof filehdr) < 0) \ + perror_with_name (NAME); \ + if (myread (DESC, &opthdr, filehdr.h_opthdr) <= 0) \ + perror_with_name (NAME); \ + for (n = 0; n < filehdr.h_nscns; n++) \ + { \ + if (myread (DESC, &txthdr, sizeof txthdr) < 0) \ + perror_with_name (NAME); \ + if ((txthdr.s_flags & S_TYPMASK) == S_TEXT) \ + break; \ + } \ +} diff --git a/gdb/tm-hp300bsd.h b/gdb/tm-hp300bsd.h new file mode 100644 index 0000000..d4601bf --- /dev/null +++ b/gdb/tm-hp300bsd.h @@ -0,0 +1,142 @@ +/* Parameters for execution on a Hewlett-Packard 9000/300, running bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * Configuration file for HP9000/300 series machine running + * University of Utah's 4.3bsd port. This is NOT for HP-UX. + * Problems to hpbsd-bugs@cs.utah.edu + */ + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +#define TARGET_NBPG 4096 +#define TARGET_UPAGES 3 + +/* On the HP300, sigtramp is in the u area. Gak! User struct is not + mapped to the same virtual address in user/kernel address space + (hence STACK_END_ADDR as opposed to KERNEL_U_ADDR). This tests + for the whole u area, since we don't necessarily have hp300bsd + include files around. */ +#define IN_SIGTRAMP(pc, name) \ + ((pc) >= STACK_END_ADDR \ + && (pc) < STACK_END_ADDR + TARGET_UPAGES * TARGET_NBPG \ + ) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0xfff00000 + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0x4e, 0x42} + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_gen (regnum, raw_buffer); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions + fmovem 0xff,-(sp) + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + trap #2 + nop +Note this is 28 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e424e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } + +#define HAVE_68881 + +#include "tm-68k.h" diff --git a/gdb/tm-hp300hpux.h b/gdb/tm-hp300hpux.h new file mode 100644 index 0000000..67c9323 --- /dev/null +++ b/gdb/tm-hp300hpux.h @@ -0,0 +1,122 @@ +/* Parameters for execution on an HP 9000 model 320, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0x4e, 0x41} + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0xFFF00000 + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM),\ + read_pc ()));} + +/* This sequence of words is the instructions + fmovem 0xff,-(sp) + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + bpt + nop +Note this is 28 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e414e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } + +#include HAVE_68881 + +#include "tm-68k.h" diff --git a/gdb/tm-i386v-g.h b/gdb/tm-i386v-g.h new file mode 100644 index 0000000..e1dc3fd --- /dev/null +++ b/gdb/tm-i386v-g.h @@ -0,0 +1,38 @@ +/* Macro definitions for i386 using the GNU object file format. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * Changes for 80386 by Pace Willisson (pace@prep.ai.mit.edu) + * July 1988 + * + * i386gnu: COFF_ENCAPSULATE + */ + + +#define COFF_ENCAPSULATE + +#include "tm-i386v.h" + +/* The version in m-i386.h is for COFF. */ +#undef N_SET_MAGIC + +#define NAMES_HAVE_UNDERSCORE + +#undef COFF_FORMAT +#define READ_DBX_FORMAT diff --git a/gdb/tm-i386v.h b/gdb/tm-i386v.h new file mode 100644 index 0000000..59f8967 --- /dev/null +++ b/gdb/tm-i386v.h @@ -0,0 +1,307 @@ +/* Macro defintions for i386. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * Changes for 80386 by Pace Willisson (pace@prep.ai.mit.edu) + * July 1988 + */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* define this if you don't have the extension to coff that allows + * file names to appear in the string table + * (aux.x_file.x_foff) + */ +#define COFF_NO_LONG_FILE_NAMES + +/* turn this on when rest of gdb is ready */ +/* #define IEEE_FLOAT */ + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +/* #define NAMES_HAVE_UNDERSCORE */ + +/* Specify debugger information format. */ + +/* #define READ_DBX_FORMAT */ +#define COFF_FORMAT + +/* number of traps that happen between exec'ing the shell + * to run an inferior, and when we finally get to + * the inferior code. This is 2 on most implementations. + */ +#define START_INFERIOR_TRAPS_EXPECTED 4 + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(frompc) {(frompc) = i386_skip_prologue((frompc));} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + (read_memory_integer (read_register (SP_REGNUM), 4)) + +/* This is only supposed to work in execcore.c, where x == 0 and + this is called before any other fields are filled in. */ +#define N_SET_MAGIC(aouthdr, x) \ + bzero ((char *) &aouthdr, sizeof aouthdr) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0x80000000 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xcc} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 1 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0xc3) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes -- not relevant on the 386. */ + +#define INVALID_FLOAT(p, len) (0) + +/* code to execute to print interesting information about the + * floating point processor (if any) + * No need to define if there is nothing to do. + */ +#define FLOAT_INFO { i386_float_info (); } + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 16 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +/* the order of the first 8 registers must match the compiler's + * numbering scheme (which is the same as the 386 scheme) + * also, this table must match regmap in i386-pinsn.c. + */ +#define REGISTER_NAMES { "eax", "ecx", "edx", "ebx", \ + "esp", "ebp", "esi", "edi", \ + "eip", "ps", "cs", "ss", \ + "ds", "es", "fs", "gs", \ + } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define FP_REGNUM 5 /* Contains address of executing stack frame */ +#define SP_REGNUM 4 /* Contains address of top of stack */ + +#define PC_REGNUM 8 +#define PS_REGNUM 9 + +#define REGISTER_U_ADDR(addr, blockend, regno) \ + (addr) = i386_register_u_addr ((blockend),(regno)); + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (NUM_REGS * 4) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N)*4) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +#define REGISTER_RAW_SIZE(N) (4) + +/* Number of bytes of storage in the program's representation + for register N. */ + +#define REGISTER_VIRTUAL_SIZE(N) (4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 4 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) {bcopy ((FROM), (TO), 4);} + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) {bcopy ((FROM), (TO), 4);} + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { (SP) -= sizeof (ADDR); \ + write_memory ((SP), &(ADDR), sizeof (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + (FRAMELESS) = frameless_look_for_prologue(FI) + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4)) + +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) (numargs) = i386_frame_num_args(fi) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ i386_frame_find_saved_regs ((frame_info), &(frame_saved_regs)); } + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME { i386_push_dummy_frame (); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME { i386_pop_frame (); } + +/* this is + * call 11223344 (32 bit relative) + * int3 + */ + +#define CALL_DUMMY { 0x223344e8, 0xcc11 } + +#define CALL_DUMMY_LENGTH 8 + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + int from, to, delta, loc; \ + loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \ + from = loc + 5; \ + to = (int)(fun); \ + delta = to - from; \ + *(int *)((char *)(dummyname) + 1) = delta; \ +} diff --git a/gdb/tm-i960.h b/gdb/tm-i960.h new file mode 100644 index 0000000..5ddf8c2 --- /dev/null +++ b/gdb/tm-i960.h @@ -0,0 +1,399 @@ +/* Parameters for target machine Intel 960, for GDB, the GNU debugger. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + Contributed by Intel Corporation. +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Definitions to target GDB to any i960. */ + +#ifndef I80960 +#define I80960 +#endif + +/* Hook for the SYMBOL_CLASS of a parameter when decoding DBX symbol + information. In the i960, parameters can be stored as locals or as + args, depending on the type of the debug record. + + From empirical observation, gcc960 uses N_LSYM to indicate + arguments passed in registers and then copied immediately + to the frame, and N_PSYM to indicate arguments passed in a + g14-relative argument block. */ + +#define DBX_PARM_SYMBOL_CLASS(type) ((type == N_LSYM)? LOC_LOCAL_ARG: LOC_ARG) + +/* Byte order is configurable, but this machine runs little-endian. */ +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* We have IEEE floating point, if we have any float at all. */ + +#define IEEE_FLOAT + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance ip across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(ip) { ip = skip_prologue (ip); } +extern CORE_ADDR skip_prologue (); + +/* Immediately after a function call, return the saved ip. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function + executes some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) (saved_pc_after_call (frame)) +extern CORE_ADDR saved_pc_after_call (); + +/* Stack grows upward */ + +#define INNER_THAN > + +/* Nonzero if instruction at ip is a return instruction. */ + +#define ABOUT_TO_RETURN(ip) (read_memory_integer(ip,4) == 0x0a000000) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes. */ + +#define INVALID_FLOAT(p, len) (0) + +/* How long (ordinary) registers are */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ +#define NUM_REGS 40 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES { \ + /* 0 */ "pfp", "sp", "rip", "r3", "r4", "r5", "r6", "r7", \ + /* 8 */ "r8", "r9", "r10", "r11", "r12", "r13", "r14", "r15",\ + /* 16 */ "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", \ + /* 24 */ "g8", "g9", "g10", "g11", "g12", "g13", "g14", "fp", \ + /* 32 */ "pc", "ac", "ip", "tc", "fp0", "fp1", "fp2", "fp3", \ +} + +/* Register numbers of various important registers (used to index + into arrays of register names and register values). */ + +#define R0_REGNUM 0 /* First local register */ +#define SP_REGNUM 1 /* Contains address of top of stack */ +#define RIP_REGNUM 2 /* Return instruction pointer (local r2) */ +#define R15_REGNUM 15 /* Last local register */ +#define G0_REGNUM 16 /* First global register */ +#define G13_REGNUM 29 /* g13 - holds struct return address */ +#define G14_REGNUM 30 /* g14 - ptr to arg block / leafproc return address */ +#define FP_REGNUM 31 /* Contains address of executing stack frame */ +#define PCW_REGNUM 32 /* process control word */ +#define ACW_REGNUM 33 /* arithmetic control word */ +#define IP_REGNUM 34 /* instruction pointer */ +#define TCW_REGNUM 35 /* trace control word */ +#define FP0_REGNUM 36 /* First floating point register */ + +/* Some registers have more than one name */ + +#define PC_REGNUM IP_REGNUM /* GDB refers to ip as the Program Counter */ +#define PFP_REGNUM R0_REGNUM /* Previous frame pointer */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES ((36*4) + (4*10)) + +/* Index within `registers' of the first byte of the space for register N. */ + +#define REGISTER_BYTE(N) ( (N) < FP0_REGNUM ? \ + (4*(N)) : ((10*(N)) - (6*FP0_REGNUM)) ) + +/* The i960 has register windows, sort of. */ + +#define HAVE_REGISTER_WINDOWS + +/* Is this register part of the register window system? A yes answer + implies that 1) The name of this register will not be the same in + other frames, and 2) This register is automatically "saved" upon + subroutine calls and thus there is no need to search more than one + stack frame for it. + + On the i960, in fact, the name of this register in another frame is + "mud" -- there is no overlap between the windows. Each window is + simply saved into the stack (true for our purposes, after having been + flushed; normally they reside on-chip and are restored from on-chip + without ever going to memory). */ + +#define REGISTER_IN_WINDOW_P(regnum) ((regnum) <= R15_REGNUM) + +/* Number of bytes of storage in the actual machine representation + for register N. On the i960, all regs are 4 bytes except for floating + point, which are 10. NINDY only sends us 8 byte values for these, + which is a pain, but VxWorks handles this correctly, so we must. */ + +#define REGISTER_RAW_SIZE(N) ( (N) < FP0_REGNUM ? 4 : 10 ) + +/* Number of bytes of storage in the program's representation for register N. */ + +#define REGISTER_VIRTUAL_SIZE(N) ( (N) < FP0_REGNUM ? 4 : 8 ) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 10 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion from raw format to virtual + format. */ + +#define REGISTER_CONVERTIBLE(N) ((N) >= FP0_REGNUM) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +{ \ + extern struct ext_format ext_format_i960[]; \ + \ + if ((REGNUM) >= FP0_REGNUM) \ + ieee_extended_to_double (ext_format_i960, (FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); \ +} + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +{ \ + extern struct ext_format ext_format_i960[]; \ + \ + if ((REGNUM) >= FP0_REGNUM) \ + double_to_ieee_extended (ext_format_i960, (FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); \ +} + + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) ((N) < FP0_REGNUM ? \ + builtin_type_int : builtin_type_double) + +/* Macros for understanding function return values... */ + +/* Does the specified function use the "struct returning" convention + or the "value returning" convention? The "value returning" convention + almost invariably returns the entire value in registers. The + "struct returning" convention often returns the entire value in + memory, and passes a pointer (out of or into the function) saying + where the value (is or should go). + + Since this sometimes depends on whether it was compiled with GCC, + this is also an argument. This is used in call_function to build a + stack, and in value_being_returned to print return values. + + On i960, a structure is returned in registers g0-g3, if it will fit. + If it's more than 16 bytes long, g13 pointed to it on entry. */ + +#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH (type) > 16) + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. This is only called if USE_STRUCT_CONVENTION for this + type is 0. + + On the i960 we just take as many bytes as we need from G0 through G3. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy(REGBUF+REGISTER_BYTE(G0_REGNUM), VALBUF, TYPE_LENGTH (TYPE)) + +/* If USE_STRUCT_CONVENTION produces a 1, + extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). + + Address of where to put structure was passed in in global + register g13 on entry. God knows what's in g13 now. The + (..., 0) below is to make it appear to return a value, though + actually all it does is call error(). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ + (error("Don't know where large structure is returned on i960"), 0) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format, for "value returning" functions. + + For 'return' command: not (yet) implemented for i960. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + error ("Returning values from functions is not implemented in i960 gdb") + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + error ("Returning values from functions is not implemented in i960 gdb") + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* We cache information about saved registers in the frame structure, + to save us from having to re-scan function prologues every time + a register in a non-current frame is accessed. */ + +#define EXTRA_FRAME_INFO \ + struct frame_saved_regs *fsr; \ + CORE_ADDR arg_pointer; + +/* Zero the frame_saved_regs pointer when the frame is initialized, + so that FRAME_FIND_SAVED_REGS () will know to allocate and + initialize a frame_saved_regs struct the first time it is called. + Set the arg_pointer to -1, which is not valid; 0 and other values + indicate real, cached values. */ + +#define INIT_EXTRA_FRAME_INFO(fi) ((fi)->fsr = 0, (fi)->arg_pointer = -1) + +/* On the i960, we get the chain pointer by reading the PFP saved + on the stack and clearing the status bits. */ + +#define FRAME_CHAIN(thisframe) \ + (read_memory_integer (FRAME_FP(thisframe), 4) & ~0xf) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one + and has no caller. In that case, FRAME_CHAIN_COMBINE is not used. + + On the i960, each various target system type must define FRAME_CHAIN_VALID, + since it differs between NINDY and VxWorks, the two currently supported + targets types. We leave it undefined here. */ + + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ + +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + { (FRAMELESS) = (leafproc_return ((FI)->pc) != 0); } + +/* Note that in the i960 architecture the return pointer is saved in the + *caller's* stack frame. + + Make sure to zero low-order bits because of bug in 960CA A-step part + (instruction addresses should always be word-aligned anyway). */ + +#define FRAME_SAVED_PC(frame) \ + ((read_memory_integer(FRAME_CHAIN(frame)+8,4)) & ~3) + +/* On the i960, FRAME_ARGS_ADDRESS should return the value of + g14 as passed into the frame, if known. We need a function for this. + We cache this value in the frame info if we've already looked it up. */ + +#define FRAME_ARGS_ADDRESS(fi) \ + (((fi)->arg_pointer != -1)? (fi)->arg_pointer: frame_args_address (fi, 0)) +extern CORE_ADDR frame_args_address (); /* i960-tdep.c */ + +/* This is the same except it should return 0 when + it does not really know where the args are, rather than guessing. + This value is not cached since it is only used infrequently. */ + +#define FRAME_ARGS_ADDRESS_CORRECT(fi) (frame_args_address (fi, 1)) + +#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame + +/* Set NUMARGS to the number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) (numargs = -1) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Produce the positions of the saved registers in a stack frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info_addr, sr) \ + frame_find_saved_regs (frame_info_addr, &sr) +extern void frame_find_saved_regs(); /* See i960-tdep.c */ + + +/* Print status when we get a random unexpected signal. We have more + kinds of signals than Unix does... */ + +#define PRINT_RANDOM_SIGNAL(stop_signal) print_fault (stop_signal) + +/* Things needed for making calls to functions in the inferior process */ + +/* Push an empty stack frame, to record the current ip, etc. + + Not (yet?) implemented for i960. */ + +#define PUSH_DUMMY_FRAME \ +error("Function calls into the inferior process are not supported on the i960") + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ + pop_frame () + + +/* This sequence of words is the instructions + + callx 0x00000000 + fmark + */ + +/* #define CALL_DUMMY { 0x86003000, 0x00000000, 0x66003e00 } */ + +/* #define CALL_DUMMY_START_OFFSET 0 *//* Start execution at beginning of dummy */ + +/* Indicate that we don't support calling inferior child functions. */ + +#undef CALL_DUMMY + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at 'dummyname'. + + Ignore arg count on i960. */ + +/* #define FIX_CALL_DUMMY(dummyname, fun, nargs) *(((int *)dummyname)+1) = fun */ + +#undef FIX_CALL_DUMMY + + +/* Interface definitions for kernel debugger KDB */ +/* (Not relevant to i960.) */ diff --git a/gdb/tm-isi.h b/gdb/tm-isi.h new file mode 100644 index 0000000..7697a9f --- /dev/null +++ b/gdb/tm-isi.h @@ -0,0 +1,227 @@ +/* Definitions to target GDB on an ISI Optimum V (3.05) under 4.3bsd. + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This has not been tested on ISI's running BSD 4.2, but it will probably + work. */ + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/*#define STACK_END_ADDR 0x10000000*/ +#define STACK_END_ADDR 0xfffe000 + +/* Data segment starts at etext rounded up to DATAROUND in {N,Z}MAGIC files */ + +#define DATAROUND 0x20000 +#define N_DATADDR(hdr) (hdr.a_magic != OMAGIC ? \ + (hdr.a_text + DATAROUND) & ~(DATAROUND-1) : hdr.a_text) + +/* Text segment starts at sizeof (struct exec) in {N,Z}MAGIC files */ + +#define N_TXTADDR(hdr) (hdr.a_magic != OMAGIC ? sizeof (struct exec) : 0) + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. + On the ISI, the kernel resets the pc to the trap instr */ + +#define DECR_PC_AFTER_BREAK 0 + + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(val, fi) \ +{ register CORE_ADDR pc = FRAME_SAVED_PC (fi); \ + register int insn = 0177777 & read_memory_integer (pc, 2); \ + val = 0; \ + if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */ \ + val = read_memory_integer (pc + 2, 2); \ + else if ((insn & 0170777) == 0050217 /* addql #N, sp */ \ + || (insn & 0170777) == 0050117) /* addqw */ \ + { val = (insn >> 9) & 7; if (val == 0) val = 8; } \ + else if (insn == 0157774) /* addal #WW, sp */ \ + val = read_memory_integer (pc + 2, 4); \ + val >>= 2; } + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ register int regnum; \ + register int regmask; \ + register CORE_ADDR next_addr; \ + register CORE_ADDR pc; \ + register int insn; \ + register int offset; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + if ((frame_info)->pc >= (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM*4 - 8*12 - 4 \ + && (frame_info)->pc <= (frame_info)->frame) \ + { next_addr = (frame_info)->frame; \ + pc = (frame_info)->frame - CALL_DUMMY_LENGTH - FP_REGNUM * 4 - 8*12 - 4; }\ + else \ + { pc = get_pc_function_start ((frame_info)->pc); \ + /* Verify we have a link a6 instruction next, \ + or a branch followed by a link a6 instruction; \ + if not we lose. If we win, find the address above the saved \ + regs using the amount of storage from the link instruction. */\ +retry: \ + insn = read_memory_integer (pc, 2); \ + if (insn == 044016) \ + next_addr = (frame_info)->frame - read_memory_integer (pc += 2, 4), pc+=4; \ + else if (insn == 047126) \ + next_addr = (frame_info)->frame - read_memory_integer (pc += 2, 2), pc+=2; \ + else if ((insn & 0177400) == 060000) /* bra insn */ \ + { offset = insn & 0377; \ + pc += 2; /* advance past bra */ \ + if (offset == 0) /* bra #word */ \ + offset = read_memory_integer (pc, 2), pc += 2; \ + else if (offset == 0377) /* bra #long */ \ + offset = read_memory_integer (pc, 4), pc += 4; \ + pc += offset; \ + goto retry; \ + } else goto lose; \ + /* If have an addal #-n, sp next, adjust next_addr. */ \ + if ((0177777 & read_memory_integer (pc, 2)) == 0157774) \ + next_addr += read_memory_integer (pc += 2, 4), pc += 4; \ + } \ + /* next should be a moveml to (sp) or -(sp) or a movl r,-(sp) */ \ + insn = read_memory_integer (pc, 2), pc += 2; \ + regmask = read_memory_integer (pc, 2); \ + if ((insn & 0177760) == 022700) /* movl rn, (sp) */ \ + (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr; \ + else if ((insn & 0177760) == 024700) /* movl rn, -(sp) */ \ + (frame_saved_regs).regs[(insn&7) + ((insn&010)?8:0)] = next_addr-=4; \ + else if (insn == 0044327) /* moveml mask, (sp) */ \ + { pc += 2; \ + /* Regmask's low bit is for register 0, the first written */ \ + next_addr -= 4; \ + for (regnum = 0; regnum < 16; regnum++, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr += 4); \ + } else if (insn == 0044347) /* moveml mask, -(sp) */ \ + { pc += 2; \ + /* Regmask's low bit is for register 15, the first pushed */ \ + for (regnum = 15; regnum >= 0; regnum--, regmask >>= 1) \ + if (regmask & 1) \ + (frame_saved_regs).regs[regnum] = (next_addr -= 4); } \ + /* clrw -(sp); movw ccr,-(sp) may follow. */ \ + if (read_memory_integer (pc, 2) == 041147 \ + && read_memory_integer (pc+2, 2) == 042347) \ + (frame_saved_regs).regs[PS_REGNUM] = (next_addr -= 4); \ + lose: ; \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame; \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4; \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame ( create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); } + +/* This sequence of words is the instructions + fmovem #<f0-f7>,-(sp) + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + bpt + nop +Note this is 24 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } + +#define HAVE_68881 1 + +#include "tm-68k.h" diff --git a/gdb/tm-m88k.h b/gdb/tm-m88k.h new file mode 100644 index 0000000..1890d6c --- /dev/null +++ b/gdb/tm-m88k.h @@ -0,0 +1,460 @@ +/* Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is currently for a 88000 running DGUX. If other 88k ports are + done, OS-specific stuff should be moved (see tm-68k.h, for example). */ +/* g++ support is not yet included. */ + +#include "tdesc.h" + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* This is not a CREATE_INFERIOR_HOOK because it also applies to + remote debugging. */ +#define START_INFERIOR_HOOK () \ + { \ + extern int safe_to_init_tdesc_context; \ + extern int tdesc_handle; \ + \ + safe_to_init_tdesc_context = 0; \ + if (tdesc_handle) \ + { \ + dc_terminate (tdesc_handle); \ + tdesc_handle = 0; \ + } \ + } + +#define EXTRA_FRAME_INFO dc_dcontext_t frame_context; +#define INIT_EXTRA_FRAME_INFO(fci) \ + { \ + if (fci->next_frame != NULL) \ + { \ + /* The call to get_prev_context */ \ + /* will update current_context for us. */ \ + int stack_error = 1; \ + jmp_buf stack_jmp; \ + if (!setjmp (stack_jmp)) \ + { \ + prev->frame_context \ + = get_prev_context (next_frame->frame_context); \ + stack_error = 0; \ + } \ + else \ + { \ + stack_error = 0; \ + next_frame->prev = 0; \ + return 0; \ + } \ + if (!prev->frame_context) \ + { \ + next_frame->prev = 0; \ + return 0; \ + } \ + } \ + else \ + { \ + /* We are creating an arbitrary frame */ \ + /* (i.e. we are in create_new_frame). */ \ + extern dc_dcontext_t current_context; \ + \ + fci->frame_context = current_context; \ + } \ + } + +#define INIT_FRAME_PC(fromleaf, prev) \ + { \ + prev->pc = dc_location (prev->frame_context); \ + prev->frame = get_frame_base (prev->pc); \ + } + +#define IEEE_FLOAT + +/* Text Description (TDESC) is used by m88k to maintain stack & reg info */ + +#define TDESC + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Hook for read_relative_register_raw_bytes */ + +#define READ_RELATIVE_REGISTER_RAW_BYTES + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(frompc) 0 + +/* The m88k kernel aligns all instructions on 4-byte boundaries. The + kernel also uses the least significant two bits for its own hocus + pocus. When gdb receives an address from the kernel, it needs to + preserve those right-most two bits, but gdb also needs to be careful + to realize that those two bits are not really a part of the address + of an instruction. Shrug. */ + +#define ADDR_BITS_REMOVE(addr) ((addr) & ~3) +#define ADDR_BITS_SET(addr) (((addr) | 0x00000002) - 4) + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + (read_register (SRP_REGNUM) & (~3)) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0xF0000000 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +/* instruction 0xF000D1FF is 'tb0 0,r0,511' + If Bit bit 0 of r0 is clear (always true), + initiate exception processing (trap). + */ +#define BREAKPOINT {0xF0, 0x00, 0xD1, 0xFF} + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0xF0000000 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +/* instruction 0xF000D1FF is 'tb0 0,r0,511' + If Bit bit 0 of r0 is clear (always true), + initiate exception processing (trap). + */ +#define BREAKPOINT {0xF0, 0x00, 0xD1, 0xFF} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ +/* 'jmp r1' or 'jmp.n r1' is used to return from a subroutine. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 2) == 0xF800) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes -- not relevant on the 386. */ + +#define INVALID_FLOAT(p, len) IEEE_isNAN(p,len) + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 38 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES {\ + "r0",\ + "r1",\ + "r2",\ + "r3",\ + "r4",\ + "r5",\ + "r6",\ + "r7",\ + "r8",\ + "r9",\ + "r10",\ + "r11",\ + "r12",\ + "r13",\ + "r14",\ + "r15",\ + "r16",\ + "r17",\ + "r18",\ + "r19",\ + "r20",\ + "r21",\ + "r22",\ + "r23",\ + "r24",\ + "r25",\ + "r26",\ + "r27",\ + "r28",\ + "r29",\ + "r30",\ + "r31",\ + "psr",\ + "fpsr",\ + "fpcr",\ + "sxip",\ + "snip",\ + "sfip",\ + "vbr",\ + "dmt0",\ + "dmd0",\ + "dma0",\ + "dmt1",\ + "dmd1",\ + "dma1",\ + "dmt2",\ + "dmd2",\ + "dma2",\ + "sr0",\ + "sr1",\ + "sr2",\ + "sr3",\ + "fpecr",\ + "fphs1",\ + "fpls1",\ + "fphs2",\ + "fpls2",\ + "fppt",\ + "fprh",\ + "fprl",\ + "fpit",\ + "fpsr",\ + "fpcr",\ + }; + + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define SRP_REGNUM 1 /* Contains subroutine return pointer */ +#define RV_REGNUM 2 /* Contains simple return values */ +#define SRA_REGNUM 12 /* Contains address of struct return values */ +#define FP_REGNUM 30 /* Contains address of executing stack frame */ +#define SP_REGNUM 31 /* Contains address of top of stack */ +#define SXIP_REGNUM 35 /* Contains Shadow Execute Instruction Pointer */ +#define SNIP_REGNUM 36 /* Contains Shadow Next Instruction Pointer */ +#define PC_REGNUM SXIP_REGNUM /* Program Counter */ +#define NPC_REGNUM SNIP_REGNUM /* Next Program Counter */ +#define PSR_REGNUM 32 /* Processor Status Register */ +#define FPSR_REGNUM 33 /* Floating Point Status Register */ +#define FPCR_REGNUM 34 /* Floating Point Control Register */ +#define SFIP_REGNUM 37 /* Contains Shadow Fetched Intruction pointer */ +#define NNPC_REGNUM SFIP_REGNUM /* Next Next Program Counter */ + +/* PSR status bit definitions. */ + +#define PSR_MODE 0x80000000 +#define PSR_BYTE_ORDER 0x40000000 +#define PSR_SERIAL_MODE 0x20000000 +#define PSR_CARRY 0x10000000 +#define PSR_SFU_DISABLE 0x000003f0 +#define PSR_SFU1_DISABLE 0x00000008 +#define PSR_MXM 0x00000004 +#define PSR_IND 0x00000002 +#define PSR_SFRZ 0x00000001 + +/* BCS requires that the SXIP_REGNUM (or PC_REGNUM) contain the address + of the next instr to be executed when a breakpoint occurs. Because + the kernel gets the next instr (SNIP_REGNUM), the instr in SNIP needs + to be put back into SFIP, and the instr in SXIP should be shifted + to SNIP */ + +/* Are you sitting down? It turns out that the 88K BCS (binary compatibility + standard) folks originally felt that the debugger should be responsible + for backing up the IPs, not the kernel (as is usually done). Well, they + have reversed their decision, and in future releases our kernel will be + handling the backing up of the IPs. So, eventually, we won't need to + do the SHIFT_INST_REGS stuff. But, for now, since there are 88K systems out + there that do need the debugger to do the IP shifting, and since there + will be systems where the kernel does the shifting, the code is a little + more complex than perhaps it needs to be (we still go inside SHIFT_INST_REGS, + and if the shifting hasn't occurred then gdb goes ahead and shifts). */ + +#define SHIFT_INST_REGS + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ + +#define REGISTER_BYTES (NUM_REGS * sizeof(REGISTER_TYPE)) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N)*sizeof(REGISTER_TYPE)) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +#define REGISTER_RAW_SIZE(N) (sizeof(REGISTER_TYPE)) + +/* Number of bytes of storage in the program's representation + for register N. */ + +#define REGISTER_VIRTUAL_SIZE(N) (sizeof(REGISTER_TYPE)) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE (sizeof(REGISTER_TYPE)) + +/* Largest value REGISTER_VIRTUAL_SIZE can have. +/* Are FPS1, FPS2, FPR "virtual" regisers? */ + +#define MAX_REGISTER_VIRTUAL_SIZE (sizeof(REGISTER_TYPE)) + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) {bcopy ((FROM), (TO), (sizeof(REGISTER_TYPE)));} + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) {bcopy ((FROM), (TO), (sizeof(REGISTER_TYPE)));} + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int) + +/* The 88k call/return conventions call for "small" values to be returned + into consecutive registers starting from r2. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (&(((void *)REGBUF)[REGISTER_BYTE(RV_REGNUM)]), (VALBUF), TYPE_LENGTH (TYPE)) + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (2*sizeof(void*), (VALBUF), TYPE_LENGTH (TYPE)) + +/* In COFF, if PCC says a parameter is a short or a char, do not + change it to int (it seems the convention is to change it). */ + +#define BELIEVE_PCC_PROMOTION 1 + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* These are just dummies for the 88k because INIT_FRAME_PC sets prev->frame + instead. */ + +#define FRAME_CHAIN(thisframe) (0) + +#define FRAME_CHAIN_VALID(chain, thisframe) (1) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (0) + +/* Define other aspects of the stack frame. */ + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame+4, 4)) + +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) ((numargs) = -1) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +/* On the 88k, parameter registers get stored into the so called "homing" + area. This *always* happens when you compiled with GCC and use -g. + Also, (with GCC and -g) the saving of the parameter register values + always happens right within the function prologue code, so these register + values can generally be relied upon to be already copied into their + respective homing slots by the time you will normally try to look at + them (we hope). + + Note that homing area stack slots are always at *positive* offsets from + the frame pointer. Thus, the homing area stack slots for the parameter + registers (passed values) for a given function are actually part of the + frame area of the caller. This is unusual, but it should not present + any special problems for GDB. + + Note also that on the 88k, we are only interested in finding the + registers that might have been saved in memory. This is a subset of + the whole set of registers because the standard calling sequence allows + the called routine to clobber many registers. + + We could manage to locate values for all of the so called "preserved" + registers (some of which may get saved within any particular frame) but + that would require decoding all of the tdesc information. Tht would be + nice information for GDB to have, but it is not strictly manditory if we + can live without the ability to look at values within (or backup to) + previous frames. +*/ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ + frame_find_saved_regs (frame_info, &frame_saved_regs) + + +/* When popping a frame on the 88k (say when doing a return command), the + calling function only expects to have the "preserved" registers restored. + Thus, those are the only ones that we even try to restore here. */ + +extern void pop_frame (); + +#define POP_FRAME pop_frame () + +/* BCS is a standard for binary compatibility. This machine uses it. */ +#define BCS diff --git a/gdb/tm-merlin.h b/gdb/tm-merlin.h new file mode 100644 index 0000000..91475c8 --- /dev/null +++ b/gdb/tm-merlin.h @@ -0,0 +1,364 @@ +/* Definitions to target GDB to a merlin under utek 2.1 + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* I don't know if this will work for cross-debugging, even if you do get + a copy of the right include file. */ +#include <machine/reg.h> + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ +{ register int op = read_memory_integer (pc, 1); \ + if (op == 0x82) \ + { op = read_memory_integer (pc+2,1); \ + if ((op & 0x80) == 0) pc += 3; \ + else if ((op & 0xc0) == 0x80) pc += 4; \ + else pc += 6; \ + }} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + read_memory_integer (read_register (SP_REGNUM), 4) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0x800000) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xf2} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p, len) 0 + +/* Define this to say that the "svc" insn is followed by + codes in memory saying which kind of system call it is. */ + +#define NS32K_SVC_IMMED_OPERANDS + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 25 + +#define NUM_GENERAL_REGS 8 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ + "pc", "sp", "fp", "ps", \ + "fsr", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "l0", "l1", "l2", "l3", "l4", \ + } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define AP_REGNUM FP_REGNUM +#define FP_REGNUM 10 /* Contains address of executing stack frame */ +#define SP_REGNUM 9 /* Contains address of top of stack */ +#define PC_REGNUM 8 /* Contains program counter */ +#define PS_REGNUM 11 /* Contains processor status */ +#define FPS_REGNUM 12 /* Floating point status register */ +#define FP0_REGNUM 13 /* Floating point register 0 */ +#define LP0_REGNUM 21 /* Double register 0 (same as FP0) */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double)) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \ + LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the 32000, all regs are 4 bytes + except for the doubled floating registers. */ + +#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4) + +/* Number of bytes of storage in the program's representation + for register N. On the 32000, all regs are 4 bytes + except for the doubled floating registers. */ + +#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 8 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + ((N) >= FP0_REGNUM ? \ + ((N) >= LP0_REGNUM ? \ + builtin_type_double \ + : builtin_type_float) \ + : builtin_type_int) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. + + On this machine this is a no-op, as gcc doesn't run on it yet. + This calling convention is not used. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the Merlin, the frame's nominal address is the FP value, + and at that address is saved previous FP value as a 4-byte word. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4)) + +/* compute base of arguments */ +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) \ +{ CORE_ADDR pc; \ + int insn; \ + int addr_mode; \ + int width; \ + \ + pc = FRAME_SAVED_PC (fi); \ + insn = read_memory_integer (pc,2); \ + addr_mode = (insn >> 11) & 0x1f; \ + insn = insn & 0x7ff; \ + if ((insn & 0x7fc) == 0x57c \ + && addr_mode == 0x14) /* immediate */ \ + { if (insn == 0x57c) /* adjspb */ \ + width = 1; \ + else if (insn == 0x57d) /* adjspw */ \ + width = 2; \ + else if (insn == 0x57f) /* adjspd */ \ + width = 4; \ + numargs = read_memory_integer (pc+2,width); \ + if (width > 1) \ + flip_bytes (&numargs, width); \ + numargs = - sign_extend (numargs, width*8) / 4; } \ + else numargs = -1; \ +} + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ int regmask,regnum; \ + int localcount; \ + CORE_ADDR enter_addr; \ + CORE_ADDR next_addr; \ + \ + enter_addr = get_pc_function_start ((frame_info)->pc); \ + regmask = read_memory_integer (enter_addr+1, 1); \ + localcount = ns32k_localcount (enter_addr); \ + next_addr = (frame_info)->frame + localcount; \ + for (regnum = 0; regnum < 8; regnum++, regmask >>= 1) \ + (frame_saved_regs).regs[regnum] \ + = (regmask & 1) ? (next_addr -= 4) : 0; \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 4; \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4; \ + (frame_saved_regs).regs[FP_REGNUM] \ + = read_memory_integer ((frame_info)->frame, 4); } + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = 0; regnum < 8; regnum++) \ + sp = push_word (sp, read_register (regnum)); \ + write_register (SP_REGNUM, sp); \ +} + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = 0; regnum < 8; regnum++) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); \ +} + +/* This sequence of words is the instructions + enter 0xff,0 82 ff 00 + jsr @0x00010203 7f ae c0 01 02 03 + adjspd 0x69696969 7f a5 01 02 03 04 + bpt f2 + Note this is 16 bytes. */ + +#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 } + +#define CALL_DUMMY_START_OFFSET 3 +#define CALL_DUMMY_LENGTH 16 +#define CALL_DUMMY_ADDR 5 +#define CALL_DUMMY_NARGS 11 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ int flipped = fun | 0xc0000000; \ + flip_bytes (&flipped, 4); \ + *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped; \ + flipped = - nargs * 4; \ + flip_bytes (&flipped, 4); \ + *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped; \ +} diff --git a/gdb/tm-mips.h b/gdb/tm-mips.h new file mode 100644 index 0000000..6fd681d --- /dev/null +++ b/gdb/tm-mips.h @@ -0,0 +1,363 @@ +/* Definitions to make GDB run on a mips box under 4.3bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + Contributed by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin + and by Alessandro Forin(af@cs.cmu.edu) at CMU + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#if !defined (TARGET_BYTE_ORDER) +#define TARGET_BYTE_ORDER LITTLE_ENDIAN +#endif + +/* Floating point is IEEE compliant */ +#define IEEE_FLOAT + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +/*#define NAMES_HAVE_UNDERSCORE*/ + +/* Debugger information will be in mips' format */ + +#define READ_MIPS_FORMAT + +/* File format is coff, but with additions */ + +#define COFF_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) pc = mips_skip_prologue(pc) + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) read_register(RA_REGNUM) + +/* Are we currently handling a signal */ + +#define IN_SIGTRAMP(pc, name) in_sigtramp(pc, name) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0x7ffff000) + +/* Stack grows downward. */ + +#define INNER_THAN < + +#define BIG_ENDIAN 4321 +#if TARGET_BYTE_ORDER == BIG_ENDIAN +#define BREAKPOINT {0, 0x5, 0, 0xd} +#else +#define BREAKPOINT {0xd, 0, 0x5, 0} +#endif + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. "j ra" on mips. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 4) == 0x3e00008) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p,l) isa_NAN(p,l) + +/* Say how long (all) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 73 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES \ + { "zero", "at", "v0", "v1", "a0", "a1", "a2", "a3", \ + "t0", "t1", "t2", "t3", "t4", "t5", "t6", "t7", \ + "s0", "s1", "s2", "s3", "s4", "s5", "s6", "s7", \ + "t8", "t9", "k0", "k1", "gp", "sp", "s8", "ra", \ + "sr", "lo", "hi", "bad", "cause","pc", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23",\ + "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31",\ + "fsr", "fir", "fp" \ + } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define SP_REGNUM 29 /* Contains address of top of stack */ +#define PC_REGNUM 37 /* Contains program counter */ +#define RA_REGNUM 31 /* Contains return address value */ +#define PS_REGNUM 32 /* Contains processor status */ +#define HI_REGNUM 34 /* Multiple/divide temp */ +#define LO_REGNUM 33 /* ... */ +#define FP0_REGNUM 38 /* Floating point register 0 (single float) */ +#define FCRCS_REGNUM 70 /* FP control/status */ +#define FCRIR_REGNUM 71 /* FP implementation/revision */ +#define FP_REGNUM 72 /* Pseudo register that contains true address of executing stack frame */ + +/* Define DO_REGISTERS_INFO() to do machine-specific formatting + of register dumps. */ + +#define DO_REGISTERS_INFO(_regnum) mips_do_registers_info(_regnum) + +#define REGISTER_U_ADDR(addr, blockend, regno) \ + if (blockend == 0) { \ + if (regno < 38) addr = (NBPG*UPAGES) + (regno - 38)*sizeof(int);\ + else addr = 0; /* ..somewhere in the pcb */ \ + } else if (regno < 32) addr = regno; \ + else if (regno == PC_REGNUM) addr = 96; \ + else if (regno == 36) addr = 97; \ + else if (regno == HI_REGNUM) addr = 98; \ + else if (regno == LO_REGNUM) addr = 99; \ + else if (regno == FCRCS_REGNUM) addr = 100; \ + else if (regno == FCRIR_REGNUM) addr = 101; \ + else if (regno >= FP0_REGNUM) addr = regno - (FP0_REGNUM-32);\ + else addr = 0; + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (NUM_REGS*4) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On mips, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) 4 + +/* Number of bytes of storage in the program's representation + for register N. On mips, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) 4 + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 4 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(addr, sp) \ + { sp = push_word(sp, addr);} + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. XXX floats */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 2), VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 2), VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF+16)) + +/* Structures are returned by ref in extra arg0 */ +#define USE_STRUCT_CONVENTION(gcc_p, type) 1 + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +#define FRAME_CHAIN(thisframe) (FRAME_ADDR)mips_frame_chain(thisframe) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +/* We handle this differently for mips, and maybe we should not */ + +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) {(FRAMELESS) = 0;} + +/* Saved Pc. */ + +#define FRAME_SAVED_PC(FRAME) (mips_frame_saved_pc(FRAME)) + +#define FRAME_ARGS_ADDRESS(fi) (fi)->frame + +#define FRAME_LOCALS_ADDRESS(fi) (fi)->frame + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(num, fi) (num = mips_frame_num_args(fi)) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) ( \ + (frame_saved_regs) = *(frame_info)->saved_regs, \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame) + + +/* Things needed for making the inferior call functions. */ + +/* Stack has strict alignment. However, use PUSH_ARGUMENTS + to take care of it. */ +/*#define STACK_ALIGN(addr) (((addr)+3)&~3)*/ + +#define PUSH_ARGUMENTS(nargs, args, sp, struct_return, struct_addr) \ + sp = mips_push_arguments(nargs, args, sp, struct_return, struct_addr) + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME mips_push_dummy_frame() + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME mips_pop_frame() + +#define MK_OP(op,rs,rt,offset) (((op)<<26)|((rs)<<21)|((rt)<<16)|(offset)) +#define CALL_DUMMY_SIZE (16*4) +#define Dest_Reg 2 +#define CALL_DUMMY {\ + MK_OP(0,RA_REGNUM,0,8), /* jr $ra # Fake ABOUT_TO_RETURN ...*/\ + 0, /* nop # ... to stop raw backtrace*/\ + 0x27bd0000, /* addu sp,?0 # Pseudo prologue */\ +/* Start here: */\ + MK_OP(061,SP_REGNUM,12,0), /* lwc1 $f12,0(sp) # Reload first 4 args*/\ + MK_OP(061,SP_REGNUM,13,4), /* lwc1 $f13,4(sp) */\ + MK_OP(061,SP_REGNUM,14,8), /* lwc1 $f14,8(sp) */\ + MK_OP(061,SP_REGNUM,15,12), /* lwc1 $f15,12(sp) */\ + MK_OP(043,SP_REGNUM,4,0), /* lw $r4,0(sp) # Re-load FP regs*/\ + MK_OP(043,SP_REGNUM,5,4), /* lw $r5,4(sp) */\ + MK_OP(043,SP_REGNUM,6,8), /* lw $r6,8(sp) */\ + MK_OP(043,SP_REGNUM,7,12), /* lw $r7,12(sp) */\ + (017<<26)| (Dest_Reg << 16), /* lui $r31,<target upper 16 bits>*/\ + MK_OP(13,Dest_Reg,Dest_Reg,0), /* ori $r31,$r31,<lower 16 bits>*/ \ + (Dest_Reg<<21) | (31<<11) | 9, /* jalr $r31 */\ + MK_OP(043,SP_REGNUM,7,12), /* lw $r7,12(sp) */\ + 0x5000d, /* bpt */\ +} + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, start_sp, fun, nargs, args, rettype, gcc_p)\ + (((int*)dummyname)[11] |= (((unsigned long)(fun)) >> 16), \ + ((int*)dummyname)[12] |= (unsigned short)(fun)) + +/* Specific information about a procedure. + This overlays the MIPS's PDR records, + mipsread.c (ab)uses this to save memory */ + +typedef struct mips_extra_func_info { + unsigned long adr; /* memory address of start of procedure */ + long isym; /* pointer to procedure symbol */ + long pad2; /* iline: start of line number entries*/ + long regmask; /* save register mask */ + long regoffset; /* save register offset */ + long numargs; /* number of args to procedure (was iopt) */ + long fregmask; /* save floating point register mask */ + long fregoffset; /* save floating point register offset */ + long framesize; /* frameoffset: frame size */ + short framereg; /* frame pointer register */ + short pcreg; /* offset or reg of return pc */ + long lnLow; /* lowest line in the procedure */ + long lnHigh; /* highest line in the procedure */ + long pad3; /* cbLineOffset: byte offset for this procedure from the fd base */ +} *mips_extra_func_info_t; + +#define EXTRA_FRAME_INFO \ + char *proc_desc; /* actually, a mips_extra_func_info_t */\ + int num_args;\ + struct frame_saved_regs *saved_regs; + +#define INIT_EXTRA_FRAME_INFO(fci) init_extra_frame_info(fci) diff --git a/gdb/tm-news.h b/gdb/tm-news.h new file mode 100644 index 0000000..ff50dbf --- /dev/null +++ b/gdb/tm-news.h @@ -0,0 +1,172 @@ +/* Parameters for execution on a Sony/NEWS, for GDB, the GNU debugger. + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* See following cpu type determination macro to get the machine type. + +Here is an m-news.h file for gdb. It supports the 68881 registers. + by hikichi@srava.sra.junet + +* Support Sun assembly format instead of Motorola one. +* Ptrace for handling floating register has a bug(before NEWS OS version 2.2), +* After NEWS OS version 3.2, some of ptrace's bug is fixed. + But we cannot change the floating register(see adb(1) in OS 3.2) yet. */ + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Symbols on this machine are in DBX format. */ +#define READ_DBX_FORMAT + +/* Use to compute STACK_END_ADDR. */ +#define TARGET_UPAGES 2 +#define TARGET_NBPG 4096 + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0x80000000 - TARGET_UPAGES * TARGET_NBPG) + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +/* when it return the floating value, use the FP0 in NEWS. */ +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + { if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + { \ + REGISTER_CONVERT_TO_VIRTUAL (FP0_REGNUM, \ + ®BUF[REGISTER_BYTE (FP0_REGNUM)], VALBUF); \ + } \ + else \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)); } + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +/* when it return the floating value, use the FP0 in NEWS. */ +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + { if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + { \ + char raw_buf[REGISTER_RAW_SIZE (FP0_REGNUM)]; \ + REGISTER_CONVERT_TO_RAW (FP0_REGNUM, VALBUF, raw_buf); \ + write_register_bytes (FP0_REGNUM, \ + raw_buf, REGISTER_RAW_SIZE (FP0_REGNUM)); \ + } \ + else \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)); } + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(val, fi) \ +{ register CORE_ADDR pc = FRAME_SAVED_PC (fi); \ + register int insn = 0177777 & read_memory_integer (pc, 2); \ + val = 0; \ + if (insn == 0047757 || insn == 0157374) /* lea W(sp),sp or addaw #W,sp */ \ + val = read_memory_integer (pc + 2, 2); \ + else if ((insn & 0170777) == 0050217 /* addql #N, sp */ \ + || (insn & 0170777) == 0050117) /* addqw */ \ + { val = (insn >> 9) & 7; if (val == 0) val = 8; } \ + else if (insn == 0157774) /* addal #WW, sp */ \ + val = read_memory_integer (pc + 2, 4); \ + val >>= 2; } + +/* Things needed for making the inferior call functions. */ +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); } + +/* This sequence of words is the instructions + fmove.m #<f0-f7>,-(sp) + movem.l 0xfffc,-(sp) ;; no save a6(fp) and a7(sp) + clr.w -(sp) + move.w ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jbsr (#32323232) + add.l #69696969,sp + bpt + nop +Note this is 24 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } + +#define HAVE_68881 + +#include "tm-68k.h" diff --git a/gdb/tm-nindy960.h b/gdb/tm-nindy960.h new file mode 100644 index 0000000..e7ed59b --- /dev/null +++ b/gdb/tm-nindy960.h @@ -0,0 +1,105 @@ +/* Parameters for Intel 960 running NINDY monitor, for GDB, the GNU debugger. + Copyright (C) 1990-1991 Free Software Foundation, Inc. + Contributed by Intel Corporation and Cygnus Support. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/***************************************************************************** + * Definitions to target GDB to an i960 debugged over a serial line. + ******************************************************************************/ + +#include "tm-i960.h" + +/* Override the standard gdb prompt when compiled for this target. */ + +#define DEFAULT_PROMPT "(gdb960) " + +/* Additional command line options accepted by nindy gdb's, for handling + the remote-nindy.c interface. These should really be target-specific + rather than architecture-specific. */ + +extern int nindy_old_protocol; /* nonzero if old NINDY serial protocol */ +extern int nindy_initial_brk; /* Send a BREAK to reset board first */ +extern char *nindy_ttyname; /* Name of serial port to talk to nindy */ + +#define ADDITIONAL_OPTIONS \ + {"O", 0, &nindy_old_protocol, 1}, \ + {"brk", 0, &nindy_initial_brk, 1}, \ + {"r", 1, 0, 1004}, /* 1004 is magic cookie for ADDL_CASES */ + +#define ADDITIONAL_OPTION_CASES \ + case 1004: /* -r option: remote nindy auto-start */ \ + nindy_ttyname = optarg; \ + break; + +#define ADDITIONAL_OPTION_HELP \ + "\ + -O Use old protocol to talk to a Nindy target\n\ + -brk Send a break to a Nindy target to reset it.\n\ + -r SERIAL Open remote Nindy session to SERIAL port.\n\ +" + +/* If specified on the command line, open tty for talking to nindy, + and download the executable file if one was specified. */ + +#define ADDITIONAL_OPTION_HANDLER \ + if (!setjmp (to_top_level) && nindy_ttyname) { \ + nindy_open (nindy_ttyname, !batch); \ + if ( !setjmp(to_top_level) && execarg ) { \ + target_load (execarg, !batch); \ + } \ + } + +/* If configured for i960 target, we take control before main loop + and demand that we configure for a nindy target. */ + +#define BEFORE_MAIN_LOOP_HOOK \ + nindy_before_main_loop(); + +/* Address of end of stack space. + * This probably doesn't matter for nindy, because it's only used + * in manipulation of core files, which we don't support. + */ + +#define STACK_END_ADDR (0xfe000000) + +/* FRAME_CHAIN_VALID returns zero if the given frame is the outermost one + and has no caller. In that case, FRAME_CHAIN_COMBINE is not used. + + On the i960, each various target system type defines FRAME_CHAIN_VALID, + since it differs between NINDY and VxWorks, the two currently supported + targets types. */ + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + nindy_frame_chain_valid (chain, thisframe) + +extern int nindy_frame_chain_valid(); /* See nindy-tdep.c */ + +/* Sequence of bytes for breakpoint instruction */ + +#define BREAKPOINT {0x00, 0x3e, 0x00, 0x66} + +/* Amount ip must be decremented by after a breakpoint. + * This is often the number of bytes in BREAKPOINT but not always. + */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Not needed, because we don't support core files: + * #define KERNEL_U_ADDR + * #define REGISTER_U_ADDR(addr, blockend, regno) + */ diff --git a/gdb/tm-np1.h b/gdb/tm-np1.h new file mode 100644 index 0000000..0bb1dcc --- /dev/null +++ b/gdb/tm-np1.h @@ -0,0 +1,515 @@ +/* Parameters for targeting on a Gould NP1, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define GOULD_NPL + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* N_ENTRY appears in libraries on Gould machines. + Don't know what 0xa4 is; it's mentioned in stab.h + but only in the sdb symbol list. */ +#define IGNORE_SYMBOL(type) (type == N_ENTRY || type == 0xa4) + +/* We don't want the extra gnu symbols on the machine; + they will interfere with the shared segment symbols. */ +#define NO_GNU_STABS + +/* Macro for text-offset and data info (in NPL a.out format). */ +#define TEXTINFO \ + text_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr); \ + exec_data_offset = N_TXTOFF (exec_coffhdr, exec_aouthdr)\ + + exec_aouthdr.a_text + +/* Macro for number of symbol table entries */ +#define NUMBER_OF_SYMBOLS \ + (coffhdr.f_nsyms) + +/* Macro for file-offset of symbol table (in NPL a.out format). */ +#define SYMBOL_TABLE_OFFSET \ + N_SYMOFF (coffhdr) + +/* Macro for file-offset of string table (in NPL a.out format). */ +#define STRING_TABLE_OFFSET \ + (N_STROFF (coffhdr)) + +/* Macro to store the length of the string table data in INTO. */ +#define READ_STRING_TABLE_SIZE(INTO) \ + { INTO = hdr.a_stsize; } + +/* Macro to declare variables to hold the file's header data. */ +#define DECLARE_FILE_HEADERS struct exec hdr; \ + FILHDR coffhdr + +/* Macro to read the header data from descriptor DESC and validate it. + NAME is the file name, for error messages. */ +#define READ_FILE_HEADERS(DESC, NAME) \ +{ val = myread (DESC, &coffhdr, sizeof coffhdr); \ + if (val < 0) \ + perror_with_name (NAME); \ + val = myread (DESC, &hdr, sizeof hdr); \ + if (val < 0) \ + perror_with_name (NAME); \ + if (coffhdr.f_magic != GNP1MAGIC) \ + error ("File \"%s\" not in coff executable format.", NAME); \ + if (N_BADMAG (hdr)) \ + error ("File \"%s\" not in executable format.", NAME); } + +/* Define COFF and other symbolic names needed on NP1 */ +#define NS32GMAGIC GNP1MAGIC +#define NS32SMAGIC GPNMAGIC + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ +#define READ_DBX_FORMAT + +/* Address of blocks in N_LBRAC and N_RBRAC symbols are absolute addresses, + not relative to start of source address. */ +#define BLOCK_ADDRESS_ABSOLUTE + +/* Offset from address of function to start of its code. + Zero on most machines. */ +#define FUNCTION_START_OFFSET 8 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. One NPL we can have one two startup + sequences depending on the size of the local stack: + + Either: + "suabr b2, #" + of + "lil r4, #", "suabr b2, #(r4)" + + "lwbr b6, #", "stw r1, 8(b2)" + Optional "stwbr b3, c(b2)" + Optional "trr r2,r7" (Gould first argument register passing) + or + Optional "stw r2,8(b3)" (Gould first argument register passing) + */ +#define SKIP_PROLOGUE(pc) { \ + register int op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0xFA0B0000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x59400000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x5F000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xD4820008) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0x5582000C) { \ + pc += 4; \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } else { \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xd5030008) { \ + pc += 4; \ + } \ + } \ + } else { \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } \ + } \ + } \ + } \ + } \ + } \ + if ((op & 0xffff0000) == 0x59000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x5F000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xD4820008) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0x5582000C) { \ + pc += 4; \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } else { \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xd5030008) { \ + pc += 4; \ + } \ + } \ + } else { \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } \ + } \ + } \ + } \ + } \ +} + +/* Immediately after a function call, return the saved pc. + Can't go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. True on NPL! Return address is in R1. + The true return address is REALLY 4 past that location! */ +#define SAVED_PC_AFTER_CALL(frame) \ + (read_register(R1_REGNUM) + 4) + +/* Address of end of stack space. */ +#define STACK_END_ADDR 0x7fffc000 + +/* Stack grows downward. */ +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. + This is padded out to the size of a machine word. When it was just + {0x28, 0x09} it gave problems if hit breakpoint on returning from a + function call. */ +#define BREAKPOINT {0x28, 0x09, 0x0, 0x0} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ +#define DECR_PC_AFTER_BREAK 2 + +/* Nonzero if instruction at PC is a return instruction. "bu 4(r1)" */ +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 4) == 0x40100004) + +/* Return 1 if P points to an invalid floating point value. */ +#define INVALID_FLOAT(p, len) ((*(short *)p & 0xff80) == 0x8000) + +/* Say how long (ordinary) registers are. */ +#define REGISTER_TYPE long + +/* Size of bytes of vector register (NP1 only), 32 elements * sizeof(int) */ +#define VR_SIZE 128 + +/* Number of machine registers */ +#define NUM_REGS 27 +#define NUM_GEN_REGS 16 +#define NUM_CPU_REGS 4 +#define NUM_VECTOR_REGS 7 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ +#define REGISTER_NAMES { \ + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ + "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", \ + "sp", "ps", "pc", "ve", \ + "v1", "v2", "v3", "v4", "v5", "v6", "v7", \ +} + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ +#define R1_REGNUM 1 /* Gr1 => return address of caller */ +#define R2_REGNUM 2 /* Gr2 => return value from function */ +#define R4_REGNUM 4 /* Gr4 => register save area */ +#define R5_REGNUM 5 /* Gr5 => register save area */ +#define R6_REGNUM 6 /* Gr6 => register save area */ +#define R7_REGNUM 7 /* Gr7 => register save area */ +#define B1_REGNUM 9 /* Br1 => start of this code routine */ +#define SP_REGNUM 10 /* Br2 == (sp) */ +#define AP_REGNUM 11 /* Br3 == (ap) */ +#define FP_REGNUM 16 /* A copy of Br2 saved in trap */ +#define PS_REGNUM 17 /* Contains processor status */ +#define PC_REGNUM 18 /* Contains program counter */ +#define VE_REGNUM 19 /* Vector end (user setup) register */ +#define V1_REGNUM 20 /* First vector register */ +#define V7_REGNUM 26 /* First vector register */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES \ + (NUM_GEN_REGS*4 + NUM_VECTOR_REGS*VR_SIZE + NUM_CPU_REGS*4) + +/* Index within `registers' of the first byte of the space for + register N. */ +#define REGISTER_BYTE(N) \ + (((N) < V1_REGNUM) ? ((N) * 4) : (((N) - V1_REGNUM) * VR_SIZE) + 80) + +/* Number of bytes of storage in the actual machine representation + for register N. On the NP1, all normal regs are 4 bytes, but + the vector registers are VR_SIZE*4 bytes long. */ +#define REGISTER_RAW_SIZE(N) \ + (((N) < V1_REGNUM) ? 4 : VR_SIZE) + +/* Number of bytes of storage in the program's representation + for register N. On the NP1, all regs are 4 bytes. */ +#define REGISTER_VIRTUAL_SIZE(N) \ + (((N) < V1_REGNUM) ? 4 : VR_SIZE) + +/* Largest value REGISTER_RAW_SIZE can have. */ +#define MAX_REGISTER_RAW_SIZE VR_SIZE + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ +#define MAX_REGISTER_VIRTUAL_SIZE VR_SIZE + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_RAW_SIZE(REGNUM)); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ +#define REGISTER_VIRTUAL_TYPE(N) \ + ((N) > VE_REGNUM ? builtin_type_np1_vector : builtin_type_int) +extern struct type *builtin_type_np1_vector; + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. + + On this machine this is a no-op, because gcc isn't used on it + yet. So this calling convention is not used. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) push_word(SP + 8, ADDR) + +/* Extract from an arrary REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (((int *)(REGBUF)) + 2, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE (R2_REGNUM), VALBUF, \ + TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*((int *)(REGBUF) + 2)) + +/* Both gcc and cc return small structs in registers (i.e. in GDB + terminology, small structs don't use the struct return convention). */ +#define USE_STRUCT_CONVENTION(gcc_p, type) (TYPE_LENGTH(type) > 8) + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the NPL, the frame's norminal address is Br2 and the + previous routines frame is up the stack X bytes, where X is the + value stored in the code function header xA(Br1). */ +#define FRAME_CHAIN(thisframe) (findframe(thisframe)) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && chain != (thisframe)->frame) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) \ + (chain) + +/* Define other aspects of the stack frame on NPL. */ +#define FRAME_SAVED_PC(FRAME) \ + (read_memory_integer ((FRAME)->frame + 8, 4)) + +#define FRAME_ARGS_ADDRESS(fi) \ + ((fi)->next_frame ? \ + read_memory_integer ((fi)->frame + 12, 4) : \ + read_register (AP_REGNUM)) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Set VAL to the number of args passed to frame described by FI. + Can set VAL to -1, meaning no way to tell. */ + +/* We can check the stab info to see how + many arg we have. No info in stack will tell us */ +#define FRAME_NUM_ARGS(val,fi) (val = findarg(fi)) + +/* Return number of bytes at start of arglist that are not really args. */ +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + (frame_saved_regs).regs[SP_REGNUM] = framechain (frame_info); \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[R4_REGNUM] = (frame_info)->frame + 0x30; \ + (frame_saved_regs).regs[R5_REGNUM] = (frame_info)->frame + 0x34; \ + (frame_saved_regs).regs[R6_REGNUM] = (frame_info)->frame + 0x38; \ + (frame_saved_regs).regs[R7_REGNUM] = (frame_info)->frame + 0x3C; \ +} + +/* Things needed for making the inferior call functions. */ + +#define CANNOT_EXECUTE_STACK + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + for (regnum = 0; regnum < FP_REGNUM; regnum++) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + write_register (SP_REGNUM, sp);} + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ CORE_ADDR sp = read_register(SP_REGNUM); \ + REGISTER_TYPE reg; \ + int regnum; \ + for(regnum = 0;regnum < FP_REGNUM;regnum++){ \ + sp-=sizeof(REGISTER_TYPE); \ + read_memory(sp,®,sizeof(REGISTER_TYPE)); \ + write_register(regnum,reg);} \ + sp-=sizeof(REGISTER_TYPE); \ + read_memory(sp,®,sizeof(REGISTER_TYPE)); \ + write_register(PS_REGNUM,reg); \ + sp-=sizeof(REGISTER_TYPE); \ + read_memory(sp,®,sizeof(REGISTER_TYPE)); \ + write_register(PC_REGNUM,reg);} + +/* MJD - Size of dummy frame pushed onto stack by PUSH_DUMMY_FRAME */ + +#define DUMMY_FRAME_SIZE (0x48) + +/* MJD - The sequence of words in the instructions is + halt + halt + halt + halt + subr b2,stack size,0 grab stack space for dummy call + labr b3,x0(b2),0 set AP_REGNUM to point at arguments + lw r2,x8(b3),0 load r2 with first argument + lwbr b1,arguments size(b2),0 load address of function to be called + brlnk r1,x8(b1),0 call function + halt + halt + labr b2,stack size(b2),0 give back stack + break break + */ + +#define CALL_DUMMY {0x00000000, \ + 0x00000000, \ + 0x59000000, \ + 0x598a0000, \ + 0xb5030008, \ + 0x5c820000, \ + 0x44810008, \ + 0x00000000, \ + 0x590a0000, \ + 0x28090000 } + +#define CALL_DUMMY_LENGTH 40 + +#define CALL_DUMMY_START_OFFSET 8 + +#define CALL_DUMMY_STACK_ADJUST 8 + +/* MJD - Fixup CALL_DUMMY for the specific function call. + OK heres the problems + 1) On a trap there are two copies of the stack pointer, one in SP_REGNUM + which is read/write and one in FP_REGNUM which is only read. It seems + that when restarting the GOULD NP1 uses FP_REGNUM's value. + 2) Loading function address into b1 looks a bit difficult if bigger than + 0x0000fffc, infact from what I can tell the compiler sets up table of + function address in base3 through which function calls are referenced. + + OK my solutions + Calculate the size of the dummy stack frame and do adjustments of + SP_REGNUM in the dummy call. + Push function address onto the stack and load it in the dummy call + */ + +#define FIX_CALL_DUMMY(dummyname, sp, fun, nargs, args, type, gcc_p) \ + { int i;\ + int arg_len = 0, total_len;\ + old_sp = push_word(old_sp,fun);\ + for(i = nargs - 1;i >= 0;i--)\ + arg_len += TYPE_LENGTH (VALUE_TYPE (value_arg_coerce (args[i])));\ + if(struct_return)\ + arg_len += TYPE_LENGTH(value_type);\ + total_len = DUMMY_FRAME_SIZE+CALL_DUMMY_STACK_ADJUST+4+arg_len;\ + dummyname[0] += total_len;\ + dummyname[2] += total_len;\ + dummyname[5] += arg_len+CALL_DUMMY_STACK_ADJUST;\ + dummyname[8] += total_len;} + +/* MJD - So the stack should end up looking like this + + | Normal stack frame | + | from normal program | + | flow | + +---------------------+ <- Final sp - 0x08 - argument size + | | - 0x4 - dummy_frame_size + | Pushed dummy frame | + | b0-b7, r0-r7 | + | pc and ps | + | | + +---------------------+ + | Function address | + +---------------------+ <- Final sp - 0x8 - arguments size + | | + | | + | | + | Arguments to | + | Function | + | | + | | + | | + +---------------------+ <- Final sp - 0x8 + | Dummy_stack_adjust | + +---------------------+ <- Final sp + | | + | where call will | + | build frame | +*/ diff --git a/gdb/tm-pn.h b/gdb/tm-pn.h new file mode 100644 index 0000000..82bf919 --- /dev/null +++ b/gdb/tm-pn.h @@ -0,0 +1,444 @@ +/* Parameters for targe of a Gould Powernode, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define GOULD_PN + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* This code appears in libraries on Gould machines. Ignore it. */ +#define IGNORE_SYMBOL(type) (type == N_ENTRY) + +/* We don't want the extra gnu symbols on the machine; + they will interfere with the shared segment symbols. */ +#define NO_GNU_STABS + +/* Macro for text-offset and data info (in PN a.out format). */ +#define TEXTINFO \ + text_offset = N_TXTOFF (exec_coffhdr); \ + exec_data_offset = N_TXTOFF (exec_coffhdr) \ + + exec_aouthdr.a_text + +/* Macro for number of symbol table entries */ +#define END_OF_TEXT_DEFAULT \ + (0xffffff) + +/* Macro for number of symbol table entries */ +#define NUMBER_OF_SYMBOLS \ + (coffhdr.f_nsyms) + +/* Macro for file-offset of symbol table (in usual a.out format). */ +#define SYMBOL_TABLE_OFFSET \ + N_SYMOFF (coffhdr) + +/* Macro for file-offset of string table (in usual a.out format). */ +#define STRING_TABLE_OFFSET \ + (N_STROFF (coffhdr) + sizeof(int)) + +/* Macro to store the length of the string table data in INTO. */ +#define READ_STRING_TABLE_SIZE(INTO) \ + { INTO = hdr.a_stsize; } + +/* Macro to declare variables to hold the file's header data. */ +#define DECLARE_FILE_HEADERS struct old_exec hdr; \ + FILHDR coffhdr + +/* Macro to read the header data from descriptor DESC and validate it. + NAME is the file name, for error messages. */ +#define READ_FILE_HEADERS(DESC, NAME) \ +{ val = myread (DESC, &coffhdr, sizeof coffhdr); \ + if (val < 0) \ + perror_with_name (NAME); \ + val = myread (DESC, &hdr, sizeof hdr); \ + if (val < 0) \ + perror_with_name (NAME); \ + if (coffhdr.f_magic != GNP1MAGIC) \ + error ("File \"%s\" not in coff executable format.", NAME); \ + if (N_BADMAG (hdr)) \ + error ("File \"%s\" not in executable format.", NAME); } + +/* Define COFF and other symbolic names needed on NP1 */ +#define NS32GMAGIC GDPMAGIC +#define NS32SMAGIC PN_MAGIC +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ +#define FUNCTION_START_OFFSET 4 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. One PN we can have one or two startup + sequences depending on the size of the local stack: + + Either: + "suabr b2, #" + of + "lil r4, #", "suabr b2, #(r4)" + + "lwbr b6, #", "stw r1, 8(b2)" + Optional "stwbr b3, c(b2)" + Optional "trr r2,r7" (Gould first argument register passing) + or + Optional "stw r2,8(b3)" (Gould first argument register passing) + */ +#define SKIP_PROLOGUE(pc) { \ + register int op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x580B0000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x59400000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x5F000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xD4820008) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0x5582000C) { \ + pc += 4; \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } else { \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xd5030008) { \ + pc += 4; \ + } \ + } \ + } else { \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } \ + } \ + } \ + } \ + } \ + } \ + if ((op & 0xffff0000) == 0x59000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if ((op & 0xffff0000) == 0x5F000000) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xD4820008) { \ + pc += 4; \ + op = read_memory_integer ((pc), 4); \ + if (op == 0x5582000C) { \ + pc += 4; \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } else { \ + op = read_memory_integer ((pc), 4); \ + if (op == 0xd5030008) { \ + pc += 4; \ + } \ + } \ + } else { \ + op = read_memory_integer ((pc), 2); \ + if (op == 0x2fa0) { \ + pc += 2; \ + } \ + } \ + } \ + } \ + } \ +} + +/* Immediately after a function call, return the saved pc. + Can't go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. True on PN! Return address is in R1. + Note: true return location is 4 bytes past R1! */ +#define SAVED_PC_AFTER_CALL(frame) \ + (read_register(R1_REGNUM) + 4) + +/* Address of end of stack space. */ +#define STACK_END_ADDR 0x480000 + +/* Stack grows downward. */ +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ +#define BREAKPOINT {0x28, 0x09} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ +#define DECR_PC_AFTER_BREAK 2 + +/* Nonzero if instruction at PC is a return instruction. "bu 4(r1)" */ +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 4) == 0xEC100004) + +/* Return 1 if P points to an invalid floating point value. */ +#define INVALID_FLOAT(p, len) ((*(short *)p & 0xff80) == 0x8000) + +/* Say how long (ordinary) registers are. */ +#define REGISTER_TYPE long + +/* Number of machine registers */ +#define NUM_REGS 19 +#define NUM_GEN_REGS 16 +#define NUM_CPU_REGS 3 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ +#define REGISTER_NAMES { \ + "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ + "b0", "b1", "b2", "b3", "b4", "b5", "b6", "b7", \ + "sp", "ps", "pc", \ +} + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ +#define R1_REGNUM 1 /* Gr1 => return address of caller */ +#define R4_REGNUM 4 /* Gr4 => register save area */ +#define R5_REGNUM 5 /* Gr5 => register save area */ +#define R6_REGNUM 6 /* Gr6 => register save area */ +#define R7_REGNUM 7 /* Gr7 => register save area */ +#define B1_REGNUM 9 /* Br1 => start of this code routine */ +#define FP_REGNUM 10 /* Br2 == (sp) */ +#define AP_REGNUM 11 /* Br3 == (ap) */ +#define SP_REGNUM 16 /* A copy of Br2 saved in trap */ +#define PS_REGNUM 17 /* Contains processor status */ +#define PC_REGNUM 18 /* Contains program counter */ + +/* This is a piece of magic that is given a register number REGNO + and as BLOCKEND the address in the system of the end of the user structure + and stores in ADDR the address in the kernel or core dump + of that register. */ +#define REGISTER_U_ADDR(addr, blockend, regno) { \ + addr = blockend + regno * 4; \ + if (regno == PC_REGNUM) addr = blockend - 8 * 4; \ + if (regno == PS_REGNUM) addr = blockend - 7 * 4; \ + if (regno == SP_REGNUM) addr = blockend - 6 * 4; \ +} + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (NUM_GEN_REGS*4 + NUM_CPU_REGS*4) + +/* Index within `registers' of the first byte of the space for + register N. */ +#define REGISTER_BYTE(N) ((N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the PN, all normal regs are 4 bytes. */ +#define REGISTER_RAW_SIZE(N) (4) + +/* Number of bytes of storage in the program's representation + for register N. On the PN, all regs are 4 bytes. */ +#define REGISTER_VIRTUAL_SIZE(N) (4) + +/* Largest value REGISTER_RAW_SIZE can have. */ +#define MAX_REGISTER_RAW_SIZE (4) + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ +#define MAX_REGISTER_VIRTUAL_SIZE (4) + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_RAW_SIZE(REGNUM)); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ +#define REGISTER_VIRTUAL_TYPE(N) (builtin_type_int) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. + + On this machine this is a no-op, because gcc isn't used on it + yet. So this calling convention is not used. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) + +/* Extract from an arrary REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the NPL, the frame's norminal address is Br2 and the + previous routines frame is up the stack X bytes, where X is the + value stored in the code function header xA(Br1). */ +#define FRAME_CHAIN(thisframe) (findframe(thisframe)) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && chain != (thisframe)->frame) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) \ + (chain) + +/* Define other aspects of the stack frame on NPL. */ +#define FRAME_SAVED_PC(frame) \ + (read_memory_integer ((frame)->frame + 8, 4)) + +#define FRAME_ARGS_ADDRESS(fi) \ + ((fi)->next_frame ? \ + read_memory_integer ((fi)->frame + 12, 4) : \ + read_register (AP_REGNUM)) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame + 80) + +/* Set VAL to the number of args passed to frame described by FI. + Can set VAL to -1, meaning no way to tell. */ + +/* We can check the stab info to see how + many arg we have. No info in stack will tell us */ +#define FRAME_NUM_ARGS(val,fi) (val = findarg(fi)) + +/* Return number of bytes at start of arglist that are not really args. */ +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[R4_REGNUM] = (frame_info)->frame + 0x30; \ + (frame_saved_regs).regs[R5_REGNUM] = (frame_info)->frame + 0x34; \ + (frame_saved_regs).regs[R6_REGNUM] = (frame_info)->frame + 0x38; \ + (frame_saved_regs).regs[R7_REGNUM] = (frame_info)->frame + 0x3C; \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame ( create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions: + halt + halt + halt + halt + suabr b2, #<stacksize> + lwbr b6, #con + stw r1, 8(b2) - save caller address, do we care? + lw r2, 60(b2) - arg1 + labr b3, 50(b2) + std r4, 30(b2) - save r4-r7 + std r6, 38(b2) + lwbr b1, #<func> - load function call address + brlnk r1, 8(b1) - call function + halt + halt + ld r4, 30(b2) - restore r4-r7 + ld r6, 38(b2) + + Setup our stack frame, load argumemts, call and then restore registers. +*/ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } diff --git a/gdb/tm-pyr.h b/gdb/tm-pyr.h new file mode 100644 index 0000000..e37f8f5 --- /dev/null +++ b/gdb/tm-pyr.h @@ -0,0 +1,530 @@ +/* Definitions to make GDB run on a Pyramidax under OSx 4.0 (4.2bsd). + Copyright (C) 1988, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* Traditional Unix virtual address spaces have thre regions: text, + data and stack. The text, initialised data, and uninitialised data + are represented in separate segments of the a.out file. + When a process dumps core, the data and stack regions are written + to a core file. This gives a debugger enough information to + reconstruct (and debug) the virtual address space at the time of + the coredump. + Pyramids have an distinct fourth region of the virtual address + space, in which the contents of the windowed registers are stacked + in fixed-size frames. Pyramid refer to this region as the control + stack. Each call (or trap) automatically allocates a new register + frame; each return deallocates the current frame and restores the + windowed registers to their values before the call. + + When dumping core, the control stack is written to a core files as + a third segment. The core-handling functions need to know to deal + with it. */ +/* Tell core.c there is an extra segment. */ +#define REG_STACK_SEGMENT + +/* Floating point is IEEE compatible on most Pyramid hardware + (Older processors do not have IEEE NaNs). */ +#define IEEE_FLOAT + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +/* FIXME -- do we want to skip insns to allocate the local frame? + If so, what do they look like? + This is becoming harder, since tege@sics.SE wants to change + gcc to not output a prologue when no frame is needed. */ +#define SKIP_PROLOGUE(pc) do {} while (0) + + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) FRAME_SAVED_PC(frame) + +/* Address of end of stack space. */ +/* This seems to be right for the 90x comp.vuw.ac.nz. + The correct value at any site may be a function of the configured + maximum control stack depth. If so, I don't know where the + control-stack depth is configured, so I can't #include it here. */ +#define STACK_END_ADDR (0xc00cc000) + +/* Register window stack (Control stack) stack definitions + - Address of beginning of control stack. + - size of control stack frame + (Note that since crts0 is usually the first function called, + main()'s control stack is one frame (0x80 bytes) beyond this value. */ + +#define CONTROL_STACK_ADDR (0xc00cd000) + +/* Bytes in a register window -- 16 parameter regs, 16 local regs + for each call, is 32 regs * 4 bytes */ + +#define CONTROL_STACK_FRAME_SIZE (32*4) + +/* FIXME. On a pyr, Data Stack grows downward; control stack goes upwards. + Which direction should we use for INNER_THAN, PC_INNER_THAN ?? */ + +#define INNER_THAN < +#define PC_INNER_THAN > + +/* Stack has strict alignment. */ + +#define STACK_ALIGN(ADDR) (((ADDR)+3)&-4) + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xf0, 00, 00, 00} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. + On a pyr, this is either "ret" or "retd". + It would be friendly to check that any "retd" always had an + argument of 0, since anything else is invalid. */ + +#define ABOUT_TO_RETURN(pc) \ +(((read_memory_integer (pc, 2) & 0x3ff0) == 0x3090) || \ + ((read_memory_integer (pc, 2) & 0x0ff0) == 0x00a0)) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes -- not relevant on the Vax. */ +/* FIXME -- this is ok for a vax, bad for big-endian ieee format. + I would use the definition for a Sun; but it is no better! */ + +#define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000) + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ +/* pyramids have 64, plus one for the PSW; plus perhaps one more for the + kernel stack pointer (ksp) and control-stack pointer (CSP) */ + +#define NUM_REGS 67 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES \ +{"gr0", "gr1", "gr2", "gr3", "gr4", "gr5", "gr6", "gr7", \ + "gr8", "gr9", "gr10", "gr11", "logpsw", "cfp", "sp", "pc", \ + "pr0", "pr1", "pr2", "pr3", "pr4", "pr5", "pr6", "pr7", \ + "pr8", "pr9", "pr10", "pr11", "pr12", "pr13", "pr14", "pr15", \ + "lr0", "lr1", "lr2", "lr3", "lr4", "lr5", "lr6", "lr7", \ + "lr8", "lr9", "lr10", "lr11", "lr12", "lr13", "lr14", "lr15", \ + "tr0", "tr1", "tr2", "tr3", "tr4", "tr5", "tr6", "tr7", \ + "tr8", "tr9", "tr10", "tr11", "tr12", "tr13", "tr14", "tr15", \ + "psw", "ksp", "csp"} + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +/* pseudo-registers: */ +#define PS_REGNUM 64 /* Contains processor status */ +#define PSW_REGNUM 64 /* Contains current psw, whatever it is.*/ +#define CSP_REGNUM 65 /* address of this control stack frame*/ +#define KSP_REGNUM 66 /* Contains process's Kernel Stack Pointer */ + +#define CFP_REGNUM 13 /* Current data-stack frame ptr */ +#define TR0_REGNUM 48 /* After function call, contains + function result */ + +/* Registers interesting to the machine-independent part of gdb*/ + +#define FP_REGNUM CSP_REGNUM /* Contains address of executing (control) + stack frame */ +#define SP_REGNUM 14 /* Contains address of top of stack -??*/ +#define PC_REGNUM 15 /* Contains program counter */ + +/* Define DO_REGISTERS_INFO() to do machine-specific formatting + of register dumps. */ + +#define DO_REGISTERS_INFO(_regnum) pyr_do_registers_info(_regnum) + +/* need this so we can find the global registers: they never get saved. */ +extern unsigned int global_reg_offset; +extern unsigned int last_frame_offset; + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (NUM_REGS*4) + +/* the Pyramid has register windows. */ + +#define HAVE_REGISTER_WINDOWS + +/* Is this register part of the register window system? A yes answer + implies that 1) The name of this register will not be the same in + other frames, and 2) This register is automatically "saved" (out + registers shifting into ins counts) upon subroutine calls and thus + there is no need to search more than one stack frame for it. */ + +#define REGISTER_IN_WINDOW_P(regnum) \ + ((regnum) >= 16 && (regnum) < 64) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the Pyramid, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) 4 + +/* Number of bytes of storage in the program's representation + for register N. On the Pyramid, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) 4 + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 4 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int + +/* FIXME: It seems impossible for both EXTRACT_RETURN_VALUE and + STORE_RETURN_VALUE to be correct. */ + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +/****FIXME****/ +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { write_register (TR0_REGNUM, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +/* Note that on a register-windowing machine (eg, Pyr, SPARC), this is + where the value is found after the function call -- ie, it should + correspond to GNU CC's FUNCTION_VALUE rather than FUNCTION_OUTGOING_VALUE.*/ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (((int *)(REGBUF))+TR0_REGNUM, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ +/* on pyrs, values are returned in */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE(TR0_REGNUM), VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ +/* FIXME */ +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ + ( ((int *)(REGBUF)) [TR0_REGNUM]) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +#define EXTRA_FRAME_INFO \ + FRAME_ADDR bottom; \ + CORE_ADDR frame_cfp; \ + CORE_ADDR frame_window_addr; + +#define INIT_EXTRA_FRAME_INFO(fci) \ +do { \ + (fci)->frame_window_addr = (fci)->frame; \ + (fci)->bottom = \ + ((fci)->next ? \ + ((fci)->frame == (fci)->next_frame ? \ + (fci)->next->bottom : (fci)->next->frame) : \ + read_register (SP_REGNUM)); \ + (fci)->frame_cfp = \ + read_register (CFP_REGNUM); \ + /***fprintf (stderr, \ + "[[creating new frame for %0x,pc=%0x,csp=%0x]]\n", \ + (fci)->frame, (fci)->pc,(fci)->frame_cfp);*/ \ +} while (0); + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the pyr, the frame's nominal address is the address + of parameter register 0. The previous frame is found 32 words up. */ + +#define FRAME_CHAIN(thisframe) \ + ( (thisframe) -> frame - CONTROL_STACK_FRAME_SIZE) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + + /*((thisframe) >= CONTROL_STACK_ADDR))*/ + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. + + I do not understand what this means on a Pyramid, where functions + *always* have a control-stack frame, but may or may not have a + frame on the data stack. Since GBD uses the value of the + control stack pointer as its "address" of a frame, FRAMELESS + is always 1, so does not need to be defined. */ + + +/* Where is the PC for a specific frame */ + +#define FRAME_SAVED_PC(fi) \ + ((CORE_ADDR) (read_memory_integer ( (fi) -> frame + 60, 4))) + +/* There may be bugs in FRAME_ARGS_ADDRESS and FRAME_LOCALS_ADDRESS; + or there may be bugs in accessing the registers that break + their definitions. + Having the macros expand into functions makes them easier to debug. + When the bug is finally located, the inline macro defintions can + be un-#if 0ed, and frame_args_addr and frame_locals_address can + be deleted from pyr-dep.c */ + +/* If the argument is on the stack, it will be here. */ +#define FRAME_ARGS_ADDRESS(fi) \ + frame_args_addr(fi) + +#define FRAME_LOCALS_ADDRESS(fi) \ + frame_locals_address(fi) + +/* The following definitions doesn't seem to work. + I don't understand why. */ +#if 0 +#define FRAME_ARGS_ADDRESS(fi) \ + /*(FRAME_FP(fi) + (13*4))*/ (read_register (CFP_REGNUM)) + +#define FRAME_LOCALS_ADDRESS(fi) \ + ((fi)->frame +(16*4)) + +#endif /* 0 */ + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(val, fi) (val = -1) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 0 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. + + Note that on register window machines, we are currently making the + assumption that window registers are being saved somewhere in the + frame in which they are being used. If they are stored in an + inferior frame, find_saved_register will break. + + On pyrs, frames of window registers are stored contiguously on a + separate stack. All window registers are always stored. + The pc and psw (gr15 and gr14) are also always saved: the call + insn saves them in pr15 and pr14 of the new frame (tr15,tr14 of the + old frame). + The data-stack frame pointer (CFP) is only saved in functions which + allocate a (data)stack frame (with "adsf"). We detect them by + looking at the first insn of the procedure. + + Other non-window registers (gr0-gr11) are never saved. Pyramid's C + compiler and gcc currently ignore them, so it's not an issue. */ + +#define FRAME_FIND_SAVED_REGS(fi_p, frame_saved_regs) \ +{ register int regnum; \ + register CORE_ADDR pc; \ + register CORE_ADDR fn_start_pc; \ + register int first_insn; \ + register CORE_ADDR prev_cf_addr; \ + register int window_ptr; \ + FRAME fid = FRAME_INFO_ID (fi_p); \ + if (!fid) fatal ("Bad frame info struct in FRAME_FIND_SAVED_REGS"); \ + bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \ + \ + window_ptr = prev_cf_addr = FRAME_FP(fi_p); \ + \ + for (regnum = 16 ; regnum < 64; regnum++,window_ptr+=4) \ + { \ + (frame_saved_regs).regs[regnum] = window_ptr; \ + } \ + \ + /* In each window, psw, and pc are "saved" in tr14,tr15. */ \ + /*** psw is sometimes saved in gr12 (so sez <sys/pcb.h>) */ \ + (frame_saved_regs).regs[PS_REGNUM] = FRAME_FP(fi_p) + (14*4); \ + \ +/*(frame_saved_regs).regs[PC_REGNUM] = (frame_saved_regs).regs[31];*/ \ + (frame_saved_regs).regs[PC_REGNUM] = FRAME_FP(fi_p) + ((15+32)*4); \ + \ + /* Functions that allocate a frame save sp *where*? */ \ +/*first_insn = read_memory_integer (get_pc_function_start ((fi_p)->pc),4); */ \ + \ + fn_start_pc = (get_pc_function_start ((fi_p)->pc)); \ + first_insn = read_memory_integer(fn_start_pc, 4); \ + \ + if (0x08 == ((first_insn >> 20) &0x0ff)) { \ + /* NB: because WINDOW_REGISTER_P(cfp) is false, a saved cfp \ + in this frame is only visible in this frame's callers. \ + That means the cfp we mark saved is my caller's cfp, ie pr13. \ + I don't understand why we don't have to do that for pc, too. */ \ + \ + (frame_saved_regs).regs[CFP_REGNUM] = FRAME_FP(fi_p)+(13*4); \ + \ + (frame_saved_regs).regs[SP_REGNUM] = \ + read_memory_integer (FRAME_FP(fi_p)+((13+32)*4),4); \ + } \ + \ +/* \ + *(frame_saved_regs).regs[CFP_REGNUM] = (frame_saved_regs).regs[61]; \ + * (frame_saved_regs).regs[SP_REGNUM] = \ + * read_memory_integer (FRAME_FP(fi_p)+((13+32)*4),4); \ + */ \ + \ + (frame_saved_regs).regs[CSP_REGNUM] = prev_cf_addr; \ +} + +/* Things needed for making the inferior call functions. */ +#if 0 +/* These are all lies. These macro definitions are appropriate for a + SPARC. On a pyramid, pushing a dummy frame will + surely involve writing the control stack pointer, + then saving the pc. This requires a privileged instruction. + Maybe one day Pyramid can be persuaded to add a syscall to do this. + Until then, we are out of luck. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM);\ + register int regnum; \ + sp = push_word (sp, 0); /* arglist */ \ + for (regnum = 11; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ +/* sp = push_word (sp, read_register (AP_REGNUM));*/ \ + sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) \ + + 0x2fff0000); \ + sp = push_word (sp, 0); \ + write_register (SP_REGNUM, sp); \ + write_register (FP_REGNUM, sp); \ +/* write_register (AP_REGNUM, sp + 17 * sizeof (int));*/ } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register CORE_ADDR fp = read_register (FP_REGNUM); \ + register int regnum; \ + register int regmask = read_memory_integer (fp + 4, 4); \ + write_register (PS_REGNUM, \ + (regmask & 0xffff) \ + | (read_register (PS_REGNUM) & 0xffff0000)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 16, 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp + 12, 4)); \ +/* write_register (AP_REGNUM, read_memory_integer (fp + 8, 4));*/ \ + fp += 16; \ + for (regnum = 0; regnum < 12; regnum++) \ + if (regmask & (0x10000 << regnum)) \ + write_register (regnum, read_memory_integer (fp += 4, 4)); \ + fp = fp + 4 + ((regmask >> 30) & 3); \ + if (regmask & 0x20000000) \ + { regnum = read_memory_integer (fp, 4); \ + fp += (regnum + 1) * 4; } \ + write_register (SP_REGNUM, fp); \ + set_current_frame (read_register (FP_REGNUM)); } + +/* This sequence of words is the instructions + calls #69, @#32323232 + bpt + Note this is 8 bytes. */ + +#define CALL_DUMMY {0x329f69fb, 0x03323232} + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *((char *) dummyname + 1) = nargs; \ + *(int *)((char *) dummyname + 3) = fun; } +#endif /* 0 */ + +#define POP_FRAME \ + { error ("The return command is not supported on this machine."); } diff --git a/gdb/tm-sparc.h b/gdb/tm-sparc.h new file mode 100644 index 0000000..b3316da --- /dev/null +++ b/gdb/tm-sparc.h @@ -0,0 +1,586 @@ +/* Parameters for target machine of Sun 4, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + Contributed by Michael Tiemann (tiemann@mcc.com) +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER BIG_ENDIAN + +/* Floating point is IEEE compatible. */ +#define IEEE_FLOAT + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* When passing a structure to a function, Sun cc passes the address + in a register, not the structure itself. It (under SunOS4) creates + two symbols, so we get a LOC_ARG saying the address is on the stack + (a lie, and a serious one since we don't know which register to + use), and a LOC_REGISTER saying that the struct is in a register + (sort of a lie, but fixable with REG_STRUCT_HAS_ADDR). + + This still doesn't work if the argument is not one passed in a + register (i.e. it's the 7th or later argument). */ +#define REG_STRUCT_HAS_ADDR(gcc_p) (!(gcc_p)) +#define STRUCT_ARG_SYM_GARBAGE(gcc_p) (!(gcc_p)) + +/* If Pcc says that a parameter is a short, it's a short. This is + because the parameter does get passed in in a register as an int, + but pcc puts it onto the stack frame as a short (not nailing + whatever else might be there. I'm not sure that I consider this + swift. Sigh.) + + No, don't do this. The problem here is that pcc says that the + argument is in the upper half of the word reserved on the stack, + but puts it in the lower half. */ +/* #define BELIEVE_PCC_PROMOTION 1 */ +/* OK, I've added code to dbxread.c to deal with this case. */ +#define BELIEVE_PCC_PROMOTION_TYPE + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ + { pc = skip_prologue (pc); } +extern CORE_ADDR skip_prologue (); + +/* Immediately after a function call, return the saved pc. + Can't go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +/* On the Sun 4 under SunOS, the compile will leave a fake insn which + encodes the structure size being returned. If we detect such + a fake insn, step past it. */ + +#define PC_ADJUST(pc) ((read_memory_integer (pc + 8, 4) & 0xfffffe00) == 0 ? \ + pc+12 : pc+8) + +#define SAVED_PC_AFTER_CALL(frame) PC_ADJUST (read_register (RP_REGNUM)) + +/* Address of the end of stack space. We get this from the system + include files. */ +#include <sys/types.h> +#include <machine/vmparam.h> +#define STACK_END_ADDR USRSTACK + +#define INNER_THAN < + +/* Stack has strict alignment. */ + +#define STACK_ALIGN(ADDR) (((ADDR)+7)&-8) + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0x91, 0xd0, 0x20, 0x01} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ +/* For SPARC, this is either a "jmpl %o7+8,%g0" or "jmpl %i7+8,%g0". + + Note: this does not work for functions returning structures under SunOS. */ +#define ABOUT_TO_RETURN(pc) \ + ((read_memory_integer (pc, 4)|0x00040000) == 0x81c7e008) + +/* Return 1 if P points to an invalid floating point value. */ + +#define INVALID_FLOAT(p, len) 0 /* Just a first guess; not checked */ + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 72 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES \ +{ "g0", "g1", "g2", "g3", "g4", "g5", "g6", "g7", \ + "o0", "o1", "o2", "o3", "o4", "o5", "sp", "o7", \ + "l0", "l1", "l2", "l3", "l4", "l5", "l6", "l7", \ + "i0", "i1", "i2", "i3", "i4", "i5", "fp", "i7", \ + \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "f8", "f9", "f10", "f11", "f12", "f13", "f14", "f15", \ + "f16", "f17", "f18", "f19", "f20", "f21", "f22", "f23", \ + "f24", "f25", "f26", "f27", "f28", "f29", "f30", "f31", \ + \ + "y", "psr", "wim", "tbr", "pc", "npc", "fpsr", "cpsr" }; + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define G0_REGNUM 0 /* %g0 */ +#define G1_REGNUM 1 /* %g1 */ +#define O0_REGNUM 8 /* %o0 */ +#define SP_REGNUM 14 /* Contains address of top of stack, \ + which is also the bottom of the frame. */ +#define RP_REGNUM 15 /* Contains return address value, *before* \ + any windows get switched. */ +#define O7_REGNUM 15 /* Last local reg not saved on stack frame */ +#define L0_REGNUM 16 /* First local reg that's saved on stack frame + rather than in machine registers */ +#define I0_REGNUM 24 /* %i0 */ +#define FP_REGNUM 30 /* Contains address of executing stack frame */ +#define I7_REGNUM 31 /* Last local reg saved on stack frame */ +#define FP0_REGNUM 32 /* Floating point register 0 */ +#define Y_REGNUM 64 /* Temp register for multiplication, etc. */ +#define PS_REGNUM 65 /* Contains processor status */ +#define WIM_REGNUM 66 /* Window Invalid Mask (not really supported) */ +#define TBR_REGNUM 67 /* Trap Base Register (not really supported) */ +#define PC_REGNUM 68 /* Contains program counter */ +#define NPC_REGNUM 69 /* Contains next PC */ +#define FPS_REGNUM 70 /* Floating point status register */ +#define CPS_REGNUM 71 /* Coprocessor status register */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (32*4+32*4+8*4) + +/* Index within `registers' of the first byte of the space for + register N. */ +/* ?? */ +#define REGISTER_BYTE(N) ((N)*4) + +/* The SPARC processor has register windows. */ + +#define HAVE_REGISTER_WINDOWS + +/* Is this register part of the register window system? A yes answer + implies that 1) The name of this register will not be the same in + other frames, and 2) This register is automatically "saved" (out + registers shifting into ins counts) upon subroutine calls and thus + there is no need to search more than one stack frame for it. */ + +#define REGISTER_IN_WINDOW_P(regnum) \ + ((regnum) >= 8 && (regnum) < 32) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +/* On the SPARC, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) (4) + +/* Number of bytes of storage in the program's representation + for register N. */ + +/* On the SPARC, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) (4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 8 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +{ bcopy ((FROM), (TO), 4); } + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +{ bcopy ((FROM), (TO), 4); } + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + ((N) < 32 ? builtin_type_int : (N) < 64 ? builtin_type_float : \ + builtin_type_int) + +/* Writing to %g0 is a noop (not an error or exception or anything like + that, however). */ + +#define CANNOT_STORE_REGISTER(regno) ((regno) == G0_REGNUM) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { target_write_memory ((SP)+(16*4), (char *)&(ADDR), 4); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + { \ + if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + { \ + bcopy (((int *)(REGBUF))+FP0_REGNUM, \ + (VALBUF), TYPE_LENGTH(TYPE)); \ + } \ + else \ + bcopy (((int *)(REGBUF))+8, (VALBUF), TYPE_LENGTH (TYPE)); \ + } + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ +/* On sparc, values are returned in register %o0. */ +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + { \ + if (TYPE_CODE (TYPE) == TYPE_CODE_FLT) \ + /* Floating-point values are returned in the register pair */ \ + /* formed by %f0 and %f1 (doubles are, anyway). */ \ + write_register_bytes (REGISTER_BYTE (FP0_REGNUM), (VALBUF), \ + TYPE_LENGTH (TYPE)); \ + else \ + /* Other values are returned in register %o0. */ \ + write_register_bytes (REGISTER_BYTE (O0_REGNUM), (VALBUF), \ + TYPE_LENGTH (TYPE)); \ + } + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) \ + (read_memory_integer (((int *)(REGBUF))[SP_REGNUM]+(16*4), 4)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* I don't know whether this will work for cross-debugging, even if you + do get the right reg.h. */ +#include <machine/reg.h> + +#define GET_RWINDOW_REG(FRAME, REG) \ + (read_memory_integer ((CORE_ADDR)&((struct rwindow *)FRAME)->REG, 4)) + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the Sun 4, the frame-chain's nominal address + is held in the frame pointer register. + + On the Sun4, the frame (in %fp) is %sp for the previous frame. + From the previous frame's %sp, we can find the previous frame's + %fp: it is in the save area just above the previous frame's %sp. + + If we are setting up an arbitrary frame, we'll need to know where + it ends. Hence the following. This part of the frame cache + structure should be checked before it is assumed that this frame's + bottom is in the stack pointer. + + If there isn't a frame below this one, the bottom of this frame is + in the stack pointer. + + If there is a frame below this one, and the frame pointers are + identical, it's a leaf frame and the bottoms are the same also. + + Otherwise the bottom of this frame is the top of the next frame. */ + +#define EXTRA_FRAME_INFO FRAME_ADDR bottom; +#define INIT_EXTRA_FRAME_INFO(fci) \ + (fci)->bottom = \ + ((fci)->next ? \ + ((fci)->frame == (fci)->next_frame ? \ + (fci)->next->bottom : (fci)->next->frame) : \ + read_register (SP_REGNUM)); + +#define FRAME_CHAIN(thisframe) \ + GET_RWINDOW_REG ((thisframe)->frame, rw_in[6]) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + (FRAMELESS) = frameless_look_for_prologue(FI) + +/* Where is the PC for a specific frame */ + +#define FRAME_SAVED_PC(FRAME) frame_saved_pc (FRAME) +CORE_ADDR frame_saved_pc (); + +/* If the argument is on the stack, it will be here. */ +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_STRUCT_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Set VAL to the number of args passed to frame described by FI. + Can set VAL to -1, meaning no way to tell. */ + +/* We can't tell how many args there are + now that the C compiler delays popping them. */ +#define FRAME_NUM_ARGS(val,fi) (val = -1) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 68 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + The actual code is in sparc-tdep.c so we can debug it sanely. */ + +#define FRAME_FIND_SAVED_REGS(fi, frame_saved_regs) \ + sparc_frame_find_saved_regs ((fi), &(frame_saved_regs)) +extern void sparc_frame_find_saved_regs (); + +/* Things needed for making the inferior call functions. */ +/* + * First of all, let me give my opinion of what the DUMMY_FRAME + * actually looks like. + * + * | | + * | | + * + - - - - - - - - - - - - - - - - +<-- fp (level 0) + * | | + * | | + * | | + * | | + * | Frame of innermost program | + * | function | + * | | + * | | + * | | + * | | + * | | + * |---------------------------------|<-- sp (level 0), fp (c) + * | | + * DUMMY | fp0-31 | + * | | + * | ------ |<-- fp - 0x80 + * FRAME | g0-7 |<-- fp - 0xa0 + * | i0-7 |<-- fp - 0xc0 + * | other |<-- fp - 0xe0 + * | ? | + * | ? | + * |---------------------------------|<-- sp' = fp - 0x140 + * | | + * xcution start | | + * sp' + 0x94 -->| CALL_DUMMY (x code) | + * | | + * | | + * |---------------------------------|<-- sp'' = fp - 0x200 + * | align sp to 8 byte boundary | + * | ==> args to fn <== | + * Room for | | + * i & l's + agg | CALL_DUMMY_STACK_ADJUST = 0x0x44| + * |---------------------------------|<-- final sp (variable) + * | | + * | Where function called will | + * | build frame. | + * | | + * | | + * + * I understand everything in this picture except what the space + * between fp - 0xe0 and fp - 0x140 is used for. Oh, and I don't + * understand why there's a large chunk of CALL_DUMMY that never gets + * executed (its function is superceeded by PUSH_DUMMY_FRAME; they + * are designed to do the same thing). + * + * PUSH_DUMMY_FRAME saves the registers above sp' and pushes the + * register file stack down one. + * + * call_function then writes CALL_DUMMY, pushes the args onto the + * stack, and adjusts the stack pointer. + * + * run_stack_dummy then starts execution (in the middle of + * CALL_DUMMY, as directed by call_function). + */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME sparc_push_dummy_frame () +#define POP_FRAME sparc_pop_frame () + +void sparc_push_dummy_frame (), sparc_pop_frame (); +/* This sequence of words is the instructions + + save %sp,-0x140,%sp + std %f30,[%fp-0x08] + std %f28,[%fp-0x10] + std %f26,[%fp-0x18] + std %f24,[%fp-0x20] + std %f22,[%fp-0x28] + std %f20,[%fp-0x30] + std %f18,[%fp-0x38] + std %f16,[%fp-0x40] + std %f14,[%fp-0x48] + std %f12,[%fp-0x50] + std %f10,[%fp-0x58] + std %f8,[%fp-0x60] + std %f6,[%fp-0x68] + std %f4,[%fp-0x70] + std %f2,[%fp-0x78] + std %f0,[%fp-0x80] + std %g6,[%fp-0x88] + std %g4,[%fp-0x90] + std %g2,[%fp-0x98] + std %g0,[%fp-0xa0] + std %i6,[%fp-0xa8] + std %i4,[%fp-0xb0] + std %i2,[%fp-0xb8] + std %i0,[%fp-0xc0] + nop ! stcsr [%fp-0xc4] + nop ! stfsr [%fp-0xc8] + nop ! wr %npc,[%fp-0xcc] + nop ! wr %pc,[%fp-0xd0] + rd %tbr,%o0 + st %o0,[%fp-0xd4] + rd %wim,%o1 + st %o0,[%fp-0xd8] + rd %psr,%o0 + st %o0,[%fp-0xdc] + rd %y,%o0 + st %o0,[%fp-0xe0] + + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following ld instruction. *../ + + ld [%sp+0x58],%o5 + ld [%sp+0x54],%o4 + ld [%sp+0x50],%o3 + ld [%sp+0x4c],%o2 + ld [%sp+0x48],%o1 + call 0x00000000 + ld [%sp+0x44],%o0 + nop + ta 1 + nop + + note that this is 192 bytes, which is a multiple of 8 (not only 4) bytes. + note that the `call' insn is a relative, not an absolute call. + note that the `nop' at the end is needed to keep the trap from + clobbering things (if NPC pointed to garbage instead). + +We actually start executing at the `sethi', since the pushing of the +registers (as arguments) is done by PUSH_DUMMY_FRAME. If this were +real code, the arguments for the function called by the CALL would be +pushed between the list of ST insns and the CALL, and we could allow +it to execute through. But the arguments have to be pushed by GDB +after the PUSH_DUMMY_FRAME is done, and we cannot allow these ST +insns to be performed again, lest the registers saved be taken for +arguments. */ + +#define CALL_DUMMY { 0x9de3bee0, 0xfd3fbff8, 0xf93fbff0, 0xf53fbfe8, \ + 0xf13fbfe0, 0xed3fbfd8, 0xe93fbfd0, 0xe53fbfc8, \ + 0xe13fbfc0, 0xdd3fbfb8, 0xd93fbfb0, 0xd53fbfa8, \ + 0xd13fbfa0, 0xcd3fbf98, 0xc93fbf90, 0xc53fbf88, \ + 0xc13fbf80, 0xcc3fbf78, 0xc83fbf70, 0xc43fbf68, \ + 0xc03fbf60, 0xfc3fbf58, 0xf83fbf50, 0xf43fbf48, \ + 0xf03fbf40, 0x01000000, 0x01000000, 0x01000000, \ + 0x01000000, 0x91580000, 0xd027bf50, 0x93500000, \ + 0xd027bf4c, 0x91480000, 0xd027bf48, 0x91400000, \ + 0xd027bf44, 0xda03a058, 0xd803a054, 0xd603a050, \ + 0xd403a04c, 0xd203a048, 0x40000000, 0xd003a044, \ + 0x01000000, 0x91d02001, 0x01000000, 0x01000000} + +#define CALL_DUMMY_LENGTH 192 + +#define CALL_DUMMY_START_OFFSET 148 + +#define CALL_DUMMY_STACK_ADJUST 68 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. + + For structs and unions, if the function was compiled with Sun cc, + it expects 'unimp' after the call. But gcc doesn't use that + (twisted) convention. So leave a nop there for gcc (FIX_CALL_DUMMY + can assume it is operating on a pristine CALL_DUMMY, not one that + has already been customized for a different function). */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + *(int *)((char *) dummyname+168) = (0x40000000|((fun-(pc+168))>>2)); \ + if (!gcc_p \ + && (TYPE_CODE (type) == TYPE_CODE_STRUCT \ + || TYPE_CODE (type) == TYPE_CODE_UNION)) \ + *(int *)((char *) dummyname+176) = (TYPE_LENGTH (type) & 0x1fff); \ +} + + +/* Sparc has no reliable single step ptrace call */ + +#define NO_SINGLE_STEP 1 +extern void single_step (); + +/* We need two arguments (in general) to the "info frame" command. + Note that the definition of this macro implies that there exists a + function "setup_arbitrary_frame" in mach-dep.c */ + +#define FRAME_SPECIFICATION_DYADIC + +/* To print every pair of float registers as a double, we use this hook. */ + +#define PRINT_REGISTER_HOOK(regno) \ + if (((regno) >= FP0_REGNUM) \ + && ((regno) < FP0_REGNUM + 32) \ + && (0 == (regno & 1))) { \ + char doublereg[8]; /* two float regs */ \ + if (!read_relative_register_raw_bytes (i , doublereg ) \ + && !read_relative_register_raw_bytes (i+1, doublereg+4)) { \ + printf("\t"); \ + print_floating (doublereg, builtin_type_double, stdout); \ + } \ + } + diff --git a/gdb/tm-sun2.h b/gdb/tm-sun2.h new file mode 100644 index 0000000..6d29462 --- /dev/null +++ b/gdb/tm-sun2.h @@ -0,0 +1,107 @@ +/* Parameters for execution on a Sun, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "m-68k.h" + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Address of the end of stack space. We get this from the system + include files. */ +#include <sys/types.h> +#include <machine/vmparam.h> +#define STACK_END_ADDR USRSTACK + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM);\ + register int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame ( create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + bpt + nop +Note this is 24 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 24 + +#define CALL_DUMMY_START_OFFSET 8 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 16) = nargs * 4; \ + *(int *)((char *) dummyname + 10) = fun; } diff --git a/gdb/tm-sun2os4.h b/gdb/tm-sun2os4.h new file mode 100644 index 0000000..bb1a061 --- /dev/null +++ b/gdb/tm-sun2os4.h @@ -0,0 +1,20 @@ +/* Copyright (C) 1990, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "tm-sun2.h" +#include "tm-sunos.h" diff --git a/gdb/tm-sun3.h b/gdb/tm-sun3.h new file mode 100644 index 0000000..4519d6a --- /dev/null +++ b/gdb/tm-sun3.h @@ -0,0 +1,120 @@ +/* Parameters for execution on a Sun, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HAVE_68881 + +#include "tm-68k.h" + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Address of the end of stack space. We get this from the system + include files. */ +#include <sys/types.h> +#include <machine/vmparam.h> +#define STACK_END_ADDR USRSTACK + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM); \ + register int regnum; \ + char raw_buffer[12]; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + { read_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); \ + sp = push_bytes (sp, raw_buffer, 12); } \ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PS_REGNUM)); \ + write_register (SP_REGNUM, sp); } + +/* Discard from the stack the innermost frame, + restoring all saved registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + char raw_buffer[12]; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = FP0_REGNUM + 7; regnum >= FP0_REGNUM; regnum--) \ + if (fsr.regs[regnum]) \ + { read_memory (fsr.regs[regnum], raw_buffer, 12); \ + write_register_bytes (REGISTER_BYTE (regnum), raw_buffer, 12); }\ + for (regnum = FP_REGNUM - 1; regnum >= 0; regnum--) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + if (fsr.regs[PS_REGNUM]) \ + write_register (PS_REGNUM, read_memory_integer (fsr.regs[PS_REGNUM], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); } + +/* This sequence of words is the instructions + fmovem 0xff,-(sp) + moveml 0xfffc,-(sp) + clrw -(sp) + movew ccr,-(sp) + /..* The arguments are pushed at this point by GDB; + no code is needed in the dummy for this. + The CALL_DUMMY_START_OFFSET gives the position of + the following jsr instruction. *../ + jsr @#32323232 + addl #69696969,sp + trap #15 + nop +Note this is 28 bytes. +We actually start executing at the jsr, since the pushing of the +registers is done by PUSH_DUMMY_FRAME. If this were real code, +the arguments for the function called by the jsr would be pushed +between the moveml and the jsr, and we could allow it to execute through. +But the arguments have to be pushed by GDB after the PUSH_DUMMY_FRAME is done, +and we cannot allow the moveml to push the registers again lest they be +taken for the arguments. */ + +#define CALL_DUMMY {0xf227e0ff, 0x48e7fffc, 0x426742e7, 0x4eb93232, 0x3232dffc, 0x69696969, 0x4e4f4e71} + +#define CALL_DUMMY_LENGTH 28 + +#define CALL_DUMMY_START_OFFSET 12 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *(int *)((char *) dummyname + 20) = nargs * 4; \ + *(int *)((char *) dummyname + 14) = fun; } diff --git a/gdb/tm-sun386.h b/gdb/tm-sun386.h new file mode 100644 index 0000000..60c8986 --- /dev/null +++ b/gdb/tm-sun386.h @@ -0,0 +1,305 @@ +/* Parameters for execution on a Sun 386i, for GDB, the GNU debugger. + Copyright (C) 1986, 1987 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +#ifndef sun386 +#define sun386 +#endif +#define SUNOS4 +#define USE_MACHINE_REG_H + +/* Perhaps some day this will work even without the following #define */ +#define COFF_ENCAPSULATE + +#ifdef COFF_ENCAPSULATE +#define NAMES_HAVE_UNDERSCORE +/* Avoid conflicts between "a.out.gnu.h" and <sys/exec.h> */ +#define _EXEC_ +#endif + +#define BROKEN_LARGE_ALLOCA + +/* sun386 ptrace seems unable to change the frame pointer */ +#define PTRACE_FP_BUG + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(frompc) {(frompc) = i386_skip_prologue((frompc));} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + (read_memory_integer (read_register (SP_REGNUM), 4)) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR 0xfc000000 + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xcc} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 1 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0xc3) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes -- not relevant on the 386. */ + +#define INVALID_FLOAT(p, len) (0) + +/* Largest integer type */ +#define LONGEST long + +/* Name of the builtin type for the LONGEST type above. */ +#define BUILTIN_TYPE_LONGEST builtin_type_long + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 35 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +/* the order of the first 8 registers must match the compiler's + * numbering scheme (which is the same as the 386 scheme) + * also, this table must match regmap in i386-pinsn.c. + */ +#define REGISTER_NAMES { "gs", "fs", "es", "ds", \ + "edi", "esi", "ebp", "esp", \ + "ebx", "edx", "ecx", "eax", \ + "retaddr", "trapnum", "errcode", "ip", \ + "cs", "ps", "sp", "ss", \ + "fst0", "fst1", "fst2", "fst3", \ + "fst4", "fst5", "fst6", "fst7", \ + "fctrl", "fstat", "ftag", "fip", \ + "fcs", "fopoff", "fopsel" \ + } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define FP_REGNUM 6 /* Contains address of executing stack frame */ +#define SP_REGNUM 18 /* Contains address of top of stack */ +#define PS_REGNUM 17 /* Contains processor status */ +#define PC_REGNUM 15 /* Contains program counter */ +#define FP0_REGNUM 20 /* Floating point register 0 */ +#define FPC_REGNUM 28 /* 80387 control register */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (20*4+8*10+7*4) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) \ + ((N) >= FPC_REGNUM ? (((N) - FPC_REGNUM) * 4) + 160 \ + : (N) >= FP0_REGNUM ? (((N) - FP0_REGNUM) * 10) + 80 \ + : (N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. */ + +#define REGISTER_RAW_SIZE(N) (((unsigned)((N) - FP0_REGNUM)) < 8 ? 10 : 4) + +/* Number of bytes of storage in the program's representation + for register N. */ + +#define REGISTER_VIRTUAL_SIZE(N) (((unsigned)((N) - FP0_REGNUM)) < 8 ? 8 : 4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 10 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) (((unsigned)((N) - FP0_REGNUM)) < 8) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \ + i387_to_double ((FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); } + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +{ if ((REGNUM) >= FP0_REGNUM && (REGNUM) < FPC_REGNUM) \ + double_to_i387 ((FROM), (TO)); \ + else \ + bcopy ((FROM), (TO), 4); } + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + (((unsigned)((N) - FP0_REGNUM)) < 8 ? builtin_type_double : builtin_type_int) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { (SP) -= sizeof (ADDR); \ + write_memory ((SP), &(ADDR), sizeof (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF + REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 11), VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 11), VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ +{ (FRAMELESS) = frameless_look_for_prologue (FI); } + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4)) + +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) (numargs) = i386_frame_num_args(fi) + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ i386_frame_find_saved_regs ((frame_info), &(frame_saved_regs)); } + + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME { i386_push_dummy_frame (); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME { i386_pop_frame (); } + +/* this is + * call 11223344 (32 bit relative) + * int3 + */ + +#define CALL_DUMMY { 0x223344e8, 0xcc11 } + +#define CALL_DUMMY_LENGTH 8 + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + *(int *)((char *)(dummyname) + 1) = (int)(fun) - (pc) - 5; \ +} diff --git a/gdb/tm-sun3os4.h b/gdb/tm-sun3os4.h new file mode 100644 index 0000000..5d89d15 --- /dev/null +++ b/gdb/tm-sun3os4.h @@ -0,0 +1,20 @@ +/* Copyright (C) 1990, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "tm-sun3.h" +#include "tm-sunos.h" diff --git a/gdb/tm-sun4os4.h b/gdb/tm-sun4os4.h new file mode 100644 index 0000000..971bb4f --- /dev/null +++ b/gdb/tm-sun4os4.h @@ -0,0 +1,24 @@ +/* Macro definitions for GDB for a Sun 4 running sunos 4. + Copyright (C) 1989, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "tm-sparc.h" +#include "tm-sunos.h" + +#undef STACK_END_ADDRESS +#define STACK_END_ADDRESS 0xf8000000 diff --git a/gdb/tm-sunos.h b/gdb/tm-sunos.h new file mode 100644 index 0000000..f33e352 --- /dev/null +++ b/gdb/tm-sunos.h @@ -0,0 +1,26 @@ +/* Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is for SunOS version 4, not for earlier versions. */ + +#define CLEAR_SOLIB clear_solib + +/* If we can't set a breakpoint, and it's in a shared library, just + disable it. */ +#define DISABLE_UNSETTABLE_BREAK(addr) solib_address(addr) +extern int solib_address (); /* solib.c */ diff --git a/gdb/tm-symmetry.h b/gdb/tm-symmetry.h new file mode 100644 index 0000000..0030b61 --- /dev/null +++ b/gdb/tm-symmetry.h @@ -0,0 +1,488 @@ +/* Definitions to make GDB run on a Sequent Symmetry under dynix 3.0, + with Weitek 1167 and i387 support. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Symmetry version by Jay Vosburgh (uunet!sequent!fubar) */ + +/* I don't know if this will work for cross-debugging, even if you do get + a copy of the right include file. */ +#include <machine/reg.h> + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. From m-i386.h */ + +#define SKIP_PROLOGUE(frompc) {(frompc) = i386_skip_prologue((frompc));} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + read_memory_integer(read_register(SP_REGNUM), 4) + +/* I don't know the real values for these. */ +#define TARGET_UPAGES UPAGES +#define TARGET_NBPG NBPG + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0x40000000 - (TARGET_UPAGES * TARGET_NBPG)) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xcc} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ +/* For Symmetry, this is really the 'leave' instruction, which */ +/* is right before the ret */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0xc9) + +/* Return 1 if P points to an invalid floating point value. +*/ + +#define INVALID_FLOAT(p, len) (0) + +/* code for 80387 fpu. Functions are from i386-dep.c, copied into + * symm-dep.c. + */ +#define FLOAT_INFO { i386_float_info(); } + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ +#define NUM_REGS 49 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +/* Symmetry registers are in this weird order to match the register + numbers in the symbol table entries. If you change the order, + things will probably break mysteriously for no apparent reason. + Also note that the st(0)...st(7) 387 registers are represented as + st0...st7. */ + +#define REGISTER_NAMES { "eax", "edx", "ecx", "st0", "st1", \ + "ebx", "esi", "edi", "st2", "st3", \ + "st4", "st5", "st6", "st7", "esp", \ + "ebp", "eip", "eflags", "fp1", "fp2", \ + "fp3", "fp4", "fp5", "fp6", "fp7", \ + "fp8", "fp9", "fp10", "fp11", "fp12", \ + "fp13", "fp14", "fp15", "fp16", "fp17", \ + "fp18", "fp19", "fp20", "fp21", "fp22", \ + "fp23", "fp24", "fp25", "fp26", "fp27", \ + "fp28", "fp29", "fp30", "fp31" } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define FP1_REGNUM 18 /* first 1167 register */ +#define SP_REGNUM 14 /* Contains address of top of stack */ +#define FP_REGNUM 15 /* Contains address of executing stack frame */ +#define PC_REGNUM 16 /* Contains program counter */ +#define PS_REGNUM 17 /* Contains processor status */ + +/* The magic numbers below are offsets into u_ar0 in the user struct. + * They live in <machine/reg.h>. Gdb calls this macro with blockend + * holding u.u_ar0 - KERNEL_U_ADDR. Only the registers listed are + * saved in the u area (along with a few others that aren't useful + * here. See <machine/reg.h>). + */ + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ struct user foo; /* needed for finding fpu regs */ \ +switch (regno) { \ + case 0: \ + addr = blockend + EAX * sizeof(int); break; \ + case 1: \ + addr = blockend + EDX * sizeof(int); break; \ + case 2: \ + addr = blockend + ECX * sizeof(int); break; \ + case 3: /* st(0) */ \ + addr = blockend - \ + ((int)&foo.u_fpusave.fpu_stack[0][0] - (int)&foo); \ + break; \ + case 4: /* st(1) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[1][0] - (int)&foo); \ + break; \ + case 5: \ + addr = blockend + EBX * sizeof(int); break; \ + case 6: \ + addr = blockend + ESI * sizeof(int); break; \ + case 7: \ + addr = blockend + EDI * sizeof(int); break; \ + case 8: /* st(2) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[2][0] - (int)&foo); \ + break; \ + case 9: /* st(3) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[3][0] - (int)&foo); \ + break; \ + case 10: /* st(4) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[4][0] - (int)&foo); \ + break; \ + case 11: /* st(5) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[5][0] - (int)&foo); \ + break; \ + case 12: /* st(6) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[6][0] - (int)&foo); \ + break; \ + case 13: /* st(7) */ \ + addr = blockend - \ + ((int) &foo.u_fpusave.fpu_stack[7][0] - (int)&foo); \ + break; \ + case 14: \ + addr = blockend + ESP * sizeof(int); break; \ + case 15: \ + addr = blockend + EBP * sizeof(int); break; \ + case 16: \ + addr = blockend + EIP * sizeof(int); break; \ + case 17: \ + addr = blockend + FLAGS * sizeof(int); break; \ + case 18: /* fp1 */ \ + case 19: /* fp2 */ \ + case 20: /* fp3 */ \ + case 21: /* fp4 */ \ + case 22: /* fp5 */ \ + case 23: /* fp6 */ \ + case 24: /* fp7 */ \ + case 25: /* fp8 */ \ + case 26: /* fp9 */ \ + case 27: /* fp10 */ \ + case 28: /* fp11 */ \ + case 29: /* fp12 */ \ + case 30: /* fp13 */ \ + case 31: /* fp14 */ \ + case 32: /* fp15 */ \ + case 33: /* fp16 */ \ + case 34: /* fp17 */ \ + case 35: /* fp18 */ \ + case 36: /* fp19 */ \ + case 37: /* fp20 */ \ + case 38: /* fp21 */ \ + case 39: /* fp22 */ \ + case 40: /* fp23 */ \ + case 41: /* fp24 */ \ + case 42: /* fp25 */ \ + case 43: /* fp26 */ \ + case 44: /* fp27 */ \ + case 45: /* fp28 */ \ + case 46: /* fp29 */ \ + case 47: /* fp30 */ \ + case 48: /* fp31 */ \ + addr = blockend - \ + ((int) &foo.u_fpasave.fpa_regs[(regno)-18] - (int)&foo); \ + } \ +} + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +/* 10 i386 registers, 8 i387 registers, and 31 Weitek 1167 registers */ +#define REGISTER_BYTES ((10 * 4) + (8 * 10) + (31 * 4)) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) \ +((N < 3) ? (N * 4) : \ +(N < 5) ? (((N - 2) * 10) + 2) : \ +(N < 8) ? (((N - 5) * 4) + 32) : \ +(N < 14) ? (((N - 8) * 10) + 44) : \ + (((N - 14) * 4) + 104)) + +/* Number of bytes of storage in the actual machine representation + * for register N. All registers are 4 bytes, except 387 st(0) - st(7), + * which are 80 bits each. + */ + +#define REGISTER_RAW_SIZE(N) \ +((N < 3) ? 4 : \ +(N < 5) ? 10 : \ +(N < 8) ? 4 : \ +(N < 14) ? 10 : \ + 4) + +/* Number of bytes of storage in the program's representation + for register N. On the vax, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) 4 + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 10 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) \ +((N < 3) ? 0 : \ +(N < 5) ? 1 : \ +(N < 8) ? 0 : \ +(N < 14) ? 1 : \ + 0) + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ +((REGNUM < 3) ? bcopy ((FROM), (TO), 4) : \ +(REGNUM < 5) ? i387_to_double((FROM), (TO)) : \ +(REGNUM < 8) ? bcopy ((FROM), (TO), 4) : \ +(REGNUM < 14) ? i387_to_double((FROM), (TO)) : \ + bcopy ((FROM), (TO), 4)) + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ +((REGNUM < 3) ? bcopy ((FROM), (TO), 4) : \ +(REGNUM < 5) ? double_to_i387((FROM), (TO)) : \ +(REGNUM < 8) ? bcopy ((FROM), (TO), 4) : \ +(REGNUM < 14) ? double_to_i387((FROM), (TO)) : \ + bcopy ((FROM), (TO), 4)) + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ +((N < 3) ? builtin_type_int : \ +(N < 5) ? builtin_type_double : \ +(N < 8) ? builtin_type_int : \ +(N < 14) ? builtin_type_double : \ + builtin_type_int) + +/* from m-i386.h */ +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { (SP) -= sizeof (ADDR); \ + write_memory ((SP), &(ADDR), sizeof (ADDR)); \ + write_register(0, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + symmetry_extract_return_value(TYPE, REGBUF, VALBUF) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* On Symmetry, %ebp points to caller's %ebp, and the return address + is right on top of that. +*/ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) \ + (FRAMELESS) = frameless_look_for_prologue(FI) + +#define FRAME_SAVED_PC(fi) (read_memory_integer((fi)->frame + 4, 4)) + +#define FRAME_ARGS_ADDRESS(fi) ((fi)->frame) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. + + The weirdness in the "addl $imm8" case is due to gcc sometimes + issuing "addl $-int" after function call returns; this would + produce ridiculously huge arg counts. */ + +#define FRAME_NUM_ARGS(numargs, fi) \ +{ \ + int op = read_memory_integer(FRAME_SAVED_PC((fi)), 4); \ + int narg; \ + if ((op & 0xff) == 0x59) /* 0x59 'popl %ecx' */ \ + { \ + numargs = 1; \ + } \ + else if ((op & 0xffff) == 0xc483) /* 0xc483 'addl $imm8' */ \ + { \ + narg = ((op >> 16) & 0xff); \ + numargs = (narg >= 128) ? -1 : narg / 4; \ + } \ + else if ((op & 0xffff) == 0xc481) /* 0xc481 'addl $imm32' */ \ + { \ + narg = read_memory_integer(FRAME_SAVED_PC((fi))+2,4); \ + numargs = (narg < 0) ? -1 : narg / 4; \ + } \ + else \ + { \ + numargs = -1; \ + } \ +} + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ i386_frame_find_saved_regs ((frame_info), &(frame_saved_regs)); } + + +/* Things needed for making the inferior call functions. */ + +#define PUSH_DUMMY_FRAME \ +{ CORE_ADDR sp = read_register (SP_REGNUM); \ + int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = 0; regnum < NUM_REGS; regnum++) \ + sp = push_word (sp, read_register (regnum)); \ + write_register (SP_REGNUM, sp); \ +} + +#define POP_FRAME \ +{ \ + FRAME frame = get_current_frame (); \ + CORE_ADDR fp; \ + int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = 0; regnum < NUM_REGS; regnum++) { \ + CORE_ADDR adr; \ + adr = fsr.regs[regnum]; \ + if (adr) \ + write_register (regnum, read_memory_integer (adr, 4)); \ + } \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame ( create_new_frame (read_register (FP_REGNUM), \ + read_pc ())); \ +} + +/* from i386-dep.c, worked better than my original... */ +/* This sequence of words is the instructions + * call (32-bit offset) + * int 3 + * This is 6 bytes. + */ + +#define CALL_DUMMY { 0x223344e8, 0xcc11 } + +#define CALL_DUMMY_LENGTH 8 + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + int from, to, delta, loc; \ + loc = (int)(read_register (SP_REGNUM) - CALL_DUMMY_LENGTH); \ + from = loc + 5; \ + to = (int)(fun); \ + delta = to - from; \ + *(int *)((char *)(dummyname) + 1) = delta; \ +} diff --git a/gdb/tm-umax.h b/gdb/tm-umax.h new file mode 100644 index 0000000..4929065 --- /dev/null +++ b/gdb/tm-umax.h @@ -0,0 +1,405 @@ +/* Definitions to make GDB run on an encore under umax 4.2 + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Exec files and symbol tables are in COFF format */ + +#define COFF_FORMAT + +/* Need to get function ends by adding this to epilogue address from .bf + record, not using x_fsize field. */ +#define FUNCTION_EPILOGUE_SIZE 4 + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 0 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ +{ register unsigned char op = read_memory_integer (pc, 1); \ + if (op == 0x82) { op = read_memory_integer (pc+2,1); \ + if ((op & 0x80) == 0) pc += 3; \ + else if ((op & 0xc0) == 0x80) pc += 4; \ + else pc += 6; \ + } \ +} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) \ + read_memory_integer (read_register (SP_REGNUM), 4) + +/* Address of end of stack space. */ + +#define STACK_END_ADDR (0xfffff000) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {0xf2} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 0x12) + +#ifndef NaN +#include <nan.h> +#endif NaN + +/* Return 1 if P points to an invalid floating point value. */ +/* Surely wrong for cross-debugging. */ +#define INVALID_FLOAT(p, s) \ + ((s == sizeof (float))? \ + NaF (*(float *) p) : \ + NaD (*(double *) p)) + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 25 + +#define NUM_GENERAL_REGS 8 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", \ + "f0", "f1", "f2", "f3", "f4", "f5", "f6", "f7", \ + "sp", "fp", "pc", "ps", \ + "fsr", \ + "l0", "l1", "l2", "l3", "xx", \ + } + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define FP0_REGNUM 8 /* Floating point register 0 */ +#define SP_REGNUM 16 /* Contains address of top of stack */ +#define AP_REGNUM FP_REGNUM +#define FP_REGNUM 17 /* Contains address of executing stack frame */ +#define PC_REGNUM 18 /* Contains program counter */ +#define PS_REGNUM 19 /* Contains processor status */ +#define FPS_REGNUM 20 /* Floating point status register */ +#define LP0_REGNUM 21 /* Double register 0 (same as FP0) */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES ((NUM_REGS - 4) * sizeof (int) + 4 * sizeof (double)) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) >= LP0_REGNUM ? \ + LP0_REGNUM * 4 + ((N) - LP0_REGNUM) * 8 : (N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the 32000, all regs are 4 bytes + except for the doubled floating registers. */ + +#define REGISTER_RAW_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4) + +/* Number of bytes of storage in the program's representation + for register N. On the 32000, all regs are 4 bytes + except for the doubled floating registers. */ + +#define REGISTER_VIRTUAL_SIZE(N) ((N) >= LP0_REGNUM ? 8 : 4) + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 8 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 8 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), REGISTER_VIRTUAL_SIZE(REGNUM)); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) \ + (((N) < FP0_REGNUM) ? \ + builtin_type_int : \ + ((N) < FP0_REGNUM + 8) ? \ + builtin_type_float : \ + ((N) < LP0_REGNUM) ? \ + builtin_type_int : \ + builtin_type_double) + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. + + On this machine this is a no-op, because gcc isn't used on it + yet. So this calling convention is not used. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF+REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (REGISTER_BYTE (TYPE_CODE (TYPE) == TYPE_CODE_FLT ? FP0_REGNUM : 0), VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the ns32000 series, the frame's nominal address is the FP + value, and at that address is saved previous FP value as a 4-byte word. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 4, 4)) + +/* Compute base of arguments. */ + +#define FRAME_ARGS_ADDRESS(fi) \ + ((ns32k_get_enter_addr ((fi)->pc) > 1) ? \ + ((fi)->frame) : (read_register (SP_REGNUM) - 4)) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Get the address of the enter opcode for this function, if it is active. + Returns positive address > 1 if pc is between enter/exit, + 1 if pc before enter or after exit, 0 otherwise. */ + +#ifndef CORE_ADDR +#include "defs.h" /* Make sure CORE_ADDR is defined. */ +#endif + +extern CORE_ADDR ns32k_get_enter_addr (); + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. + Encore's C compiler often reuses same area on stack for args, + so this will often not work properly. If the arg names + are known, it's likely most of them will be printed. */ + +#define FRAME_NUM_ARGS(numargs, fi) \ +{ CORE_ADDR pc; \ + CORE_ADDR enter_addr; \ + unsigned int insn; \ + unsigned int addr_mode; \ + int width; \ + \ + numargs = -1; \ + enter_addr = ns32k_get_enter_addr ((fi)->pc); \ + if (enter_addr > 0) \ + { \ + pc = (enter_addr == 1) ? \ + SAVED_PC_AFTER_CALL (fi) : \ + FRAME_SAVED_PC (fi); \ + insn = read_memory_integer (pc,2); \ + addr_mode = (insn >> 11) & 0x1f; \ + insn = insn & 0x7ff; \ + if ((insn & 0x7fc) == 0x57c && \ + addr_mode == 0x14) /* immediate */ \ + { \ + if (insn == 0x57c) /* adjspb */ \ + width = 1; \ + else if (insn == 0x57d) /* adjspw */ \ + width = 2; \ + else if (insn == 0x57f) /* adjspd */ \ + width = 4; \ + numargs = read_memory_integer (pc+2,width); \ + if (width > 1) \ + flip_bytes (&numargs, width); \ + numargs = - sign_extend (numargs, width*8) / 4;\ + } \ + } \ +} + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 8 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ \ + register int regmask, regnum; \ + int localcount; \ + register CORE_ADDR enter_addr; \ + register CORE_ADDR next_addr; \ + \ + bzero (&(frame_saved_regs), sizeof (frame_saved_regs)); \ + enter_addr = ns32k_get_enter_addr ((frame_info)->pc); \ + if (enter_addr > 1) \ + { \ + regmask = read_memory_integer (enter_addr+1, 1) & 0xff; \ + localcount = ns32k_localcount (enter_addr); \ + next_addr = (frame_info)->frame + localcount; \ + for (regnum = 0; regnum < 8; regnum++, regmask >>= 1) \ + (frame_saved_regs).regs[regnum] = (regmask & 1) ? \ + (next_addr -= 4) : 0; \ + (frame_saved_regs).regs[SP_REGNUM] = (frame_info)->frame + 4;\ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 4;\ + (frame_saved_regs).regs[FP_REGNUM] = \ + (read_memory_integer ((frame_info)->frame, 4));\ + } \ + else if (enter_addr == 1) \ + { \ + CORE_ADDR sp = read_register (SP_REGNUM); \ + (frame_saved_regs).regs[PC_REGNUM] = sp; \ + (frame_saved_regs).regs[SP_REGNUM] = sp + 4; \ + } \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM);\ + register int regnum; \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + write_register (FP_REGNUM, sp); \ + for (regnum = 0; regnum < 8; regnum++) \ + sp = push_word (sp, read_register (regnum)); \ + write_register (SP_REGNUM, sp); \ +} + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register FRAME frame = get_current_frame (); \ + register CORE_ADDR fp; \ + register int regnum; \ + struct frame_saved_regs fsr; \ + struct frame_info *fi; \ + fi = get_frame_info (frame); \ + fp = fi->frame; \ + get_frame_saved_regs (fi, &fsr); \ + for (regnum = 0; regnum < 8; regnum++) \ + if (fsr.regs[regnum]) \ + write_register (regnum, read_memory_integer (fsr.regs[regnum], 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp, 4)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 4, 4)); \ + write_register (SP_REGNUM, fp + 8); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions + enter 0xff,0 82 ff 00 + jsr @0x00010203 7f ae c0 01 02 03 + adjspd 0x69696969 7f a5 01 02 03 04 + bpt f2 + Note this is 16 bytes. */ + +#define CALL_DUMMY { 0x7f00ff82, 0x0201c0ae, 0x01a57f03, 0xf2040302 } + +#define CALL_DUMMY_START_OFFSET 3 +#define CALL_DUMMY_LENGTH 16 +#define CALL_DUMMY_ADDR 5 +#define CALL_DUMMY_NARGS 11 + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ \ + int flipped; \ + flipped = fun | 0xc0000000; \ + flip_bytes (&flipped, 4); \ + *((int *) (((char *) dummyname)+CALL_DUMMY_ADDR)) = flipped; \ + flipped = - nargs * 4; \ + flip_bytes (&flipped, 4); \ + *((int *) (((char *) dummyname)+CALL_DUMMY_NARGS)) = flipped; \ +} diff --git a/gdb/tm-vax.h b/gdb/tm-vax.h new file mode 100644 index 0000000..c7a91b4 --- /dev/null +++ b/gdb/tm-vax.h @@ -0,0 +1,377 @@ +/* Definitions to make GDB run on a vax under 4.2bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* There is one known bug with VAX support that I don't know how to + fix: if you do a backtrace from a signal handler, you get something + like: +#0 0xbc in kill (592, 3) +#1 0x7f in hand (...) (...) +#2 0x7fffec7e in ?? (2, 0, 2147478112, 94) + ^^ GDB doesn't know about sigtramp +#3 0x7fffec70 in ?? (592, 2) + ^^^^^^^^^^ wrong address +#4 0xae in main (...) (...) + +when the correct backtrace (as given by adb) is: +_kill(250,3) from _hand+21 +_hand(2,0,7fffea60,5e) from 7fffec7e +sigtramp(2,0,7fffea60,5e) from _kill+4 +_kill(250,2) from _main+2e +_main(1,7fffeac4,7fffeacc) from start+3d + +If anyone knows enough about VAX BSD to fix this, please send the +fix to bug-gdb@prep.ai.mit.edu. */ + +#define TARGET_BYTE_ORDER LITTLE_ENDIAN + +/* Define this if the C compiler puts an underscore at the front + of external names before giving them to the linker. */ + +#define NAMES_HAVE_UNDERSCORE + +/* Debugger information will be in DBX format. */ + +#define READ_DBX_FORMAT + +/* Offset from address of function to start of its code. + Zero on most machines. */ + +#define FUNCTION_START_OFFSET 2 + +/* Advance PC across any function entry prologue instructions + to reach some "real" code. */ + +#define SKIP_PROLOGUE(pc) \ +{ register int op = (unsigned char) read_memory_integer (pc, 1); \ + if (op == 0x11) pc += 2; /* skip brb */ \ + if (op == 0x31) pc += 3; /* skip brw */ \ + if (op == 0xC2 && \ + ((unsigned char) read_memory_integer (pc+2, 1)) == 0x5E) \ + pc += 3; /* skip subl2 */ \ + if (op == 0x9E && \ + ((unsigned char) read_memory_integer (pc+1, 1)) == 0xAE && \ + ((unsigned char) read_memory_integer(pc+3, 1)) == 0x5E) \ + pc += 4; /* skip movab */ \ + if (op == 0x9E && \ + ((unsigned char) read_memory_integer (pc+1, 1)) == 0xCE && \ + ((unsigned char) read_memory_integer(pc+4, 1)) == 0x5E) \ + pc += 5; /* skip movab */ \ + if (op == 0x9E && \ + ((unsigned char) read_memory_integer (pc+1, 1)) == 0xEE && \ + ((unsigned char) read_memory_integer(pc+6, 1)) == 0x5E) \ + pc += 7; /* skip movab */ \ +} + +/* Immediately after a function call, return the saved pc. + Can't always go through the frames for this because on some machines + the new frame is not set up until the new function executes + some instructions. */ + +#define SAVED_PC_AFTER_CALL(frame) FRAME_SAVED_PC(frame) + +#define TARGET_UPAGES 10 +#define TARGET_NBPG 512 +#define STACK_END_ADDR (0x80000000 - (TARGET_UPAGES * TARGET_NBPG)) + +/* On the VAX, sigtramp is in the u area. Can't check the exact + addresses because for cross-debugging we don't have VAX include + files around. This should be close enough. */ +#define IN_SIGTRAMP(pc, name) ((pc) >= STACK_END_ADDR && (pc < 0x80000000)) + +/* Stack grows downward. */ + +#define INNER_THAN < + +/* Sequence of bytes for breakpoint instruction. */ + +#define BREAKPOINT {3} + +/* Amount PC must be decremented by after a breakpoint. + This is often the number of bytes in BREAKPOINT + but not always. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* Nonzero if instruction at PC is a return instruction. */ + +#define ABOUT_TO_RETURN(pc) (read_memory_integer (pc, 1) == 04) + +/* Return 1 if P points to an invalid floating point value. + LEN is the length in bytes -- not relevant on the Vax. */ + +#define INVALID_FLOAT(p, len) ((*(short *) p & 0xff80) == 0x8000) + +/* Say how long (ordinary) registers are. */ + +#define REGISTER_TYPE long + +/* Number of machine registers */ + +#define NUM_REGS 17 + +/* Initializer for an array of names of registers. + There should be NUM_REGS strings in this initializer. */ + +#define REGISTER_NAMES {"r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "ap", "fp", "sp", "pc", "ps"} + +/* Register numbers of various important registers. + Note that some of these values are "real" register numbers, + and correspond to the general registers of the machine, + and some are "phony" register numbers which are too large + to be actual register numbers as far as the user is concerned + but do serve to get the desired values when passed to read_register. */ + +#define AP_REGNUM 12 +#define FP_REGNUM 13 /* Contains address of executing stack frame */ +#define SP_REGNUM 14 /* Contains address of top of stack */ +#define PC_REGNUM 15 /* Contains program counter */ +#define PS_REGNUM 16 /* Contains processor status */ + +/* Total amount of space needed to store our copies of the machine's + register state, the array `registers'. */ +#define REGISTER_BYTES (17*4) + +/* Index within `registers' of the first byte of the space for + register N. */ + +#define REGISTER_BYTE(N) ((N) * 4) + +/* Number of bytes of storage in the actual machine representation + for register N. On the vax, all regs are 4 bytes. */ + +#define REGISTER_RAW_SIZE(N) 4 + +/* Number of bytes of storage in the program's representation + for register N. On the vax, all regs are 4 bytes. */ + +#define REGISTER_VIRTUAL_SIZE(N) 4 + +/* Largest value REGISTER_RAW_SIZE can have. */ + +#define MAX_REGISTER_RAW_SIZE 4 + +/* Largest value REGISTER_VIRTUAL_SIZE can have. */ + +#define MAX_REGISTER_VIRTUAL_SIZE 4 + +/* Nonzero if register N requires conversion + from raw format to virtual format. */ + +#define REGISTER_CONVERTIBLE(N) 0 + +/* Convert data from raw format for register REGNUM + to virtual format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_VIRTUAL(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Convert data from virtual format for register REGNUM + to raw format for register REGNUM. */ + +#define REGISTER_CONVERT_TO_RAW(REGNUM,FROM,TO) \ + bcopy ((FROM), (TO), 4); + +/* Return the GDB type object for the "standard" data type + of data in register N. */ + +#define REGISTER_VIRTUAL_TYPE(N) builtin_type_int + +/* Store the address of the place in which to copy the structure the + subroutine will return. This is called from call_function. */ + +#define STORE_STRUCT_RETURN(ADDR, SP) \ + { write_register (1, (ADDR)); } + +/* Extract from an array REGBUF containing the (raw) register state + a function return value of type TYPE, and copy that, in virtual format, + into VALBUF. */ + +#define EXTRACT_RETURN_VALUE(TYPE,REGBUF,VALBUF) \ + bcopy (REGBUF, VALBUF, TYPE_LENGTH (TYPE)) + +/* Write into appropriate registers a function return value + of type TYPE, given in virtual format. */ + +#define STORE_RETURN_VALUE(TYPE,VALBUF) \ + write_register_bytes (0, VALBUF, TYPE_LENGTH (TYPE)) + +/* Extract from an array REGBUF containing the (raw) register state + the address in which a function should return its structure value, + as a CORE_ADDR (or an expression that can be used as one). */ + +#define EXTRACT_STRUCT_VALUE_ADDRESS(REGBUF) (*(int *)(REGBUF)) + + +/* Describe the pointer in each stack frame to the previous stack frame + (its caller). */ + +/* FRAME_CHAIN takes a frame's nominal address + and produces the frame's chain-pointer. + + FRAME_CHAIN_COMBINE takes the chain pointer and the frame's nominal address + and produces the nominal address of the caller frame. + + However, if FRAME_CHAIN_VALID returns zero, + it means the given frame is the outermost one and has no caller. + In that case, FRAME_CHAIN_COMBINE is not used. */ + +/* In the case of the Vax, the frame's nominal address is the FP value, + and 12 bytes later comes the saved previous FP value as a 4-byte word. */ + +#define FRAME_CHAIN(thisframe) \ + (outside_startup_file ((thisframe)->pc) ? \ + read_memory_integer ((thisframe)->frame + 12, 4) :\ + 0) + +#define FRAME_CHAIN_VALID(chain, thisframe) \ + (chain != 0 && (outside_startup_file (FRAME_SAVED_PC (thisframe)))) + +#define FRAME_CHAIN_COMBINE(chain, thisframe) (chain) + +/* Define other aspects of the stack frame. */ + +/* A macro that tells us whether the function invocation represented + by FI does not have a frame on the stack associated with it. If it + does not, FRAMELESS is set to 1, else 0. */ +/* On the vax, all functions have frames. */ +#define FRAMELESS_FUNCTION_INVOCATION(FI, FRAMELESS) {(FRAMELESS) = 0;} + +/* Saved Pc. */ + +#define FRAME_SAVED_PC(FRAME) (read_memory_integer ((FRAME)->frame + 16, 4)) + +/* Cannot find the AP register value directly from the FP value. Must + find it saved in the frame called by this one, or in the AP + register for the innermost frame. However, there is no way to tell + the difference between the innermost frame and a frame for which we + just don't know the frame that it called (e.g. "info frame + 0x7ffec789"). For the sake of argument suppose that the stack is + somewhat trashed (which is one reason that "info frame" exists). + So return 0 (indicating we don't know the address of + the arglist) if we don't know what frame this frame calls. */ +#define FRAME_ARGS_ADDRESS_CORRECT(fi) \ + (((fi)->next_frame \ + ? read_memory_integer ((fi)->next_frame + 8, 4) \ + : /* read_register (AP_REGNUM) */ 0)) + +/* In most of GDB, getting the args address is too important to + just say "I don't know". This is sometimes wrong for functions + that aren't on top of the stack, but c'est la vie. */ +#define FRAME_ARGS_ADDRESS(fi) \ + (((fi)->next_frame \ + ? read_memory_integer ((fi)->next_frame + 8, 4) \ + : read_register (AP_REGNUM) /* 0 */)) + +#define FRAME_LOCALS_ADDRESS(fi) ((fi)->frame) + +/* Return number of args passed to a frame. + Can return -1, meaning no way to tell. */ + +#define FRAME_NUM_ARGS(numargs, fi) \ +{ numargs = (0xff & read_memory_integer (FRAME_ARGS_ADDRESS (fi), 1)); } + +/* Return number of bytes at start of arglist that are not really args. */ + +#define FRAME_ARGS_SKIP 4 + +/* Put here the code to store, into a struct frame_saved_regs, + the addresses of the saved registers of frame described by FRAME_INFO. + This includes special registers such as pc and fp saved in special + ways in the stack frame. sp is even more special: + the address we return for it IS the sp for the next frame. */ + +#define FRAME_FIND_SAVED_REGS(frame_info, frame_saved_regs) \ +{ register int regnum; \ + register int regmask = read_memory_integer ((frame_info)->frame+4, 4) >> 16; \ + register CORE_ADDR next_addr; \ + bzero (&frame_saved_regs, sizeof frame_saved_regs); \ + next_addr = (frame_info)->frame + 16; \ + /* Regmask's low bit is for register 0, \ + which is the first one that would be pushed. */ \ + for (regnum = 0; regnum < 12; regnum++, regmask >>= 1) \ + (frame_saved_regs).regs[regnum] = (regmask & 1) ? (next_addr += 4) : 0; \ + (frame_saved_regs).regs[SP_REGNUM] = next_addr + 4; \ + if (read_memory_integer ((frame_info)->frame + 4, 4) & 0x20000000) \ + (frame_saved_regs).regs[SP_REGNUM] += 4 + 4 * read_memory_integer (next_addr + 4, 4); \ + (frame_saved_regs).regs[PC_REGNUM] = (frame_info)->frame + 16; \ + (frame_saved_regs).regs[FP_REGNUM] = (frame_info)->frame + 12; \ + (frame_saved_regs).regs[AP_REGNUM] = (frame_info)->frame + 8; \ + (frame_saved_regs).regs[PS_REGNUM] = (frame_info)->frame + 4; \ +} + +/* Things needed for making the inferior call functions. */ + +/* Push an empty stack frame, to record the current PC, etc. */ + +#define PUSH_DUMMY_FRAME \ +{ register CORE_ADDR sp = read_register (SP_REGNUM);\ + register int regnum; \ + sp = push_word (sp, 0); /* arglist */ \ + for (regnum = 11; regnum >= 0; regnum--) \ + sp = push_word (sp, read_register (regnum)); \ + sp = push_word (sp, read_register (PC_REGNUM)); \ + sp = push_word (sp, read_register (FP_REGNUM)); \ + sp = push_word (sp, read_register (AP_REGNUM)); \ + sp = push_word (sp, (read_register (PS_REGNUM) & 0xffef) \ + + 0x2fff0000); \ + sp = push_word (sp, 0); \ + write_register (SP_REGNUM, sp); \ + write_register (FP_REGNUM, sp); \ + write_register (AP_REGNUM, sp + 17 * sizeof (int)); } + +/* Discard from the stack the innermost frame, restoring all registers. */ + +#define POP_FRAME \ +{ register CORE_ADDR fp = read_register (FP_REGNUM); \ + register int regnum; \ + register int regmask = read_memory_integer (fp + 4, 4); \ + write_register (PS_REGNUM, \ + (regmask & 0xffff) \ + | (read_register (PS_REGNUM) & 0xffff0000)); \ + write_register (PC_REGNUM, read_memory_integer (fp + 16, 4)); \ + write_register (FP_REGNUM, read_memory_integer (fp + 12, 4)); \ + write_register (AP_REGNUM, read_memory_integer (fp + 8, 4)); \ + fp += 16; \ + for (regnum = 0; regnum < 12; regnum++) \ + if (regmask & (0x10000 << regnum)) \ + write_register (regnum, read_memory_integer (fp += 4, 4)); \ + fp = fp + 4 + ((regmask >> 30) & 3); \ + if (regmask & 0x20000000) \ + { regnum = read_memory_integer (fp, 4); \ + fp += (regnum + 1) * 4; } \ + write_register (SP_REGNUM, fp); \ + flush_cached_frames (); \ + set_current_frame (create_new_frame (read_register (FP_REGNUM),\ + read_pc ())); } + +/* This sequence of words is the instructions + calls #69, @#32323232 + bpt + Note this is 8 bytes. */ + +#define CALL_DUMMY {0x329f69fb, 0x03323232} + +#define CALL_DUMMY_START_OFFSET 0 /* Start execution at beginning of dummy */ + +/* Insert the specified number of args and function address + into a call sequence of the above form stored at DUMMYNAME. */ + +#define FIX_CALL_DUMMY(dummyname, pc, fun, nargs, args, type, gcc_p) \ +{ *((char *) dummyname + 1) = nargs; \ + *(int *)((char *) dummyname + 3) = fun; } diff --git a/gdb/tm-vxworks68.h b/gdb/tm-vxworks68.h new file mode 100755 index 0000000..a3cd7c2 --- /dev/null +++ b/gdb/tm-vxworks68.h @@ -0,0 +1,48 @@ +/* Parameters for execution on VxWorks 68k's, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + Contributed by Cygnus Support. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define GDBINIT_FILENAME ".vxgdbinit" + +#define DEFAULT_PROMPT "(vxgdb) " + +/* Kludge... */ +#include "tm-sun3.h" + +/* We have more complex, useful breakpoints on the target. */ +#undef DECR_PC_AFTER_BREAK +#define DECR_PC_AFTER_BREAK 0 + +/* We are guaranteed to have a zero frame pointer at bottom of stack, too. */ +#undef FRAME_CHAIN +#undef FRAME_CHAIN_VALID + +/* Takes the current frame-struct pointer and returns the chain-pointer + to get to the calling frame. + + If our current frame pointer is zero, we're at the top; else read out + the saved FP from memory pointed to by the current FP. */ + +#define FRAME_CHAIN(thisframe) ((thisframe)->frame? read_memory_integer ((thisframe)->frame, 4): 0) + +/* If the chain pointer is zero (either because the saved value fetched + by FRAME_CHAIN was zero, or because the current FP was zero so FRAME_CHAIN + never fetched anything), we are at the top of the stack. */ + +#define FRAME_CHAIN_VALID(chain, thisframe) (chain != 0) diff --git a/gdb/tm-vxworks960.h b/gdb/tm-vxworks960.h new file mode 100755 index 0000000..fc5c214 --- /dev/null +++ b/gdb/tm-vxworks960.h @@ -0,0 +1,48 @@ +/* Parameters for VxWorks Intel 960's, for GDB, the GNU debugger. + Copyright (C) 1986-1991 Free Software Foundation, Inc. + Contributed by Cygnus Support. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "tm-i960.h" + +#define GDBINIT_FILENAME ".vxgdbinit" + +#define DEFAULT_PROMPT "(vxgdb) " + +/* We have more complex, useful breakpoints on the target. + Amount ip must be decremented by after a breakpoint. */ + +#define DECR_PC_AFTER_BREAK 0 + +/* We are guaranteed to have a zero frame pointer at bottom of stack, too. */ + +#define FRAME_CHAIN_VALID(chain, thisframe) (chain != 0) + +/* Breakpoint patching is handled at the target end in VxWorks. */ +/* #define BREAKPOINT {0x00, 0x3e, 0x00, 0x66} */ + +/* Not needed, because we don't support core files: + #define KERNEL_U_ADDR + #define REGISTER_U_ADDR(addr, blockend, regno) + */ + +/* Address of end of stack space. + This doesn't matter for VxWorks, because it's only used + in manipulation of core files, which we don't support. */ + +/* #define STACK_END_ADDR (0xfe000000) */ diff --git a/gdb/umax-xdep.c b/gdb/umax-xdep.c new file mode 100644 index 0000000..f3504da --- /dev/null +++ b/gdb/umax-xdep.c @@ -0,0 +1,139 @@ +/* umax host stuff. + Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include "defs.h" +#include "param.h" +#include "frame.h" +#include "inferior.h" + +#include <sys/param.h> +#include <sys/dir.h> +#include <signal.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#include "gdbcore.h" +#include <sys/ptrace.h> +#define PTRACE_ATTACH PT_ATTACH +#define PTRACE_DETACH PT_FREEPROC + +#include <sys/file.h> +#include <sys/stat.h> + +/* Work with core dump and executable files, for GDB. + This code would be in core.c if it weren't machine-dependent. */ + +void +core_file_command (filename, from_tty) + char *filename; + int from_tty; +{ + int val; + extern char registers[]; + + /* Discard all vestiges of any previous core file + and mark data and stack spaces as empty. */ + + if (corefile) + free (corefile); + corefile = 0; + + if (corechan >= 0) + close (corechan); + corechan = -1; + + data_start = 0; + data_end = 0; + stack_start = STACK_END_ADDR; + stack_end = STACK_END_ADDR; + + /* Now, if a new core file was specified, open it and digest it. */ + + if (filename) + { + filename = tilde_expand (filename); + make_cleanup (free, filename); + + if (have_inferior_p ()) + error ("To look at a core file, you must kill the inferior with \"kill\"."); + corechan = open (filename, O_RDONLY, 0); + if (corechan < 0) + perror_with_name (filename); + /* 4.2-style (and perhaps also sysV-style) core dump file. */ + { + struct ptrace_user u; + int reg_offset; + + val = myread (corechan, &u, sizeof u); + if (val < 0) + perror_with_name (filename); + data_start = exec_data_start; + + data_end = data_start + u.pt_dsize; + stack_start = stack_end - u.pt_ssize; + data_offset = sizeof u; + stack_offset = data_offset + u.pt_dsize; + reg_offset = 0; + + bcopy (&u.pt_aouthdr, &core_aouthdr, sizeof (AOUTHDR)); + printf ("Core file is from \"%s\".\n", u.pt_comm); + if (u.pt_signal > 0) + printf ("Program terminated with signal %d, %s.\n", + u.pt_signal, + u.pt_signal < NSIG + ? sys_siglist[u.pt_signal] + : "(undocumented)"); + + /* Read the register values out of the core file and store + them where `read_register' will find them. */ + + { + register int regno; + + for (regno = 0; regno < NUM_REGS; regno++) + { + char buf[MAX_REGISTER_RAW_SIZE]; + + val = lseek (corechan, register_addr (regno, reg_offset), 0); + if (val < 0) + perror_with_name (filename); + + val = myread (corechan, buf, sizeof buf); + if (val < 0) + perror_with_name (filename); + supply_register (regno, buf); + } + } + } + if (filename[0] == '/') + corefile = savestring (filename, strlen (filename)); + else + { + corefile = concat (current_directory, "/", filename); + } + + set_current_frame ( create_new_frame (read_register (FP_REGNUM), + read_pc ())); + select_frame (get_current_frame (), 0); + validate_files (); + } + else if (from_tty) + printf ("No core file now.\n"); +} diff --git a/gdb/values.c b/gdb/values.c new file mode 100644 index 0000000..39ec8ea --- /dev/null +++ b/gdb/values.c @@ -0,0 +1,1337 @@ +/* Low level packing and unpacking of values for GDB. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> +#include <string.h> +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "value.h" +#include "gdbcore.h" +#include "frame.h" +#include "command.h" + +/* The value-history records all the values printed + by print commands during this session. Each chunk + records 60 consecutive values. The first chunk on + the chain records the most recent values. + The total number of values is in value_history_count. */ + +#define VALUE_HISTORY_CHUNK 60 + +struct value_history_chunk +{ + struct value_history_chunk *next; + value values[VALUE_HISTORY_CHUNK]; +}; + +/* Chain of chunks now in use. */ + +static struct value_history_chunk *value_history_chain; + +static int value_history_count; /* Abs number of last entry stored */ + + +/* List of all value objects currently allocated + (except for those released by calls to release_value) + This is so they can be freed after each command. */ + +static value all_values; + +/* Allocate a value that has the correct length for type TYPE. */ + +value +allocate_value (type) + struct type *type; +{ + register value val; + + check_stub_type (type); + + val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type)); + VALUE_NEXT (val) = all_values; + all_values = val; + VALUE_TYPE (val) = type; + VALUE_LVAL (val) = not_lval; + VALUE_ADDRESS (val) = 0; + VALUE_FRAME (val) = 0; + VALUE_OFFSET (val) = 0; + VALUE_BITPOS (val) = 0; + VALUE_BITSIZE (val) = 0; + VALUE_REPEATED (val) = 0; + VALUE_REPETITIONS (val) = 0; + VALUE_REGNO (val) = -1; + VALUE_LAZY (val) = 0; + VALUE_OPTIMIZED_OUT (val) = 0; + return val; +} + +/* Allocate a value that has the correct length + for COUNT repetitions type TYPE. */ + +value +allocate_repeat_value (type, count) + struct type *type; + int count; +{ + register value val; + + val = (value) xmalloc (sizeof (struct value) + TYPE_LENGTH (type) * count); + VALUE_NEXT (val) = all_values; + all_values = val; + VALUE_TYPE (val) = type; + VALUE_LVAL (val) = not_lval; + VALUE_ADDRESS (val) = 0; + VALUE_FRAME (val) = 0; + VALUE_OFFSET (val) = 0; + VALUE_BITPOS (val) = 0; + VALUE_BITSIZE (val) = 0; + VALUE_REPEATED (val) = 1; + VALUE_REPETITIONS (val) = count; + VALUE_REGNO (val) = -1; + VALUE_LAZY (val) = 0; + VALUE_OPTIMIZED_OUT (val) = 0; + return val; +} + +/* Free all the values that have been allocated (except for those released). + Called after each command, successful or not. */ + +void +free_all_values () +{ + register value val, next; + + for (val = all_values; val; val = next) + { + next = VALUE_NEXT (val); + value_free (val); + } + + all_values = 0; +} + +/* Remove VAL from the chain all_values + so it will not be freed automatically. */ + +void +release_value (val) + register value val; +{ + register value v; + + if (all_values == val) + { + all_values = val->next; + return; + } + + for (v = all_values; v; v = v->next) + { + if (v->next == val) + { + v->next = val->next; + break; + } + } +} + +/* Return a copy of the value ARG. + It contains the same contents, for same memory address, + but it's a different block of storage. */ + +static value +value_copy (arg) + value arg; +{ + register value val; + register struct type *type = VALUE_TYPE (arg); + if (VALUE_REPEATED (arg)) + val = allocate_repeat_value (type, VALUE_REPETITIONS (arg)); + else + val = allocate_value (type); + VALUE_LVAL (val) = VALUE_LVAL (arg); + VALUE_ADDRESS (val) = VALUE_ADDRESS (arg); + VALUE_OFFSET (val) = VALUE_OFFSET (arg); + VALUE_BITPOS (val) = VALUE_BITPOS (arg); + VALUE_BITSIZE (val) = VALUE_BITSIZE (arg); + VALUE_REGNO (val) = VALUE_REGNO (arg); + VALUE_LAZY (val) = VALUE_LAZY (arg); + if (!VALUE_LAZY (val)) + { + bcopy (VALUE_CONTENTS_RAW (arg), VALUE_CONTENTS_RAW (val), + TYPE_LENGTH (VALUE_TYPE (arg)) + * (VALUE_REPEATED (arg) ? VALUE_REPETITIONS (arg) : 1)); + } + return val; +} + +/* Access to the value history. */ + +/* Record a new value in the value history. + Returns the absolute history index of the entry. + Result of -1 indicates the value was not saved; otherwise it is the + value history index of this new item. */ + +int +record_latest_value (val) + value val; +{ + int i; + + /* Check error now if about to store an invalid float. We return -1 + to the caller, but allow them to continue, e.g. to print it as "Nan". */ + if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FLT) { + (void) unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &i); + if (i) return -1; /* Indicate value not saved in history */ + } + + /* Here we treat value_history_count as origin-zero + and applying to the value being stored now. */ + + i = value_history_count % VALUE_HISTORY_CHUNK; + if (i == 0) + { + register struct value_history_chunk *new + = (struct value_history_chunk *) + xmalloc (sizeof (struct value_history_chunk)); + bzero (new->values, sizeof new->values); + new->next = value_history_chain; + value_history_chain = new; + } + + value_history_chain->values[i] = val; + release_value (val); + + /* Now we regard value_history_count as origin-one + and applying to the value just stored. */ + + return ++value_history_count; +} + +/* Return a copy of the value in the history with sequence number NUM. */ + +value +access_value_history (num) + int num; +{ + register struct value_history_chunk *chunk; + register int i; + register int absnum = num; + + if (absnum <= 0) + absnum += value_history_count; + + if (absnum <= 0) + { + if (num == 0) + error ("The history is empty."); + else if (num == 1) + error ("There is only one value in the history."); + else + error ("History does not go back to $$%d.", -num); + } + if (absnum > value_history_count) + error ("History has not yet reached $%d.", absnum); + + absnum--; + + /* Now absnum is always absolute and origin zero. */ + + chunk = value_history_chain; + for (i = (value_history_count - 1) / VALUE_HISTORY_CHUNK - absnum / VALUE_HISTORY_CHUNK; + i > 0; i--) + chunk = chunk->next; + + return value_copy (chunk->values[absnum % VALUE_HISTORY_CHUNK]); +} + +/* Clear the value history entirely. + Must be done when new symbol tables are loaded, + because the type pointers become invalid. */ + +void +clear_value_history () +{ + register struct value_history_chunk *next; + register int i; + register value val; + + while (value_history_chain) + { + for (i = 0; i < VALUE_HISTORY_CHUNK; i++) + if (val = value_history_chain->values[i]) + free (val); + next = value_history_chain->next; + free (value_history_chain); + value_history_chain = next; + } + value_history_count = 0; +} + +static void +value_history_info (num_exp, from_tty) + char *num_exp; + int from_tty; +{ + register int i; + register value val; + static int num = 1; + + if (num_exp) + { + if (num_exp[0] == '+' && num_exp[1] == '\0') + /* "info history +" should print from the stored position. */ + ; + else + /* "info history <exp>" should print around value number <exp>. */ + num = parse_and_eval_address (num_exp) - 5; + } + else + { + /* "info history" means print the last 10 values. */ + num = value_history_count - 9; + } + + if (num <= 0) + num = 1; + + for (i = num; i < num + 10 && i <= value_history_count; i++) + { + val = access_value_history (i); + printf_filtered ("$%d = ", i); + value_print (val, stdout, 0, Val_pretty_default); + printf_filtered ("\n"); + } + + /* The next "info history +" should start after what we just printed. */ + num += 10; + + /* Hitting just return after this command should do the same thing as + "info history +". If num_exp is null, this is unnecessary, since + "info history +" is not useful after "info history". */ + if (from_tty && num_exp) + { + num_exp[0] = '+'; + num_exp[1] = '\0'; + } +} + +/* Internal variables. These are variables within the debugger + that hold values assigned by debugger commands. + The user refers to them with a '$' prefix + that does not appear in the variable names stored internally. */ + +static struct internalvar *internalvars; + +/* Look up an internal variable with name NAME. NAME should not + normally include a dollar sign. + + If the specified internal variable does not exist, + one is created, with a void value. */ + +struct internalvar * +lookup_internalvar (name) + char *name; +{ + register struct internalvar *var; + + for (var = internalvars; var; var = var->next) + if (!strcmp (var->name, name)) + return var; + + var = (struct internalvar *) xmalloc (sizeof (struct internalvar)); + var->name = concat (name, "", ""); + var->value = allocate_value (builtin_type_void); + release_value (var->value); + var->next = internalvars; + internalvars = var; + return var; +} + +value +value_of_internalvar (var) + struct internalvar *var; +{ + register value val; + +#ifdef IS_TRAPPED_INTERNALVAR + if (IS_TRAPPED_INTERNALVAR (var->name)) + return VALUE_OF_TRAPPED_INTERNALVAR (var); +#endif + + val = value_copy (var->value); + if (VALUE_LAZY (val)) + value_fetch_lazy (val); + VALUE_LVAL (val) = lval_internalvar; + VALUE_INTERNALVAR (val) = var; + return val; +} + +void +set_internalvar_component (var, offset, bitpos, bitsize, newval) + struct internalvar *var; + int offset, bitpos, bitsize; + value newval; +{ + register char *addr = VALUE_CONTENTS (var->value) + offset; + +#ifdef IS_TRAPPED_INTERNALVAR + if (IS_TRAPPED_INTERNALVAR (var->name)) + SET_TRAPPED_INTERNALVAR (var, newval, bitpos, bitsize, offset); +#endif + + if (bitsize) + modify_field (addr, (int) value_as_long (newval), + bitpos, bitsize); + else + bcopy (VALUE_CONTENTS (newval), addr, + TYPE_LENGTH (VALUE_TYPE (newval))); +} + +void +set_internalvar (var, val) + struct internalvar *var; + value val; +{ +#ifdef IS_TRAPPED_INTERNALVAR + if (IS_TRAPPED_INTERNALVAR (var->name)) + SET_TRAPPED_INTERNALVAR (var, val, 0, 0, 0); +#endif + + free (var->value); + var->value = value_copy (val); + release_value (var->value); +} + +char * +internalvar_name (var) + struct internalvar *var; +{ + return var->name; +} + +/* Free all internalvars. Done when new symtabs are loaded, + because that makes the values invalid. */ + +void +clear_internalvars () +{ + register struct internalvar *var; + + while (internalvars) + { + var = internalvars; + internalvars = var->next; + free (var->name); + free (var->value); + free (var); + } +} + +static void +convenience_info () +{ + register struct internalvar *var; + int varseen = 0; + + for (var = internalvars; var; var = var->next) + { +#ifdef IS_TRAPPED_INTERNALVAR + if (IS_TRAPPED_INTERNALVAR (var->name)) + continue; +#endif + if (!varseen) + { +#if 0 + /* Useless noise. */ + printf ("Debugger convenience variables:\n\n"); +#endif + varseen = 1; + } + printf ("$%s = ", var->name); + value_print (var->value, stdout, 0, Val_pretty_default); + printf ("\n"); + } + if (!varseen) + printf ("No debugger convenience variables now defined.\n\ +Convenience variables have names starting with \"$\";\n\ +use \"set\" as in \"set $foo = 5\" to define them.\n"); +} + +/* Extract a value as a C number (either long or double). + Knows how to convert fixed values to double, or + floating values to long. + Does not deallocate the value. */ + +LONGEST +value_as_long (val) + register value val; +{ + /* This coerces arrays and functions, which is necessary (e.g. + in disassemble_command). It also dereferences references, which + I suspect is the most logical thing to do. */ + if (TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_ENUM) + COERCE_ARRAY (val); + return unpack_long (VALUE_TYPE (val), VALUE_CONTENTS (val)); +} + +double +value_as_double (val) + register value val; +{ + double foo; + int inv; + + foo = unpack_double (VALUE_TYPE (val), VALUE_CONTENTS (val), &inv); + if (inv) + error ("Invalid floating value found in program."); + return foo; +} + +/* Unpack raw data (copied from debugee, target byte order) at VALADDR + as a long, or as a double, assuming the raw data is described + by type TYPE. Knows how to convert different sizes of values + and can convert between fixed and floating point. We don't assume + any alignment for the raw data. Return value is in host byte order. + + If you want functions and arrays to be coerced to pointers, and + references to be dereferenced, call value_as_long() instead. + + C++: It is assumed that the front-end has taken care of + all matters concerning pointers to members. A pointer + to member which reaches here is considered to be equivalent + to an INT (or some size). After all, it is only an offset. */ + +LONGEST +unpack_long (type, valaddr) + struct type *type; + char *valaddr; +{ + register enum type_code code = TYPE_CODE (type); + register int len = TYPE_LENGTH (type); + register int nosign = TYPE_UNSIGNED (type); + + if (code == TYPE_CODE_ENUM) + code = TYPE_CODE_INT; + if (code == TYPE_CODE_FLT) + { + if (len == sizeof (float)) + { + float retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (double)) + { + double retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + else + { + error ("Unexpected type of floating point number."); + } + } + else if (code == TYPE_CODE_INT && nosign) + { + if (len == sizeof (char)) + { + unsigned char retval = * (unsigned char *) valaddr; + /* SWAP_TARGET_AND_HOST (&retval, sizeof (unsigned char)); */ + return retval; + } + + if (len == sizeof (short)) + { + unsigned short retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (int)) + { + unsigned int retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (long)) + { + unsigned long retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } +#ifdef LONG_LONG + if (len == sizeof (long long)) + { + unsigned long long retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } +#endif + else + { + error ("That operation is not possible on an integer of that size."); + } + } + else if (code == TYPE_CODE_INT) + { + if (len == sizeof (char)) + { + char retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (short)) + { + short retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (int)) + { + int retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (long)) + { + long retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + +#ifdef LONG_LONG + if (len == sizeof (long long)) + { + long long retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } +#endif + else + { + error ("That operation is not possible on an integer of that size."); + } + } + else if (code == TYPE_CODE_PTR + || code == TYPE_CODE_REF) + { + if (len == sizeof (char *)) + { + CORE_ADDR retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + } + else if (code == TYPE_CODE_MEMBER) + error ("not implemented: member types in unpack_long"); + + error ("Value not integer or pointer."); + return 0; /* For lint -- never reached */ +} + +/* Return a double value from the specified type and address. + INVP points to an int which is set to 0 for valid value, + 1 for invalid value (bad float format). In either case, + the returned double is OK to use. Argument is in target + format, result is in host format. */ + +double +unpack_double (type, valaddr, invp) + struct type *type; + char *valaddr; + int *invp; +{ + register enum type_code code = TYPE_CODE (type); + register int len = TYPE_LENGTH (type); + register int nosign = TYPE_UNSIGNED (type); + + *invp = 0; /* Assume valid. */ + if (code == TYPE_CODE_FLT) + { + if (INVALID_FLOAT (valaddr, len)) + { + *invp = 1; + return 1.234567891011121314; + } + + if (len == sizeof (float)) + { + float retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + + if (len == sizeof (double)) + { + double retval; + bcopy (valaddr, &retval, sizeof (retval)); + SWAP_TARGET_AND_HOST (&retval, sizeof (retval)); + return retval; + } + else + { + error ("Unexpected type of floating point number."); + } + } + else if (nosign) { + /* Unsigned -- be sure we compensate for signed LONGEST. */ +#ifdef LONG_LONG + return (unsigned long long) unpack_long (type, valaddr); +#else + return (unsigned long ) unpack_long (type, valaddr); +#endif + } else { + /* Signed -- we are OK with unpack_long. */ + return unpack_long (type, valaddr); + } +} + +/* Given a value ARG1 (offset by OFFSET bytes) + of a struct or union type ARG_TYPE, + extract and return the value of one of its fields. + FIELDNO says which field. + + For C++, must also be able to return values from static fields */ + +value +value_primitive_field (arg1, offset, fieldno, arg_type) + register value arg1; + int offset; + register int fieldno; + register struct type *arg_type; +{ + register value v; + register struct type *type; + + check_stub_type (arg_type); + type = TYPE_FIELD_TYPE (arg_type, fieldno); + + /* Handle packed fields */ + + offset += TYPE_FIELD_BITPOS (arg_type, fieldno) / 8; + if (TYPE_FIELD_BITSIZE (arg_type, fieldno)) + { + v = value_from_long (type, + unpack_field_as_long (arg_type, + VALUE_CONTENTS (arg1), + fieldno)); + VALUE_BITPOS (v) = TYPE_FIELD_BITPOS (arg_type, fieldno) % 8; + VALUE_BITSIZE (v) = TYPE_FIELD_BITSIZE (arg_type, fieldno); + } + else + { + v = allocate_value (type); + if (VALUE_LAZY (arg1)) + VALUE_LAZY (v) = 1; + else + bcopy (VALUE_CONTENTS_RAW (arg1) + offset, + VALUE_CONTENTS_RAW (v), + TYPE_LENGTH (type)); + } + VALUE_LVAL (v) = VALUE_LVAL (arg1); + if (VALUE_LVAL (arg1) == lval_internalvar) + VALUE_LVAL (v) = lval_internalvar_component; + VALUE_ADDRESS (v) = VALUE_ADDRESS (arg1); + VALUE_OFFSET (v) = offset + VALUE_OFFSET (arg1); + return v; +} + +/* Given a value ARG1 of a struct or union type, + extract and return the value of one of its fields. + FIELDNO says which field. + + For C++, must also be able to return values from static fields */ + +value +value_field (arg1, fieldno) + register value arg1; + register int fieldno; +{ + return value_primitive_field (arg1, 0, fieldno, VALUE_TYPE (arg1)); +} + +value +value_fn_field (arg1, fieldno, subfieldno) + register value arg1; + register int fieldno; + int subfieldno; +{ + register value v; + struct fn_field *f = TYPE_FN_FIELDLIST1 (VALUE_TYPE (arg1), fieldno); + register struct type *type = TYPE_FN_FIELD_TYPE (f, subfieldno); + struct symbol *sym; + + sym = lookup_symbol (TYPE_FN_FIELD_PHYSNAME (f, subfieldno), + 0, VAR_NAMESPACE, 0, NULL); + if (! sym) error ("Internal error: could not find physical method named %s", + TYPE_FN_FIELD_PHYSNAME (f, subfieldno)); + + v = allocate_value (type); + VALUE_ADDRESS (v) = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)); + VALUE_TYPE (v) = type; + return v; +} + +/* Return a virtual function as a value. + ARG1 is the object which provides the virtual function + table pointer. ARG1 is side-effected in calling this function. + F is the list of member functions which contains the desired virtual + function. + J is an index into F which provides the desired virtual function. */ +value +value_virtual_fn_field (arg1, f, j) + value arg1; + struct fn_field *f; + int j; +{ + /* First, get the virtual function table pointer. That comes + with a strange type, so cast it to type `pointer to long' (which + should serve just fine as a function type). Then, index into + the table, and convert final value to appropriate function type. */ + value entry, vfn, vtbl; + value vi = value_from_long (builtin_type_int, + (LONGEST) TYPE_FN_FIELD_VOFFSET (f, j)); + struct type *context = lookup_pointer_type (TYPE_FN_FIELD_FCONTEXT (f, j)); + if (TYPE_TARGET_TYPE (context) != VALUE_TYPE (arg1)) + arg1 = value_ind (value_cast (context, value_addr (arg1))); + + context = VALUE_TYPE (arg1); + + /* This type may have been defined before its virtual function table + was. If so, fill in the virtual function table entry for the + type now. */ + if (TYPE_VPTR_FIELDNO (context) < 0) + TYPE_VPTR_FIELDNO (context) + = fill_in_vptr_fieldno (context); + + /* The virtual function table is now an array of structures + which have the form { int16 offset, delta; void *pfn; }. */ + vtbl = value_ind (value_field (arg1, TYPE_VPTR_FIELDNO (context))); + + /* Index into the virtual function table. This is hard-coded because + looking up a field is not cheap, and it may be important to save + time, e.g. if the user has set a conditional breakpoint calling + a virtual function. */ + entry = value_subscript (vtbl, vi); + + /* Move the `this' pointer according to the virtual function table. */ + VALUE_OFFSET (arg1) += value_as_long (value_field (entry, 0)); + if (! VALUE_LAZY (arg1)) + { + VALUE_LAZY (arg1) = 1; + value_fetch_lazy (arg1); + } + + vfn = value_field (entry, 2); + /* Reinstantiate the function pointer with the correct type. */ + VALUE_TYPE (vfn) = lookup_pointer_type (TYPE_FN_FIELD_TYPE (f, j)); + + return vfn; +} + +/* The value of a static class member does not depend + on its instance, only on its type. If FIELDNO >= 0, + then fieldno is a valid field number and is used directly. + Otherwise, FIELDNAME is the name of the field we are + searching for. If it is not a static field name, an + error is signaled. TYPE is the type in which we look for the + static field member. */ +value +value_static_field (type, fieldname, fieldno) + register struct type *type; + char *fieldname; + register int fieldno; +{ + register value v; + struct symbol *sym; + char *phys_name; + + if (fieldno < 0) + { + register struct type *t = type; + /* Look for static field. */ + while (t) + { + int i; + for (i = TYPE_NFIELDS (t) - 1; i >= TYPE_N_BASECLASSES (t); i--) + if (! strcmp (TYPE_FIELD_NAME (t, i), fieldname)) + { + if (TYPE_FIELD_STATIC (t, i)) + { + fieldno = i; + goto found; + } + else + error ("field `%s' is not static"); + } + /* FIXME: this does not recursively check multiple baseclasses. */ + t = TYPE_N_BASECLASSES (t) ? TYPE_BASECLASS (t, 0) : 0; + } + + t = type; + + if (destructor_name_p (fieldname, t)) + error ("Cannot get value of destructor"); + + while (t) + { + int i; + + for (i = TYPE_NFN_FIELDS (t) - 1; i >= 0; i--) + { + if (! strcmp (TYPE_FN_FIELDLIST_NAME (t, i), fieldname)) + { + error ("Cannot get value of method \"%s\"", fieldname); + } + } + t = TYPE_N_BASECLASSES (t) ? TYPE_BASECLASS (t, 0) : 0; + } + error("there is no field named %s", fieldname); + } + + found: + phys_name = TYPE_FIELD_STATIC_PHYSNAME (type, fieldno); + sym = lookup_symbol (phys_name, 0, VAR_NAMESPACE, 0, NULL); + if (! sym) error ("Internal error: could not find physical static variable named %s", phys_name); + + type = TYPE_FIELD_TYPE (type, fieldno); + v = value_at (type, (CORE_ADDR)SYMBOL_BLOCK_VALUE (sym)); + return v; +} + +/* Compute the address of the baseclass which is + the INDEXth baseclass of TYPE. The TYPE base + of the object is at VALADDR. */ + +char * +baseclass_addr (type, index, valaddr, valuep) + struct type *type; + int index; + char *valaddr; + value *valuep; +{ + struct type *basetype = TYPE_BASECLASS (type, index); + + if (BASETYPE_VIA_VIRTUAL (type, index)) + { + /* Must hunt for the pointer to this virtual baseclass. */ + register int i, len = TYPE_NFIELDS (type); + register int n_baseclasses = TYPE_N_BASECLASSES (type); + char *vbase_name, *type_name = type_name_no_tag (basetype); + + if (TYPE_MAIN_VARIANT (basetype)) + basetype = TYPE_MAIN_VARIANT (basetype); + + vbase_name = (char *)alloca (strlen (type_name) + 8); + sprintf (vbase_name, "_vb$%s", type_name); + /* First look for the virtual baseclass pointer + in the fields. */ + for (i = n_baseclasses; i < len; i++) + { + if (! strcmp (vbase_name, TYPE_FIELD_NAME (type, i))) + { + value v = value_at (basetype, + unpack_long (TYPE_FIELD_TYPE (type, i), + valaddr + (TYPE_FIELD_BITPOS (type, i) / 8))); + if (valuep) + *valuep = v; + return (char *) VALUE_CONTENTS (v); + } + } + /* Not in the fields, so try looking through the baseclasses. */ + for (i = index+1; i < n_baseclasses; i++) + { + char *baddr; + + baddr = baseclass_addr (type, i, valaddr, valuep); + if (baddr) + return baddr; + } + /* Not found. */ + if (valuep) + *valuep = 0; + return 0; + } + + /* Baseclass is easily computed. */ + if (valuep) + *valuep = 0; + return valaddr + TYPE_BASECLASS_BITPOS (type, index) / 8; +} + +/* Ugly hack to convert method stubs into method types. + + He ain't kiddin'. This demangles the name of the method into a string + including argument types, parses out each argument type, generates + a string casting a zero to that type, evaluates the string, and stuffs + the resulting type into an argtype vector!!! Then it knows the type + of the whole function (including argument types for overloading), + which info used to be in the stab's but was removed to hack back + the space required for them. */ +void +check_stub_method (type, i, j) + struct type *type; + int i, j; +{ + extern char *gdb_mangle_typename (), *strchr (); + struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i); + char *inner_name = gdb_mangle_typename (type); + char *mangled_name + = (char *)xmalloc (strlen (TYPE_FN_FIELDLIST_NAME (type, i)) + + strlen (inner_name) + + strlen (TYPE_FN_FIELD_PHYSNAME (f, j)) + + 1); + char *demangled_name, *cplus_demangle (); + char *argtypetext, *p; + int depth = 0, argcount = 1; + struct type **argtypes; + + strcpy (mangled_name, TYPE_FN_FIELDLIST_NAME (type, i)); + strcat (mangled_name, inner_name); + strcat (mangled_name, TYPE_FN_FIELD_PHYSNAME (f, j)); + demangled_name = cplus_demangle (mangled_name, 0); + + /* Now, read in the parameters that define this type. */ + argtypetext = strchr (demangled_name, '(') + 1; + p = argtypetext; + while (*p) + { + if (*p == '(') + depth += 1; + else if (*p == ')') + depth -= 1; + else if (*p == ',' && depth == 0) + argcount += 1; + + p += 1; + } + /* We need one more slot for the void [...] or NULL [end of arglist] */ + argtypes = (struct type **)xmalloc ((argcount+1) * sizeof (struct type *)); + p = argtypetext; + argtypes[0] = lookup_pointer_type (type); + argcount = 1; + + if (*p != ')') /* () means no args, skip while */ + { + while (*p) + { + if (*p == '(') + depth += 1; + else if (*p == ')') + depth -= 1; + + if (depth <= 0 && (*p == ',' || *p == ')')) + { + char *tmp = (char *)alloca (p - argtypetext + 4); + value val; + tmp[0] = '('; + bcopy (argtypetext, tmp+1, p - argtypetext); + tmp[p-argtypetext+1] = ')'; + tmp[p-argtypetext+2] = '0'; + tmp[p-argtypetext+3] = '\0'; + val = parse_and_eval (tmp); + argtypes[argcount] = VALUE_TYPE (val); + argcount += 1; + argtypetext = p + 1; + } + p += 1; + } + } + + if (p[-2] != '.') /* ... */ + argtypes[argcount] = builtin_type_void; /* Ellist terminator */ + else + argtypes[argcount] = NULL; /* List terminator */ + + free (demangled_name); + smash_to_method_type (TYPE_FN_FIELD_TYPE (f, j), type, + TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)), + argtypes); + TYPE_FN_FIELD_PHYSNAME (f, j) = mangled_name; + TYPE_FLAGS (TYPE_FN_FIELD_TYPE (f, j)) &= ~TYPE_FLAG_STUB; +} + +long +unpack_field_as_long (type, valaddr, fieldno) + struct type *type; + char *valaddr; + int fieldno; +{ + long val; + int bitpos = TYPE_FIELD_BITPOS (type, fieldno); + int bitsize = TYPE_FIELD_BITSIZE (type, fieldno); + + bcopy (valaddr + bitpos / 8, &val, sizeof val); + SWAP_TARGET_AND_HOST (&val, sizeof val); + + /* Extracting bits depends on endianness of the machine. */ +#ifdef BITS_BIG_ENDIAN + val = val >> (sizeof val * 8 - bitpos % 8 - bitsize); +#else + val = val >> (bitpos % 8); +#endif + + val &= (1 << bitsize) - 1; + return val; +} + +void +modify_field (addr, fieldval, bitpos, bitsize) + char *addr; + int fieldval; + int bitpos, bitsize; +{ + long oword; + + /* Reject values too big to fit in the field in question. + Otherwise adjoining fields may be corrupted. */ + if (fieldval & ~((1<<bitsize)-1)) + error ("Value %d does not fit in %d bits.", fieldval, bitsize); + + bcopy (addr, &oword, sizeof oword); + + /* Shifting for bit field depends on endianness of the machine. */ +#ifdef BITS_BIG_ENDIAN + bitpos = sizeof (oword) * 8 - bitpos - bitsize; +#endif + + oword &= ~(((1 << bitsize) - 1) << bitpos); + oword |= fieldval << bitpos; + bcopy (&oword, addr, sizeof oword); +} + +/* Convert C numbers into newly allocated values */ + +value +value_from_long (type, num) + struct type *type; + register LONGEST num; +{ + register value val = allocate_value (type); + register enum type_code code = TYPE_CODE (type); + register int len = TYPE_LENGTH (type); + + if (code == TYPE_CODE_INT || code == TYPE_CODE_ENUM) + { + if (len == sizeof (char)) + * (char *) VALUE_CONTENTS_RAW (val) = num; + else if (len == sizeof (short)) + * (short *) VALUE_CONTENTS_RAW (val) = num; + else if (len == sizeof (int)) + * (int *) VALUE_CONTENTS_RAW (val) = num; + else if (len == sizeof (long)) + * (long *) VALUE_CONTENTS_RAW (val) = num; +#ifdef LONG_LONG + else if (len == sizeof (long long)) + * (long long *) VALUE_CONTENTS_RAW (val) = num; +#endif + else + error ("Integer type encountered with unexpected data length."); + } + else + error ("Unexpected type encountered for integer constant."); + + /* num was in host byte order. So now put the value's contents + into target byte order. */ + SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len); + + return val; +} + +value +value_from_double (type, num) + struct type *type; + double num; +{ + register value val = allocate_value (type); + register enum type_code code = TYPE_CODE (type); + register int len = TYPE_LENGTH (type); + + if (code == TYPE_CODE_FLT) + { + if (len == sizeof (float)) + * (float *) VALUE_CONTENTS_RAW (val) = num; + else if (len == sizeof (double)) + * (double *) VALUE_CONTENTS_RAW (val) = num; + else + error ("Floating type encountered with unexpected data length."); + } + else + error ("Unexpected type encountered for floating constant."); + + /* num was in host byte order. So now put the value's contents + into target byte order. */ + SWAP_TARGET_AND_HOST (VALUE_CONTENTS_RAW (val), len); + + return val; +} + +/* Deal with the value that is "about to be returned". */ + +/* Return the value that a function returning now + would be returning to its caller, assuming its type is VALTYPE. + RETBUF is where we look for what ought to be the contents + of the registers (in raw form). This is because it is often + desirable to restore old values to those registers + after saving the contents of interest, and then call + this function using the saved values. + struct_return is non-zero when the function in question is + using the structure return conventions on the machine in question; + 0 when it is using the value returning conventions (this often + means returning pointer to where structure is vs. returning value). */ + +value +value_being_returned (valtype, retbuf, struct_return) + register struct type *valtype; + char retbuf[REGISTER_BYTES]; + int struct_return; + /*ARGSUSED*/ +{ + register value val; + CORE_ADDR addr; + +#if defined (EXTRACT_STRUCT_VALUE_ADDRESS) + /* If this is not defined, just use EXTRACT_RETURN_VALUE instead. */ + if (struct_return) { + addr = EXTRACT_STRUCT_VALUE_ADDRESS (retbuf); + if (!addr) + error ("Function return value unknown"); + return value_at (valtype, addr); + } +#endif + + val = allocate_value (valtype); + EXTRACT_RETURN_VALUE (valtype, retbuf, VALUE_CONTENTS_RAW (val)); + + return val; +} + +/* Should we use EXTRACT_STRUCT_VALUE_ADDRESS instead of + EXTRACT_RETURN_VALUE? GCC_P is true if compiled with gcc + and TYPE is the type (which is known to be struct, union or array). + + On most machines, the struct convention is used unless we are + using gcc and the type is of a special size. */ +#if !defined (USE_STRUCT_CONVENTION) +#define USE_STRUCT_CONVENTION(gcc_p, type)\ + (!((gcc_p) && (TYPE_LENGTH (value_type) == 1 \ + || TYPE_LENGTH (value_type) == 2 \ + || TYPE_LENGTH (value_type) == 4 \ + || TYPE_LENGTH (value_type) == 8 \ + ) \ + )) +#endif + +/* Return true if the function specified is using the structure returning + convention on this machine to return arguments, or 0 if it is using + the value returning convention. FUNCTION is the value representing + the function, FUNCADDR is the address of the function, and VALUE_TYPE + is the type returned by the function. GCC_P is nonzero if compiled + with GCC. */ + +int +using_struct_return (function, funcaddr, value_type, gcc_p) + value function; + CORE_ADDR funcaddr; + struct type *value_type; + int gcc_p; + /*ARGSUSED*/ +{ + register enum type_code code = TYPE_CODE (value_type); + + if (code == TYPE_CODE_ERROR) + error ("Function return type unknown."); + + if (code == TYPE_CODE_STRUCT || + code == TYPE_CODE_UNION || + code == TYPE_CODE_ARRAY) + return USE_STRUCT_CONVENTION (gcc_p, value_type); + + return 0; +} + +/* Store VAL so it will be returned if a function returns now. + Does not verify that VAL's type matches what the current + function wants to return. */ + +void +set_return_value (val) + value val; +{ + register enum type_code code = TYPE_CODE (VALUE_TYPE (val)); + double dbuf; + LONGEST lbuf; + + if (code == TYPE_CODE_ERROR) + error ("Function return type unknown."); + + if (code == TYPE_CODE_STRUCT + || code == TYPE_CODE_UNION) + error ("Specifying a struct or union return value is not supported."); + + /* FIXME, this is bogus. We don't know what the return conventions + are, or how values should be promoted.... */ + if (code == TYPE_CODE_FLT) + { + dbuf = value_as_double (val); + + STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&dbuf); + } + else + { + lbuf = value_as_long (val); + STORE_RETURN_VALUE (VALUE_TYPE (val), (char *)&lbuf); + } +} + +void +_initialize_values () +{ + add_info ("convenience", convenience_info, + "Debugger convenience (\"$foo\") variables.\n\ +These variables are created when you assign them values;\n\ +thus, \"print $foo=1\" gives \"$foo\" the value 1. Values may be any type.\n\n\ +A few convenience variables are given values automatically:\n\ +\"$_\"holds the last address examined with \"x\" or \"info lines\",\n\ +\"$__\" holds the contents of the last address examined with \"x\"."); + + add_info ("values", value_history_info, + "Elements of value history around item number IDX (or last ten)."); + add_info_alias ("history", "values", 0); +} diff --git a/gdb/vax-opcode.h b/gdb/vax-opcode.h new file mode 100755 index 0000000..18a2ffb --- /dev/null +++ b/gdb/vax-opcode.h @@ -0,0 +1,382 @@ +/* Vax opcde list. + Copyright (C) 1989, Free Software Foundation, Inc. + +This file is part of GDB and GAS. + +GDB and GAS are free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB and GAS are distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB or GAS; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#ifndef vax_opcodeT +#define vax_opcodeT int +#endif /* no vax_opcodeT */ + +struct vot_wot /* vax opcode table: wot to do with this */ + /* particular opcode */ +{ + char * args; /* how to compile said opcode */ + vax_opcodeT code; /* op-code (may be > 8 bits!) */ +}; + +struct vot /* vax opcode text */ +{ + char * name; /* opcode name: lowercase string [key] */ + struct vot_wot detail; /* rest of opcode table [datum] */ +}; + +#define vot_how args +#define vot_code code +#define vot_detail detail +#define vot_name name + +static struct vot +votstrs[] = +{ +{ "halt", {"", 0x00 } }, +{ "nop", {"", 0x01 } }, +{ "rei", {"", 0x02 } }, +{ "bpt", {"", 0x03 } }, +{ "ret", {"", 0x04 } }, +{ "rsb", {"", 0x05 } }, +{ "ldpctx", {"", 0x06 } }, +{ "svpctx", {"", 0x07 } }, +{ "cvtps", {"rwabrwab", 0x08 } }, +{ "cvtsp", {"rwabrwab", 0x09 } }, +{ "index", {"rlrlrlrlrlwl", 0x0a } }, +{ "crc", {"abrlrwab", 0x0b } }, +{ "prober", {"rbrwab", 0x0c } }, +{ "probew", {"rbrwab", 0x0d } }, +{ "insque", {"abab", 0x0e } }, +{ "remque", {"abwl", 0x0f } }, +{ "bsbb", {"bb", 0x10 } }, +{ "brb", {"bb", 0x11 } }, +{ "bneq", {"bb", 0x12 } }, +{ "bnequ", {"bb", 0x12 } }, +{ "beql", {"bb", 0x13 } }, +{ "beqlu", {"bb", 0x13 } }, +{ "bgtr", {"bb", 0x14 } }, +{ "bleq", {"bb", 0x15 } }, +{ "jsb", {"ab", 0x16 } }, +{ "jmp", {"ab", 0x17 } }, +{ "bgeq", {"bb", 0x18 } }, +{ "blss", {"bb", 0x19 } }, +{ "bgtru", {"bb", 0x1a } }, +{ "blequ", {"bb", 0x1b } }, +{ "bvc", {"bb", 0x1c } }, +{ "bvs", {"bb", 0x1d } }, +{ "bcc", {"bb", 0x1e } }, +{ "bgequ", {"bb", 0x1e } }, +{ "blssu", {"bb", 0x1f } }, +{ "bcs", {"bb", 0x1f } }, +{ "addp4", {"rwabrwab", 0x20 } }, +{ "addp6", {"rwabrwabrwab", 0x21 } }, +{ "subp4", {"rwabrwab", 0x22 } }, +{ "subp6", {"rwabrwabrwab", 0x23 } }, +{ "cvtpt", {"rwababrwab", 0x24 } }, +{ "mulp", {"rwabrwabrwab", 0x25 } }, +{ "cvttp", {"rwababrwab", 0x26 } }, +{ "divp", {"rwabrwabrwab", 0x27 } }, +{ "movc3", {"rwabab", 0x28 } }, +{ "cmpc3", {"rwabab", 0x29 } }, +{ "scanc", {"rwababrb", 0x2a } }, +{ "spanc", {"rwababrb", 0x2b } }, +{ "movc5", {"rwabrbrwab", 0x2c } }, +{ "cmpc5", {"rwabrbrwab", 0x2d } }, +{ "movtc", {"rwabrbabrwab", 0x2e } }, +{ "movtuc", {"rwabrbabrwab", 0x2f } }, +{ "bsbw", {"bw", 0x30 } }, +{ "brw", {"bw", 0x31 } }, +{ "cvtwl", {"rwwl", 0x32 } }, +{ "cvtwb", {"rwwb", 0x33 } }, +{ "movp", {"rwabab", 0x34 } }, +{ "cmpp3", {"rwabab", 0x35 } }, +{ "cvtpl", {"rwabwl", 0x36 } }, +{ "cmpp4", {"rwabrwab", 0x37 } }, +{ "editpc", {"rwababab", 0x38 } }, +{ "matchc", {"rwabrwab", 0x39 } }, +{ "locc", {"rbrwab", 0x3a } }, +{ "skpc", {"rbrwab", 0x3b } }, +{ "movzwl", {"rwwl", 0x3c } }, +{ "acbw", {"rwrwmwbw", 0x3d } }, +{ "movaw", {"awwl", 0x3e } }, +{ "pushaw", {"aw", 0x3f } }, +{ "addf2", {"rfmf", 0x40 } }, +{ "addf3", {"rfrfwf", 0x41 } }, +{ "subf2", {"rfmf", 0x42 } }, +{ "subf3", {"rfrfwf", 0x43 } }, +{ "mulf2", {"rfmf", 0x44 } }, +{ "mulf3", {"rfrfwf", 0x45 } }, +{ "divf2", {"rfmf", 0x46 } }, +{ "divf3", {"rfrfwf", 0x47 } }, +{ "cvtfb", {"rfwb", 0x48 } }, +{ "cvtfw", {"rfww", 0x49 } }, +{ "cvtfl", {"rfwl", 0x4a } }, +{ "cvtrfl", {"rfwl", 0x4b } }, +{ "cvtbf", {"rbwf", 0x4c } }, +{ "cvtwf", {"rwwf", 0x4d } }, +{ "cvtlf", {"rlwf", 0x4e } }, +{ "acbf", {"rfrfmfbw", 0x4f } }, +{ "movf", {"rfwf", 0x50 } }, +{ "cmpf", {"rfrf", 0x51 } }, +{ "mnegf", {"rfwf", 0x52 } }, +{ "tstf", {"rf", 0x53 } }, +{ "emodf", {"rfrbrfwlwf", 0x54 } }, +{ "polyf", {"rfrwab", 0x55 } }, +{ "cvtfd", {"rfwd", 0x56 } }, + /* opcode 57 is not defined yet */ +{ "adawi", {"rwmw", 0x58 } }, + /* opcode 59 is not defined yet */ + /* opcode 5a is not defined yet */ + /* opcode 5b is not defined yet */ +{ "insqhi", {"abaq", 0x5c } }, +{ "insqti", {"abaq", 0x5d } }, +{ "remqhi", {"aqwl", 0x5e } }, +{ "remqti", {"aqwl", 0x5f } }, +{ "addd2", {"rdmd", 0x60 } }, +{ "addd3", {"rdrdwd", 0x61 } }, +{ "subd2", {"rdmd", 0x62 } }, +{ "subd3", {"rdrdwd", 0x63 } }, +{ "muld2", {"rdmd", 0x64 } }, +{ "muld3", {"rdrdwd", 0x65 } }, +{ "divd2", {"rdmd", 0x66 } }, +{ "divd3", {"rdrdwd", 0x67 } }, +{ "cvtdb", {"rdwb", 0x68 } }, +{ "cvtdw", {"rdww", 0x69 } }, +{ "cvtdl", {"rdwl", 0x6a } }, +{ "cvtrdl", {"rdwl", 0x6b } }, +{ "cvtbd", {"rbwd", 0x6c } }, +{ "cvtwd", {"rwwd", 0x6d } }, +{ "cvtld", {"rlwd", 0x6e } }, +{ "acbd", {"rdrdmdbw", 0x6f } }, +{ "movd", {"rdwd", 0x70 } }, +{ "cmpd", {"rdrd", 0x71 } }, +{ "mnegd", {"rdwd", 0x72 } }, +{ "tstd", {"rd", 0x73 } }, +{ "emodd", {"rdrbrdwlwd", 0x74 } }, +{ "polyd", {"rdrwab", 0x75 } }, +{ "cvtdf", {"rdwf", 0x76 } }, + /* opcode 77 is not defined yet */ +{ "ashl", {"rbrlwl", 0x78 } }, +{ "ashq", {"rbrqwq", 0x79 } }, +{ "emul", {"rlrlrlwq", 0x7a } }, +{ "ediv", {"rlrqwlwl", 0x7b } }, +{ "clrd", {"wd", 0x7c } }, +{ "clrg", {"wg", 0x7c } }, +{ "clrq", {"wd", 0x7c } }, +{ "movq", {"rqwq", 0x7d } }, +{ "movaq", {"aqwl", 0x7e } }, +{ "movad", {"adwl", 0x7e } }, +{ "pushaq", {"aq", 0x7f } }, +{ "pushad", {"ad", 0x7f } }, +{ "addb2", {"rbmb", 0x80 } }, +{ "addb3", {"rbrbwb", 0x81 } }, +{ "subb2", {"rbmb", 0x82 } }, +{ "subb3", {"rbrbwb", 0x83 } }, +{ "mulb2", {"rbmb", 0x84 } }, +{ "mulb3", {"rbrbwb", 0x85 } }, +{ "divb2", {"rbmb", 0x86 } }, +{ "divb3", {"rbrbwb", 0x87 } }, +{ "bisb2", {"rbmb", 0x88 } }, +{ "bisb3", {"rbrbwb", 0x89 } }, +{ "bicb2", {"rbmb", 0x8a } }, +{ "bicb3", {"rbrbwb", 0x8b } }, +{ "xorb2", {"rbmb", 0x8c } }, +{ "xorb3", {"rbrbwb", 0x8d } }, +{ "mnegb", {"rbwb", 0x8e } }, +{ "caseb", {"rbrbrb", 0x8f } }, +{ "movb", {"rbwb", 0x90 } }, +{ "cmpb", {"rbrb", 0x91 } }, +{ "mcomb", {"rbwb", 0x92 } }, +{ "bitb", {"rbrb", 0x93 } }, +{ "clrb", {"wb", 0x94 } }, +{ "tstb", {"rb", 0x95 } }, +{ "incb", {"mb", 0x96 } }, +{ "decb", {"mb", 0x97 } }, +{ "cvtbl", {"rbwl", 0x98 } }, +{ "cvtbw", {"rbww", 0x99 } }, +{ "movzbl", {"rbwl", 0x9a } }, +{ "movzbw", {"rbww", 0x9b } }, +{ "rotl", {"rbrlwl", 0x9c } }, +{ "acbb", {"rbrbmbbw", 0x9d } }, +{ "movab", {"abwl", 0x9e } }, +{ "pushab", {"ab", 0x9f } }, +{ "addw2", {"rwmw", 0xa0 } }, +{ "addw3", {"rwrwww", 0xa1 } }, +{ "subw2", {"rwmw", 0xa2 } }, +{ "subw3", {"rwrwww", 0xa3 } }, +{ "mulw2", {"rwmw", 0xa4 } }, +{ "mulw3", {"rwrwww", 0xa5 } }, +{ "divw2", {"rwmw", 0xa6 } }, +{ "divw3", {"rwrwww", 0xa7 } }, +{ "bisw2", {"rwmw", 0xa8 } }, +{ "bisw3", {"rwrwww", 0xa9 } }, +{ "bicw2", {"rwmw", 0xaa } }, +{ "bicw3", {"rwrwww", 0xab } }, +{ "xorw2", {"rwmw", 0xac } }, +{ "xorw3", {"rwrwww", 0xad } }, +{ "mnegw", {"rwww", 0xae } }, +{ "casew", {"rwrwrw", 0xaf } }, +{ "movw", {"rwww", 0xb0 } }, +{ "cmpw", {"rwrw", 0xb1 } }, +{ "mcomw", {"rwww", 0xb2 } }, +{ "bitw", {"rwrw", 0xb3 } }, +{ "clrw", {"ww", 0xb4 } }, +{ "tstw", {"rw", 0xb5 } }, +{ "incw", {"mw", 0xb6 } }, +{ "decw", {"mw", 0xb7 } }, +{ "bispsw", {"rw", 0xb8 } }, +{ "bicpsw", {"rw", 0xb9 } }, +{ "popr", {"rw", 0xba } }, +{ "pushr", {"rw", 0xbb } }, +{ "chmk", {"rw", 0xbc } }, +{ "chme", {"rw", 0xbd } }, +{ "chms", {"rw", 0xbe } }, +{ "chmu", {"rw", 0xbf } }, +{ "addl2", {"rlml", 0xc0 } }, +{ "addl3", {"rlrlwl", 0xc1 } }, +{ "subl2", {"rlml", 0xc2 } }, +{ "subl3", {"rlrlwl", 0xc3 } }, +{ "mull2", {"rlml", 0xc4 } }, +{ "mull3", {"rlrlwl", 0xc5 } }, +{ "divl2", {"rlml", 0xc6 } }, +{ "divl3", {"rlrlwl", 0xc7 } }, +{ "bisl2", {"rlml", 0xc8 } }, +{ "bisl3", {"rlrlwl", 0xc9 } }, +{ "bicl2", {"rlml", 0xca } }, +{ "bicl3", {"rlrlwl", 0xcb } }, +{ "xorl2", {"rlml", 0xcc } }, +{ "xorl3", {"rlrlwl", 0xcd } }, +{ "mnegl", {"rlwl", 0xce } }, +{ "casel", {"rlrlrl", 0xcf } }, +{ "movl", {"rlwl", 0xd0 } }, +{ "cmpl", {"rlrl", 0xd1 } }, +{ "mcoml", {"rlwl", 0xd2 } }, +{ "bitl", {"rlrl", 0xd3 } }, +{ "clrf", {"wf", 0xd4 } }, +{ "clrl", {"wl", 0xd4 } }, +{ "tstl", {"rl", 0xd5 } }, +{ "incl", {"ml", 0xd6 } }, +{ "decl", {"ml", 0xd7 } }, +{ "adwc", {"rlml", 0xd8 } }, +{ "sbwc", {"rlml", 0xd9 } }, +{ "mtpr", {"rlrl", 0xda } }, +{ "mfpr", {"rlwl", 0xdb } }, +{ "movpsl", {"wl", 0xdc } }, +{ "pushl", {"rl", 0xdd } }, +{ "moval", {"alwl", 0xde } }, +{ "movaf", {"afwl", 0xde } }, +{ "pushal", {"al", 0xdf } }, +{ "pushaf", {"af", 0xdf } }, +{ "bbs", {"rlabbb", 0xe0 } }, +{ "bbc", {"rlabbb", 0xe1 } }, +{ "bbss", {"rlabbb", 0xe2 } }, +{ "bbcs", {"rlabbb", 0xe3 } }, +{ "bbsc", {"rlabbb", 0xe4 } }, +{ "bbcc", {"rlabbb", 0xe5 } }, +{ "bbssi", {"rlabbb", 0xe6 } }, +{ "bbcci", {"rlabbb", 0xe7 } }, +{ "blbs", {"rlbb", 0xe8 } }, +{ "blbc", {"rlbb", 0xe9 } }, +{ "ffs", {"rlrbvbwl", 0xea } }, +{ "ffc", {"rlrbvbwl", 0xeb } }, +{ "cmpv", {"rlrbvbrl", 0xec } }, +{ "cmpzv", {"rlrbvbrl", 0xed } }, +{ "extv", {"rlrbvbwl", 0xee } }, +{ "extzv", {"rlrbvbwl", 0xef } }, +{ "insv", {"rlrlrbvb", 0xf0 } }, +{ "acbl", {"rlrlmlbw", 0xf1 } }, +{ "aoblss", {"rlmlbb", 0xf2 } }, +{ "aobleq", {"rlmlbb", 0xf3 } }, +{ "sobgeq", {"mlbb", 0xf4 } }, +{ "sobgtr", {"mlbb", 0xf5 } }, +{ "cvtlb", {"rlwb", 0xf6 } }, +{ "cvtlw", {"rlww", 0xf7 } }, +{ "ashp", {"rbrwabrbrwab", 0xf8 } }, +{ "cvtlp", {"rlrwab", 0xf9 } }, +{ "callg", {"abab", 0xfa } }, +{ "calls", {"rlab", 0xfb } }, +{ "xfc", {"", 0xfc } }, + /* undefined opcodes here */ +{ "cvtdh", {"rdwh", 0x32fd } }, +{ "cvtgf", {"rgwh", 0x33fd } }, +{ "addg2", {"rgmg", 0x40fd } }, +{ "addg3", {"rgrgwg", 0x41fd } }, +{ "subg2", {"rgmg", 0x42fd } }, +{ "subg3", {"rgrgwg", 0x43fd } }, +{ "mulg2", {"rgmg", 0x44fd } }, +{ "mulg3", {"rgrgwg", 0x45fd } }, +{ "divg2", {"rgmg", 0x46fd } }, +{ "divg3", {"rgrgwg", 0x47fd } }, +{ "cvtgb", {"rgwb", 0x48fd } }, +{ "cvtgw", {"rgww", 0x49fd } }, +{ "cvtgl", {"rgwl", 0x4afd } }, +{ "cvtrgl", {"rgwl", 0x4bfd } }, +{ "cvtbg", {"rbwg", 0x4cfd } }, +{ "cvtwg", {"rwwg", 0x4dfd } }, +{ "cvtlg", {"rlwg", 0x4efd } }, +{ "acbg", {"rgrgmgbw", 0x4ffd } }, +{ "movg", {"rgwg", 0x50fd } }, +{ "cmpg", {"rgrg", 0x51fd } }, +{ "mnegg", {"rgwg", 0x52fd } }, +{ "tstg", {"rg", 0x53fd } }, +{ "emodg", {"rgrwrgwlwg", 0x54fd } }, +{ "polyg", {"rgrwab", 0x55fd } }, +{ "cvtgh", {"rgwh", 0x56fd } }, + /* undefined opcodes here */ +{ "addh2", {"rhmh", 0x60fd } }, +{ "addh3", {"rhrhwh", 0x61fd } }, +{ "subh2", {"rhmh", 0x62fd } }, +{ "subh3", {"rhrhwh", 0x63fd } }, +{ "mulh2", {"rhmh", 0x64fd } }, +{ "mulh3", {"rhrhwh", 0x65fd } }, +{ "divh2", {"rhmh", 0x66fd } }, +{ "divh3", {"rhrhwh", 0x67fd } }, +{ "cvthb", {"rhwb", 0x68fd } }, +{ "cvthw", {"rhww", 0x69fd } }, +{ "cvthl", {"rhwl", 0x6afd } }, +{ "cvtrhl", {"rhwl", 0x6bfd } }, +{ "cvtbh", {"rbwh", 0x6cfd } }, +{ "cvtwh", {"rwwh", 0x6dfd } }, +{ "cvtlh", {"rlwh", 0x6efd } }, +{ "acbh", {"rhrhmhbw", 0x6ffd } }, +{ "movh", {"rhwh", 0x70fd } }, +{ "cmph", {"rhrh", 0x71fd } }, +{ "mnegh", {"rhwh", 0x72fd } }, +{ "tsth", {"rh", 0x73fd } }, +{ "emodh", {"rhrwrhwlwh", 0x74fd } }, +{ "polyh", {"rhrwab", 0x75fd } }, +{ "cvthg", {"rhwg", 0x76fd } }, + /* undefined opcodes here */ +{ "clrh", {"wh", 0x7cfd } }, +{ "clro", {"wo", 0x7cfd } }, +{ "movo", {"rowo", 0x7dfd } }, +{ "movah", {"ahwl", 0x7efd } }, +{ "movao", {"aowl", 0x7efd } }, +{ "pushah", {"ah", 0x7ffd } }, +{ "pushao", {"ao", 0x7ffd } }, + /* undefined opcodes here */ +{ "cvtfh", {"rfwh", 0x98fd } }, +{ "cvtfg", {"rfwg", 0x99fd } }, + /* undefined opcodes here */ +{ "cvthf", {"rhwf", 0xf6fd } }, +{ "cvthd", {"rhwd", 0xf7fd } }, + /* undefined opcodes here */ +{ "bugl", {"rl", 0xfdff } }, +{ "bugw", {"rw", 0xfeff } }, + /* undefined opcodes here */ + +{ "" , "" } /* empty is end sentinel */ + +}; /* votstrs */ + +/* end: vax.opcode.h */ diff --git a/gdb/vax-pinsn.c b/gdb/vax-pinsn.c new file mode 100644 index 0000000..4c159af --- /dev/null +++ b/gdb/vax-pinsn.c @@ -0,0 +1,240 @@ +/* Print vax instructions for GDB, the GNU debugger. + Copyright (C) 1986, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include <stdio.h> + +#include "defs.h" +#include "param.h" +#include "symtab.h" +#include "vax-opcode.h" + +/* Vax instructions are never longer than this. */ +#define MAXLEN 62 + +/* Number of elements in the opcode table. */ +#define NOPCODES (sizeof votstrs / sizeof votstrs[0]) + +extern char *reg_names[]; + +static unsigned char *print_insn_arg (); + +/* Print the vax instruction at address MEMADDR in debugged memory, + on STREAM. Returns length of the instruction, in bytes. */ + +int +print_insn (memaddr, stream) + CORE_ADDR memaddr; + FILE *stream; +{ + unsigned char buffer[MAXLEN]; + register int i; + register unsigned char *p; + register char *d; + + read_memory (memaddr, buffer, MAXLEN); + + for (i = 0; i < NOPCODES; i++) + if (votstrs[i].detail.code == buffer[0] + || votstrs[i].detail.code == *(unsigned short *)buffer) + break; + + /* Handle undefined instructions. */ + if (i == NOPCODES) + { + fprintf (stream, "0%o", buffer[0]); + return 1; + } + + fprintf (stream, "%s", votstrs[i].name); + + /* Point at first byte of argument data, + and at descriptor for first argument. */ + p = buffer + 1 + (votstrs[i].detail.code >= 0x100); + d = votstrs[i].detail.args; + + if (*d) + fputc (' ', stream); + + while (*d) + { + p = print_insn_arg (d, p, memaddr + (p - buffer), stream); + d += 2; + if (*d) + fprintf (stream, ","); + } + return p - buffer; +} + +static unsigned char * +print_insn_arg (d, p, addr, stream) + char *d; + register char *p; + CORE_ADDR addr; + FILE *stream; +{ + register int regnum = *p & 0xf; + float floatlitbuf; + + if (*d == 'b') + { + if (d[1] == 'b') + fprintf (stream, "0x%x", addr + *p++ + 1); + else + { + fprintf (stream, "0x%x", addr + *(short *)p + 2); + p += 2; + } + } + else + switch ((*p++ >> 4) & 0xf) + { + case 0: + case 1: + case 2: + case 3: /* Literal mode */ + if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h') + { + *(int *)&floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4); + fprintf (stream, "$%f", floatlitbuf); + } + else + fprintf (stream, "$%d", p[-1] & 0x3f); + break; + + case 4: /* Indexed */ + p = (char *) print_insn_arg (d, p, addr + 1, stream); + fprintf (stream, "[%s]", reg_names[regnum]); + break; + + case 5: /* Register */ + fprintf (stream, reg_names[regnum]); + break; + + case 7: /* Autodecrement */ + fputc ('-', stream); + case 6: /* Register deferred */ + fprintf (stream, "(%s)", reg_names[regnum]); + break; + + case 9: /* Autoincrement deferred */ + fputc ('@', stream); + if (regnum == PC_REGNUM) + { + fputc ('#', stream); + print_address (*(long *)p, stream); + p += 4; + break; + } + case 8: /* Autoincrement */ + if (regnum == PC_REGNUM) + { + fputc ('#', stream); + switch (d[1]) + { + case 'b': + fprintf (stream, "%d", *p++); + break; + + case 'w': + fprintf (stream, "%d", *(short *)p); + p += 2; + break; + + case 'l': + fprintf (stream, "%d", *(long *)p); + p += 4; + break; + + case 'q': + fprintf (stream, "0x%x%08x", ((long *)p)[1], ((long *)p)[0]); + p += 8; + break; + + case 'o': + fprintf (stream, "0x%x%08x%08x%08x", + ((long *)p)[3], ((long *)p)[2], + ((long *)p)[1], ((long *)p)[0]); + p += 16; + break; + + case 'f': + if (INVALID_FLOAT (p, 4)) + fprintf (stream, "<<invalid float 0x%x>>", *(int *) p); + else + fprintf (stream, "%f", *(float *) p); + p += 4; + break; + + case 'd': + if (INVALID_FLOAT (p, 8)) + fprintf (stream, "<<invalid float 0x%x%08x>>", + ((long *)p)[1], ((long *)p)[0]); + else + fprintf (stream, "%f", *(double *) p); + p += 8; + break; + + case 'g': + fprintf (stream, "g-float"); + p += 8; + break; + + case 'h': + fprintf (stream, "h-float"); + p += 16; + break; + + } + } + else + fprintf (stream, "(%s)+", reg_names[regnum]); + break; + + case 11: /* Byte displacement deferred */ + fputc ('@', stream); + case 10: /* Byte displacement */ + if (regnum == PC_REGNUM) + print_address (addr + *p + 2, stream); + else + fprintf (stream, "%d(%s)", *p, reg_names[regnum]); + p += 1; + break; + + case 13: /* Word displacement deferred */ + fputc ('@', stream); + case 12: /* Word displacement */ + if (regnum == PC_REGNUM) + print_address (addr + *(short *)p + 3, stream); + else + fprintf (stream, "%d(%s)", *(short *)p, reg_names[regnum]); + p += 2; + break; + + case 15: /* Long displacement deferred */ + fputc ('@', stream); + case 14: /* Long displacement */ + if (regnum == PC_REGNUM) + print_address (addr + *(long *)p + 5, stream); + else + fprintf (stream, "%d(%s)", *(long *)p, reg_names[regnum]); + p += 4; + } + + return (unsigned char *) p; +} diff --git a/gdb/vx-share/dbgRpcLib.h b/gdb/vx-share/dbgRpcLib.h new file mode 100644 index 0000000..c420075 --- /dev/null +++ b/gdb/vx-share/dbgRpcLib.h @@ -0,0 +1,28 @@ +/* dbgRpcLib.h - header file for remote debugging via rpc */ + +/* +modification history +-------------------- +01b,04oct90,maf added VX_BOOT_FILE_INQ. +01a,05jun90,llk extracted from xdr_dbx.h. +*/ + +#ifndef INCdbxRpcLibh +#define INCdbxRpcLibh 1 + +#define PROCESS_START 50 +#define PROCESS_WAIT 51 +#define VX_STATE_INQ 60 +#define VX_LOAD 61 +#define VX_SYMBOL_INQ 62 +#define VX_BREAK_ADD 63 +#define VX_BREAK_DELETE 64 +#define VX_FP_INQUIRE 65 +#define VX_TASK_SUSPEND 66 +#define VX_CALL_FUNC 67 +#define VX_CONV_FROM_68881 68 +#define VX_CONV_TO_68881 69 +#define VX_BOOT_FILE_INQ 70 +#define VX_SOURCE_STEP 71 + +#endif INCdbxRpcLibh diff --git a/gdb/vx-share/ptrace.h b/gdb/vx-share/ptrace.h new file mode 100644 index 0000000..34801c7 --- /dev/null +++ b/gdb/vx-share/ptrace.h @@ -0,0 +1,44 @@ +/* @(#)ptrace.h 1.1 86/07/07 SMI */ + +/* + * Copyright (c) 1985 by Sun Microsystems, Inc. + */ + +/* +modification history +-------------------- +01a,05jun90,llk borrowed. +*/ + +#ifndef _PTRACE_ +#define _PTRACE_ + +/* + * Request values for the ptrace system call + */ +enum ptracereq { + PTRACE_TRACEME = 0, /* 0, by tracee to begin tracing */ + PTRACE_CHILDDONE = 0, /* 0, tracee is done with his half */ + PTRACE_PEEKTEXT, /* 1, read word from text segment */ + PTRACE_PEEKDATA, /* 2, read word from data segment */ + PTRACE_PEEKUSER, /* 3, read word from user struct */ + PTRACE_POKETEXT, /* 4, write word into text segment */ + PTRACE_POKEDATA, /* 5, write word into data segment */ + PTRACE_POKEUSER, /* 6, write word into user struct */ + PTRACE_CONT, /* 7, continue process */ + PTRACE_KILL, /* 8, terminate process */ + PTRACE_SINGLESTEP, /* 9, single step process */ + PTRACE_ATTACH, /* 10, attach to an existing process */ + PTRACE_DETACH, /* 11, detach from a process */ + PTRACE_GETREGS, /* 12, get all registers */ + PTRACE_SETREGS, /* 13, set all registers */ + PTRACE_GETFPREGS, /* 14, get all floating point regs */ + PTRACE_SETFPREGS, /* 15, set all floating point regs */ + PTRACE_READDATA, /* 16, read data segment */ + PTRACE_WRITEDATA, /* 17, write data segment */ + PTRACE_READTEXT, /* 18, read text segment */ + PTRACE_WRITETEXT, /* 19, write text segment */ + PTRACE_GETFPAREGS, /* 20, get all fpa regs */ + PTRACE_SETFPAREGS, /* 21, set all fpa regs */ +}; +#endif !_PTRACE diff --git a/gdb/vx-share/reg.h b/gdb/vx-share/reg.h new file mode 100644 index 0000000..84658b7 --- /dev/null +++ b/gdb/vx-share/reg.h @@ -0,0 +1,209 @@ +/* @(#)reg.h 1.1 86/07/07 SMI */ + +/* + * Copyright (c) 1986 by Sun Microsystems, Inc. + */ + +/* +modification history +-------------------- +01a,05jun90,llk borrowed. +*/ + +#ifndef _REG_ +#define _REG_ + +#ifdef I80960 + +/* Intel 960 register values passed over the wire by RPC: */ + +struct regs +{ + int r_lreg[16]; /* local registers */ + int r_greg[16]; /* global registers */ + int r_pcw; /* process control word */ + int r_acw; /* arithmetic control word */ + int r_tcw; /* trace control word */ +}; + +#define FP_REG_SIZE 12 + +struct fp_status { + char fps_regs[4][FP_REG_SIZE]; /* floating point regs */ +}; + +#else /* For now, just 68000 */ + +/* + * Location of the users' stored + * registers relative to R0. + * Usage is u.u_ar0[XX]. + */ +#define R0 (0) +#define R1 (1) +#define R2 (2) +#define R3 (3) +#define R4 (4) +#define R5 (5) +#define R6 (6) +#define R7 (7) +#define AR0 (8) +#define AR1 (9) +#define AR2 (10) +#define AR3 (11) +#define AR4 (12) +#define AR5 (13) +#define AR6 (14) +#define AR7 (15) +#define SP (15) +#define PS (16) +#define PC (17) + +/* + * And now for something completely the same... + */ +#ifndef LOCORE +struct regs { + int r_dreg[8]; /* data registers */ +#define r_r0 r_dreg[0] /* r0 for portability */ + int r_areg[8]; /* address registers */ +#define r_sp r_areg[7] /* user stack pointer */ + int r_sr; /* status register (actually a short) */ +#define r_ps r_sr + int r_pc; /* program counter */ +}; + +struct stkfmt { + int f_stkfmt : 4; /* stack format */ + int : 2; + int f_vector : 10; /* vector offset */ + short f_beibase; /* start of bus error info (if any) */ +}; + + +/* + * Struct for floating point registers and general state + * for the MC68881 (the sky fpp has no user visible state). + * If fps_flags == FPS_UNUSED, the other 68881 fields have no meaning. + * fps_code and fps_flags are software implemented fields. + * fps_flags is not used when set by user level programs, + * but changing fps_code has the side effect of changing u.u_code. + */ + +typedef struct ext_fp { + int fp[3]; +} ext_fp; /* extended 96-bit 68881 fp registers */ + +struct fp_status { + ext_fp fps_regs[8]; /* 68881 floating point regs */ + int fps_control; /* 68881 control reg */ + int fps_status; /* 68881 status reg */ + int fps_iaddr; /* 68881 instruction address reg */ + int fps_code; /* additional word for signals */ + int fps_flags; /* r/o - unused, idle or busy */ +}; +#endif !LOCORE + +/* + * Values defined for `fps_flags'. + */ +#define FPS_UNUSED 0 /* 68881 never used yet */ +#define FPS_IDLE 1 /* 68881 instruction completed */ +#define FPS_BUSY 2 /* 68881 instruction interrupted */ + +/* + * The EXT_FPS_FLAGS() macro is used to convert a pointer to an + * fp_istate into a value to be used for the user visible state + * found in fps_flags. As a speed optimization, this convertion + * is only done is required (e.g. the PTRACE_GETFPREGS ptrace + * call or when dumping core) instead of on each context switch. + * The tests that we base the state on are that a fpis_vers of + * FPIS_VERSNULL means NULL state, else a fpis_bufsiz of FPIS_IDLESZ + * means IDLE state, else we assume BUSY state. + */ +#define FPIS_VERSNULL 0x0 +#define FPIS_IDLESIZE 0x18 + +#define EXT_FPS_FLAGS(istatep) \ + ((istatep)->fpis_vers == FPIS_VERSNULL ? FPS_UNUSED : \ + (istatep)->fpis_bufsiz == FPIS_IDLESIZE ? FPS_IDLE : FPS_BUSY) + +#ifndef LOCORE +/* + * Struct for the internal state of the MC68881 + * Although the MC68881 can have a smaller maximum for + * internal state, we allow for more to allow for expansion. + */ +#define FPIS_BUFSIZ 0xc0 + +struct fp_istate { + unsigned char fpis_vers; /* version number */ + unsigned char fpis_bufsiz; /* size of info in fpis_buf */ + unsigned short fpis_reserved; /* reserved word */ + unsigned char fpis_buf[FPIS_BUFSIZ]; /* fpp internal state buffer */ +}; + +/* + * Structures for the status and data registers are defined here. + * Struct fpa_status are included in the u area. + * Struct fpa_regs is included in struct core. + */ + +/* struct fpa_status is saved/restored during context switch */ +struct fpa_status { + unsigned int fpas_state; /* STATE, supervisor privileged reg */ + unsigned int fpas_imask; /* IMASK */ + unsigned int fpas_load_ptr; /* LOAD_PTR */ + unsigned int fpas_ierr; /* IERR */ + unsigned int fpas_act_instr; /* pipe active instruction halves */ + unsigned int fpas_nxt_instr; /* pipe next instruction halves */ + unsigned int fpas_act_d1half;/* pipe active data first half */ + unsigned int fpas_act_d2half;/* pipe active data second half */ + unsigned int fpas_nxt_d1half;/* pipe next data first half */ + unsigned int fpas_nxt_d2half;/* pipe next data second half */ + unsigned int fpas_mode3_0; /* FPA MODE3_0 register */ + unsigned int fpas_wstatus; /* FPA WSTATUS register */ +}; + +/* + * Since there are 32 contexts supported by the FPA hardware, + * when we do context switch on the FPA, we don't save/restore + * the data registers between the FPA and the u area. + * If there are already 32 processes using the fpa concurrently, + * we give an error message to the 33rd process trying to use the fpa. + * (Hopefully there will not be this many processes using FPA concurrently.) + */ + +#define FPA_NCONTEXTS 32 +#define FPA_NDATA_REGS 32 + +typedef struct fpa_long { + int fpl_data[2]; +} fpa_long; /* 64 bit double precision registers */ + +/* Struct fpa_regs is included in struct core. */ +struct fpa_regs { + unsigned int fpar_flags; /* if zero, other fields are meaningless */ + struct fpa_status fpar_status; + fpa_long fpar_data[FPA_NDATA_REGS]; +}; + +/* + * The size of struct fpa_regs is changed from 141 ints in 3.0 to + * 77 ints in 3.x. A pad of this size difference is added to struct core. + */ +#define CORE_PADLEN 64 + +/* + * If there is going to be external FPU state then we must define the FPU + * variable + */ +struct fpu { + struct fp_status f_fpstatus; /* External FPP state, if any */ + struct fpa_regs f_fparegs; /* FPA registers, if any */ + int f_pad[CORE_PADLEN]; /* see comment above */ +}; + +#endif !LOCORE +#endif /* !I80960 */ +#endif !_REG_ diff --git a/gdb/vx-share/vxTypes.h b/gdb/vx-share/vxTypes.h new file mode 100644 index 0000000..3ebd7c6 --- /dev/null +++ b/gdb/vx-share/vxTypes.h @@ -0,0 +1,70 @@ +/* vxTypes.h - VxWorks type definition header */ + +/* Copyright 1984-1990 Wind River Systems, Inc. */ + +/* +modification history +-------------------- +01c,05oct90,shl added copyright notice. + made #endif ANSI style. +01b,10aug90,dnw added VOIDFUNCPTR +01a,29may90,del written. +*/ + +#ifndef INCvxTypesh +#define INCvxTypesh + +/* The following stuff must NOT be included if this include file is used + * from assembly language. Just #define ASMLANGUAGE before the include, + * to get rid of it. + */ + +#ifndef ASMLANGUAGE + +/* vxWorks types */ + +typedef char INT8; +typedef short INT16; +typedef int INT32; + +typedef unsigned char UINT8; +typedef unsigned short UINT16; +typedef unsigned int UINT32; + +typedef unsigned char UCHAR; +typedef unsigned short USHORT; +typedef unsigned int UINT; +typedef unsigned long ULONG; + +typedef int BOOL; +typedef int VOID; +typedef int STATUS; +typedef int ARGINT; + +typedef int (*FUNCPTR) (); /* ptr to function returning int */ +typedef VOID (*VOIDFUNCPTR) (); /* ptr to function returning VOID */ + + +/* historical definitions - now obsolete */ + +typedef char TINY; /* obsolete */ +typedef char TBOOL; /* obsolete */ +typedef unsigned char UTINY; /* obsolete */ + + +/* architecture dependent typedefs */ + +#ifdef CPU_FAMILY + +#if CPU_FAMILY==MC680X0 +typedef unsigned short INSTR; /* word-aligned instructions */ +#endif /* CPU_FAMILY==MC680X0 */ + +#if CPU_FAMILY==SPARC +typedef unsigned long INSTR; /* 32 bit word-aligned instructions */ +#endif /* CPU_FAMILY==SPARC */ + +#endif + +#endif /* ASMLANGUAGE */ +#endif /* INCvxTypesh */ diff --git a/gdb/vx-share/vxWorks.h b/gdb/vx-share/vxWorks.h new file mode 100644 index 0000000..483313e --- /dev/null +++ b/gdb/vx-share/vxWorks.h @@ -0,0 +1,177 @@ +/* vxWorks.h - VxWorks standard definitions header */ + +/* Copyright 1984-1990 Wind River Systems, Inc. */ + +/* +modification history +-------------------- +01z,05oct90,shl added copyright notice. + made #endif ANSI style. +01y,28sep90,del added I960 defines. +01x,29may90,del moved types to vxTypes.h +01w,09apr90,jcf added timeout definitions. +01v,24jan90,gae moved network configuration flags here from makefile's. +01u,01sep88,mcl definition of INSTR dependent on processor family; added SPARC. + +gae added MC680X0 and defined CPU_FAMILY. +01t,08apr89,dnw added ifdef to prevent inclusion of vxWorks.h more than once. +01s,22jun88,dnw moved READ, WRITE, and UPDATE back here from ioLib.h. +01r,22apr88,gae oops! forgot some #endif's in 01q. +01q,12apr88,gae removed QUICK & WAIT; added STD_{IN,OUT,ERR}. + fixed #define's of FALSE, TRUE, etc. + moved READ, WRITE, and UPDATE to ioLib.h. +01p,04dec87,dnw added undefine of MC68000 to get around Green Hills bug that + pre-defines MC68000. +01o,12nov87,ecs added type ULONG. +01n,08feb86,dnw added types INSTR, UINT, USHORT. +01m,14oct85,rdc added BUS types. +01l,16jul85,jlf added conditional for NULL and EOF. +01k,24jun85,rdc installed condtional compile so we can include in + assembly language files. See instructions below. + Added System type macro and CPU type macro. +01j,13jun85,dnw cleaned-up, removed more obsolete stuff to wrs.h +01i,11sep84,jlf changed name from wrs.h to vxWorks.h. removed GLOBAL. +01h,03jun84,dnw removed IGNORE declaration. +01g,09apr84,jlf added MEMBER_SIZE macro. +01f,14dec83,dnw added MSB, LSB macros +01e,17nov83,jlf added STATUS type, for routines which return a status. +01d,13jul83,dnw added NELEMENTS macro +01c,14May83,dnw added OFFSET macro +01b,17Feb83,dnw added stuff from Whitesmiths std.h +01a,15Feb83,dnw written +*/ + +#ifndef INCvxWorksh +#define INCvxWorksh + +#if !defined(NULL) || (NULL!=0) +#define NULL 0 +#endif + +#if !defined(EOF) || (EOF!=(-1)) +#define EOF (-1) +#endif + +#if !defined(FALSE) || (FALSE!=0) +#define FALSE 0 +#endif + +#if !defined(TRUE) || (TRUE!=1) +#define TRUE 1 +#endif + + +#define NONE (-1) /* for times when NULL won't do */ +#define EOS '\0' /* C string terminator */ + + +/* return status values */ + +#define OK 0 +#define ERROR (-1) + +/* timeout defines */ + +#define NO_WAIT 0 +#define WAIT_FOREVER (-1) + +/* low-level I/O input, output, error fd's */ + +#define STD_IN 0 +#define STD_OUT 1 +#define STD_ERR 2 + +/* modes - must match O_RDONLY/O_WRONLY/O_RDWR in ioLib.h! */ + +#define READ 0 +#define WRITE 1 +#define UPDATE 2 + +/* SYSTEM types */ + +#define V7 1 /* ATT version 7 */ +#define SYS_V 2 /* ATT System 5 */ +#define BSD_4_2 3 /* Berkeley BSD 4.2 */ + +/* CPU types */ + +/* The Green Hills compiler pre-defines "MC68000"!! */ +#ifdef MC68000 +#undef MC68000 +#endif + +#define MC68000 1 +#define MC68010 2 +#define MC68020 3 +#define MC68030 4 +#define MC68040 5 +#define MC680X0 9 + +#define SPARC 10 + +#ifndef I960 +#define I960 20 +#endif + +#define I960KB 21 +#define I960CA 22 + +#if CPU==MC68000 || CPU==MC68010 || CPU==MC68020 || CPU==MC68030 +#define CPU_FAMILY MC680X0 +#endif /* CPU==MC68000 || CPU==MC68010 || CPU==MC68020 || CPU==MC68030 */ + +#if CPU==SPARC +#define CPU_FAMILY SPARC +#endif /* CPU==SPARC */ + +#if CPU==I960KB +#define CPU_FAMILY I960 +#endif /* CPU==I960KB */ + +#if CPU==I960CA +#define CPU_FAMILY I960 +#endif /* CPU==I960CA */ + +/* BUS types */ + +#define VME_BUS 1 +#define MULTI_BUS 2 + +/* network configuration parameters */ + +#define INET /* include internet protocols */ +#define BSD 43 /* BSD 4.3 -like OS */ +#define BSDDEBUG /* turn on debug */ +#define GATEWAY /* tables to be initialized for gateway routing */ + +/* common macros */ + +#define MSB(x) (((x) >> 8) & 0xff) /* most signif byte of 2-byte integer */ +#define LSB(x) ((x) & 0xff) /* least signif byte of 2-byte integer*/ + +#define OFFSET(structure, member) /* byte offset of member in structure*/\ + ((int) &(((structure *) 0) -> member)) + +#define MEMBER_SIZE(structure, member) /* size of a member of a structure */\ + (sizeof (((structure *) 0) -> member)) + +#define NELEMENTS(array) /* number of elements in an array */ \ + (sizeof (array) / sizeof ((array) [0])) + +#define FOREVER for (;;) + +#define max(x, y) (((x) < (y)) ? (y) : (x)) +#define min(x, y) (((x) < (y)) ? (x) : (y)) + + +/* storage class specifier definitions */ + +#define FAST register +#define IMPORT extern +#define LOCAL static + + +/* include typedefs - must come after CPU_FAMILY definitions above */ + +#include "vxTypes.h" + +#endif /* INCvxWorksh */ diff --git a/gdb/vx-share/wait.h b/gdb/vx-share/wait.h new file mode 100644 index 0000000..bb81f5b --- /dev/null +++ b/gdb/vx-share/wait.h @@ -0,0 +1,42 @@ +/* wait.h - header file for remote wait call */ + +/* +modification history +-------------------- +01a,05jun90,llk borrowed. +*/ + +/* Define how to access the structure that the wait system call stores. + On many systems, there is a structure defined for this. + But on vanilla-ish USG systems there is not. */ + +#ifndef HAVE_WAIT_STRUCT +#define WAITTYPE int +#define WIFSTOPPED(w) (((w)&0377) == 0177) +#define WIFSIGNALED(w) (((w)&0377) != 0177 && ((w)&~0377) == 0) +#define WIFEXITED(w) (((w)&0377) == 0) +#define WRETCODE(w) ((w) >> 8) +#define WSTOPSIG(w) ((w) >> 8) +#define WCOREDUMP(w) (((w)&0200) != 0) +#define WTERMSIG(w) ((w) & 0177) +#define WSETEXIT(w, status) ((w) = (status)) +#define WSETSTOP(w,sig) ((w) = (0177 | ((sig) << 8))) +#else +#if FALSE +#ifndef ORIG + +/* don't include sys/wait.h */ + +#else ORIG +#include <sys/wait.h> +#endif ORIG +#endif FALSE +#define WAITTYPE union wait +#define WRETCODE(w) (w).w_retcode +#define WSTOPSIG(w) (w).w_stopsig +#define WCOREDUMP(w) (w).w_coredump +#define WTERMSIG(w) (w).w_termsig +#define WSETEXIT(w, status) ((w).w_status = (status)) +#define WSETSTOP(w,sig) \ + ((w).w_stopsig = (sig), (w).w_coredump = 0, (w).w_termsig = 0177) +#endif diff --git a/gdb/vx-share/xdr_ld.c b/gdb/vx-share/xdr_ld.c new file mode 100644 index 0000000..4935c34 --- /dev/null +++ b/gdb/vx-share/xdr_ld.c @@ -0,0 +1,82 @@ +/* xdr_ld.c - xdr routines for remote dbx interface to VxWorks */ + +/* Copyright 1984,1985,1986,1987,1988,1989 Wind River Systems, Inc. */ +/*extern char copyright_wind_river[]; static char *copyright=copyright_wind_river;*/ + +/* +modification history +-------------------- +01a,05jun90,llk extracted from xdr_dbx.c. +*/ + +/* +DESCRIPTION +This module contains the eXternal Data Representation (XDR) routines +for object files that are downloaded to VxWorks. They are used by +remote debuggers that use RPC (such as dbxWorks and vxGdb). +*/ + +#include "vxWorks.h" +#include "rpc/rpc.h" +#include "xdr_ld.h" + +/* forward declarations */ + +bool_t xdr_String(); /* xdr routine for argument list */ + + +/******************************************************************************* +* +* xdr_String - xdr routine for strings. +* +* Used by xdr_arg_info to handle the actual argument +* strings. normally calls xdr_string - but does something +* reasonable encode of null pointer. +*/ + +bool_t xdr_String (xdrs, strp) + XDR *xdrs; + char **strp; + + { + if ((*strp == NULL) & (xdrs->x_op == XDR_ENCODE)) + return(FALSE); + else + return(xdr_string(xdrs, strp, MAXSTRLEN)); + } +/******************************************************************************* +* +* xdr_ldfile - xdr routine for a single element in the load table +*/ + +bool_t xdr_ldfile (xdrs, objp) + XDR *xdrs; + ldfile *objp; + + { + if (! xdr_String(xdrs, &objp->name)) + return(FALSE); + if (! xdr_int(xdrs, &objp->txt_addr)) + return(FALSE); + if (! xdr_int(xdrs, &objp->data_addr)) + return(FALSE); + if (! xdr_int(xdrs, &objp->bss_addr)) + return(FALSE); + + return(TRUE); + } +/******************************************************************************* +* +* xdr_ldtabl - +* +* xdr routine for a list of files and load addresses loaded into VxWorks. +*/ + +bool_t xdr_ldtabl (xdrs,objp) + XDR *xdrs; + ldtabl *objp; + + { + return (xdr_array (xdrs, (char *) &objp->tbl_ent, (UINT *) &objp->tbl_size, + MAXTBLSZ, sizeof(ldfile), xdr_ldfile)); + } diff --git a/gdb/vx-share/xdr_ld.h b/gdb/vx-share/xdr_ld.h new file mode 100644 index 0000000..8021ccf --- /dev/null +++ b/gdb/vx-share/xdr_ld.h @@ -0,0 +1,41 @@ +/* xdr_ld.h - xdr for additional dbxWorks structures */ + +/* +modification history +-------------------- +01a,05jun90,llk extracted from xdr_dbx.h. +*/ + +#ifndef INCxdrldh +#define INCxdrldh + +#define MAXSTRLEN 256 +#define MAXTBLSZ 100 + +/* + * structure used to pass back the information for a single file + * loaded in VxWorks + */ +struct ldfile { + char *name; + int txt_addr; + int data_addr; + int bss_addr; +}; +typedef struct ldfile ldfile; + +/* + * structure used to return a list of all files loaded over to + * VxWorks. (VX_STATE_INQ return) + */ +struct ldtabl { + u_int tbl_size; + ldfile *tbl_ent; +}; +typedef struct ldtabl ldtabl; + + +bool_t xdr_ldfile(); +bool_t xdr_ldtabl(); + +#endif INCxdrldh diff --git a/gdb/vx-share/xdr_ptrace.c b/gdb/vx-share/xdr_ptrace.c new file mode 100644 index 0000000..08813fc --- /dev/null +++ b/gdb/vx-share/xdr_ptrace.c @@ -0,0 +1,171 @@ +/* xdr_ptrace.c - xdr routines for remote ptrace calls */ + +/* Copyright 1984,1985,1986,1987,1988,1989 Wind River Systems, Inc. */ +/* extern char copyright_wind_river[]; static char *copyright=copyright_wind_river;*/ + +/* +modification history +-------------------- +01a,05jun90,llk extracted from xdr_ptrace.h, version 01c. +*/ + +#include <vxWorks.h> +#include <rpc/rpc.h> +#include <xdr_ptrace.h> + +#define MAX_LEN 32000 + +/******************************************************************** +* +* xdr_regs_ptr - +* +* xdr routine to get regs* branch of discriminated union ptrace_info +* +*/ + +LOCAL bool_t xdr_regs_ptr(xdrs,objp) + XDR *xdrs; + struct regs **objp; + { + return (xdr_pointer(xdrs, (char **) objp, sizeof(struct regs), xdr_regs)); + } /* xdr_regs_ptr */ + +/******************************************************************** +* +* xdr_fp_status_ptr - +* +* xdr routine for fp_status * branch of discrimanated union +* +*/ + +LOCAL bool_t xdr_fp_status_ptr(xdrs,objp) + XDR *xdrs; + struct fp_status **objp; + { + return(xdr_pointer(xdrs, (char **) objp, sizeof(struct fp_status), + xdr_fp_status)); + } /* xdr_fp_status_ptr */ + +#ifndef I80960 +/******************************************************************** +* +* xdr_fpa_regs_ptr - +* +* xdr routine for fpa_regs* branch of ptrace_info +* +*/ + +LOCAL bool_t xdr_fpa_regs_ptr(xdrs,objp) + XDR *xdrs; + struct fpa_regs **objp; + { + if (! xdr_pointer(xdrs, (char **) objp, sizeof(struct fpa_regs), + xdr_fpa_regs)) + return(FALSE); + else + return(TRUE); + } /* xdr_fpa_regs_ptr */ +#endif + +/******************************************************************** +* +* xdr_c_bytes_ptr - +* +* xdr routine for counted bytes branch of ptrace_info +* +*/ + +LOCAL bool_t xdr_c_bytes_ptr(xdrs,objp) + XDR *xdrs; + C_bytes **objp; + { + return(xdr_pointer(xdrs, (char **) objp, sizeof(C_bytes), xdr_c_bytes)); + } /* xdr_c_bytes_ptr */ + +/******************************************************************** +* +* xdr_ptrace_info - +* +* xdr routine for discriminated union ptrace_info +* +*/ + +bool_t xdr_ptrace_info(xdrs,objp) + XDR *xdrs; + Ptrace_info *objp; + { + static struct xdr_discrim choices[] = + { + { (int) REGS, xdr_regs_ptr }, + { (int) FPREGS, xdr_fp_status_ptr }, +#ifndef I80960 + { (int) FPAREGS, xdr_fpa_regs_ptr }, +#endif + { (int) DATA, xdr_c_bytes_ptr }, + { __dontcare__, NULL } + }; + + return(xdr_union(xdrs, (enum_t *) &objp->ttype, + (char *) &objp->more_data, choices, xdr_void)); + } /* xdr_ptrace_info */ + +/******************************************************************** +* +* xdr_rptrace - +* +* xdr routine for remote ptrace data into server +* +*/ + +bool_t xdr_rptrace(xdrs,objp) + XDR *xdrs; + Rptrace *objp; + { + if (! xdr_int(xdrs, &objp->pid)) + return(FALSE); + if (! xdr_int(xdrs, &objp->data)) + return(FALSE); + if (! xdr_int(xdrs, &objp->addr)) + return(FALSE); + if (! xdr_ptrace_info(xdrs, &objp->info)) + return(FALSE); + + return(TRUE); + } /* xdr_rptrace */ + +/******************************************************************** +* +* xdr_ptrace_return - +* +* xdr routine for remote ptrace data returned by server +* +*/ + +bool_t xdr_ptrace_return(xdrs, objp) + XDR *xdrs; + Ptrace_return *objp; + { + if (! xdr_int(xdrs, &objp->status)) + return(FALSE); + if (! xdr_int(xdrs, &objp->errno)) + return(FALSE); + if (! xdr_ptrace_info(xdrs, &objp->info)) + return(FALSE); + + return(TRUE); + } /* xdr_ptrace_return */ + +/******************************************************************** +* +* xdr_c_bytes - +* +* xdr routine for counted bytes +* +*/ +bool_t xdr_c_bytes(xdrs,objp) + XDR *xdrs; + C_bytes *objp; + { + return(xdr_bytes(xdrs, &objp->bytes, (u_int *) &objp->len, MAX_LEN)); + } /* xdr_c_bytes */ + diff --git a/gdb/vx-share/xdr_ptrace.h b/gdb/vx-share/xdr_ptrace.h new file mode 100644 index 0000000..1fe7ab4 --- /dev/null +++ b/gdb/vx-share/xdr_ptrace.h @@ -0,0 +1,68 @@ +/* xdr_ptrace.h - xdr header for remote ptrace structures */ + +/* +modification history +-------------------- +01a,05jun90,llk extracted from xdr_ptrace.h. +*/ + + +#include "xdr_regs.h" +#include "reg.h" + +/* + * Counted byte structure used by READ/WRITE TEXT/DATA + */ +struct c_bytes { + u_int len; + caddr_t bytes; +}; +typedef struct c_bytes C_bytes; + +/* + * enum for discriminated union ptrace_info + */ +enum ptype { + NOINFO = 0, /* no additional infomation */ + REGS = 1, /* regs (SETREGS) */ + FPREGS = 2, /* fp_status (SETFPREGS) */ + FPAREGS = 3, /* fpa_regs (SETFPAREGS) */ + DATA = 4, /* c_bytes (WRITETEXT/DATA)*/ +}; +typedef enum ptype ptype; + +/* + * discrimnated union for passing additional data to be + * written to the debugged process. With the exception of + * c_bytes, the structures are defined in <machine/reg.h> + */ +struct ptrace_info { + ptype ttype; + caddr_t more_data; +}; +typedef struct ptrace_info Ptrace_info; + +/* + * structure passed to server on all remote ptrace calls + */ +struct rptrace { + int pid; + int data; + int addr; /* FIX! this really should be caddr_t or something */ + Ptrace_info info; +}; +typedef struct rptrace Rptrace; +/* + * structure returned by server on all remote ptrace calls + */ +struct ptrace_return { + int status; + int errno; + Ptrace_info info; +}; +typedef struct ptrace_return Ptrace_return; + +bool_t xdr_c_bytes(); +bool_t xdr_ptrace_info(); +bool_t xdr_rptrace(); +bool_t xdr_ptrace_return(); diff --git a/gdb/vx-share/xdr_rdb.c b/gdb/vx-share/xdr_rdb.c new file mode 100644 index 0000000..3c70fbf --- /dev/null +++ b/gdb/vx-share/xdr_rdb.c @@ -0,0 +1,207 @@ +/* xdr_rdb.c - xdr routines for Remote Debug interface to VxWorks */ + +/* +modification history +-------------------- +01a,21mar90,llk created using modification 01d of xdr_dbx.c. +*/ + +/* +DESCRIPTION +This module contains the eXternal Data Representation (XDR) routines +for the RDB interface for VxWorks. +*/ + +#include "vxWorks.h" +#include <rpc/rpc.h> +#include "xdr_rdb.h" + +/* forward declarations */ + +bool_t +xdr_arg_type(xdrs, objp) + XDR *xdrs; + arg_type *objp; +{ + if (!xdr_enum(xdrs, (enum_t *)objp)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_arg_value(xdrs, objp) + XDR *xdrs; + arg_value *objp; +{ + if (!xdr_arg_type(xdrs, &objp->type)) { + return (FALSE); + } + switch (objp->type) { + case T_BYTE: + if (!xdr_char(xdrs, &objp->arg_value_u.v_byte)) { + return (FALSE); + } + break; + case T_WORD: + if (!xdr_short(xdrs, &objp->arg_value_u.v_word)) { + return (FALSE); + } + break; + case T_INT: + if (!xdr_int(xdrs, &objp->arg_value_u.v_int)) { + return (FALSE); + } + break; + case T_FLOAT: + if (!xdr_float(xdrs, &objp->arg_value_u.v_fp)) { + return (FALSE); + } + break; + case T_DOUBLE: + if (!xdr_double(xdrs, &objp->arg_value_u.v_dp)) { + return (FALSE); + } + break; + case T_UNKNOWN: + break; + } + return (TRUE); +} + +bool_t +xdr_func_call(xdrs, objp) + XDR *xdrs; + func_call *objp; +{ + if (!xdr_int(xdrs, &objp->func_addr)) { + return (FALSE); + } + if (!xdr_array(xdrs, (char **)&objp->args.args_val, (u_int *)&objp->args.args_len, MAX_FUNC_ARGS, sizeof(arg_value), xdr_arg_value)) { + return (FALSE); + } + return (TRUE); +} + +bool_t +xdr_arg_one(xdrs, objp) + XDR *xdrs; + arg_one *objp; +{ + if (!xdr_string(xdrs, objp, MAX_ARG_LEN)) { + return (FALSE); + } + return (TRUE); +} + + + + +bool_t +xdr_arg_array(xdrs, objp) + XDR *xdrs; + arg_array *objp; +{ + if (!xdr_array(xdrs, (char **)&objp->arg_array_val, (u_int *)&objp->arg_array_len, MAX_ARG_CNT, sizeof(arg_one), xdr_arg_one)) { + return (FALSE); + } + return (TRUE); +} + +/********************************************************************* +* +* xdr_EVENT_TYPE - +* +*/ + +bool_t xdr_EVENT_TYPE(xdrs, objp) + XDR *xdrs; + EVENT_TYPE *objp; + + { + if (!xdr_enum (xdrs, (enum_t *) objp)) + return (FALSE); + return (TRUE); + } + +/********************************************************************* +* +* xdr_RDB_EVENT - +* +*/ + +bool_t xdr_RDB_EVENT (xdrs, objp) + XDR *xdrs; + RDB_EVENT *objp; + + { + if (!xdr_int (xdrs, &objp->status)) + return (FALSE); + if (!xdr_int (xdrs, &objp->taskId)) + return (FALSE); + if (!xdr_EVENT_TYPE (xdrs, &objp->eventType)) + return (FALSE); + if (!xdr_int (xdrs, &objp->sigType)) + return (FALSE); + return (TRUE); + } + +/********************************************************************* +* +* xdr_TASK_START - +* +*/ + +bool_t +xdr_TASK_START (xdrs, objp) + XDR *xdrs; + TASK_START *objp; + + { + if (!xdr_int (xdrs, &objp->status)) + return (FALSE); + if (!xdr_int (xdrs, &objp->pid)) + return (FALSE); + return (TRUE); + } + + +/********************************************************************* +* +* xdr_SYMBOL_ADDR - +* +*/ + +bool_t +xdr_SYMBOL_ADDR (xdrs, objp) + XDR *xdrs; + SYMBOL_ADDR *objp; + + { + if (!xdr_int (xdrs, &objp->status)) + return (FALSE); + if (!xdr_u_int (xdrs, &objp->addr)) + return (FALSE); + return (TRUE); + } + +/********************************************************************* +* +* xdr_SOURCE_STEP - +* +*/ + +bool_t +xdr_SOURCE_STEP (xdrs, objp) + XDR *xdrs; + SOURCE_STEP *objp; + + { + if (!xdr_int (xdrs, &objp->taskId)) + return (FALSE); + if (!xdr_u_int (xdrs, &objp->startAddr)) + return (FALSE); + if (!xdr_u_int (xdrs, &objp->endAddr)) + return (FALSE); + return (TRUE); + } diff --git a/gdb/vx-share/xdr_rdb.h b/gdb/vx-share/xdr_rdb.h new file mode 100644 index 0000000..eebec43 --- /dev/null +++ b/gdb/vx-share/xdr_rdb.h @@ -0,0 +1,132 @@ +/* xdr_rdb.h - xdr for additional rdb structures */ + +/* +modification history +-------------------- +01a,23may90,llk created using xdr_dbx.h. + added arg_array to replace arg_info. arg_info had + MAXNCMDARGS (= 100) as the max limit of char strings, + but it should be MAX_TASK_ARGS (= 10). +*/ + +#ifndef INCxdrrdbh +#define INCxdrrdbh + +enum arg_type { + T_UNKNOWN = 0, + T_BYTE = 1, + T_WORD = 2, + T_INT = 3, + T_FLOAT = 4, + T_DOUBLE = 5, +}; +typedef enum arg_type arg_type; +bool_t xdr_arg_type(); + + +struct arg_value { + arg_type type; + union { + char v_byte; + short v_word; + int v_int; + float v_fp; + double v_dp; + } arg_value_u; +}; +typedef struct arg_value arg_value; +bool_t xdr_arg_value(); + +struct func_call { + int func_addr; + struct { + u_int args_len; + arg_value *args_val; + } args; +}; +typedef struct func_call func_call; +bool_t xdr_func_call(); + + +typedef char *arg_one; +bool_t xdr_arg_one(); + + +typedef struct { + u_int arg_array_len; + arg_one *arg_array_val; +} arg_array; +bool_t xdr_arg_array(); + + +/* + * Structures used to pass structures required for + * process control but not part of the standard ptrace interface + */ + +/* + * arg_info is used to pass arguments into process start + */ +struct arg_info { + int rargc; + char **rargv; +}; +typedef struct arg_info Arg_info; + + +enum EVENT_TYPE { + EVENT_BREAK = 0, + EVENT_STOP = 1, + EVENT_EXIT = 2, + EVENT_BUS_ERR = 3, + EVENT_SUSPEND = 4, + EVENT_ZERO_DIV = 5, + EVENT_SIGNAL = 6, + EVENT_START = 7, +}; +typedef enum EVENT_TYPE EVENT_TYPE; + + +struct RDB_EVENT { + int status; + int taskId; + EVENT_TYPE eventType; + int sigType; +}; +typedef struct RDB_EVENT RDB_EVENT; + + +struct TASK_START { + int status; + int pid; +}; +typedef struct TASK_START TASK_START; + + +struct SYMBOL_ADDR { + int status; + u_int addr; +}; +typedef struct SYMBOL_ADDR SYMBOL_ADDR; + +struct SOURCE_STEP { + int taskId; + u_int startAddr; + u_int endAddr; +}; +typedef struct SOURCE_STEP SOURCE_STEP; + +#define MAX_ARG_CNT 10 +#define MAX_FUNC_ARGS 100 +#define MAX_ARG_LEN 100 + +bool_t xdr_arg_info(); +bool_t xdr_EVENT_TYPE(); +bool_t xdr_RDB_EVENT(); +bool_t xdr_TASK_START(); +bool_t xdr_SYMBOL_ADDR(); +bool_t xdr_SOURCE_STEP(); + +#define RDBPROG (u_long) 0x44444444 +#define RDBVERS (u_long) 1 +#endif INCxdrrdbh diff --git a/gdb/vx-share/xdr_regs.c b/gdb/vx-share/xdr_regs.c new file mode 100644 index 0000000..9152423 --- /dev/null +++ b/gdb/vx-share/xdr_regs.c @@ -0,0 +1,216 @@ +/* xdr_regs.c - xdr routines for 68k registers */ + +/* Copyright 1984,1985,1986,1987,1988,1989 Wind River Systems, Inc. */ + +/* +DESCRIPTION +This module contains the eXternal Data Representation (XDR) routines +for the GDB interface for VxWorks. +*/ + +#include <vxWorks.h> +#include <rpc/rpc.h> +#include <reg.h> +#include <xdr_regs.h> + + +#ifdef I80960 +/******************************************************************************* +* +* xdr_regs - xdr routine for i960 registers +*/ + +bool_t xdr_regs (xdrs, objp) + XDR *xdrs; + struct regs *objp; + + { + if (! xdr_opaque(xdrs, (char *) objp->r_lreg, 16 * sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) objp->r_greg, 16 * sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) &objp->r_pcw, sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) &objp->r_acw, sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) &objp->r_tcw, sizeof(int))) + return(FALSE); + + return(TRUE); + } + +/******************************************************************************* +* +* xdr_fp_status - xdr routine for i960 floating point registers +*/ + +bool_t xdr_fp_status (xdrs, objp) + XDR *xdrs; + struct fp_status *objp; + + { + unsigned int size = 4 * FP_REG_SIZE; + + /* We use xdr_bytes to indicate how many bytes of FP regs there are! */ + if (! xdr_bytes (xdrs, (char *) objp->fps_regs, &size, 4 * FP_REG_SIZE)) + return (FALSE); + return (TRUE); + } + +/******************************************************************************* +* +* xdr_ext_fp - xdr for a single fp register +*/ + +bool_t xdr_ext_fp (xdrs, objp) + XDR *xdrs; + char *objp; + + { + unsigned int size = FP_REG_SIZE; + + if (! xdr_bytes (xdrs, objp, &size, FP_REG_SIZE)) + return(FALSE); + + return(TRUE); + } +#else /* Must be 68K if it isn't i960 -- for now. FIXME! */ + +/******************************************************************************* +* +* xdr_regs - xdr routine for 68k registers +*/ + +bool_t xdr_regs (xdrs, objp) + XDR *xdrs; + struct regs *objp; + + { + if (! xdr_opaque(xdrs, (char *) objp->r_dreg, 8 * sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) objp->r_areg, 8 * sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) &objp->r_sr, sizeof(int))) + return(FALSE); + if (! xdr_opaque(xdrs, (char *) &objp->r_pc, sizeof(int))) + return(FALSE); + + return(TRUE); + } + +/******************************************************************************* +* +* xdr_ext_fp - xdr for a single fp register +*/ + +bool_t xdr_ext_fp (xdrs, objp) + XDR *xdrs; + ext_fp *objp; + + { + if (! xdr_vector(xdrs, (char *) objp->fp, 3, sizeof(int), xdr_int)) + return(FALSE); + + return(TRUE); + } +/******************************************************************************* +* +* xdr_fp_status - xdr routine for floating point registers +*/ + +bool_t xdr_fp_status (xdrs, objp) + XDR *xdrs; + struct fp_status *objp; + + { + if (! xdr_vector (xdrs, (char *) objp->fps_regs, 8, + sizeof(ext_fp), xdr_ext_fp)) + return (FALSE); + if (! xdr_int (xdrs, &objp->fps_control)) + return (FALSE); + if (! xdr_int (xdrs, &objp->fps_status)) + return (FALSE); + if (! xdr_int (xdrs, &objp->fps_iaddr)) + return (FALSE); + if (! xdr_int (xdrs, &objp->fps_code)) + return (FALSE); + if (! xdr_int (xdrs, &objp->fps_flags)) + return (FALSE); + + return (TRUE); + } +/******************************************************************************* +* +* xdr_fpa_status - xdr for fpa status +*/ + +bool_t xdr_fpa_status (xdrs, objp) + XDR *xdrs; + struct fpa_status *objp; + + { + if (! xdr_u_int (xdrs, &objp->fpas_state)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_imask)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_load_ptr)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_ierr)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_act_instr)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_nxt_instr)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_act_d1half)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_act_d2half)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_nxt_d1half)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_nxt_d2half)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_mode3_0)) + return (FALSE); + if (! xdr_u_int (xdrs, &objp->fpas_wstatus)) + return (FALSE); + + return (TRUE); + } +/******************************************************************************* +* +* xdr_fpa_long - xdr for fpa data register +*/ + +bool_t xdr_fpa_long (xdrs,objp) + XDR *xdrs; + fpa_long *objp; + + { + if (! xdr_vector (xdrs, (char *) objp->fpl_data, 2, sizeof(int), xdr_int)) + return (FALSE); + + return (TRUE); + } +/******************************************************************************* +* +* xdr_fpa_regs - xdr for fpa_regs +*/ + +bool_t xdr_fpa_regs (xdrs, objp) + XDR *xdrs; + struct fpa_regs *objp; + + { + if (! xdr_u_int (xdrs, &objp->fpar_flags)) + return (FALSE); + if (! xdr_fpa_status (xdrs, &objp->fpar_status)) + return (FALSE); + if (! xdr_vector (xdrs, (char *) objp->fpar_data, + FPA_NDATA_REGS, sizeof(fpa_long), xdr_fpa_long)) + return (FALSE); + + return (TRUE); + } + +#endif /* I80960 */ + diff --git a/gdb/vx-share/xdr_regs.h b/gdb/vx-share/xdr_regs.h new file mode 100644 index 0000000..c829d64 --- /dev/null +++ b/gdb/vx-share/xdr_regs.h @@ -0,0 +1,16 @@ +/* xdr_regs.h - xdr header for 68k registers */ + +/* +modification history +-------------------- +01a,05jun90,llk extracted from xdr_regs.h. +*/ + +/* xdr structures are defined in reg.h (a bad place for them, i might add) */ + +bool_t xdr_regs(); +bool_t xdr_ext_fp(); +bool_t xdr_fp_status(); +bool_t xdr_fpa_status(); +bool_t xdr_fpa_long(); +bool_t xdr_fpa_regs(); diff --git a/gdb/xm-3b1.h b/gdb/xm-3b1.h new file mode 100644 index 0000000..6efef40 --- /dev/null +++ b/gdb/xm-3b1.h @@ -0,0 +1,87 @@ +/* Parameters for execution on a 3b1. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +#define HAVE_TERMIO +#define USG + +#define MAXPATHLEN 200 + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR 0x70000 + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ addr = blockend + regno * 4; } + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } + +#endif diff --git a/gdb/xm-altos.h b/gdb/xm-altos.h new file mode 100644 index 0000000..3a4dc5f --- /dev/null +++ b/gdb/xm-altos.h @@ -0,0 +1,208 @@ +/* Definitions to make GDB run on an Altos 3068 (m68k running SVR2) + Copyright (C) 1987,1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* The altos support would make a good base for a port to other USGR2 systems + (like the 3b1 and the Convergent miniframe). */ + +/* This is only needed in one file, but it's cleaner to put it here than + putting in more #ifdef's. */ +#include <sys/page.h> +#include <sys/net.h> + +#define USG + +#define HAVE_TERMIO + +#define CBREAK XTABS /* It takes all kinds... */ + +#ifndef R_OK +#define R_OK 4 +#define W_OK 2 +#define X_OK 1 +#define F_OK 0 +#endif + +#ifndef MAXPATHLEN +#define MAXPATHLEN (1024) +#endif + +/* Get sys/wait.h ie. from a Sun and edit it a little (mc68000 to m68k) */ +/* Why bother? */ +#if 0 +#define HAVE_WAIT_STRUCT +#endif + +#define vfork fork + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR 0x1fbf000 + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ if (regno <= SP_REGNUM) \ + addr = blockend + regno * 4; \ + else if (regno == PS_REGNUM) \ + addr = blockend + regno * 4 + 4; \ + else if (regno == PC_REGNUM) \ + addr = blockend + regno * 4 + 2; \ +} + +#define REGISTER_ADDR(u_ar0, regno) \ + (((regno) < PS_REGNUM) \ + ? (&((struct exception_stack *) (u_ar0))->e_regs[(regno + R0)]) \ + : (((regno) == PS_REGNUM) \ + ? ((int *) (&((struct exception_stack *) (u_ar0))->e_PS)) \ + : (&((struct exception_stack *) (u_ar0))->e_PC))) + +#define FP_REGISTER_ADDR(u, regno) \ + (((char *) \ + (((regno) < FPC_REGNUM) \ + ? (&u.u_pcb.pcb_mc68881[FMC68881_R0 + (((regno) - FP0_REGNUM) * 3)]) \ + : (&u.u_pcb.pcb_mc68881[FMC68881_C + ((regno) - FPC_REGNUM)]))) \ + - ((char *) (& u))) + + +#ifndef __GNUC__ +#undef USE_GAS +#define ALTOS_AS +#else +#define USE_GAS +#endif + +/* Motorola assembly format */ +#if !defined(USE_GAS) && !defined(ALTOS) +#define MOTOROLA +#endif + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#ifdef MOTOROLA +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("move.l $ end, sp"); \ + asm ("clr.l fp"); } +#else +#ifdef ALTOS_AS +#define INIT_STACK(beg, end) \ +{ asm ("global end"); \ + asm ("mov.l &end,%sp"); \ + asm ("clr.l %fp"); } +#else +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } +#endif +#endif + +/* Push the frame pointer register on the stack. */ +#ifdef MOTOROLA +#define PUSH_FRAME_PTR \ + asm ("move.l fp, -(sp)"); +#else +#ifdef ALTOS_AS +#define PUSH_FRAME_PTR \ + asm ("mov.l %fp, -(%sp)"); +#else +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); +#endif +#endif + +/* Copy the top-of-stack to the frame pointer register. */ +#ifdef MOTOROLA +#define POP_FRAME_PTR \ + asm ("move.l (sp), fp"); +#else +#ifdef ALTOS_AS +#define POP_FRAME_PTR \ + asm ("mov.l (%sp), %fp"); +#else +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); +#endif +#endif + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#ifdef MOTOROLA +#define PUSH_REGISTERS \ +{ asm ("clr.w -(sp)"); \ + asm ("pea (10,sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } +#else +#ifdef ALTOS_AS +#define PUSH_REGISTERS \ +{ asm ("clr.w -(%sp)"); \ + asm ("pea (10,%sp)"); \ + asm ("movm.l &0xfffe,-(%sp)"); } +#else +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } +#endif +#endif + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#ifdef MOTOROLA +#define POP_REGISTERS \ +{ asm ("subi.l $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } +#else +#ifdef ALTOS_AS +#define POP_REGISTERS \ +{ asm ("sub.l &8,28(%sp)"); \ + asm ("movem (%sp),&0xffff"); \ + asm ("rte"); } +#else +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } +#endif +#endif diff --git a/gdb/xm-arm.h b/gdb/xm-arm.h new file mode 100644 index 0000000..3251fae --- /dev/null +++ b/gdb/xm-arm.h @@ -0,0 +1,88 @@ +/* Definitions to make GDB run on an ARM under RISCiX (4.3bsd). + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR (0x01000000 - (UPAGES * NBPG)) + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ +#define FETCH_INFERIOR_REGISTERS + + +#if 0 +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \ + 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movl $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("pushl fp"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("pushl 8(sp)"); \ + asm ("pushl 8(sp)"); \ + asm ("pushal 0x14(sp)"); \ + asm ("pushr $037777"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("popr $037777"); \ + asm ("subl2 $8,(sp)"); \ + asm ("movl (sp),sp"); \ + asm ("rei"); } +#endif /* 0 */ diff --git a/gdb/xm-bigmips.h b/gdb/xm-bigmips.h new file mode 100644 index 0000000..0c1102d --- /dev/null +++ b/gdb/xm-bigmips.h @@ -0,0 +1,21 @@ +/* Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +#include "xm-mips.h" diff --git a/gdb/xm-convex.h b/gdb/xm-convex.h new file mode 100644 index 0000000..ed102bb --- /dev/null +++ b/gdb/xm-convex.h @@ -0,0 +1,51 @@ +/* Definitions to make GDB run on Convex Unix (4bsd) + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +#define LONG_LONG +#define ATTACH_DETACH +#define HAVE_WAIT_STRUCT +#define NO_SIGINTERRUPT + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* Use SIGCONT rather than SIGTSTP because convex Unix occasionally + turkeys SIGTSTP. I think. */ + +#define STOP_SIGNAL SIGCONT + +/* Use csh to do argument expansion so we get ~ and such. */ + +/* Doesn't work. */ +/* #define SHELL_FILE "/bin/csh" */ + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + +/* Hook to call after creating inferior process. */ + +#define CREATE_INFERIOR_HOOK create_inferior_hook + + +/* Interface definitions for kernel debugger KDB. */ + +/* (no kdb) */ diff --git a/gdb/xm-hp300bsd.h b/gdb/xm-hp300bsd.h new file mode 100644 index 0000000..4ae5a5c --- /dev/null +++ b/gdb/xm-hp300bsd.h @@ -0,0 +1,113 @@ +/* Parameters for execution on a Hewlett-Packard 9000/300, running bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * Configuration file for HP9000/300 series machine running + * University of Utah's 4.3bsd port. This is NOT for HP-UX. + * Problems to hpbsd-bugs@cs.utah.edu + */ + +#include <machine/endian.h> + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* Get kernel u area address at run-time using BSD style nlist (). */ +#define KERNEL_U_ADDR_BSD + +/* This is a piece of magic that is given a register number REGNO + and as BLOCKEND the address in the system of the end of the user structure + and stores in ADDR the address in the kernel or core dump + of that register. */ + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ \ + if (regno < PS_REGNUM) \ + addr = (int) &((struct frame *)(blockend))->f_regs[regno]; \ + else if (regno == PS_REGNUM) \ + addr = (int) &((struct frame *)(blockend))->f_stackadj; \ + else if (regno == PC_REGNUM) \ + addr = (int) &((struct frame *)(blockend))->f_pc; \ + else if (regno < FPC_REGNUM) \ + addr = (int) \ + &((struct user *)0)->u_pcb.pcb_fpregs.fpf_regs[((regno)-FP0_REGNUM)*3];\ + else if (regno == FPC_REGNUM) \ + addr = (int) &((struct user *)0)->u_pcb.pcb_fpregs.fpf_fpcr; \ + else if (regno == FPS_REGNUM) \ + addr = (int) &((struct user *)0)->u_pcb.pcb_fpregs.fpf_fpsr; \ + else \ + addr = (int) &((struct user *)0)->u_pcb.pcb_fpregs.fpf_fpiar; \ +} + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel #end, sp"); \ + asm ("movel #0,a6"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel a6,sp@-"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl sp@,a6"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea sp@(10)"); \ + asm ("movem #0xfffe,sp@-"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil #8,sp@(28)"); \ + asm ("movem sp@,#0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-hp300hpux.h b/gdb/xm-hp300hpux.h new file mode 100644 index 0000000..6583748 --- /dev/null +++ b/gdb/xm-hp300hpux.h @@ -0,0 +1,173 @@ +/* Parameters for execution on an HP 9000 model 320, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Define this to indicate problems with traps after continuing. */ +#define HP_OS_BUG + +/* fetch_inferior_registers is in hp300hpux-dep.c. */ +#define FETCH_INFERIOR_REGISTERS + +/* Set flag to indicate whether HP's assembler is in use. */ +#ifdef __GNUC__ +#ifdef __HPUX_ASM__ +#define HPUX_ASM +#endif +#else /* not GNU C. */ +#define HPUX_ASM +#endif /* not GNU C. */ + +/* Define this for versions of hp-ux older than 6.0 */ +/* #define HPUX_VERSION_5 */ + +/* define USG if you are using sys5 /usr/include's */ +#undef USG /* In case it was defined in the Makefile for cplus-dem.c */ +#define USG + +#define HAVE_TERMIO + +/* Get rid of any system-imposed stack limit if possible. */ +/* The hp9k320.h doesn't seem to have this feature. */ +/* #define SET_STACK_LIMIT_HUGE */ +/* So we'll just have to avoid big alloca's. */ +#define BROKEN_LARGE_ALLOCA + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#ifdef HPUX_VERSION_5 +#define KERNEL_U_ADDR 0x00979000 +#else /* Not HPUX version 5. */ +/* Use HPUX-style nlist() to get kernel_u_addr. */ +#define KERNEL_U_ADDR_HPUX +#endif /* Not HPUX version 5. */ + +#define REGISTER_ADDR(u_ar0, regno) \ + (unsigned int) \ + (((regno) < PS_REGNUM) \ + ? (&((struct exception_stack *) (u_ar0))->e_regs[(regno + R0)]) \ + : (((regno) == PS_REGNUM) \ + ? ((int *) (&((struct exception_stack *) (u_ar0))->e_PS)) \ + : (&((struct exception_stack *) (u_ar0))->e_PC))) + +#define FP_REGISTER_ADDR(u, regno) \ + (((char *) \ + (((regno) < FPC_REGNUM) \ + ? (&u.u_pcb.pcb_mc68881[FMC68881_R0 + (((regno) - FP0_REGNUM) * 3)]) \ + : (&u.u_pcb.pcb_mc68881[FMC68881_C + ((regno) - FPC_REGNUM)]))) \ + - ((char *) (& u))) + +/* Do implement the attach and detach commands. */ + +#define ATTACH_DETACH + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +#ifndef HPUX_ASM + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } + +#else /* HPUX_ASM */ + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm ("global end"); \ + asm ("mov.l &end,%sp"); \ + asm ("clr.l %a6"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("mov.l %fp,-(%sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("mov.l (%sp),%fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clr.w -(%sp)"); \ + asm ("pea 10(%sp)"); \ + asm ("movm.l &0xfffe,-(%sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subi.l &8,28(%sp)"); \ + asm ("mov.m (%sp),&0xffff"); \ + asm ("rte"); } + +#endif /* HPUX_ASM */ diff --git a/gdb/xm-i386v.h b/gdb/xm-i386v.h new file mode 100644 index 0000000..840cb58 --- /dev/null +++ b/gdb/xm-i386v.h @@ -0,0 +1,99 @@ +/* Macro defintions for i386. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* + * Changes for 80386 by Pace Willisson (pace@prep.ai.mit.edu) + * July 1988 + */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* I'm running gdb 3.4 under 386/ix 2.0.2, which is a derivative of AT&T's +Sys V/386 3.2. + +On some machines, gdb crashes when it's starting up while calling the +vendor's termio tgetent() routine. It always works when run under +itself (actually, under 3.2, it's not an infinitely recursive bug.) +After some poking around, it appears that depending on the environment +size, or whether you're running YP, or the phase of the moon or something, +the stack is not always long-aligned when main() is called, and tgetent() +takes strong offense at that. On some machines this bug never appears, but +on those where it does, it occurs quite reliably. */ +#define ALIGN_STACK_ON_STARTUP + +/* define USG if you are using sys5 /usr/include's */ +#define USG + +/* USG systems need these */ +#define vfork() fork() +#define MAXPATHLEN 500 + +#define HAVE_TERMIO + +/* Get rid of any system-imposed stack limit if possible. */ + +/* #define SET_STACK_LIMIT_HUGE not in sys5 */ + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR 0xe0000000 + + +#if 0 +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) {} + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR {} + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR {} + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS {} + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS {} +#endif /* 0 */ diff --git a/gdb/xm-i386v32.h b/gdb/xm-i386v32.h new file mode 100644 index 0000000..b343be0 --- /dev/null +++ b/gdb/xm-i386v32.h @@ -0,0 +1,28 @@ +/* Macro defintions for i386, running System V 3.2. + Copyright (C) 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "xm-i386v.h" + +/* Apparently there is inconsistency among various System V's about what + the name of this field is. */ +#define U_FPSTATE(u) u.u_fps.u_fpstate + +/* TIOCGETC is defined in System V 3.2 termio.h, but struct tchars + is not. This makes problems for inflow.c. */ +#define TIOCGETC_BROKEN diff --git a/gdb/xm-isi.h b/gdb/xm-isi.h new file mode 100644 index 0000000..21c0134 --- /dev/null +++ b/gdb/xm-isi.h @@ -0,0 +1,95 @@ +/* Definitions to make GDB run on an ISI Optimum V (3.05) under 4.3bsd. + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* This has not been tested on ISI's running BSD 4.2, but it will probably + work. */ + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +/*#define KERNEL_U_ADDR 0x10800000*/ +#define KERNEL_U_ADDR 0 + +/* expects blockend to be u.u_ar0 */ +extern int rloc[]; /* Defined in isi-dep.c */ +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ blockend &= UPAGES*NBPG - 1; \ + if (regno < 18) addr = (int)blockend + rloc[regno]*4; \ + else if (regno < 26) addr = (int) &((struct user *)0)->u_68881_regs \ + + (regno - 18) * 12; \ + else if (regno < 29) addr = (int) &((struct user *)0)->u_68881_regs \ + + 8 * 12 + (regno - 26) * 4; \ +} + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movl $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-m88k.h b/gdb/xm-m88k.h new file mode 100644 index 0000000..240459b --- /dev/null +++ b/gdb/xm-m88k.h @@ -0,0 +1,124 @@ +/* Copyright (C) 1986, 1987, 1988, 1989, 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is currently for a 88000 running DGUX. If other 88k ports are + done, OS-specific stuff should be moved (see tm-68k.h, for example). */ +/* g++ support is not yet included. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +#define USG +/* DGUX has bcopy(), etc. */ +#define USG_UTILS 0 + +#include <sys/param.h> + +#define vfork() fork() +#define index strchr +#define rindex strrchr +#define getwd(BUF) getcwd(BUF,MAXPATHLEN); +#define bzero(ptr,count) (memset((ptr),0,(count))) +#define bcopy(src,dst,count) (memcpy((dst),(src),(count))) +#define bcmp(left,right,count) (memcmp((right),(left),(count))) +#ifdef __GNUC__ +#define memcpy __builtin_memcpy +#define memset __builtin_memset +#define strcmp __builtin_strcmp +#endif + +#ifdef DGUX +#define x_foff _x_x._x_offset +#define x_fname _x_name +#define USER ptrace_user +#define _BSD_WAIT_FLAVOR +#endif + +#define HAVE_TERMIO + + +#define USIZE 2048 +#define NBPG NBPC +#define UPAGES USIZE + +#define HAVE_GETPAGESIZE + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* number of traps that happen between exec'ing the shell + * to run an inferior, and when we finally get to + * the inferior code. This is 2 on most implementations. + */ +#define START_INFERIOR_TRAPS_EXPECTED 2 + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +/* Since registers r0 through r31 are stored directly in the struct ptrace_user, + (for m88k BCS) + the ptrace_user offsets are sufficient and KERNEL_U_ADDRESS can be 0 */ + +#define KERNEL_U_ADDR 0 + +#define REGISTER_U_ADDR(addr, blockend, regno) \ + (addr) = m88k_register_u_addr ((blockend),(regno)); + +#define HAVE_WAIT_STRUCT + +#define FETCH_INFERIOR_REGISTERS + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) {} + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR {} + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR {} + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS {} + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS {} diff --git a/gdb/xm-merlin.h b/gdb/xm-merlin.h new file mode 100644 index 0000000..54c1baf --- /dev/null +++ b/gdb/xm-merlin.h @@ -0,0 +1,120 @@ +/* Definitions to make GDB run on a merlin under utek 2.1 + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This machine doesn't have the siginterrupt call. */ +#define NO_SIGINTERRUPT + +/* Under Utek, a ptrace'd process can be the only active process for + an executable. Therefore instead of /bin/sh use gdb-sh (which should + just be a copy of /bin/sh which is world readable and writeable). */ +#define SHELL_FILE "/usr/gnu/lib/gdb-sh" + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR (0xfef000) + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ \ + switch (regno) { \ + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: \ + addr = blockend + (R0 - regno) * sizeof (int); break; \ + case PC_REGNUM: \ + addr = blockend + PC * sizeof (int); break; \ + case SP_REGNUM: \ + addr = blockend + SP * sizeof (int); break; \ + case FP_REGNUM: \ + addr = blockend + FP * sizeof (int); break; \ + case PS_REGNUM: \ + addr = blockend + 12 * sizeof (int); break; \ + case FPS_REGNUM: \ + addr = 108; break; \ + case FP0_REGNUM + 0: case FP0_REGNUM + 1: \ + case FP0_REGNUM + 2: case FP0_REGNUM + 3: \ + case FP0_REGNUM + 4: case FP0_REGNUM + 5: \ + case FP0_REGNUM + 6: case FP0_REGNUM + 7: \ + addr = 76 + (regno - FP0_REGNUM) * sizeof (float); break; \ + case LP0_REGNUM + 0: case LP0_REGNUM + 1: \ + case LP0_REGNUM + 2: case LP0_REGNUM + 3: \ + addr = 76 + (regno - LP0_REGNUM) * sizeof (double); break; \ + default: \ + printf ("bad argument to REGISTER_U_ADDR %d\n", regno); \ + abort (); \ + } \ +} + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + +#if 0 +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \ + 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movl $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("pushl fp"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("pushl 8(sp)"); \ + asm ("pushl 8(sp)"); \ + asm ("pushal 0x14(sp)"); \ + asm ("pushr $037777"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("popr $037777"); \ + asm ("subl2 $8,(sp)"); \ + asm ("movl (sp),sp"); \ + asm ("rei"); } +#endif /* 0 */ diff --git a/gdb/xm-mips.h b/gdb/xm-mips.h new file mode 100644 index 0000000..3f7fce2 --- /dev/null +++ b/gdb/xm-mips.h @@ -0,0 +1,44 @@ +/* Definitions to make GDB run on a mips box under 4.3bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + Contributed by Per Bothner(bothner@cs.wisc.edu) at U.Wisconsin + and by Alessandro Forin(af@cs.cmu.edu) at CMU + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#if !defined (HOST_BYTE_ORDER) +#define HOST_BYTE_ORDER LITTLE_ENDIAN +#endif + +/* wait.h */ +#define HAVE_WAIT_STRUCT + +/* Get rid of any system-imposed stack limit if possible */ + +#define SET_STACK_LIMIT_HUGE + +/* This WOULD BE the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. + But Mips' ptrace works on regnums, not displacements */ + +#define KERNEL_U_ADDR (int)u.u_ar0 + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ +#define FETCH_INFERIOR_REGISTERS + +/* Interface definitions for kernel debugger KDB */ + +/* I am not going to pretend I've done anything about this */ diff --git a/gdb/xm-news.h b/gdb/xm-news.h new file mode 100644 index 0000000..1c5c6f1 --- /dev/null +++ b/gdb/xm-news.h @@ -0,0 +1,143 @@ +/* Parameters for execution on a Sony/NEWS, for GDB, the GNU debugger. + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +#define HAVE_WAIT_STRUCT + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* We can't use "isatty" or "fileno" on this machine. This isn't good, + but it will have to do. */ +#define ISATTY(FP) ((FP) == stdin || (FP) == stdout) + +/* THis is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR UADDR + +/* The offsets in this macro are from /usr/include/machine/reg.h */ + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ static char offsets[] = { \ + /*d0-d7:*/1,2,3,4,5,6,7,8, \ + /*a0-a6:*/9,10,11,12,13,14,15, /*sp:*/-4, /*ps:*/0, /*pc:*/-1, \ + /*fp0-fp7:*/19,22,25,28,31,34,37,40, /*fpc:*/16,17,18 }; \ + addr = blockend + 4 * offsets[regno]; \ +} + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + +/* NewsOS 3 apparently dies on large alloca's -- roland@ai.mit.edu. */ +#define BROKEN_LARGE_ALLOCA + + +/* Interface definitions for kernel debugger KDB. */ + +/* Use GNU assembler instead of standard assembler */ +#define USE_GAS + +/* Motorola assembly format */ +#ifndef USE_GAS +#define MOTOROLA +#endif + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#ifdef MOTOROLA +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("move.l $ end, sp"); \ + asm ("clr.l fp"); } +#else +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } +#endif + +/* Push the frame pointer register on the stack. */ +#ifdef MOTOROLA +#define PUSH_FRAME_PTR \ + asm ("move.l fp, -(sp)"); +#else +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); +#endif + +/* Copy the top-of-stack to the frame pointer register. */ +#ifdef MOTOROLA +#define POP_FRAME_PTR \ + asm ("move.l (sp), fp"); +#else +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); +#endif + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#ifdef MOTOROLA +#define PUSH_REGISTERS \ +{ asm ("clr.w -(sp)"); \ + asm ("pea (10,sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } +#else +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } +#endif + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#ifdef MOTOROLA +#define POP_REGISTERS \ +{ asm ("subi.l $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } +#else +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } +#endif diff --git a/gdb/xm-news1000.h b/gdb/xm-news1000.h new file mode 100644 index 0000000..aade898 --- /dev/null +++ b/gdb/xm-news1000.h @@ -0,0 +1,26 @@ +/* Parameters for a Sony/NEWS series 1000 with News-OS version 3, + for GDB, the GNU debugger. + Copyright (C) 1990 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* This is required by Sony include files like <sys/user.h> so we + get the right offset into the u area. Relying on the compiler + to define this only works for cc, not gcc. */ +#undef mc68030 +#define mc68030 +#include "xm-news.h" diff --git a/gdb/xm-np1.h b/gdb/xm-np1.h new file mode 100644 index 0000000..0608e36 --- /dev/null +++ b/gdb/xm-np1.h @@ -0,0 +1,99 @@ +/* Parameters for execution on a Gould NP1, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ +#define SET_STACK_LIMIT_HUGE + +/* Address of U in kernel space */ +#define KERNEL_U_ADDR 0x7fffc000 + +/* This is a piece of magic that is given a register number REGNO + and as BLOCKEND the address in the system of the end of the user structure + and stores in ADDR the address in the kernel or core dump + of that register. */ +#define REGISTER_U_ADDR(addr, blockend, regno) { \ + addr = blockend + regno * 4; \ + if (regno == VE_REGNUM) addr = blockend - 9 * 4; \ + if (regno == PC_REGNUM) addr = blockend - 8 * 4; \ + if (regno == PS_REGNUM) addr = blockend - 7 * 4; \ + if (regno == FP_REGNUM) addr = blockend - 6 * 4; \ + if (regno >= V1_REGNUM) \ + addr = blockend + 16 * 4 + (regno - V1_REGNUM) * VR_SIZE; \ +} + +/* Don't try to write the frame pointer. */ +#define CANNOT_STORE_REGISTER(regno) ((regno) == FP_REGNUM) + +#define MISSING_VPRINTF + +/* + * No KDB support, Yet! */ +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-pn.h b/gdb/xm-pn.h new file mode 100644 index 0000000..f9fa986 --- /dev/null +++ b/gdb/xm-pn.h @@ -0,0 +1,82 @@ +/* Parameters for execution on a Gould PN, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ +#define SET_STACK_LIMIT_HUGE + +#define MISSING_VPRINTF + +/* Address of U in kernel space */ +#define KERNEL_U_ADDR 0x3fc000 + +/* + * No KDB support, Yet! */ +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-pyr.h b/gdb/xm-pyr.h new file mode 100644 index 0000000..8a01569 --- /dev/null +++ b/gdb/xm-pyr.h @@ -0,0 +1,105 @@ +/* Definitions to make GDB run on a Pyramidax under OSx 4.0 (4.2bsd). + Copyright (C) 1988, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Define PYRAMID_CONTROL_FRAME_DEBUGGING to get copious messages + about reading the control stack on standard output. This + makes gdb unusable as a debugger. */ + +/* #define PYRAMID_CONTROL_FRAME_DEBUGGING */ + +/* Define PYRAMID_FRAME_DEBUGGING for ? */ + +/* use Pyramid's slightly strange ptrace */ +#define PYRAMID_PTRACE + +/* Traditional Unix virtual address spaces have thre regions: text, + data and stack. The text, initialised data, and uninitialised data + are represented in separate segments of the a.out file. + When a process dumps core, the data and stack regions are written + to a core file. This gives a debugger enough information to + reconstruct (and debug) the virtual address space at the time of + the coredump. + Pyramids have an distinct fourth region of the virtual address + space, in which the contents of the windowed registers are stacked + in fixed-size frames. Pyramid refer to this region as the control + stack. Each call (or trap) automatically allocates a new register + frame; each return deallocates the current frame and restores the + windowed registers to their values before the call. + + When dumping core, the control stack is written to a core files as + a third segment. The core-handling functions need to know to deal + with it. */ + +/* Tell dep.c what the extra segment is. */ +#define PYRAMID_CORE + +#define NO_SIGINTERRUPT + +#define HAVE_WAIT_STRUCT + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR (0x80000000 - (UPAGES * NBPG)) + +/* Define offsets of registers in the core file (or maybe u area) */ +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ struct user __u; \ + addr = blockend + (regno - 16 ) * 4; \ + if (regno == 67) { \ + printf("\\geting reg 67\\"); \ + addr = (int)(&__u.u_pcb.pcb_csp) - (int) &__u; \ + } else if (regno == KSP_REGNUM) { \ + printf("\\geting KSP (reg %d)\\", KSP_REGNUM); \ + addr = (int)(&__u.u_pcb.pcb_ksp) - (int) &__u; \ + } else if (regno == CSP_REGNUM) { \ + printf("\\geting CSP (reg %d\\",CSP_REGNUM); \ + addr = (int)(&__u.u_pcb.pcb_csp) - (int) &__u; \ + } else if (regno == 64) { \ + printf("\\geting reg 64\\"); \ + addr = (int)(&__u.u_pcb.pcb_csp) - (int) &__u; \ + } else if (regno == PS_REGNUM) \ + addr = blockend - 4; \ + else if (1 && ((16 > regno) && (regno > 11))) \ + addr = last_frame_offset + (4 *(regno+32)); \ + else if (0 && (12 > regno)) \ + addr = global_reg_offset + (4 *regno); \ + else if (16 > regno) \ + addr = global_reg_offset + (4 *regno); \ + else \ + addr = blockend + (regno - 16 ) * 4; \ +} + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ +#define FETCH_INFERIOR_REGISTERS + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF + + +/* Interface definitions for kernel debugger KDB. */ + +/* I have *no idea* how to debug OSx kernels, so this + is flushed, possible forever. */ diff --git a/gdb/xm-sparc.h b/gdb/xm-sparc.h new file mode 100644 index 0000000..c8b9b34 --- /dev/null +++ b/gdb/xm-sparc.h @@ -0,0 +1,60 @@ +/* Parameters for execution on a Sun 4, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + Contributed by Michael Tiemann (tiemann@mcc.com) +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* Enable use of alternate code for Sun's format of core dump file. */ + +#define NEW_SUN_CORE + +/* Do implement the attach and detach commands. */ + +#define ATTACH_DETACH + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ + +#define FETCH_INFERIOR_REGISTERS + +/* Before storing, we need to read all the registers. */ + +#define CHILD_PREPARE_TO_STORE() read_register_bytes (0, NULL, REGISTER_BYTES) + +/* It does have a wait structure, and it might help things out . . . */ + +#define HAVE_WAIT_STRUCT + +/* Optimization for storing registers to the inferior. The hook + DO_DEFERRED_STORES + actually executes any deferred stores. It is called any time + we are going to proceed the child, or read its registers. + The hook CLEAR_DEFERRED_STORES is called when we want to throw + away the inferior process, e.g. when it dies or we kill it. + FIXME, this does not handle remote debugging cleanly. */ + +extern int deferred_stores; +extern int store_inferior_registers (); +#define DO_DEFERRED_STORES \ + if (deferred_stores) \ + store_inferior_registers (-2); +#define CLEAR_DEFERRED_STORES \ + deferred_stores = 0; diff --git a/gdb/xm-sun2.h b/gdb/xm-sun2.h new file mode 100644 index 0000000..278198a --- /dev/null +++ b/gdb/xm-sun2.h @@ -0,0 +1,96 @@ +/* Parameters for execution on a Sun, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR 0x2800 + +/* Enable use of alternate code for Sun's format of core dump file. */ + +#define NEW_SUN_CORE + +/* Do implement the attach and detach commands. */ + +#define ATTACH_DETACH + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ +#define FETCH_INFERIOR_REGISTERS + +/* This is a piece of magic that is given a register number REGNO + and as BLOCKEND the address in the system of the end of the user structure + and stores in ADDR the address in the kernel or core dump + of that register. */ + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ addr = blockend + regno * 4; } + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel fp, -(sp)"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea 10(sp)"); \ + asm ("movem $ 0xfffe,-(sp)"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil $8,28(sp)"); \ + asm ("movem (sp),$ 0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-sun3.h b/gdb/xm-sun3.h new file mode 100644 index 0000000..e67cc13 --- /dev/null +++ b/gdb/xm-sun3.h @@ -0,0 +1,93 @@ +/* Parameters for execution on a Sun, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER BIG_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* Enable use of alternate code for Sun's format of core dump file. */ + +#define NEW_SUN_CORE + +/* Do implement the attach and detach commands. */ + +#define ATTACH_DETACH + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ + +#define FETCH_INFERIOR_REGISTERS + +/* We have to grab the regs since we store all regs at once. */ + +#define CHILD_PREPARE_TO_STORE() \ + read_register_bytes (0, (char *)NULL, REGISTER_BYTES) + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, 0, 0, 0, SIGTRAP, 0, 0, 0, \ + 0, SIGTRAP, 0, 0, 0, 0, 0, SIGKILL, \ + 0, 0, 0, 0, 0, 0, 0, 0, \ + SIGILL } + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movel #end, sp"); \ + asm ("movel #0,a6"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("movel a6,sp@-"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl sp@,a6"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("clrw -(sp)"); \ + asm ("pea sp@(10)"); \ + asm ("movem #0xfffe,sp@-"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("subil #8,sp@(28)"); \ + asm ("movem sp@,#0xffff"); \ + asm ("rte"); } diff --git a/gdb/xm-sun386.h b/gdb/xm-sun386.h new file mode 100644 index 0000000..69b3673 --- /dev/null +++ b/gdb/xm-sun386.h @@ -0,0 +1,37 @@ +/* Parameters for execution on a Sun 386i, for GDB, the GNU debugger. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* Enable use of alternate code for Sun's format of core dump file. */ + +#define NEW_SUN_CORE + +/* Do implement the attach and detach commands. */ + +#define ATTACH_DETACH + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ +#define FETCH_INFERIOR_REGISTERS + +#define PREPARE_TO_STORE() read_register_bytes (0, NULL, REGISTER_BYTES) diff --git a/gdb/xm-sun3os4.h b/gdb/xm-sun3os4.h new file mode 100644 index 0000000..b9ffc8d --- /dev/null +++ b/gdb/xm-sun3os4.h @@ -0,0 +1,28 @@ +/* Macro definitions for a sun 3 running os 4. + Copyright (C) 1989, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "xm-sun3.h" +#define FPU + +/* There is a bug which can cause alloca to fail to allocate large + areas of memory one time in every 4096 (we think). */ +/* chase@orc.olivetti.com says that 4 megabyte alloca's consistently fail, + even though the stack limit (SET_STACK_LIMIT_HUGE) has been set + to 250 megabytes. */ +#define BROKEN_LARGE_ALLOCA diff --git a/gdb/xm-sun4os4.h b/gdb/xm-sun4os4.h new file mode 100644 index 0000000..eaf7473 --- /dev/null +++ b/gdb/xm-sun4os4.h @@ -0,0 +1,22 @@ +/* Macro definitions for running gdb on a Sun 4 running sunos 4. + Copyright (C) 1989, Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#include "xm-sparc.h" + +#define FPU diff --git a/gdb/xm-symmetry.h b/gdb/xm-symmetry.h new file mode 100644 index 0000000..c941cf0 --- /dev/null +++ b/gdb/xm-symmetry.h @@ -0,0 +1,152 @@ +/* Definitions to make GDB run on a Sequent Symmetry under dynix 3.0, + with Weitek 1167 and i387 support. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +/* Symmetry version by Jay Vosburgh (uunet!sequent!fubar) */ + +/* This machine doesn't have the siginterrupt call. */ +#define NO_SIGINTERRUPT + +#define HAVE_WAIT_STRUCT + +/* XPT_DEBUG doesn't work yet under Dynix 3.0.12, but UNDEBUG does... */ +/* #define PTRACE_ATTACH XPT_DEBUG +#define PTRACE_DETACH XPT_UNDEBUG +#define ATTACH_DETACH */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR (0x80000000 - (UPAGES * NBPG)) + +/* Compensate for lack of `vprintf' function. */ + +#define MISSING_VPRINTF + +/* Override copies of {fetch,store}_inferior_registers in infptrace.c. */ + +#define FETCH_INFERIOR_REGISTERS + +/* We must fetch all the regs before storing, since we store all at once. */ + +#define CHILD_PREPARE_TO_STORE() read_register_bytes (0, NULL, REGISTER_BYTES) + +/* Interface definitions for kernel debugger KDB. */ +/* This doesn't work... */ +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \ + 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movl $ end, %esp"); \ + asm ("movl %ebp, $0"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("pushl %ebp"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (%esp), %ebp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm("pushad"); } +/* +{ asm("pushl %eax"); \ + asm("pushl %edx"); \ + asm("pushl %ecx"); \ + asm("pushl %st(0)"); \ + asm("pushl %st(1)"); \ + asm("pushl %ebx"); \ + asm("pushl %esi"); \ + asm("pushl %edi"); \ + asm("pushl %st(2)"); \ + asm("pushl %st(3)"); \ + asm("pushl %st(4)"); \ + asm("pushl %st(5)"); \ + asm("pushl %st(6)"); \ + asm("pushl %st(7)"); \ + asm("pushl %esp"); \ + asm("pushl %ebp"); \ + asm("pushl %eip"); \ + asm("pushl %eflags"); \ + asm("pushl %fp1"); \ + asm("pushl %fp2"); \ + asm("pushl %fp3"); \ + asm("pushl %fp4"); \ + asm("pushl %fp5"); \ + asm("pushl %fp6"); \ + asm("pushl %fp7"); \ + asm("pushl %fp8"); \ + asm("pushl %fp9"); \ + asm("pushl %fp10"); \ + asm("pushl %fp11"); \ + asm("pushl %fp12"); \ + asm("pushl %fp13"); \ + asm("pushl %fp14"); \ + asm("pushl %fp15"); \ + asm("pushl %fp16"); \ + asm("pushl %fp17"); \ + asm("pushl %fp18"); \ + asm("pushl %fp19"); \ + asm("pushl %fp20"); \ + asm("pushl %fp21"); \ + asm("pushl %fp22"); \ + asm("pushl %fp23"); \ + asm("pushl %fp24"); \ + asm("pushl %fp25"); \ + asm("pushl %fp26"); \ + asm("pushl %fp27"); \ + asm("pushl %fp28"); \ + asm("pushl %fp29"); \ + asm("pushl %fp30"); \ + asm("pushl %fp31"); \ +} +*/ +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("popad"); } diff --git a/gdb/xm-umax.h b/gdb/xm-umax.h new file mode 100644 index 0000000..873e808 --- /dev/null +++ b/gdb/xm-umax.h @@ -0,0 +1,64 @@ +/* Definitions to make GDB run on an encore under umax 4.2 + Copyright (C) 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +#define HAVE_WAIT_STRUCT + +/* Offset of registers within u area. */ +#define U_REGS_OFFSET 0 + +/* Do implement the attach and detach commands... */ +#define ATTACH_DETACH + +/* Doesn't have siginterupt. */ +#define NO_SIGINTERRUPT + +/* called from register_addr() -- blockend not used for now */ +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ \ + switch (regno) { \ + case 0: case 1: case 2: case 3: case 4: case 5: case 6: case 7: \ + addr = PU_R0 - (regno * sizeof (int)); break; \ + case SP_REGNUM: \ + addr = PU_SP; break; \ + case PC_REGNUM: \ + addr = PU_PC; break; \ + case FP_REGNUM: \ + addr = PU_FP; break; \ + case PS_REGNUM: \ + addr = PU_PSL; break; \ + case FPS_REGNUM: \ + addr = PU_FSR; break; \ + case FP0_REGNUM + 0: case FP0_REGNUM + 1: \ + case FP0_REGNUM + 2: case FP0_REGNUM + 3: \ + case FP0_REGNUM + 4: case FP0_REGNUM + 5: \ + case FP0_REGNUM + 6: case FP0_REGNUM + 7: \ + addr = PU_F0 + (regno - FP0_REGNUM) * sizeof (float); break; \ + case LP0_REGNUM + 0: case LP0_REGNUM + 1: \ + case LP0_REGNUM + 2: case LP0_REGNUM + 3: \ + addr = PU_F0 + (regno - LP0_REGNUM) * sizeof (double); break; \ + default: \ + printf ("bad argument to REGISTER_U_ADDR %d\n", regno); \ + abort (); \ + } \ +} + +/* Compensate for lack of `vprintf' function. */ +#define MISSING_VPRINTF diff --git a/gdb/xm-vax.h b/gdb/xm-vax.h new file mode 100644 index 0000000..1bc6aa4 --- /dev/null +++ b/gdb/xm-vax.h @@ -0,0 +1,90 @@ +/* Definitions to make GDB run on a vax under 4.2bsd. + Copyright (C) 1986, 1987, 1989 Free Software Foundation, Inc. + +This file is part of GDB. + +GDB is free software; you can redistribute it and/or modify +it under the terms of the GNU General Public License as published by +the Free Software Foundation; either version 1, or (at your option) +any later version. + +GDB is distributed in the hope that it will be useful, +but WITHOUT ANY WARRANTY; without even the implied warranty of +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +GNU General Public License for more details. + +You should have received a copy of the GNU General Public License +along with GDB; see the file COPYING. If not, write to +the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ + +#define HOST_BYTE_ORDER LITTLE_ENDIAN + +/* Get rid of any system-imposed stack limit if possible. */ + +#define SET_STACK_LIMIT_HUGE + +/* This is the amount to subtract from u.u_ar0 + to get the offset in the core file of the register values. */ + +#define KERNEL_U_ADDR (0x80000000 - (UPAGES * NBPG)) + +#define REGISTER_U_ADDR(addr, blockend, regno) \ +{ addr = blockend - 0110 + regno * 4; \ + if (regno == PC_REGNUM) addr = blockend - 8; \ + if (regno == PS_REGNUM) addr = blockend - 4; \ + if (regno == FP_REGNUM) addr = blockend - 0120; \ + if (regno == AP_REGNUM) addr = blockend - 0124; \ + if (regno == SP_REGNUM) addr = blockend - 20; } + +/* Interface definitions for kernel debugger KDB. */ + +/* Map machine fault codes into signal numbers. + First subtract 0, divide by 4, then index in a table. + Faults for which the entry in this table is 0 + are not handled by KDB; the program's own trap handler + gets to handle then. */ + +#define FAULT_CODE_ORIGIN 0 +#define FAULT_CODE_UNITS 4 +#define FAULT_TABLE \ +{ 0, SIGKILL, SIGSEGV, 0, 0, 0, 0, 0, \ + 0, 0, SIGTRAP, SIGTRAP, 0, 0, 0, 0, \ + 0, 0, 0, 0, 0, 0, 0, 0} + +/* Start running with a stack stretching from BEG to END. + BEG and END should be symbols meaningful to the assembler. + This is used only for kdb. */ + +#define INIT_STACK(beg, end) \ +{ asm (".globl end"); \ + asm ("movl $ end, sp"); \ + asm ("clrl fp"); } + +/* Push the frame pointer register on the stack. */ +#define PUSH_FRAME_PTR \ + asm ("pushl fp"); + +/* Copy the top-of-stack to the frame pointer register. */ +#define POP_FRAME_PTR \ + asm ("movl (sp), fp"); + +/* After KDB is entered by a fault, push all registers + that GDB thinks about (all NUM_REGS of them), + so that they appear in order of ascending GDB register number. + The fault code will be on the stack beyond the last register. */ + +#define PUSH_REGISTERS \ +{ asm ("pushl 8(sp)"); \ + asm ("pushl 8(sp)"); \ + asm ("pushal 0x14(sp)"); \ + asm ("pushr $037777"); } + +/* Assuming the registers (including processor status) have been + pushed on the stack in order of ascending GDB register number, + restore them and return to the address in the saved PC register. */ + +#define POP_REGISTERS \ +{ asm ("popr $037777"); \ + asm ("subl2 $8,(sp)"); \ + asm ("movl (sp),sp"); \ + asm ("rei"); } |