Symbolic Debuggers

A while ago I asked about references on high-level symbolic debuggers.
A number of people asked me fo the results of my query, and then
I decided to post them to this group.


__
Fabio da Silva


University of Edinburgh JANET: fabio@uk.ac.ed.dcs
LFCS - Computer Science Dept. UUCP: ..!mcsun!ukc!lfcs!fabio
JCMB - The King's Buildings ARPA: fabio%dcs.ed.ac.uk@nsfnet-relay.ac.uk
Mayfield Road - Edinburgh
EH9 3JZ - Scotland
-------------------------Included messages------------------------------------
Reply-To: Paul Hudak <hudak-paul@edu.yale.cs>
Organization: Yale University Computer Science Dept., New Haven, CT 06520-2158


You should look at our recent paper:


@InProceedings{kishonhudakconsel91,
    author = "A. Kishon and C. Consel and P. Hudak",
    title = "Monitoring Semantics: a Formal Framework for Specifying,
                              Implementing and Reasoning about Execution Monitors",
    booktitle = "ACM SIGPLAN Conference on Programming Language Design
                              and Implementation",
    year = "1991",
    pages = "338-352"
}




    -Paul
--
Professor Paul Hudak
Department of Computer Science
Yale University
Box 2158 Yale Station
New Haven, CT 06520




Reply-To: Dan Pierson <pierson@com.encore>


You might look at UPS from the Mark Russell <mtr@ukc.ac.uk>. It's
based on an ANSI C interpreter.


                                                                                        dan


Reply-To: Jack Campin <jack@uk.ac.glasgow.dcs>


By far the nicest debugger I have ever seen was "ups", the C debugger
developed by John Bovey at the Software Tools Project, University of Kent
at Canterbury. It had a sort of folding editor for the stack; you could
selectively display variables, function parameters, or random bits of
memory, choose the coercion you wanted (integer/string/real...), step
through arrays an element at a time, dereference pointers,... all using
a fully graphical interface. Try writing UKC about it; the Software Tools
Project is long defunct. It only ran on the Perq.


cheers - jack


-- Jack Campin Computing Science Department, Glasgow University, 17 Lilybank
Gardens, Glasgow G12 8QQ, Scotland 041 339 8855 x6854 work 041 556 1878 home
JANET: jack@dcs.glasgow.ac.uk BANG!net: via mcsun and ukc FAX: 041 330 4913
INTERNET: via nsfnet-relay.ac.uk BITNET: via UKACRL UUCP: jack@glasgow.uucp


>From johnson@edu.uiuc.cs Mon Aug 12 09:23:10 1991


Have you seen the work by Larry Zurawski and me on debugging optimized code?
You can get a postscript version of a large paper that was recently accepted
in TOPLAS by anonymous ftp from st.cs.uiuc.edu in /pub/papers. It is called
something like debugging-opt-code.ps. The paper is most of what was in
Larry's thesis. If you don't have ftp to us, there is a mail archive server,
which you can access at archive-server@st.cs.uiuc.edu by sending the line
"help".


Ralph Johnson




Reply-To: Andrew Tolmach <apt@edu.princeton>


My thesis work (being completed this autumn, I hop) is on a symbolic debugger
for Standard ML of New Jersey, the Princeton/ATT Bell Labs implementation of
Standard ML. A version of the debugger is included in recent distributions of
the compiler; I'm sure someone at Edinburgh LFCS has a copy. A preliminary
description of the system appeared in Proc. 1990 ACM Conf. on Lisp and
Functional Programming.


Although most of my work has been on implementation technology, I am currently
working on some formal semantics aspects too; I will be interested to see your
stuff.


You might also be interested in recent work of Kishon, Hudak, and Consel:
"Monitoring Semantics: A formal Framework for Specifying, IMplementing and
Reasoning about Exevution Monitors" in SIGPLAN 91 PLDI Proceedings.


-- Andrew Tolmach (apt@princeton.edu)


>From wilson@edu.utexas.cs Mon Aug 12 09:25:13 1991
Organization: Dept of Computer Sciences, UTexas, Austin


You might have a look at Andrew Appel's time-travel debugger for Standard ML
of New Jersey. It's vaguely based on my reconstructive memory system (Wilson
and Moher, SIGPLAN PLDI '89), but simplified and taking advantage of ML
specifics. See his and Andrew Tolmach's paper in the 1990 Lisp and Functional
Programming conference proceedings.


One of the interesting things he does is to coordinate checkpointing with
garbage collection to make checkpointing more efficient. I did that too, but
in a very different way. Tolmach and Appel use the garbage collector and
continuation capture *as* a checkpointing mechanism. In a purely functional
language, that would be enough. In ML, you also have to hack in support for
undoing side effects, but it's pretty simple. They didn't have to modify the
Standard ML implementation much at all.


        -- Paul


Paul R. Wilson, asst. prof. and garbage man
| U. of Texas Computer Sciences Dept.
| Taylor Hall 2.124, Austin, TX 78712-1188
| wilson@cs.utexas.edu (512) 471-9555


Reply-To: mtr@uk.ac.ukc


The only paper that mentions ups is:


John Bovey, Mark Russell and Olav Folkestad, `Direct Manipulation
Tools for UNIX Workstations', Proceedings of the EUUG, Portugal, 1988


The ups distribution is available by ni-ftp. The files are:


<NETLIB>unix/ups/ups-2.31.README from uk.ac.ukc.harrier
<NETLIB>unix/ups/ups-2.31.tar.Z from uk.ac.ukc.harrier


user guest
password <your email address>


Mark




Reply-To: William Pickles <will@uucp.sstl>


Dear Fabio
would you like to study STRAND88 and its compiler/debugger relationship






>From CHCHAVES@br.ansp.cpqd.orion Mon Aug 12 09:32:43 1991


- P. Corsini, C. A. Prete, ``Multibug: Interactive Debugging in Distributed
Systems'', IEEE MICRO, June 1986.


- R. Glass, ``Real-Time: The `Lost World' of Software Debugging and Testing'',
CACM, 23(5), 1980.


- C. Mcdowell, D. Helmbold, ``Debugging Concurrent Programs'', ACM Computing
Surveys, 21(4), 1989.


- S. Utter, C. Pancake, ``A Bibliography of Parallel Debuggers'', SIGPLAN
Notices, 24(11).


- Proceedings of the ACM SIGSOFT/SIGPLAN Software Engineering Symposium on
High-Level Debugging, august 1983.


- ACM SIGPLAN/SIGOPS Workshop on Parallel and Distributed Debugging, may 1988.
--

Return to the comp.compilers page.
Search the comp.compilers archives again.