diff --git a/tools/gdbst03/Makefile b/tools/gdbst03/Makefile
deleted file mode 100644
index 5279e5b5558da2c38b277048348ddd5493dca571..0000000000000000000000000000000000000000
--- a/tools/gdbst03/Makefile
+++ /dev/null
@@ -1,83 +0,0 @@
-#
-# Makefile for GDB Stub for DJGPP/Mingw 0.3 source distribution
-#
-# Copyright 2000 by Jonathan Brogdon
-#
-
-include Makefile.cfg
-
-default:
- @$(ECHO) Welcome to GDB Stub for DJGPP & Mingw 0.3 source distribution!
- @$(ECHO) To make the GDB stub type:
- @$(ECHO) make all - Make library and demo programs
- @$(ECHO) make library - Make only library
- @$(ECHO) make demo - Make demo program
- @$(ECHO) make install - Install library and header files
- @$(ECHO) make uninstall - Uninstall library and header files
- @$(ECHO) make clean - Remove .o files
- @$(ECHO) make distclean - Remove ready binaries and .o files
- @$(ECHO) make dep - Make dependences
-
-# Inform make of phony targets
-.PHONY: library demo clean blankdep dep distclean install
-
-all: dep library demo
- @$(ECHO) Library and demo program created
-
-./lib/libgdbst.a:
- @mkdir -p lib
- @make -s -C ./src/library all
-
-library: ./lib/libgdbst.a
- @$(ECHO) Library created
-
-demo: ./lib/libgdbst.a
- @mkdir -p demo
- @make -s -C ./src/demo all
- @$(ECHO) Demo program created
-
-clean:
- @make -s -C ./src/library clean
- @make -s -C ./src/demo clean
- @$(ECHO) Clean complete
-
-blankdep:
-# Create blank depend.dep files to avoid errors
- @$(ECHOBLANK) > ./src/library/depend.dep
- @$(ECHOBLANK) > ./src/demo/depend.dep
-
-# Now carry on as usual
-dep: blankdep
- @make -s -C ./src/library dep
- @make -s -C ./src/demo dep
- @$(ECHO) Created dependency files
-
-# Blank all the dependencies too
-distclean: blankdep
- @make -s -C ./src/library distclean
- @make -s -C ./src/demo distclean
- @$(RM) -r ./demo/
- @$(RM) -r ./lib/
- @$(ECHO) Cleaned up files
-
-install: library
-ifdef DJGPP
- @cp lib/*.a $(DJDIR)/lib
- @ginstall -d $(DJDIR)/include
- @cp include/*.h $(DJDIR)/include
- @$(ECHO) GDB Stub Library for DJGPP installed
-endif
-
-uninstall:
-ifdef DJGPP
- @$(RM) $(DJDIR)/lib/libgdb.a
- @$(RM) $(DJDIR)/include/i386-stub.h
- @$(ECHO) GDB Stub Library for DJGPP uninstalled
-ifdef DJGPP
-
-
-
-
-
-
-
diff --git a/tools/gdbst03/announce b/tools/gdbst03/announce
deleted file mode 100644
index ac976b64483258aeb0a6c9dc5a1164b7010b5e6a..0000000000000000000000000000000000000000
--- a/tools/gdbst03/announce
+++ /dev/null
@@ -1,27 +0,0 @@
-GDB Stub for DJGPP 0.1 Announcement
-===================================
-
-GDB Stub for DJGPP Copyright 2000 by Jonathan Brogdon
-
-Hello.
-
- I'd like to announce the GDB Stub for DJGPP for DJGPP, the latest version of
-a GDB stub for DJGPP targets. The GDB Stub for DJGPP conforms to the GNU GDB stub
-interface as specified in the GDB User's Manual. It allows for debugging of a
-DJGPP target remotely over a serial link with GDB.
-
- It comes with an example program for demonstrating remote debugging of
-DJGPP targets, and documentation (man and HTML pages).
-
- The GDB Stub for DJGPP is distributed under the GNU Library General Public License
-(LGPL).
-
- If you have any questions relating to libsocket, please mail me and I'll
-be happy to help.
-
- Thanks,
-
- Jonathan Brogdon
- <brogdo@austin.rr.com>
-
- June 29th 2000
diff --git a/tools/gdbst03/include/i386-stub.h b/tools/gdbst03/include/i386-stub.h
deleted file mode 100644
index 092a3dfc63260dece4ac294592937da46900dc86..0000000000000000000000000000000000000000
--- a/tools/gdbst03/include/i386-stub.h
+++ /dev/null
@@ -1,43 +0,0 @@
-/****************************************************************************
- *
- * i386-stub.h
- *
- * Description: Data definitions and constants for low level
- * GDB server support.
- *
- * Terms of use: This software is provided for use under the terms
- * and conditions of the GNU General Public License.
- * 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., 59 Temple Place
- * Suite 330, Boston, MA 02111-1307, USA.
- *
- * Credits: Created by Jonathan Brogdon
- *
- * History
- * Engineer: Date: Notes:
- * --------- ----- ------
- * Jonathan Brogdon 20000617 Genesis
- * Gordon Schumacher 20020212 Updated for modularity
- *
- ****************************************************************************/
-#ifndef _GDBSTUB_H_
-#define _GDBSTUB_H_
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-extern int gdb_serial_init(unsigned int port, unsigned int speed);
-extern void gdb_target_init(void);
-extern void gdb_target_close(void);
-
-extern void set_debug_traps(void);
-extern void restore_traps(void);
-extern void breakpoint(void);
-#ifdef __cplusplus
-}
-#endif
-
-
-#endif /* _GDBSTUB_H_ */
diff --git a/tools/gdbst03/install b/tools/gdbst03/install
deleted file mode 100644
index b92c39c0417c349352aaa133de7063158cf5f7de..0000000000000000000000000000000000000000
--- a/tools/gdbst03/install
+++ /dev/null
@@ -1,20 +0,0 @@
-The makefile contains the information about the target products
-available.
-
-Note: Makefile.cfg contains macros for various tools used during
-the build process. Of particular note: some folks use the echo.exe
-that is available from the DJGPP (or other) site(s). Others may not
-have installed this, and therefore calls to echo during the build
-will use the built-in DOS echo command. When attempting to echo a
-blank line, the arguments to these two echo commands are different.
-Therefore, makefile.cfg contains the macro ECHOBLANK. Please set
-this macro according to the needs of your environment. If you change
-this in makefile.cfg, it will be picked up by all other project
-makefiles.
-
-Type 'make' to see a list of targets. When the 'install'
-target is made, the libgdb.a will be copied into your $(DJDIR)/lib
-directory. In addition, the i386-stub.h file will be copied into
-your $(DJDIR)/include directory. The uninstall target will remove
-these files.
-
diff --git a/tools/gdbst03/license b/tools/gdbst03/license
deleted file mode 100644
index 4356f26edf24c819b62b0676d83115eeab71c0d8..0000000000000000000000000000000000000000
--- a/tools/gdbst03/license
+++ /dev/null
@@ -1,454 +0,0 @@
-
-GNU LIBRARY GENERAL PUBLIC LICENSE
-**********************************
-
- Version 2, June 1991
-
- Copyright (C) 1991 Free Software Foundation, Inc.
- 675 Mass Ave, Cambridge, MA 02139, USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
- [This is the first released version of the library GPL. It is
- numbered 2 because it goes with version 2 of the ordinary GPL.]
-
-Preamble
-========
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Library General Public License, applies to some
-specially designated Free Software Foundation software, and to any
-other libraries whose authors decide to use it. You can use it for
-your libraries, too.
-
- When we speak of free software, we are referring to freedom, not
-price. Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-this service if you wish), that you receive source code or can get it
-if you want it, that you can change the software or use pieces of it in
-new free programs; and that you know you can do these things.
-
- To protect your rights, we need to make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the library, or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link a program with the library, you must provide
-complete object files to the recipients so that they can relink them
-with the library, after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- Our method of protecting your rights has two steps: (1) copyright
-the library, and (2) offer you this license which gives you legal
-permission to copy, distribute and/or modify the library.
-
- Also, for each distributor's protection, we want to make certain
-that everyone understands that there is no warranty for this free
-library. If the library is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original
-version, so that any problems introduced by others will not reflect on
-the original authors' reputations.
-
- Finally, any free program is threatened constantly by software
-patents. We wish to avoid the danger that companies distributing free
-software will individually obtain patent licenses, thus in effect
-transforming the program into proprietary software. To prevent this,
-we have made it clear that any patent must be licensed for everyone's
-free use or not licensed at all.
-
- Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License, which was designed for utility
-programs. This license, the GNU Library General Public License,
-applies to certain designated libraries. This license is quite
-different from the ordinary one; be sure to read it in full, and don't
-assume that anything in it is the same as in the ordinary license.
-
- The reason we have a separate public license for some libraries is
-that they blur the distinction we usually make between modifying or
-adding to a program and simply using it. Linking a program with a
-library, without changing the library, is in some sense simply using
-the library, and is analogous to running a utility program or
-application program. However, in a textual and legal sense, the linked
-executable is a combined work, a derivative of the original library,
-and the ordinary General Public License treats it as such.
-
- Because of this blurred distinction, using the ordinary General
-Public License for libraries did not effectively promote software
-sharing, because most developers did not use the libraries. We
-concluded that weaker conditions might promote sharing better.
-
- However, unrestricted linking of non-free programs would deprive the
-users of those programs of all benefit from the free status of the
-libraries themselves. This Library General Public License is intended
-to permit developers of non-free programs to use free libraries, while
-preserving your freedom as a user of such programs to change the free
-libraries that are incorporated in them. (We have not seen how to
-achieve this as regards changes in header files, but we have achieved
-it as regards changes in the actual functions of the Library.) The
-hope is that this will lead to faster development of free libraries.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, while the latter only
-works together with the library.
-
- Note that it is possible for a library to be covered by the ordinary
-General Public License rather than by this special one.
-
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library which
- contains a notice placed by the copyright holder or other
- authorized party saying it may be distributed under the terms of
- this Library General Public License (also called "this License").
- Each licensee is addressed as "you".
-
- A "library" means a collection of software functions and/or data
- prepared so as to be conveniently linked with application programs
- (which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
- which has been distributed under these terms. A "work based on the
- Library" means either the Library or any derivative work under
- copyright law: that is to say, a work containing the Library or a
- portion of it, either verbatim or with modifications and/or
- translated straightforwardly into another language. (Hereinafter,
- translation is included without limitation in the term
- "modification".)
-
- "Source code" for a work means the preferred form of the work for
- making modifications to it. For a library, complete source code
- means all the source code for all modules it contains, plus any
- associated interface definition files, plus the scripts used to
- control compilation and installation of the library.
-
- Activities other than copying, distribution and modification are
- not covered by this License; they are outside its scope. The act
- of running a program using the Library is not restricted, and
- output from such a program is covered only if its contents
- constitute a work based on the Library (independent of the use of
- the Library in a tool for writing it). Whether that is true
- depends on what the Library does and what the program that uses
- the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
- complete source code as you receive it, in any medium, provided
- that you conspicuously and appropriately publish on each copy an
- appropriate copyright notice and disclaimer of warranty; keep
- intact all the notices that refer to this License and to the
- absence of any warranty; and distribute a copy of this License
- along with the Library.
-
- You may charge a fee for the physical act of transferring a copy,
- and you may at your option offer warranty protection in exchange
- for a fee.
-
- 2. You may modify your copy or copies of the Library or any portion
- of it, thus forming a work based on the Library, and copy and
- distribute such modifications or work under the terms of Section 1
- above, provided that you also meet all of these conditions:
-
- a. The modified work must itself be a software library.
-
- b. You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c. You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d. If a facility in the modified Library refers to a function or
- a table of data to be supplied by an application program that
- uses the facility, other than as an argument passed when the
- facility is invoked, then you must make a good faith effort
- to ensure that, in the event an application does not supply
- such function or table, the facility still operates, and
- performs whatever part of its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots
- has a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function
- must be optional: if the application does not supply it, the
- square root function must still compute square roots.)
-
- These requirements apply to the modified work as a whole. If
- identifiable sections of that work are not derived from the
- Library, and can be reasonably considered independent and separate
- works in themselves, then this License, and its terms, do not
- apply to those sections when you distribute them as separate
- works. But when you distribute the same sections as part of a
- whole which is a work based on the Library, the distribution of
- the whole must be on the terms of this License, whose permissions
- for other licensees extend to the entire whole, and thus to each
- and every part regardless of who wrote it.
-
- Thus, it is not the intent of this section to claim rights or
- contest your rights to work written entirely by you; rather, the
- intent is to exercise the right to control the distribution of
- derivative or collective works based on the Library.
-
- In addition, mere aggregation of another work not based on the
- Library with the Library (or with a work based on the Library) on
- a volume of a storage or distribution medium does not bring the
- other work under the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
- License instead of this License to a given copy of the Library.
- To do this, you must alter all the notices that refer to this
- License, so that they refer to the ordinary GNU General Public
- License, version 2, instead of to this License. (If a newer
- version than version 2 of the ordinary GNU General Public License
- has appeared, then you can specify that version instead if you
- wish.) Do not make any other change in these notices.
-
- Once this change is made in a given copy, it is irreversible for
- that copy, so the ordinary GNU General Public License applies to
- all subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
- the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
- derivative of it, under Section 2) in object code or executable
- form under the terms of Sections 1 and 2 above provided that you
- accompany it with the complete corresponding machine-readable
- source code, which must be distributed under the terms of Sections
- 1 and 2 above on a medium customarily used for software
- interchange.
-
- If distribution of object code is made by offering access to copy
- from a designated place, then offering equivalent access to copy
- the source code from the same place satisfies the requirement to
- distribute the source code, even though third parties are not
- compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
- Library, but is designed to work with the Library by being
- compiled or linked with it, is called a "work that uses the
- Library". Such a work, in isolation, is not a derivative work of
- the Library, and therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
- creates an executable that is a derivative of the Library (because
- it contains portions of the Library), rather than a "work that
- uses the library". The executable is therefore covered by this
- License. Section 6 states terms for distribution of such
- executables.
-
- When a "work that uses the Library" uses material from a header
- file that is part of the Library, the object code for the work may
- be a derivative work of the Library even though the source code is
- not. Whether this is true is especially significant if the work
- can be linked without the Library, or if the work is itself a
- library. The threshold for this to be true is not precisely
- defined by law.
-
- If such an object file uses only numerical parameters, data
- structure layouts and accessors, and small macros and small inline
- functions (ten lines or less in length), then the use of the object
- file is unrestricted, regardless of whether it is legally a
- derivative work. (Executables containing this object code plus
- portions of the Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
- distribute the object code for the work under the terms of Section
- 6. Any executables containing that work also fall under Section 6,
- whether or not they are linked directly with the Library itself.
-
- 6. As an exception to the Sections above, you may also compile or
- link a "work that uses the Library" with the Library to produce a
- work containing portions of the Library, and distribute that work
- under terms of your choice, provided that the terms permit
- modification of the work for the customer's own use and reverse
- engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
- Library is used in it and that the Library and its use are covered
- by this License. You must supply a copy of this License. If the
- work during execution displays copyright notices, you must include
- the copyright notice for the Library among them, as well as a
- reference directing the user to the copy of this License. Also,
- you must do one of these things:
-
- a. Accompany the work with the complete corresponding
- machine-readable source code for the Library including
- whatever changes were used in the work (which must be
- distributed under Sections 1 and 2 above); and, if the work
- is an executable linked with the Library, with the complete
- machine-readable "work that uses the Library", as object code
- and/or source code, so that the user can modify the Library
- and then relink to produce a modified executable containing
- the modified Library. (It is understood that the user who
- changes the contents of definitions files in the Library will
- not necessarily be able to recompile the application to use
- the modified definitions.)
-
- b. Accompany the work with a written offer, valid for at least
- three years, to give the same user the materials specified in
- Subsection 6a, above, for a charge no more than the cost of
- performing this distribution.
-
- c. If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the
- above specified materials from the same place.
-
- d. Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
- Library" must include any data and utility programs needed for
- reproducing the executable from it. However, as a special
- exception, the source code distributed need not include anything
- that is normally distributed (in either source or binary form)
- with the major components (compiler, kernel, and so on) of the
- operating system on which the executable runs, unless that
- component itself accompanies the executable.
-
- It may happen that this requirement contradicts the license
- restrictions of other proprietary libraries that do not normally
- accompany the operating system. Such a contradiction means you
- cannot use both them and the Library together in an executable
- that you distribute.
-
- 7. You may place library facilities that are a work based on the
- Library side-by-side in a single library together with other
- library facilities not covered by this License, and distribute
- such a combined library, provided that the separate distribution
- of the work based on the Library and of the other library
- facilities is otherwise permitted, and provided that you do these
- two things:
-
- a. Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b. Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same
- work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute the
- Library except as expressly provided under this License. Any
- attempt otherwise to copy, modify, sublicense, link with, or
- distribute the Library is void, and will automatically terminate
- your rights under this License. However, parties who have
- received copies, or rights, from you under this License will not
- have their licenses terminated so long as such parties remain in
- full compliance.
-
- 9. You are not required to accept this License, since you have not
- signed it. However, nothing else grants you permission to modify
- or distribute the Library or its derivative works. These actions
- are prohibited by law if you do not accept this License.
- Therefore, by modifying or distributing the Library (or any work
- based on the Library), you indicate your acceptance of this
- License to do so, and all its terms and conditions for copying,
- distributing or modifying the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
- Library), the recipient automatically receives a license from the
- original licensor to copy, distribute, link with or modify the
- Library subject to these terms and conditions. You may not impose
- any further restrictions on the recipients' exercise of the rights
- granted herein. You are not responsible for enforcing compliance
- by third parties to this License.
-
- 11. If, as a consequence of a court judgment or allegation of patent
- infringement or for any other reason (not limited to patent
- issues), conditions are imposed on you (whether by court order,
- agreement or otherwise) that contradict the conditions of this
- License, they do not excuse you from the conditions of this
- License. If you cannot distribute so as to satisfy simultaneously
- your obligations under this License and any other pertinent
- obligations, then as a consequence you may not distribute the
- Library at all. For example, if a patent license would not permit
- royalty-free redistribution of the Library by all those who
- receive copies directly or indirectly through you, then the only
- way you could satisfy both it and this License would be to refrain
- entirely from distribution of the Library.
-
- If any portion of this section is held invalid or unenforceable
- under any particular circumstance, the balance of the section is
- intended to apply, and the section as a whole is intended to apply
- in other circumstances.
-
- It is not the purpose of this section to induce you to infringe any
- patents or other property right claims or to contest validity of
- any such claims; this section has the sole purpose of protecting
- the integrity of the free software distribution system which is
- implemented by public license practices. Many people have made
- generous contributions to the wide range of software distributed
- through that system in reliance on consistent application of that
- system; it is up to the author/donor to decide if he or she is
- willing to distribute software through any other system and a
- licensee cannot impose that choice.
-
- This section is intended to make thoroughly clear what is believed
- to be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
- certain countries either by patents or by copyrighted interfaces,
- the original copyright holder who places the Library under this
- License may add an explicit geographical distribution limitation
- excluding those countries, so that distribution is permitted only
- in or among countries not thus excluded. In such case, this
- License incorporates the limitation as if written in the body of
- this License.
-
- 13. The Free Software Foundation may publish revised and/or new
- versions of the Library General Public License from time to time.
- Such new versions will be similar in spirit to the present version,
- but may differ in detail to address new problems or concerns.
-
- Each version is given a distinguishing version number. If the
- Library specifies a version number of this License which applies
- to it and "any later version", you have the option of following
- the terms and conditions either of that version or of any later
- version published by the Free Software Foundation. If the Library
- does not specify a license version number, you may choose any
- version ever published by the Free Software Foundation.
-
- 14. If you wish to incorporate parts of the Library into other free
- programs whose distribution conditions are incompatible with these,
- write to the author to ask for permission. For software which is
- copyrighted by the Free Software Foundation, write to the Free
- Software Foundation; we sometimes make exceptions for this. Our
- decision will be guided by the two goals of preserving the free
- status of all derivatives of our free software and of promoting
- the sharing and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
- WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE
- LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
- HOLDERS AND/OR OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT
- WARRANTY OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT
- NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
- FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE
- QUALITY AND PERFORMANCE OF THE LIBRARY IS WITH YOU. SHOULD THE
- LIBRARY PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY
- SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
- WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY
- MODIFY AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE
- LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL,
- INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR
- INABILITY TO USE THE LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF
- DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
- OR THIRD PARTIES OR A FAILURE OF THE LIBRARY TO OPERATE WITH ANY
- OTHER SOFTWARE), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN
- ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
-
- END OF TERMS AND CONDITIONS
-
diff --git a/tools/gdbst03/makefile.cfg b/tools/gdbst03/makefile.cfg
deleted file mode 100644
index 4265258a71e65b80fd8599f83ea05a073e126765..0000000000000000000000000000000000000000
--- a/tools/gdbst03/makefile.cfg
+++ /dev/null
@@ -1,67 +0,0 @@
-#
-# Makefile.cfg for GDB stub for DJGPP and Mingw
-#
-# libgdbst Copyright 2000 by Jonathan Brogodn
-#
-
-#
-# GNU compiler & tools' flags
-#
-CC = gcc
-CFLAGS = -Wall -Werror -march=i486 -O2 -g
-
-# Archiver
-AR = ar
-ARFLAGS = -r
-
-# Stripper
-STRIP = strip
-
-# Assembler
-AS = as
-ASFLAGS =
-
-# Linker
-LD = ld
-LDFLAGS =
-
-# Remove
-RM = rm -f
-
-# Echo
-ECHO = echo
-
-# Echo Blank
-#ECHOBLANK = echo ""
-ECHOBLANK = echo.
-
-#
-# check for OS... badly
-#
-
-ifndef DJDIR
-ifndef DJGPP
- WINDOWS=1
-endif
-endif
-
-ifndef windir
-ifndef WINDOWS
- DJGPP=1
-endif
-endif
-
-#
-# Rules
-#
-.SUFFIXES: .c .asm .o
-
-.asm.o:
- @$(CC) $(CFLAGS) -I$(INC_PATH) -c -o ./$@ ./$<
-
-.s.o:
- @$(AS) $(ASFLAGS) ./$<
-
-.c.o :
- @$(CC) $(CFLAGS) -c -I$(INC_PATH) -c -o ./$@ ./$<
-
diff --git a/tools/gdbst03/readme b/tools/gdbst03/readme
deleted file mode 100644
index 316e61caec6688276197ce6c8510493f0ebf680f..0000000000000000000000000000000000000000
--- a/tools/gdbst03/readme
+++ /dev/null
@@ -1,171 +0,0 @@
-GDB Stub for DJGPP 0.2 Readme File
-==================================
-
-Copyright
----------
-GDB Stub for DJGPP is distributed under the terms of the GNU Library
-General Public License (GNU LGPL) - please see the document LICENSE,
-which should be found in the same directory as this file.
-
-Copyright (c) 2000 by Jonathan Brogdon, 2002 by Gordon Schumacher
-
-What It Does
-------------
-The GDB stub is used to debug a DJGPP target remotely over a one of
-the PC COM ports. GDB, running on a host machine, communicates with
-the target using the GDB serial protocol over the serial link. For
-more information on the GDB stub, see "Debugging with GDB, The GNU
-Source-Level Debugger", by Richard M. Stallman and Roland H. Pesch
-(http://sources.redhat.com/gdb/download/onlinedocs/gdb.html)
-
-How It Works
-------------
-
-Exceptions:
-
-The GDB stub needs to handle all processor exceptions. Since these
-exceptions already handled by DJGPP, we cannot handle them directly.
-DJGPP maps all processor exceptions to signals. Therefore, we can
-install the GDB stub handler as the signal handler for those signals
-that represent processor exceptions. The following table shows the
-processor exception to signal mapping:
-
- Exception/Interrupt: Exception #: Signal:
- ------------------- ----------- ------
- Divide Error 0 SIGFPE
- Debug Exception 1 SIGTRAP
- NMI Interrupt 2 No signal defined
- Breakpoint 3 SIGTRAP
- INTO-detected overflow 4 SIGFPE
- BOUND Range Exceeded 5 SIGSEGV
- Invalid Opcode 6 No signal defined
- Coprocessor not available 7 SIGNOFP
- Double Fault 8 SIGSEGV
- Coprocessor Seg overrun 9 SIGSEGV
- Invalid Task State Seg 10 No signal defined
- Segment not present 11 SIGSEGV
- Stack Fault 12 SIGSEGV
- General Protection Fault 13 SIGSEGV
- Page Fault 14 SIGSEGV
- Intel Reserved 15 No signal defined
- Coprocessor Error 16 SIGFPE
-
-The GDB stub handler services requests from the GDB host. These
-requests are seen by the GDB stub handler as command messages from
-the GDB host. These commands and command formats are defined in
-"Debugging with GDB, The GNU Source-Level Debugger", by Richard M.
-Stallman and Roland H. Pesch (http://sources.redhat.com/gdb/
-download/onlinedocs/gdb.html -- one of many sources).
-
-Serial Interface:
-
-Interface functions for sending and receiving characters from the
-serial interface must be provided by the engineer porting the GDB
-stub. The following funtions must be provided to support the
-implementation.
-
- int getDebugChar(void);
- void putDebugChar(int c);
-
-There are a variety of serial libraries for DJGPP. The user may
-already be using one of these libraries in their application, and
-installing more than one serial library often causes conflicts.
-To this end, a modular function layer was written that allows any
-serial library to be used with the GDB stub. Layers have been
-written to support SVAsync, DZComm, and the _bios_serialcom()
-function. At the time of this writing, DZComm appears to work the
-best for serial debugging.
-
-Hard Coded Breakpoint:
-
-A breakpoint() function is provided to manually invoke the stub.
-This function, inserts a breakpoint instruction directly in the code
-to invoke the GDB stub handler.
-
-How You Use It
---------------
-First, you need to select a serial library. In the i386-supp.c file,
-there are lines of the form
-
- // #include "some_layer.h"
-
-Uncomment the line for the serial library you intend to use - or add
-a new include line for a file written for some other library.
-In the main() function of your target program, you should initilize
-the GDB serial handlers and the GDB stub. The following functions
-are provided in the GDB stub library for this purpose.
-
- gdb_serial_init(unsigned int port, unsigned int speed);
- gdb_target_init(void);
-
-Where, port is the COM port number, and speed is the baud rate for
-the serial link.
-
-After initialing the GDB serial interface and target, you should
-invoke the breakpoint() function somewhere. You may choose to do
-this immediately after initialization, or at a specific location in
-your code where you wish to set a breakpoint. By putting the
-breakpoint() function in the beginning of main(), you can use the
-GDB host to set a breakpoint at any place in your code.
-
-Make sure that you use the '-g' option when compiling your files with
-gcc.
-
-After the target executable is running, start up gdb on the host,
-passing the target executable as an argument.
-
- Example: gdb demo.exe
-
-Now, tell gdb which serial interface to use for communicating to
-the target.
-
- Example: (gdb) target remote COM1
-
-This example uses COM1 on the host to communicate with the target.
-GDB is now 'listening' on COM for a valid GDB serial packet.
-
-Once your GDB host finds your target, you may need to tell GDB where
-to find any source files which were used to generate your program.
-Use the directory command to do this.
-
- Example: (gdb) directory ../src/demo
-
-That's it. You should now be able to single step through code, set
-breakpoints, set variables, examine variables, any anthing else that
-you would normally use GDB to accomplish.
-
-What You Build
---------------
-Read the INSTALL file for more information on installing the GDB stub
-library. After installing the library, your code should include
-i386-stub.h for function prototypes. In addition, your code should
-link against the libgdb.a library. The source for a demonstration
-program has been included with this distributias an example.
-As an alternative, you can simply include the i386-stub and i386-supp
-files and the layer header for the serial library you plan to use into
-your project and link them in directly.
-
-For More Info
--------------
-See "Debugging with GDB, The GNU Source-Level Debugger", by Richard
-M. Stallman and Roland H. Pesch (http://sources.redhat.com/gdb/
-download/onlinedocs/gdb.html -- one of many sources).
-
-TODO
-----
-Port for network operation.
-
-Contact Info
-------------
-My contact info is below. If you have any comments, suggestions, bug
-reports or problems, please mail me, and I'll see what I can do.
-
- Regards,
- Jonathan Brogdon
- <brogdon@austin.rr.com>
- 6th June 2000
-
- Modular update:
- Gordon Schumacher
- <gordons@valleyhold.org>
- 12th February 2002
\ No newline at end of file
diff --git a/tools/gdbst03/src/demo/crc_16.c b/tools/gdbst03/src/demo/crc_16.c
deleted file mode 100644
index ad1f53cd1caad6559a64f92781c577744626402e..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/demo/crc_16.c
+++ /dev/null
@@ -1,46 +0,0 @@
-#define POLY 0x8408
-/*
-// 16 12 5
-// this is the CCITT CRC 16 polynomial X + X + X + 1.
-// This works out to be 0x1021, but the way the algorithm works
-// lets us use 0x8408 (the reverse of the bit pattern). The high
-// bit is always assumed to be set, thus we only use 16 bits to
-// represent the 17 bit value.
-*/
-
-#include "crc.h"
-
-WORD crc16(char *data_p, WORD length)
-{
- unsigned char i;
- unsigned int data;
- unsigned int crc = 0xffff;
-
- if (length == 0)
- return (~crc);
-
- do
- {
- for (i=0, data=(unsigned int)0xff & *data_p++;
- i < 8;
- i++, data >>= 1)
- {
- if ((crc & 0x0001) ^ (data & 0x0001))
- crc = (crc >> 1) ^ POLY;
- else crc >>= 1;
- }
- } while (--length);
-
- crc = ~crc;
- data = crc;
- crc = (crc << 8) | ((data >> 8) & 0xff);
-
- return (crc);
-}
-
-
-
-
-
-
-
diff --git a/tools/gdbst03/src/demo/makefile b/tools/gdbst03/src/demo/makefile
deleted file mode 100644
index ab48954b22f5839054ae9da9fbffa911b2d52344..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/demo/makefile
+++ /dev/null
@@ -1,42 +0,0 @@
-#
-# Makefile for GDB Stub demo
-# Written by Jonathan Brogodn
-#
-# GDB Stub for DJGPP Copyright 2000 by Jonathan Brogdon
-#
-
-include ../../Makefile.cfg
-
-CFLAGS += -g
-CFLAGS += -I../../include -I../include -I.
-CFLAGS += -DDEBUG_COM_PORT=1
-CFLAGS += -DDEBUG_COM_PORT_SPEED=9600
-CFLAGS += -DREMOTE_DEBUGGING
-
-# Objects to build
-OBJS = serdbg.o crc_16.o
-
-all: demo
-
-demo: $(OBJS)
-ifdef DJGPP
- @$(LD) $(LDFLAGS) -Map ./$@.map -o../../demo/$@.exe $(DJDIR)/lib/crt0.o $(OBJS) -L$(DJDIR)/lib -L../../lib -lgdbst -ldzcom -lc -lgcc
-endif
-ifdef WINDOWS
- @$(LD) $(LDFLAGS) -Map ./$@.map -o../../demo/$@.exe $(DJDIR)/lib/crt0.o $(OBJS) -L../../lib -lgdbst -lwsock32 -lc -lgcc
-endif
-
-clean:
- @$(RM) $(OBJS)
- @$(RM) *.map
-
-distclean: clean
- @$(RM) $(OBJS)
- @$(RM) depend.dep
- @$(RM) ../../demo/*.exe
-
-dep:
- @$(CC) $(CFLAGS) -M *.c > depend.dep
-
-$(OBJS):
-include depend.dep
diff --git a/tools/gdbst03/src/demo/serdbg.c b/tools/gdbst03/src/demo/serdbg.c
deleted file mode 100644
index 01778789cafd1e3acea348280f64a82af9fc1527..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/demo/serdbg.c
+++ /dev/null
@@ -1,102 +0,0 @@
-/***********************************************************************
- * serdbg.c
- *
- * Description: Pretty simple demonstration program. It accomplishes
- * the following.
- *
- * 1. Allocate a block of memory Feel free to change
- * size (memBlockSize) with debugger.
- *
- * 2. Writes a word pattern to the entire block. Feel
- * free to change the pattern (memPatternWord) with
- * debugger.
- *
- * 3. Computes the CRC-16 on the block. Feel free to
- * check the size with the debuger.
- *
- * 4. Free the memory block allocated in step 1. Repeat
- * step 1. If you wish to exit, set doneFlag to 0 with
- * the debugger.
- *
- * Credits: Created by Jonathan Brogdon
- *
- * Terms of use: Use as you will.
- *
- * Global Data: None.
- * Global Functions: main
- *
- * History
- * Engineer: Date: Notes:
- * --------- ----- ------
- * Jonathan Brogdon 070500 Genesis
- *
- ***********************************************************************/
-#include <stdio.h>
-#include <stdlib.h>
-#include <i386-stub.h>
-#include <crc.h>
-
-#define MEM_BLOCK_SIZE 100 /* Words */
-#define MEM_PATTERN_WORD 0x55AA
-
-void write_mem_pattern(unsigned short*, unsigned short, unsigned short);
-
-/************************************************************************
- *
- * main()
- *
- ************************************************************************/
-int main(int argc, char *argv[])
-{
- volatile int doneFlag = 0;
- unsigned short crcValue = 0;
- unsigned short * memBlockPtr = NULL;
- short memBlockSize = MEM_BLOCK_SIZE;
- short memPatternWord = MEM_PATTERN_WORD;
-
-#ifdef REMOTE_DEBUGGING
- /* Only setup if demonstrating remote debugging */
- gdb_serial_init(DEBUG_COM_PORT,DEBUG_COM_PORT_SPEED);
- gdb_target_init();
- breakpoint();
-#endif
-
- while(doneFlag != 1)
- {
- memBlockSize = MEM_BLOCK_SIZE;
- memPatternWord = MEM_PATTERN_WORD;
- memBlockPtr = (unsigned short *) malloc((int)memBlockSize);
-
- write_mem_pattern(memBlockPtr, memBlockSize, memPatternWord);
-
- crcValue = crc16((char *)memBlockPtr,memBlockSize);
-
- free(memBlockPtr);
- }
-
- exit(0);
-}
-
-/************************************************************************
- *
- * write_mem_pattern()
- *
- * Description: Writes a word pattern to a block of RAM.
- *
- ************************************************************************/
-void write_mem_pattern(unsigned short *block, unsigned short blockSize, unsigned short patternWord)
-{
- int index = 0;
-
- for(index = 0; index < blockSize; index++)
- {
- block[index] = patternWord;
- }
-}
-
-
-
-
-
-
-
diff --git a/tools/gdbst03/src/include/crc.h b/tools/gdbst03/src/include/crc.h
deleted file mode 100644
index 937d0b794319b9c8b1795705215c2f691168bf55..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/include/crc.h
+++ /dev/null
@@ -1,20 +0,0 @@
-/*
- * CRC.H - header file for CRC functions
- */
-
-#ifndef _CRC_H_
-#define _CRC_H_
-
-#include <stdlib.h> /* For size_t */
-
-typedef unsigned char BYTE;
-typedef unsigned short WORD;
-typedef unsigned long DWORD;
-
-/*
-** File: CRC-16.C
-*/
-
-WORD crc16(char *data_p, WORD length);
-
-#endif /* _CRC_H_ */
diff --git a/tools/gdbst03/src/include/i386-supp.h b/tools/gdbst03/src/include/i386-supp.h
deleted file mode 100644
index e1923377cdd6d302398bfaf3b0843f3c870098c3..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/include/i386-supp.h
+++ /dev/null
@@ -1,30 +0,0 @@
-/****************************************************************************
- *
- * i386-supp.h
- *
- * Description: Data definitions and constants for low level
- * GDB stub support.
- *
- * Terms of use: This software is provided for use under the terms
- * and conditions of the GNU General Public License.
- * 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., 59 Temple Place
- * Suite 330, Boston, MA 02111-1307, USA.
- *
- * Credits: Created by Jonathan Brogdon
- *
- * History
- * Engineer: Date: Notes:
- * --------- ----- ------
- * Jonathan Brogdon 20000629 Genesis
- * Gordon Schumacher 20020212 Updated for modularity
- *
- ****************************************************************************/
-#ifndef _GDBSUPP_H_
-#define _GDBSUPP_H_
-
-extern int putDebugChar(char c);
-extern int getDebugChar(void);
-
-#endif /* _GDBSUPP_H_ */
diff --git a/tools/gdbst03/src/library/bios_layer.h b/tools/gdbst03/src/library/bios_layer.h
deleted file mode 100644
index 946f40997d4587b96559427aa7ba8b1b3a3174e1..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/bios_layer.h
+++ /dev/null
@@ -1,137 +0,0 @@
-//=======================================================================================================
-// bios_layer.h - Serial command layer for standard BIOS calls
-// It's here if you want it, but I wouldn't suggest it...
-//=======================================================================================================
-
-//=======================================================================================================
-//=======================================================================================================
-
-#ifndef _BIOS_LAYER_H
-#define _BIOS_LAYER_H
-
-
-//===============================================================================
-// Include files
-//===============================================================================
-
-#include <pc.h>
-
-//===============================================================================
-// Static variable definitions
-//===============================================================================
-
-unsigned comport;
-
-//===============================================================================
-// Inline function definitions
-//===============================================================================
-
-#define BIOS_SER_TIMEOUT 1000000
-
-// Initialize the serial library
-// Should return 0 if no error occurred
-__inline int GDBStub_SerInit(int port)
-{
- comport = (unsigned) port;
- return 0;
-}
-
-
-// Set the serial port speed (and other configurables)
-// Should return 0 if the speed is set properly
-__inline int GDBStub_SerSpeed(int speed)
-{
- unsigned bps;
-
- switch (speed)
- {
- case 110:
- bps = _COM_110;
- break;
-
- case 150:
- bps = _COM_150;
- break;
-
- case 300:
- bps = _COM_300;
- break;
-
- case 600:
- bps = _COM_600;
- break;
-
- case 1200:
- bps = _COM_1200;
- break;
-
- case 2400:
- bps = _COM_2400;
- break;
-
- case 4800:
- bps = _COM_4800;
- break;
-
- case 9600:
- default:
- bps = _COM_9600;
- break;
- }
-
- _bios_serialcom(_COM_INIT, comport,
- bps | _COM_NOPARITY | _COM_CHR8 | _COM_STOP1);
- return 0;
-}
-
-
-// Check to see if there's room in the buffer to send data
-// Should return 0 if it is okay to send
-__inline int GDBStub_SerSendOk(void)
-{
- return 0;
-}
-
-
-// Send a character to the serial port
-// Should return 0 if the send succeeds
-__inline int GDBStub_SerSend(int c)
-{
- register int ret;
- register int timeout = 0;
-
- do
- {
- ret = _bios_serialcom(_COM_SEND, comport, (unsigned) c);
- } while((ret != 0) && (timeout++ < BIOS_SER_TIMEOUT));
- return (timeout >= BIOS_SER_TIMEOUT);
-}
-
-
-// Check to see if there are characters waiting in the buffer
-// Should return 0 if there's data waiting
-__inline int GDBStub_SerRecvOk(void)
-{
- return 0;
-}
-
-
-// Read a character from the serial port
-// Should return the character read
-__inline int GDBStub_SerRecv(void)
-{
- register int data;
- register int timeout = 0;
-
- do
- {
- data = _bios_serialcom(_COM_RECEIVE, comport, 0) & 0xff;
- } while((data > 0xff) && (timeout++ < BIOS_SER_TIMEOUT));
-
- return data;
-}
-
-
-
-
-#endif
diff --git a/tools/gdbst03/src/library/dzc_layer.h b/tools/gdbst03/src/library/dzc_layer.h
deleted file mode 100644
index cc083077fce99c03fabd3ae9e988469a7529e538..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/dzc_layer.h
+++ /dev/null
@@ -1,169 +0,0 @@
-//=======================================================================================================
-// dzc_layer.h - Serial command layer for DZcomm
-//
-//=======================================================================================================
-
-//=======================================================================================================
-//=======================================================================================================
-
-#ifndef _DZC_LAYER_H
-#define _DZC_LAYER_H
-
-
-//===============================================================================
-// Include files
-//===============================================================================
-
-#include <dzcomm.h>
-
-//===============================================================================
-// Static variable definitions
-//===============================================================================
-
-comm_port *comport;
-
-//===============================================================================
-// Inline function definitions
-//===============================================================================
-
-// Initialize the serial library
-// Should return 0 if no error occurred
-__inline int GDBStub_SerInit(int port)
-{
- int ret;
- comm com;
-
- ret = dzcomm_init();
- if (ret != 0)
- {
- switch (port)
- {
- case 4:
- com = _com4;
- break;
-
- case 3:
- com = _com3;
- break;
-
- case 2:
- com = _com2;
- break;
-
- case 1:
- default:
- com = _com1;
- break;
- }
- comport = comm_port_init(com);
- }
- return (ret == 0);
-}
-
-// Set the serial port speed (and other configurables)
-// Should return 0 if the speed is set properly
-__inline int GDBStub_SerSpeed(int speed)
-{
- baud_bits bps;
-
- switch (speed)
- {
- case 110:
- bps = _110;
- break;
-
- case 150:
- bps = _150;
- break;
-
- case 300:
- bps = _300;
- break;
-
- case 600:
- bps = _600;
- break;
-
- case 1200:
- bps = _1200;
- break;
-
- case 2400:
- bps = _2400;
- break;
-
- case 4800:
- bps = _4800;
- break;
-
- case 9600:
- bps = _9600;
- break;
-
- case 19200:
- bps = _19200;
- break;
-
- case 38400:
- bps = _38400;
- break;
-
- case 57600:
- bps = _57600;
- break;
-
- case 115200:
- default:
- bps = _115200;
- break;
- }
-
- comm_port_set_baud_rate(comport, bps);
- comm_port_set_parity(comport, NO_PARITY);
- comm_port_set_data_bits(comport, BITS_8);
- comm_port_set_stop_bits(comport, STOP_1);
- comm_port_set_flow_control(comport, RTS_CTS);
- comm_port_install_handler(comport);
-
- return 0;
-}
-
-// Check to see if there's room in the buffer to send data
-// Should return 0 if it is okay to send
-__inline int GDBStub_SerSendOk(void)
-{
- return (comm_port_out_full(comport) == 0);
-}
-
-// Send a character to the serial port
-// Should return 0 if the send succeeds
-__inline int GDBStub_SerSend(int c)
-{
- return comm_port_out(comport, (unsigned char) c);
-}
-
-// Check to see if there are characters waiting in the buffer
-// Should return 0 if there's data waiting
-__inline int GDBStub_SerRecvOk(void)
-{
- return (comm_port_in_empty(comport) == 0);
-}
-
-// Read a character from the serial port
-// Should return the character read
-__inline int GDBStub_SerRecv(void)
-{
- return comm_port_test(comport);
-}
-
-
-
-
-#endif
-
-/*==================================================================
-
- $Log: $
-
-
-===============================================================*/
diff --git a/tools/gdbst03/src/library/i386-stub.c b/tools/gdbst03/src/library/i386-stub.c
deleted file mode 100644
index 1ab2ceeebecf9349371068ea3d0f545dbbce6c08..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/i386-stub.c
+++ /dev/null
@@ -1,1555 +0,0 @@
-/****************************************************************************
-
- THIS SOFTWARE IS NOT COPYRIGHTED
-
- HP offers the following for use in the public domain. HP makes no
- warranty with regard to the software or it's performance and the
- user accepts the software "AS IS" with all faults.
-
- HP DISCLAIMS ANY WARRANTIES, EXPRESS OR IMPLIED, WITH REGARD
- TO THIS SOFTWARE INCLUDING BUT NOT LIMITED TO THE WARRANTIES
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
-
-****************************************************************************/
-
-/****************************************************************************
- * Header: remcom.c,v 1.34 91/03/09 12:29:49 glenne Exp $
- *
- * Module name: remcom.c $
- * Revision: 1.34 $
- * Date: 91/03/09 12:29:49 $
- * Contributor: Lake Stevens Instrument Division$
- *
- * Description: low level support for gdb debugger. $
- *
- * Considerations: only works on target hardware $
- *
- * Written by: Glenn Engel $
- * ModuleState: Experimental $
- *
- * NOTES: See Below $
- *
- * Modified for 386 by Jim Kingdon, Cygnus Support.
- *
- * To enable debugger support, two things need to happen. One, a
- * call to set_debug_traps() is necessary in order to allow any breakpoints
- * or error conditions to be properly intercepted and reported to gdb.
- * Two, a breakpoint needs to be generated to begin communication. This
- * is most easily accomplished by a call to breakpoint(). Breakpoint()
- * simulates a breakpoint by executing a trap #1.
- *
- * The external function exceptionHandler() is
- * used to attach a specific handler to a specific 386 vector number.
- * It should use the same privilege level it runs at. It should
- * install it as an interrupt gate so that interrupts are masked
- * while the handler runs.
- *
- * Because gdb will sometimes write to the stack area to execute function
- * calls, this program cannot rely on using the supervisor stack so it
- * uses it's own stack area reserved in the int array remcomStack.
- *
- *************
- *
- * The following gdb commands are supported:
- *
- * command function Return value
- *
- * g return the value of the CPU registers hex data or ENN
- * G set the value of the CPU registers OK or ENN
- *
- * mAA..AA,LLLL Read LLLL bytes at address AA..AA hex data or ENN
- * MAA..AA,LLLL: Write LLLL bytes at address AA.AA OK or ENN
- *
- * c Resume at current address SNN ( signal NN)
- * cAA..AA Continue at address AA..AA SNN
- *
- * s Step one instruction SNN
- * sAA..AA Step one instruction from AA..AA SNN
- *
- * k kill
- *
- * ? What was the last sigval ? SNN (signal NN)
- *
- * All commands and responses are sent with a packet which includes a
- * checksum. A packet consists of
- *
- * $<packet info>#<checksum>.
- *
- * where
- * <packet info> :: <characters representing the command or response>
- * <checksum> :: < two hex digits computed as modulo 256 sum of <packetinfo>>
- *
- * When a packet is received, it is first acknowledged with either '+' or '-'.
- * '+' indicates a successful transfer. '-' indicates a failed transfer.
- *
- * Example:
- *
- * Host: Reply:
- * $m0,10#2a +$00010203040506070809101112131415#42
- *
- ****************************************************************************/
-
-#include <stdio.h>
-#include <string.h>
-#ifdef DJGPP
-#include <dpmi.h>
-#include <setjmp.h>
-#include <signal.h>
-#include <sys/exceptn.h>
-#endif //#ifdef DJGPP
-
-
-/*
- *
- * external low-level support routines
- */
-
-extern void putDebugChar(); /* write a single character */
-extern int getDebugChar(); /* read and return a single char */
-#ifndef DJGPP
-extern void exceptionHandler(); /* assign an exception handler */
-#endif
-
-/*
- * BUFMAX defines the maximum number of characters in inbound/outbound buffers
- * at least NUMREGBYTES*2 are needed for register packets
- */
-#define BUFMAX 400
-
-/*
- * boolean flag. != 0 means we've been initialized
- */
-static char gdb_initialized;
-
-/*
- * debug > 0 prints ill-formed commands in valid packets & checksum errors
- */
-int remote_debug;
-
-/*
- * Hexadecimal character string.
- */
-#ifndef DJGPP
-static const char hexchars[]="0123456789abcdef";
-#else
-static char hexchars[]="0123456789abcdef";
-#endif
-
-/*
- * Number of registers.
-*/
-#define NUMREGS 16
-
-/*
- * Number of bytes of registers.
-*/
-#define NUMREGBYTES (NUMREGS * 4)
-
-/*
- * i386 Registers
- */
-enum regnames {EAX, ECX, EDX, EBX, ESP, EBP, ESI, EDI,
- PC /* also known as eip */,
- PS /* also known as eflags */,
- CS, SS, DS, ES, FS, GS
-};
-
-/*
- * Register storage buffer.
- */
-static int registers[NUMREGS];
-
-/*
- * Address of a routine to RTE to if we get a memory fault.
-*/
-#ifndef DJGPP
-static void (*volatile mem_fault_routine) () = NULL;
-#else
-static void (*mem_fault_routine)() = NULL;
-#endif
-
-/* I/O buffers */
-static char remcomInBuffer[BUFMAX];
-static char remcomOutBuffer[BUFMAX];
-
-#if !(defined(DJGPP) || defined(_WIN32)) //MF
-#define STACKSIZE 10000
-int remcomStack[STACKSIZE/sizeof(int)];
-static int* stackPtr = &remcomStack[STACKSIZE/sizeof(int) - 1];
-#endif
-
-#ifdef DJGPP
-static void lock_handler_data(void);
-#endif //#ifdef DJGPP
-
-void _returnFromException ();
-
-/*************************** ASSEMBLY CODE MACROS *************************/
-/* */
-
-extern void
-return_to_prog ();
-
-/* Restore the program's registers (including the stack pointer, which
- means we get the right stack and don't have to worry about popping our
- return address and any stack frames and so on) and return. */
-asm(".text");
-asm(".globl _return_to_prog");
-asm("_return_to_prog:");
-asm(" movw _registers+44, %ss");
-asm(" movl _registers+16, %esp");
-asm(" movl _registers+4, %ecx");
-asm(" movl _registers+8, %edx");
-asm(" movl _registers+12, %ebx");
-asm(" movl _registers+20, %ebp");
-asm(" movl _registers+24, %esi");
-asm(" movl _registers+28, %edi");
-asm(" movw _registers+48, %ds");
-asm(" movw _registers+52, %es");
-asm(" movw _registers+56, %fs");
-asm(" movw _registers+60, %gs");
-asm(" movl _registers+36, %eax");
-asm(" pushl %eax"); /* saved eflags */
-asm(" movl _registers+40, %eax");
-asm(" pushl %eax"); /* saved cs */
-asm(" movl _registers+32, %eax");
-asm(" pushl %eax"); /* saved eip */
-asm(" movl _registers, %eax");
-/* use iret to restore pc and flags together so
- that trace flag works right. */
-asm(" iret");
-
-/*
- * BREAKPOINT macro
- */
-#ifdef _MSC_VER //MF
-#define BREAKPOINT() __asm int 3;
-#else
-#define BREAKPOINT() asm(" int $3");
-#endif
-
-/*
- * Store the error code here just in case the user cares.
-*/
-int gdb_i386errcode;
-
-/*
- * Store the vector number here (since GDB only gets the signal
- * number through the usual means, and that's not very specific).
- */
-#ifndef _WIN32 //MF
-int gdb_i386vector = -1;
-#endif // !_WIN32
-
-#if defined(DJGPP) || defined(_WIN32)
-static void handle_exception(int);
-#endif
-
-#ifdef DJGPP
-
-/***********************************************************************
- * save_regs
- *
- * Description: Retreives the i386 registers as they were when the
- * exception occurred. Registers are stored in the
- * local static buffer.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void save_regs(void)
-{
- registers[EAX] = (int) __djgpp_exception_state->__eax;
- registers[ECX] = (int) __djgpp_exception_state->__ecx;
- registers[EDX] = (int) __djgpp_exception_state->__edx;
- registers[EBX] = (int) __djgpp_exception_state->__ebx;
- registers[ESP] = (int) __djgpp_exception_state->__esp;
- registers[EBP] = (int) __djgpp_exception_state->__ebp;
- registers[ESI] = (int) __djgpp_exception_state->__esi;
- registers[EDI] = (int) __djgpp_exception_state->__edi;
- registers[PC] = (int) __djgpp_exception_state->__eip;
- registers[PS] = (int) __djgpp_exception_state->__eflags;
- registers[CS] = (int) __djgpp_exception_state->__cs;
- registers[SS] = (int) __djgpp_exception_state->__ss;
- registers[DS] = (int) __djgpp_exception_state->__ds;
- registers[ES] = (int) __djgpp_exception_state->__es;
- registers[FS] = (int) __djgpp_exception_state->__fs;
- registers[GS] = (int) __djgpp_exception_state->__gs;
-}
-static void end_save_regs(void){}
-
-/***********************************************************************
- * set_regs
- *
- * Description: Restores i386 registers to the DJGPP register buffer.
- * DJGPP exception handler will restore registers from
- * it's buffer on exit from the handler.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void set_regs(void)
-{
- __djgpp_exception_state->__eax = (unsigned long) registers[EAX];
- __djgpp_exception_state->__ecx = (unsigned long) registers[ECX];
- __djgpp_exception_state->__edx = (unsigned long) registers[EDX];
- __djgpp_exception_state->__ebx = (unsigned long) registers[EBX];
- __djgpp_exception_state->__esp = (unsigned long) registers[ESP];
- __djgpp_exception_state->__ebp = (unsigned long) registers[EBP];
- __djgpp_exception_state->__esi = (unsigned long) registers[ESI];
- __djgpp_exception_state->__edi = (unsigned long) registers[EDI];
- __djgpp_exception_state->__eip = (unsigned long) registers[PC];
- __djgpp_exception_state->__eflags = (unsigned long) registers[PS];
- __djgpp_exception_state->__cs = (unsigned long) registers[CS];
- __djgpp_exception_state->__ss = (unsigned long) registers[SS];
- __djgpp_exception_state->__ds = (unsigned long) registers[DS];
- __djgpp_exception_state->__es = (unsigned long) registers[ES];
- __djgpp_exception_state->__fs = (unsigned long) registers[FS];
- __djgpp_exception_state->__gs = (unsigned long) registers[GS];
-}
-static void end_set_regs(void){}
-
-/***********************************************************************
- * sigsegv_handler
- *
- * Description: Handles SIGSEGV signal
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void sigsegv_handler(int except_num){
-
- /* Save general purpose registers */
- save_regs();
-
- /* Dispatch memory fault handling routine if one is registered. */
- if(mem_fault_routine != 0)
- {
- (*mem_fault_routine)();
- mem_fault_routine = NULL;
- }
- else
- {
- /* Save error code */
- gdb_i386errcode = __djgpp_exception_state->__sigmask & 0xffff;
-
- /* Call the general exception handler */
- handle_exception(except_num);
- }
- /* Write back registers */
- set_regs();
-
- /* Return from handler */
- longjmp(__djgpp_exception_state,__djgpp_exception_state->__eax);
-}
-static void end_sigsegv_handler(void){}
-
-/***********************************************************************
- * sigfpe_handler
- *
- * Description: Handles SIGFPE signal
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void sigfpe_handler(int except_num){
-
- /* Save general purpose registers */
- save_regs();
-
- /* Call the general purpose exception handler */
- handle_exception(except_num);
-
- /* Write back registers */
- set_regs();
-
- /* Return from handler */
- longjmp(__djgpp_exception_state,__djgpp_exception_state->__eax);
-}
-static void end_sigfpe_handler(void){}
-
-/***********************************************************************
- * sigtrap_handler
- *
- * Description: Handles SIGTRAP signal
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void sigtrap_handler(int except_num) {
-
- /* Save general purpose registers */
- save_regs();
-
- /* Call the general purpose exception handler */
- handle_exception(except_num);
-
- /* Write back registers */
- set_regs();
-
- /* Return from handler */
- longjmp(__djgpp_exception_state,__djgpp_exception_state->__eax);
-}
-static void end_sigtrap_handler(int except_num){}
-
-/***********************************************************************
- * sigill_handler
- *
- * Description: Handles SIGILL signal
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void sigill_handler(int except_num) {
-
- /* Save general purpose registers */
- save_regs();
-
- /* Call the general purpose exception handler */
- handle_exception(except_num);
-
- /* Write back registers */
- set_regs();
-
- /* Return from handler */
- longjmp(__djgpp_exception_state,__djgpp_exception_state->__eax);
-}
-static void end_sigill_handler(int except_num){}
-#endif
-
-#ifdef _WIN32 //MF
-
-void win32_exception_handler(EXCEPTION_POINTERS* exc_info)
-{
- PCONTEXT ctx = exc_info->ContextRecord;
-
- registers[EAX] = ctx->Eax;
- registers[ECX] = ctx->Ecx;
- registers[EDX] = ctx->Edx;
- registers[EBX] = ctx->Ebx;
- registers[ESP] = ctx->Esp;
- registers[EBP] = ctx->Ebp;
- registers[ESI] = ctx->Esi;
- registers[EDI] = ctx->Edi;
- registers[PC] = ctx->Eip;
- registers[PS] = ctx->EFlags;
- registers[CS] = ctx->SegCs;
- registers[SS] = ctx->SegSs;
- registers[DS] = ctx->SegDs;
- registers[ES] = ctx->SegEs;
- registers[FS] = ctx->SegFs;
- registers[GS] = ctx->SegGs;
-
- handle_exception((int)(exc_info->ExceptionRecord->ExceptionCode & 0xFFFF));
-
- ctx->Eax = registers[EAX];
- ctx->Ecx = registers[ECX];
- ctx->Edx = registers[EDX];
- ctx->Ebx = registers[EBX];
- ctx->Esp = registers[ESP];
- ctx->Ebp = registers[EBP];
- ctx->Esi = registers[ESI];
- ctx->Edi = registers[EDI];
- ctx->Eip = registers[PC];
- ctx->EFlags = registers[PS];
- ctx->SegCs = registers[CS];
- ctx->SegSs = registers[SS];
- ctx->SegDs = registers[DS];
- ctx->SegEs = registers[ES];
- ctx->SegFs = registers[FS];
- ctx->SegGs = registers[GS];
-}
-
-#endif // _WIN32
-
-/***********************************************************************
- * hex
- *
- * Description: Convert ASCII character values, representing hex
- * digits, to the integer value.
- *
- * Inputs:
- * ch - data character
- * Outputs: None.
- * Returns: integer value represented by the input character.
- *
- ***********************************************************************/
-static int hex (char ch)
-{
- if ((ch >= 'a') && (ch <= 'f'))
- return (ch - 'a' + 10);
- if ((ch >= '0') && (ch <= '9'))
- return (ch - '0');
- if ((ch >= 'A') && (ch <= 'F'))
- return (ch - 'A' + 10);
- return (-1);
-}
-#ifdef DJGPP
-static void end_hex(void) {}
-#endif
-
-/***********************************************************************
- * getpacket
- *
- * Description: Retrieve GDB data packet.
- * Scan for the sequence $<data>#<checksum>
- * Inputs: None.
- * Outputs: None.
- * Returns: Beginning of packet buffer.
- *
- ***********************************************************************/
-static unsigned char *getpacket (void)
-{
- unsigned char *buffer = &remcomInBuffer[0];
- unsigned char checksum;
- unsigned char xmitcsum;
- int count;
- char ch;
-
- while (1)
- {
- /* wait around for the start character, ignore all other characters */
- while ((ch = getDebugChar ()) != '$')
- ;
-
- retry:
- checksum = 0;
- xmitcsum = -1;
- count = 0;
-
- /* now, read until a # or end of buffer is found */
- while (count < BUFMAX)
- {
- ch = getDebugChar ();
- if (ch == '$')
- goto retry;
- if (ch == '#')
- break;
- checksum = checksum + ch;
- buffer[count] = ch;
- count = count + 1;
- }
- buffer[count] = 0;
-
- if (ch == '#')
- {
- ch = getDebugChar ();
- xmitcsum = hex (ch) << 4;
- ch = getDebugChar ();
- xmitcsum += hex (ch);
-
- if (checksum != xmitcsum)
- {
- if (remote_debug)
- {
- fprintf (stderr,
- "bad checksum. My count = 0x%x, sent=0x%x. buf=%s\n",
- checksum, xmitcsum, buffer);
- }
- putDebugChar ('-'); /* failed checksum */
- }
- else
- {
- putDebugChar ('+'); /* successful transfer */
-
- /* if a sequence char is present, reply the sequence ID */
- if (buffer[2] == ':')
- {
- putDebugChar (buffer[0]);
- putDebugChar (buffer[1]);
-
- return &buffer[3];
- }
-
- return &buffer[0];
- }
- }
- }
-}
-#ifdef DJGPP
-static void end_getpacket(void) {}
-#endif
-
-/***********************************************************************
- * putpacket
- *
- * Description: Send GDB data packet.
- *
- * Inputs: Buffer of data to send.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void putpacket (unsigned char *buffer)
-{
- unsigned char checksum;
- int count;
- char ch;
-
- /* $<packet info>#<checksum>. */
- do
- {
- putDebugChar ('$');
- checksum = 0;
- count = 0;
-
- while ((ch = buffer[count]))
- {
- putDebugChar (ch);
- checksum += ch;
- count += 1;
- }
-
- putDebugChar ('#');
- putDebugChar (hexchars[checksum >> 4]);
- putDebugChar (hexchars[checksum % 16]);
-
- }
- while (getDebugChar () != '+');
-}
-#ifdef DJGPP
-static void end_putpacket(void) {}
-#endif
-
-
-/***********************************************************************
- * debug_error
- *
- * Description: Log errors
- *
- * Inputs:
- * format - Format string.
- * parm - parameter string
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void debug_error (const char *format, char *parm)
-{
- if (remote_debug)
- fprintf (stderr, format, parm);
-}
-#ifdef DJGPP
-static void end_debug_error(void) {}
-#endif
-
-/*
- * Indicate to caller of mem2hex or hex2mem that there has been an error.
- */
-#ifndef DJGPP
-static volatile int mem_err = 0;
-#else
-static int mem_err = 0;
-#endif
-
-/***********************************************************************
- * set_mem_err
- *
- * Description: set memory error flag
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void set_mem_err (void)
-{
- mem_err = 1;
-}
-#ifdef DJGPP
-static void end_set_mem_err(void) {}
-#endif
-
-/***********************************************************************
- * get_char
- *
- * Description: Retreive a character from the specified address.
- * These are separate functions so that they are so
- * short and sweet that the compiler won't save any
- * registers (if there is a fault to mem_fault, they
- * won't get restored, so there better not be any saved).
- *
- * Inputs: addr - The address to read from.
- * Outputs: None.
- * Returns: data read from address.
- *
- ***********************************************************************/
-static int get_char (char *addr)
-{
- return *addr;
-}
-#ifdef DJGPP
-static void end_get_char(void) {}
-#endif
-
-/***********************************************************************
- * set_char
- *
- * Description: Write a value to the specified address.
- * These are separate functions so that they are so
- * short and sweet that the compiler won't save any
- * registers (if there is a fault to mem_fault, they
- * won't get restored, so there better not be any saved).
- *
- * Inputs:
- * addr - The address to read from.
- * val - value to write.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void set_char (char *addr, int val)
-{
- *addr = val;
-}
-#ifdef DJGPP
-static void end_set_char(void) {}
-#endif
-
-
-/***********************************************************************
- * mem2hex
- *
- * Description: Convert the memory pointed to by mem into hex, placing
- * result in buf. Return a pointer to the last char put
- * in buf (null). If MAY_FAULT is non-zero, then we should
- * set mem_err in response to a fault; if zero treat a
- * fault like any other fault in the stub.
- *
- * Inputs:
- * mem - Memory address
- * buf - data buffer
- * count - number of bytes
- * may_fault - flag indicating that the operation may cause a mem fault.
- * Outputs: None.
- * Returns: Pointer to last character.
- *
- ***********************************************************************/
-static char *mem2hex (char *mem,char *buf,int count,int may_fault)
-{
- int i;
- unsigned char ch;
-
-#ifdef _WIN32 //MF
- if (IsBadReadPtr(mem, (DWORD)count))
- return mem;
-#else
- if (may_fault)
- mem_fault_routine = set_mem_err;
-#endif
- for (i = 0; i < count; i++)
- {
- ch = get_char (mem++);
- if (may_fault && mem_err)
- return (buf);
- *buf++ = hexchars[ch >> 4];
- *buf++ = hexchars[ch % 16];
- }
- *buf = 0;
-#ifndef _WIN32 //MF
- if (may_fault)
- mem_fault_routine = NULL;
-#endif
- return (buf);
-}
-#ifdef DJGPP
-static void end_mem2hex(void) {}
-#endif
-
-/***********************************************************************
- * hex2mem
- *
- * Description: Convert the hex array pointed to by buf into binary to
- * be placed in mem. Return a pointer to the character
- * AFTER the last byte written
- * Inputs:
- * buf
- * mem
- * count
- * may_fault
- * Outputs: None.
- * Returns: Pointer to buffer after last byte.
- *
- ***********************************************************************/
-static char *hex2mem (char *buf,char *mem,int count,int may_fault)
-{
- int i;
- unsigned char ch;
-
-#ifdef _WIN32 //MF
- // MinGW does not support structured exception handling, so let's
- // go safe and make memory writable by default
- DWORD old_protect;
-
- VirtualProtect(mem, (DWORD)count, PAGE_EXECUTE_READWRITE, &old_protect);
-#else
- if (may_fault)
- mem_fault_routine = set_mem_err;
-#endif
- for (i = 0; i < count; i++)
- {
- ch = hex (*buf++) << 4;
- ch = ch + hex (*buf++);
- set_char (mem++, ch);
- if (may_fault && mem_err)
- return (mem);
- }
-#ifndef _WIN32 //MF
- if (may_fault)
- mem_fault_routine = NULL;
-#endif
- return (mem);
-}
-#ifdef DJGPP
-static void end_hex2mem(void) {}
-#endif
-
-/***********************************************************************
- * computeSignal
- *
- * Description: This function takes the 386 exception vector and
- * attempts to translate this number into a unix
- * compatible signal value.
- * Inputs:
- * exceptionVector
- * Outputs: None.
- * Returns:
- *
- ***********************************************************************/
-static int computeSignal (int exceptionVector)
-{
- int sigval;
- switch (exceptionVector)
- {
- case 0:
- sigval = 8;
- break; /* divide by zero */
- case 1:
- sigval = 5;
- break; /* debug exception */
- case 3:
- sigval = 5;
- break; /* breakpoint */
- case 4:
- sigval = 16;
- break; /* into instruction (overflow) */
- case 5:
- sigval = 16;
- break; /* bound instruction */
- case 6:
- sigval = 4;
- break; /* Invalid opcode */
- case 7:
- sigval = 8;
- break; /* coprocessor not available */
- case 8:
- sigval = 7;
- break; /* double fault */
- case 9:
- sigval = 11;
- break; /* coprocessor segment overrun */
- case 10:
- sigval = 11;
- break; /* Invalid TSS */
- case 11:
- sigval = 11;
- break; /* Segment not present */
- case 12:
- sigval = 11;
- break; /* stack exception */
- case 13:
- sigval = 11;
- break; /* general protection */
- case 14:
- sigval = 11;
- break; /* page fault */
- case 16:
- sigval = 7;
- break; /* coprocessor error */
- default:
- sigval = 7; /* "software generated" */
- }
- return (sigval);
-}
-#ifdef DJGPP
-static void end_computeSignal(void) {}
-#endif
-
-/***********************************************************************
- * hexToInt
- *
- * Description: Convert an ASCII string to an integer.
- *
- * Inputs:
- * Outputs: None.
- * Returns: Number of chars processed
- *
- ***********************************************************************/
-int hexToInt (char **ptr, int *intValue)
-{
- int numChars = 0;
- int hexValue;
-
- *intValue = 0;
-
- while (**ptr)
- {
- hexValue = hex (**ptr);
- if (hexValue >= 0)
- {
- *intValue = (*intValue << 4) | hexValue;
- numChars++;
- }
- else
- break;
-
- (*ptr)++;
- }
-
- return (numChars);
-}
-#ifdef DJGPP
-static void end_hexToInt(void) {}
-#endif
-
-
-/***********************************************************************
- * handle_exception
- *
- * Description: This function does all command procesing for interfacing
- * to GDB.
- * Inputs:
- * exceptionVector - number of the vector.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void handle_exception (int exceptionVector)
-{
- int sigval, stepping;
- int addr, length;
- char *ptr;
- int newPC;
-
-#ifndef _WIN32 //MF
- gdb_i386vector = exceptionVector;
-#endif
-
- if (remote_debug)
- {
- printf ("vector=%d, sr=0x%x, pc=0x%x\n",
- exceptionVector, registers[PS], registers[PC]);
- }
-
- /* reply to host that an exception has occurred */
- sigval = computeSignal (exceptionVector);
-
- ptr = remcomOutBuffer;
-
- *ptr++ = 'T'; /* notify gdb with signo, PC, FP and SP */
- *ptr++ = hexchars[sigval >> 4];
- *ptr++ = hexchars[sigval & 0xf];
-
- *ptr++ = hexchars[ESP];
- *ptr++ = ':';
- ptr = mem2hex((char *)®isters[ESP], ptr, 4, 0); /* SP */
- *ptr++ = ';';
-
- *ptr++ = hexchars[EBP];
- *ptr++ = ':';
- ptr = mem2hex((char *)®isters[EBP], ptr, 4, 0); /* FP */
- *ptr++ = ';';
-
- *ptr++ = hexchars[PC];
- *ptr++ = ':';
- ptr = mem2hex((char *)®isters[PC], ptr, 4, 0); /* PC */
- *ptr++ = ';';
-
- *ptr = '\0';
-
- putpacket (remcomOutBuffer);
-
- stepping = 0;
-
- while (1 == 1)
- {
- remcomOutBuffer[0] = 0;
- ptr = getpacket ();
-
- switch (*ptr++)
- {
- case '?':
- remcomOutBuffer[0] = 'S';
- remcomOutBuffer[1] = hexchars[sigval >> 4];
- remcomOutBuffer[2] = hexchars[sigval % 16];
- remcomOutBuffer[3] = 0;
- break;
- case 'd':
- remote_debug = !(remote_debug); /* toggle debug flag */
- break;
- case 'g': /* return the value of the CPU registers */
- mem2hex ((char *) registers, remcomOutBuffer, NUMREGBYTES, 0);
- break;
- case 'G': /* set the value of the CPU registers - return OK */
- hex2mem (ptr, (char *) registers, NUMREGBYTES, 0);
- strcpy (remcomOutBuffer, "OK");
- break;
- case 'P': /* set the value of a single CPU register - return OK */
- {
- int regno;
-
- if (hexToInt (&ptr, ®no) && *ptr++ == '=')
- if (regno >= 0 && regno < NUMREGS)
- {
- hex2mem (ptr, (char *) ®isters[regno], 4, 0);
- strcpy (remcomOutBuffer, "OK");
- break;
- }
-
- strcpy (remcomOutBuffer, "E01");
- break;
- }
-
- /* mAA..AA,LLLL Read LLLL bytes at address AA..AA */
- case 'm':
- /* TRY TO READ %x,%x. IF SUCCEED, SET PTR = 0 */
- if (hexToInt (&ptr, &addr))
- if (*(ptr++) == ',')
- if (hexToInt (&ptr, &length))
- {
- ptr = 0;
- mem_err = 0;
- mem2hex ((char *) addr, remcomOutBuffer, length, 1);
- if (mem_err)
- {
- strcpy (remcomOutBuffer, "E03");
- debug_error ("%s","memory fault");
- }
- }
-
- if (ptr)
- {
- strcpy (remcomOutBuffer, "E01");
- }
- break;
-
- /* MAA..AA,LLLL: Write LLLL bytes at address AA.AA return OK */
- case 'M':
- /* TRY TO READ '%x,%x:'. IF SUCCEED, SET PTR = 0 */
- if (hexToInt (&ptr, &addr))
- if (*(ptr++) == ',')
- if (hexToInt (&ptr, &length))
- if (*(ptr++) == ':')
- {
- mem_err = 0;
- hex2mem (ptr, (char *) addr, length, 1);
-
- if (mem_err)
- {
- strcpy (remcomOutBuffer, "E03");
- debug_error ("%s","memory fault");
- }
- else
- {
- strcpy (remcomOutBuffer, "OK");
- }
-
- ptr = 0;
- }
- if (ptr)
- {
- strcpy (remcomOutBuffer, "E02");
- }
- break;
-
- /* cAA..AA Continue at address AA..AA(optional) */
- /* sAA..AA Step one instruction from AA..AA(optional) */
- case 's':
- stepping = 1;
- case 'c':
- /* try to read optional parameter, pc unchanged if no parm */
- if (hexToInt (&ptr, &addr))
- registers[PC] = addr;
-
- newPC = registers[PC];
-
- /* clear the trace bit */
- registers[PS] &= 0xfffffeff;
-
- /* set the trace bit if we're stepping */
- if (stepping)
- registers[PS] |= 0x100;
-
-#ifdef _WIN32 //MF
- return;
-#else
- _returnFromException (); /* this is a jump */
-
- break;
-
- /* kill the program */
- case 'k': /* do nothing */
-#if 0
- /* Huh? This doesn't look like "nothing".
- m68k-stub.c and sparc-stub.c don't have it. */
- BREAKPOINT ();
-#endif
- break;
-#endif
- } /* switch */
-
- /* reply to the request */
- putpacket (remcomOutBuffer);
- }
-}
-#ifdef DJGPP
-static void end_handle_exception(void) {}
-#endif
-
-#ifndef DJGPP
-/* GDB stores segment registers in 32-bit words (that's just the way
- m-i386v.h is written). So zero the appropriate areas in registers. */
-#define SAVE_REGISTERS1() \
- asm ("movl %eax, _registers"); \
- asm ("movl %ecx, _registers+4"); \
- asm ("movl %edx, _registers+8"); \
- asm ("movl %ebx, _registers+12"); \
- asm ("movl %ebp, _registers+20"); \
- asm ("movl %esi, _registers+24"); \
- asm ("movl %edi, _registers+28"); \
- asm ("movw $0, %ax"); \
- asm ("movw %ds, _registers+48"); \
- asm ("movw %ax, _registers+50"); \
- asm ("movw %es, _registers+52"); \
- asm ("movw %ax, _registers+54"); \
- asm ("movw %fs, _registers+56"); \
- asm ("movw %ax, _registers+58"); \
- asm ("movw %gs, _registers+60"); \
- asm ("movw %ax, _registers+62");
-#define SAVE_ERRCODE() \
- asm ("popl %ebx"); \
- asm ("movl %ebx, _gdb_i386errcode");
-#define SAVE_REGISTERS2() \
- asm ("popl %ebx"); /* old eip */ \
- asm ("movl %ebx, _registers+32"); \
- asm ("popl %ebx"); /* old cs */ \
- asm ("movl %ebx, _registers+40"); \
- asm ("movw %ax, _registers+42"); \
- asm ("popl %ebx"); /* old eflags */ \
- asm ("movl %ebx, _registers+36"); \
- /* Now that we've done the pops, we can save the stack pointer."); */ \
- asm ("movw %ss, _registers+44"); \
- asm ("movw %ax, _registers+46"); \
- asm ("movl %esp, _registers+16");
-
-/* See if mem_fault_routine is set, if so just IRET to that address. */
-#define CHECK_FAULT() \
- asm ("cmpl $0, _mem_fault_routine"); \
- asm ("jne mem_fault");
-
-asm (".text");
-asm ("mem_fault:");
-/* OK to clobber temp registers; we're just going to end up in set_mem_err. */
-/* Pop error code from the stack and save it. */
-asm (" popl %eax");
-asm (" movl %eax, _gdb_i386errcode");
-
-asm (" popl %eax"); /* eip */
-/* We don't want to return there, we want to return to the function
- pointed to by mem_fault_routine instead. */
-asm (" movl _mem_fault_routine, %eax");
-asm (" popl %ecx"); /* cs (low 16 bits; junk in hi 16 bits). */
-asm (" popl %edx"); /* eflags */
-
-/* Remove this stack frame; when we do the iret, we will be going to
- the start of a function, so we want the stack to look just like it
- would after a "call" instruction. */
-asm (" leave");
-
-/* Push the stuff that iret wants. */
-asm (" pushl %edx"); /* eflags */
-asm (" pushl %ecx"); /* cs */
-asm (" pushl %eax"); /* eip */
-
-/* Zero mem_fault_routine. */
-asm (" movl $0, %eax");
-asm (" movl %eax, _mem_fault_routine");
-
-asm ("iret");
-
-
-#define CALL_HOOK() asm("call _remcomHandler");
-
-/* This function is called when a i386 exception occurs. It saves
- * all the cpu regs in the _registers array, munges the stack a bit,
- * and invokes an exception handler (remcom_handler).
- *
- * stack on entry: stack on exit:
- * old eflags vector number
- * old cs (zero-filled to 32 bits)
- * old eip
- *
- */
-extern void _catchException3();
-asm(".text");
-asm(".globl __catchException3");
-asm("__catchException3:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $3");
-CALL_HOOK();
-
-/* Same thing for exception 1. */
-extern void _catchException1();
-asm(".text");
-asm(".globl __catchException1");
-asm("__catchException1:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $1");
-CALL_HOOK();
-
-/* Same thing for exception 0. */
-extern void _catchException0();
-asm(".text");
-asm(".globl __catchException0");
-asm("__catchException0:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $0");
-CALL_HOOK();
-
-/* Same thing for exception 4. */
-extern void _catchException4();
-asm(".text");
-asm(".globl __catchException4");
-asm("__catchException4:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $4");
-CALL_HOOK();
-
-/* Same thing for exception 5. */
-extern void _catchException5();
-asm(".text");
-asm(".globl __catchException5");
-asm("__catchException5:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $5");
-CALL_HOOK();
-
-/* Same thing for exception 6. */
-extern void _catchException6();
-asm(".text");
-asm(".globl __catchException6");
-asm("__catchException6:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $6");
-CALL_HOOK();
-
-/* Same thing for exception 7. */
-extern void _catchException7();
-asm(".text");
-asm(".globl __catchException7");
-asm("__catchException7:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $7");
-CALL_HOOK();
-
-/* Same thing for exception 8. */
-extern void _catchException8();
-asm(".text");
-asm(".globl __catchException8");
-asm("__catchException8:");
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $8");
-CALL_HOOK();
-
-/* Same thing for exception 9. */
-extern void _catchException9();
-asm(".text");
-asm(".globl __catchException9");
-asm("__catchException9:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $9");
-CALL_HOOK();
-
-/* Same thing for exception 10. */
-extern void _catchException10();
-asm(".text");
-asm(".globl __catchException10");
-asm("__catchException10:");
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $10");
-CALL_HOOK();
-
-/* Same thing for exception 12. */
-extern void _catchException12();
-asm(".text");
-asm(".globl __catchException12");
-asm("__catchException12:");
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $12");
-CALL_HOOK();
-
-/* Same thing for exception 16. */
-extern void _catchException16();
-asm(".text");
-asm(".globl __catchException16");
-asm("__catchException16:");
-SAVE_REGISTERS1();
-SAVE_REGISTERS2();
-asm ("pushl $16");
-CALL_HOOK();
-
-/* For 13, 11, and 14 we have to deal with the CHECK_FAULT stuff. */
-
-/* Same thing for exception 13. */
-extern void _catchException13 ();
-asm (".text");
-asm (".globl __catchException13");
-asm ("__catchException13:");
-CHECK_FAULT();
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $13");
-CALL_HOOK();
-
-/* Same thing for exception 11. */
-extern void _catchException11 ();
-asm (".text");
-asm (".globl __catchException11");
-asm ("__catchException11:");
-CHECK_FAULT();
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $11");
-CALL_HOOK();
-
-/* Same thing for exception 14. */
-extern void _catchException14 ();
-asm (".text");
-asm (".globl __catchException14");
-asm ("__catchException14:");
-CHECK_FAULT();
-SAVE_REGISTERS1();
-SAVE_ERRCODE();
-SAVE_REGISTERS2();
-asm ("pushl $14");
-CALL_HOOK();
-
-/*
- * remcomHandler is a front end for handle_exception. It moves the
- * stack pointer into an area reserved for debugger use.
- */
-asm("_remcomHandler:");
-asm(" popl %eax"); /* pop off return address */
-asm(" popl %eax"); /* get the exception number */
-asm(" movl _stackPtr, %esp"); /* move to remcom stack area */
-asm(" pushl %eax"); /* push exception onto stack */
-asm(" call _handle_exception"); /* this never returns */
-#endif
-
-void _returnFromException ()
-{
-#ifndef DJGPP
- return_to_prog ();
-#else
-/* Return from handler */
- longjmp(__djgpp_exception_state,__djgpp_exception_state->__eax);
-#endif
-}
-
-/* this function is used to set up exception handlers for tracing and
- breakpoints */
-#ifndef DJGPP
-void
-set_debug_traps (void)
-{
-#ifndef _WIN32 //MF
- stackPtr = &remcomStack[STACKSIZE / sizeof (int) - 1];
-
- exceptionHandler (0, _catchException0);
- exceptionHandler (1, _catchException1);
- exceptionHandler (3, _catchException3);
- exceptionHandler (4, _catchException4);
- exceptionHandler (5, _catchException5);
- exceptionHandler (6, _catchException6);
- exceptionHandler (7, _catchException7);
- exceptionHandler (8, _catchException8);
- exceptionHandler (9, _catchException9);
- exceptionHandler (10, _catchException10);
- exceptionHandler (11, _catchException11);
- exceptionHandler (12, _catchException12);
- exceptionHandler (13, _catchException13);
- exceptionHandler (14, _catchException14);
- exceptionHandler (16, _catchException16);
-#endif // _WIN32
-
- gdb_initialized = 1;
-}
-#endif //#ifndef DJGPP
-
-
-// DJGPP stuff
-#ifdef DJGPP
-/***********************************************************************
- * restore_traps
- *
- * Description: This function restores all used signal handlers to
- * defaults.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-void restore_traps(void)
-{
- /* Restore default signal handlers */
- signal(SIGSEGV,SIG_DFL);
- signal(SIGTRAP,SIG_DFL);
- signal(SIGFPE,SIG_DFL);
- signal(SIGTRAP,SIG_DFL);
- signal(SIGILL,SIG_DFL);
-
- /* Clear init flag */
- gdb_initialized = 0;
-}
-
-/***********************************************************************
- * lock_handler_data
- *
- * Description: This function locks all data that is used by the signal
- * handlers.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-static void lock_handler_data(void)
-{
- _go32_dpmi_lock_data(&gdb_initialized,sizeof(gdb_initialized));
- _go32_dpmi_lock_data(&remote_debug,sizeof(remote_debug));
- _go32_dpmi_lock_data(hexchars,sizeof(hexchars));
- _go32_dpmi_lock_data(registers,sizeof(registers));
- _go32_dpmi_lock_data(&gdb_i386errcode,sizeof(gdb_i386errcode));
- _go32_dpmi_lock_data(&gdb_i386vector,sizeof(gdb_i386vector));
-
- _go32_dpmi_lock_data(remcomInBuffer,sizeof(remcomInBuffer));
- _go32_dpmi_lock_data(remcomOutBuffer,sizeof(remcomOutBuffer));
-
- _go32_dpmi_lock_code(getpacket,(unsigned long)end_getpacket-
- (unsigned long)getpacket);
- _go32_dpmi_lock_code(putpacket,(unsigned long)end_putpacket-
- (unsigned long)putpacket);
- _go32_dpmi_lock_code(debug_error,(unsigned long)end_debug_error-
- (unsigned long)debug_error);
-
- _go32_dpmi_lock_data(&mem_fault_routine,sizeof(mem_fault_routine));
- _go32_dpmi_lock_data(&mem_err,sizeof(mem_err));
-
- _go32_dpmi_lock_code(set_mem_err,(unsigned long)end_set_mem_err-(unsigned long)set_mem_err);
- _go32_dpmi_lock_code(get_char,(unsigned long)end_get_char-(unsigned long)get_char);
- _go32_dpmi_lock_code(set_char,(unsigned long)end_set_char-(unsigned long)set_char);
- _go32_dpmi_lock_code(mem2hex,(unsigned long)end_hex-(unsigned long)hex);
- _go32_dpmi_lock_code(mem2hex,(unsigned long)end_mem2hex-(unsigned long)mem2hex);
- _go32_dpmi_lock_code(hex2mem,(unsigned long)end_hex2mem-(unsigned long)hex2mem);
- _go32_dpmi_lock_code(computeSignal,(unsigned long)end_computeSignal-
- (unsigned long)computeSignal);
- _go32_dpmi_lock_code(hexToInt,(unsigned long)end_hexToInt-(unsigned long)hexToInt);
- _go32_dpmi_lock_code(handle_exception,(unsigned long)end_handle_exception-
- (unsigned long)handle_exception);
-
- _go32_dpmi_lock_code(sigsegv_handler,
- (unsigned long)end_sigsegv_handler-(unsigned long)sigsegv_handler);
-
- _go32_dpmi_lock_code(sigfpe_handler,
- (unsigned long)end_sigfpe_handler-(unsigned long)sigfpe_handler);
-
- _go32_dpmi_lock_code(sigtrap_handler,
- (unsigned long)end_sigtrap_handler-(unsigned long)sigtrap_handler);
-
- _go32_dpmi_lock_code(sigill_handler,
- (unsigned long)end_sigill_handler-(unsigned long)sigill_handler);
-
- _go32_dpmi_lock_code(save_regs,
- (unsigned long)end_save_regs-(unsigned long)save_regs);
-
- _go32_dpmi_lock_code(set_regs,
- (unsigned long)end_set_regs-(unsigned long)set_regs);
-
-}
-
-/***********************************************************************
- * set_debug_traps
- *
- * Description: This function installs signal handlers.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-void set_debug_traps(void)
-{
- /* Lock any data that may be used by the trap handlers */
- lock_handler_data();
-
- /* Install signal handlers here */
- signal(SIGSEGV,sigsegv_handler);
- signal(SIGFPE,sigfpe_handler);
- signal(SIGTRAP,sigtrap_handler);
- signal(SIGILL,sigill_handler);
-
- /* Set init flag */
- gdb_initialized = 1;
-
-}
-#endif //#ifdef DJGPP
-
-/***********************************************************************
- * breakpoint
- *
- * Description: This function will generate a breakpoint exception.
- * It is used at the beginning of a program to sync up
- * with a debugger and can be used otherwise as a quick
- * means to stop program execution and "break" into the
- * debugger.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-void breakpoint ()
-{
- if (gdb_initialized)
- BREAKPOINT ();
-}
-
diff --git a/tools/gdbst03/src/library/i386-supp.c b/tools/gdbst03/src/library/i386-supp.c
deleted file mode 100644
index baf465b4e3152b6740126a84e59df199db2c30fa..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/i386-supp.c
+++ /dev/null
@@ -1,424 +0,0 @@
-/***********************************************************************
- * i386-supp.c
- *
- * Description: Support functions for the i386 GDB target stub.
- *
- * Credits: Created by Jonathan Brogdon
- *
- * Terms of use: This software is provided for use under the terms
- * and conditions of the GNU General Public License.
- * 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., 59 Temple Place
- * Suite 330, Boston, MA 02111-1307, USA.
- *
- * Global Data: None.
- * Global Functions:
- * gdb_serial_init
- * gdb_target_init
- * gdb_target_close
- * putDebugChar
- * getDebugChar
- *
- * History
- * Engineer: Date: Notes:
- * --------- ----- ------
- * Jonathan Brogdon 20000617 Genesis
- * Gordon Schumacher 20020212 Updated for modularity
- *
- ***********************************************************************/
-
-
-#ifdef DJGPP
-#include <bios.h>
-#endif
-
-#ifdef _WIN32
-#define WIN32_LEAN_AND_MEAN
-#include <windows.h>
-#include <winsock.h>
-#include <errno.h>
-#define DEBUGBUFFERSIZE 1024
-HANDLE ser_port = (HANDLE)(-1);
-
-//#include "utility/utility.h"
-#ifdef _MSC_VER
-#ifndef DEBUG_SERIAL
-#pragma comment(lib, "wsock32")
-#endif
-#endif
-#endif
-
-#include <stdlib.h>
-#include <i386-stub.h>
-
-#ifdef DJGPP
-//#include "bios_layer.h" // Include this for BIOS calls - NOT RECOMMENDED!
-//#include "sva_layer.h" // Include this for SVAsync usage
-#include "dzc_layer.h" // Include this for DZComm usage
-
-
-#endif
-#define SER_TIMEOUT 1000000
-
-#ifdef _WIN32
-static LPTOP_LEVEL_EXCEPTION_FILTER s_prev_exc_handler = 0;
-
-
-#define I386_EXCEPTION_CNT 17
-
-LONG WINAPI exc_protection_handler(EXCEPTION_POINTERS* exc_info)
-{
- int exc_nr = exc_info->ExceptionRecord->ExceptionCode & 0xFFFF;
-
- if (exc_nr < I386_EXCEPTION_CNT) {
- //LOG(FmtString(TEXT("exc_protection_handler: Exception %x"), exc_nr));
-
-#if 0
- if (exc_nr==11 || exc_nr==13 || exc_nr==14) {
- if (mem_fault_routine)
- mem_fault_routine();
- }
-#endif
-
- ++exc_info->ContextRecord->Eip;
- }
-
- return EXCEPTION_CONTINUE_EXECUTION;
-}
-
-LONG WINAPI exc_handler(EXCEPTION_POINTERS* exc_info)
-{
- int exc_nr = exc_info->ExceptionRecord->ExceptionCode & 0xFFFF;
-
- if (exc_nr < I386_EXCEPTION_CNT) {
- //LOG(FmtString("Exception %x", exc_nr));
- //LOG(FmtString("EIP=%08X EFLAGS=%08X", exc_info->ContextRecord->Eip, exc_info->ContextRecord->EFlags));
-
- // step over initial breakpoint
- if (s_initial_breakpoint) {
- s_initial_breakpoint = 0;
- ++exc_info->ContextRecord->Eip;
- }
-
- SetUnhandledExceptionFilter(exc_protection_handler);
-
- win32_exception_handler(exc_info);
- //LOG(FmtString("EIP=%08X EFLAGS=%08X", exc_info->ContextRecord->Eip, exc_info->ContextRecord->EFlags));
-
- SetUnhandledExceptionFilter(exc_handler);
-
- return EXCEPTION_CONTINUE_EXECUTION;
- }
-
- return EXCEPTION_CONTINUE_SEARCH;
-}
-
-void disable_debugging()
-{
- if (s_prev_exc_handler) {
- SetUnhandledExceptionFilter(s_prev_exc_handler);
- s_prev_exc_handler = 0;
- }
-}
-#endif
-
-#if !(defined(DJGPP) || defined(_WIN32))
-void exceptionHandler(int exc_nr, void* exc_addr)
-{
- if (exc_nr>=0 && exc_nr<I386_EXCEPTION_CNT)
- exc_handlers[exc_nr] = exc_addr;
-}
-#endif
-
-/***********************************************************************
- * gdb_serial_init
- *
- * Description: Initializes the serial port for remote debugging.
- *
- * Inputs:
- * port - the PC COM port to use.
- * speed - the COM port speed.
- * Outputs: None.
- * Returns: 0 for success
- *
- ***********************************************************************/
-int gdb_serial_init(unsigned int port, unsigned int speed)
-{
-#ifdef DJGPP
- int ret;
-
- ret = GDBStub_SerInit(port);
- if (ret == 0)
- ret = GDBStub_SerSpeed(speed);
-
- return ret;
-#elif defined(_WIN32)
- DCB dcb ;
-
- port = 0; //TODO
-
- s_prev_exc_handler = SetUnhandledExceptionFilter(exc_handler);
-
- ser_port = CreateFile( "COM1", GENERIC_READ | GENERIC_WRITE,
- 0, // exclusive access
- NULL, // no security attrs
- OPEN_EXISTING,
- FILE_ATTRIBUTE_NORMAL,
- NULL );
- if( ser_port == (HANDLE)(-1) )
- {
- return 0;
- }
- // buffers
- SetupComm( ser_port, DEBUGBUFFERSIZE, DEBUGBUFFERSIZE ) ;
-
- // purge buffers
- PurgeComm( ser_port, PURGE_TXABORT | PURGE_RXABORT |
- PURGE_TXCLEAR | PURGE_RXCLEAR ) ;
-
- // setup port to 9600 8N1
- dcb.DCBlength = sizeof( DCB ) ;
-
- GetCommState( ser_port, &dcb ) ;
-
- dcb.BaudRate = speed;
- dcb.ByteSize = 8;
- dcb.Parity = NOPARITY ;
- dcb.StopBits = ONESTOPBIT ;
-
- dcb.fDtrControl = DTR_CONTROL_ENABLE ;
- dcb.fRtsControl = RTS_CONTROL_ENABLE ;
-
- dcb.fBinary = TRUE ;
- dcb.fParity = FALSE ;
-
- SetCommState( ser_port, &dcb ) ;
-
- return 1;
-#endif
-}
-/***********************************************************************
- * gdb_target_init
- *
- * Description: This function inializes the GDB target.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-void gdb_target_init(void)
-{
- set_debug_traps();
- atexit(restore_traps);
-}
-
-/***********************************************************************
- * gdb_target_close
- *
- * Description: This function closes the GDB target.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: None.
- *
- ***********************************************************************/
-void gdb_target_close(void)
-{
- restore_traps();
-}
-
-/***********************************************************************
- * putDebugChar
- *
- * Description: sends a character to the debug COM port.
- *
- * Inputs:
- * c - the data character to be sent
- * Outputs: None.
- * Returns: 0 for success
- *
- ***********************************************************************/
-int putDebugChar(char c)
-{
- register int timeout = 0;
-#ifdef DJGPP
-
- while ((GDBStub_SerSendOk() == 0) && (timeout < SER_TIMEOUT))
- timeout++;
- return GDBStub_SerSend(c);
-#elif defined(_WIN32)
- DWORD buffer[DEBUGBUFFERSIZE];
- COMSTAT ComStat ;
- DWORD dwErrorFlags;
- DWORD dwLength;
-
- if(ser_port == (HANDLE)-1)
- return 0;
-
- buffer[0] = c;
-
- retrywrite:
- ClearCommError( ser_port, &dwErrorFlags, &ComStat ) ;
- dwLength = ComStat.cbOutQue;
-
- if (dwLength < DEBUGBUFFERSIZE || timeout > SER_TIMEOUT)
- {
- if(WriteFile( ser_port, buffer, 1, &dwLength, NULL ))
- return 1;
- else if(timeout > SER_TIMEOUT)
- return 0;
- }
- else timeout++;
- goto retrywrite;
-#endif
-}
-
-/***********************************************************************
- * getDebugChar
- *
- * Description: gets a character from the debug COM port.
- *
- * Inputs: None.
- * Outputs: None.
- * Returns: character data from the serial support.
- *
- ***********************************************************************/
-int getDebugChar(void)
-{
- register int timeout = 0;
-#ifdef DJGPP
- register int ret = -1;
-
- while ((GDBStub_SerRecvOk() == 0) && (timeout < SER_TIMEOUT))
- timeout++;
- if (timeout < SER_TIMEOUT)
- ret = GDBStub_SerRecv();
-
- return ret;
-#elif defined(_WIN32)
- DWORD buffer[DEBUGBUFFERSIZE];
- COMSTAT ComStat ;
- DWORD dwErrorFlags;
- DWORD dwLength;
-
- if(ser_port == (HANDLE)-1)
- return -1;
-
- retryread:
- ClearCommError( ser_port, &dwErrorFlags, &ComStat ) ;
- dwLength = min( DEBUGBUFFERSIZE, ComStat.cbInQue ) ;
-
- if (dwLength > 0 || timeout > SER_TIMEOUT)
- {
- if(ReadFile( ser_port, buffer, 1, &dwLength, NULL ))
- return buffer[0];
- else if(timeout > SER_TIMEOUT)
- return -1;
- }
- else timeout++;
- goto retryread;
-#endif
-}
-
-#if 0
-static SOCKET s_rem_fd = INVALID_SOCKET;
-
-int init_gdb_connect()
-{
-#ifdef _WIN32
- WORD wVersionRequested;
- WSADATA wsa_data;
-#endif
- SOCKADDR_IN srv_addr;
- SOCKADDR_IN rem_addr;
- SOCKET srv_socket;
- int rem_len;
-
- memset(&srv_addr,0,sizeof(srv_addr));
- s_prev_exc_handler = SetUnhandledExceptionFilter(exc_handler);
-
-#ifdef _WIN32
- wVersionRequested= MAKEWORD( 2, 2 );
- if (WSAStartup(wVersionRequested, &wsa_data)) {
- fprintf(stderr, "WSAStartup() failed");
- return 0;
- }
-#endif
-
- srv_addr.sin_family = AF_INET;
- srv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
- srv_addr.sin_port = htons(9999);
-
- srv_socket = socket(PF_INET, SOCK_STREAM, 0);
- if (srv_socket == INVALID_SOCKET) {
- perror("socket()");
- return 0;
- }
-
- if (bind(srv_socket, (struct sockaddr*) &srv_addr, sizeof(srv_addr)) == -1) {
- perror("bind()");
- return 0;
- }
-
- if (listen(srv_socket, 4) == -1) {
- perror("listen()");
- return 0;
- }
-
- rem_len = sizeof(rem_addr);
-
- for(;;) {
- s_rem_fd = accept(srv_socket, (struct sockaddr*)&rem_addr, &rem_len);
-
- if (s_rem_fd == INVALID_SOCKET) {
- if (errno == EINTR)
- continue;
-
- perror("accept()");
- return 0;
- }
-
- break;
- }
-
- return 1;
-}
-
-
-int getDebugChar()
-{
- char buffer[DEBUGBUFFERSIZE];
- int r;
-
- if (s_rem_fd == INVALID_SOCKET)
- return EOF;
-
- r = recv(s_rem_fd, buffer, 1, 0);
- if (r == -1) {
- perror("recv()");
- //LOG(TEXT("debugger connection broken"));
- s_rem_fd = INVALID_SOCKET;
- return EOF;
- }
-
- if (!r)
- return EOF;
-
- return buffer[0];
-}
-
-void putDebugChar(int c)
-{
- if (s_rem_fd == INVALID_SOCKET) {
- const char buffer[] = {c};
-
- if (!send(s_rem_fd, buffer, 1, 0)) {
- perror("send()");
- //LOG(TEXT("debugger connection broken"));
- exit(-1);
- }
- }
-}
-#endif
diff --git a/tools/gdbst03/src/library/makefile b/tools/gdbst03/src/library/makefile
deleted file mode 100644
index 05e1e9030f9335b29da1ecefab081f2334e6402d..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/makefile
+++ /dev/null
@@ -1,30 +0,0 @@
-#
-# Makefile for GDB Stub for DJGPP
-#
-# GDB Stub for DJGPP Copyright 2000 by Jonathan Brogdon
-#
-
-include ../../Makefile.cfg
-
-CFLAGS += -I../../include -I../include
-
-LOBJS = i386-stub.o i386-supp.o
-
-all: library
-
-library: $(LOBJS)
- @$(RM) ../../lib/libgdbst.a
- @$(AR) rcs ../../lib/libgdbst.a $(LOBJS)
-
-dep:
- @$(CC) $(CFLAGS) -M *.c > depend.dep
-
-clean:
- @$(RM) $(LOBJS)
-
-distclean: clean
- @$(RM) ../../lib/libgdbst.a
- @$(RM) depend.dep
-
-$(OBJS) $(LOBJS):
-include depend.dep
diff --git a/tools/gdbst03/src/library/sva_layer.h b/tools/gdbst03/src/library/sva_layer.h
deleted file mode 100644
index 4cdd1628b7edc648aab6522f77704d0ef2ae339b..0000000000000000000000000000000000000000
--- a/tools/gdbst03/src/library/sva_layer.h
+++ /dev/null
@@ -1,83 +0,0 @@
-//=======================================================================================================
-// sva_layer.h - Serial command layer for SVAsync
-//
-//=======================================================================================================
-
-//=======================================================================================================
-//=======================================================================================================
-
-#ifndef _SVA_LAYER_H
-#define _SVA_LAYER_H
-
-
-//===============================================================================
-// Include files
-//===============================================================================
-
-#include "svasync.h"
-
-//===============================================================================
-// Inline function definitions
-//===============================================================================
-
-// Initialize the serial library
-// Should return 0 if no error occurred
-__inline int GDBStub_SerInit(int port)
-{
- int ret, init;
-
- ret = init = SVAsyncInit(port - 1);
- if (ret == 0)
- ret = SVAsyncFifoInit();
- if (init == 0)
- atexit(SVAsyncStop);
- return ret;
-}
-
-
-// Set the serial port speed (and other configurables)
-// Should return 0 if the speed is set properly
-__inline int GDBStub_SerSpeed(int speed)
-{
- SVAsyncSet(speed, BITS_8 | NO_PARITY | STOP_1);
- SVAsyncHand(DTR | RTS);
- return 0;
-}
-
-
-// Check to see if there's room in the buffer to send data
-// Should return 0 if it is okay to send
-__inline int GDBStub_SerSendOk(void)
-{
- return !SVAsyncOutStat();
-}
-
-
-// Send a character to the serial port
-// Should return 0 if the send succeeds
-__inline int GDBStub_SerSend(int c)
-{
- SVAsyncOut((char) c);
- return 0;
-}
-
-
-// Check to see if there are characters waiting in the buffer
-// Should return 0 if there's data waiting
-__inline int GDBStub_SerRecvOk(void)
-{
- return SVAsyncInStat();
-}
-
-
-// Read a character from the serial port
-// Should return the character read
-__inline int GDBStub_SerRecv(void)
-{
- return SVAsyncIn();
-}
-
-
-
-
-#endif