Return to ddt68.1 CVS log

Up to [CSRG BSD Unix] / 43BSDReno / share / doc / ucs / sumacc

Annotation of 43BSDReno/share/doc/ucs/sumacc/ddt68.1, revision 1.1

1.1     ! root        1: .TH DDT68 1 MC68000
        !             2: .SU
        !             3: .SH NAME
        !             4: ddt68, fddt68 \- symbolic debugger for 68000
        !             5: .SH SYNOPSIS
        !             6: .B fddt68
        !             7: b.out
        !             8: .br
        !             9: .B cc68 ... -lddt (Sun)
        !            10: 
        !            11: .SH DESCRIPTION
        !            12: .I fddt68
        !            13: is a symbolic disassembler for b.out files created by the 68000 linker
        !            14: (ld68). Its main purpose is to allow testing of ddt logic in a
        !            15: more hospitable environment than the 68000.  It also gives a way of inspecting
        !            16: the assembly language form of a program without having to produce a .s file.
        !            17: In addition it gives a check on the operation of as68 and ld68.  It is called
        !            18: by typing:
        !            19: .sp
        !            20: fddt68 
        !            21: .I filename
        !            22: .sp
        !            23: on the Vax.
        !            24: .PP
        !            25: .I ddt68
        !            26: is a symbolic debugger for the 68000.  It is loaded at link edit time with
        !            27: the cc68 flag -lddt.  On starting a program with ddt loaded the user will be
        !            28: at the ddt command level.  Breakpoints may be set, and the program started,
        !            29: using the commands described below.
        !            30: .SH COMMANDS
        !            31: .I ddt68
        !            32: recognizes the following commands (\fI$\fP is used for \fI<esc>\fP):
        !            33: .TP
        !            34: .IB expression /
        !            35: .TP
        !            36: .IB expression \e
        !            37: open the location at \fIexpression\fP and display the contents in the
        !            38: current typeout mode.  The user may then optionally type an expression, whose
        !            39: value replaces the contents of the open location.  Finally the location is
        !            40: \fIclosed\fP by typing one of \fIreturn\fP (to return to \fIddt\fP's main
        !            41: command loop), \fI/\fP (to open the next location), or \fI\\\fP (to open the
        !            42: previous location).
        !            43: .TP
        !            44: .IB expression $g
        !            45: go - plant any breakpoints set with the \fI$b\fP command, load the registers,
        !            46: and start execution at \fIexpression\fP. If \fIexpression\fP is unspecified
        !            47: or zero, execution resumes starting from the current value of \fI$pc\fP
        !            48: (normally the point where the program was last interrupted).
        !            49: .TP
        !            50: .IB expression $x
        !            51: execute the next \fIexpression\fP instructions, starting from the current
        !            52: value of \fI$pc\fP and printing out all executed instructions.  If
        !            53: \fIexpression\fP is omitted, 1 is assumed.
        !            54: .TP
        !            55: .IB expression $$x
        !            56: same as above except execute subroutine calls and traps as single instructions,
        !            57: i.e. do not descend into the called subroutine.
        !            58: .TP
        !            59: .IB expression $p
        !            60: proceed - like \fIgo\fP with no argument, except that if we are presently at
        !            61: a breakpoint then \fIexpression\fP counts the number of times to pass this
        !            62: breakpoint before breaking.  \fI1$p\fP is synonymous with \fI$g\fP.
        !            63: .TP
        !            64: .IB expression $ bno b
        !            65: set breakpoint \fIbno\fP (in the range 1-9) at \fIexpression\fP.  If \fIbno\fP
        !            66: is omitted the first unused breakpoint number is assigned (the commonest
        !            67: usage).  If \fIexpression\fP is 0 the named breakpoint is cleared, or if there
        !            68: is no named breakpoint (\fIbno\fP is omitted) all breakpoints are cleared.
        !            69: If \fIexpression\fP is omitted all breakpoints are printed, whether or not
        !            70: \fIbno\fP is present.
        !            71: .TP
        !            72: .BI $ rspec /
        !            73: .TP
        !            74: .BI $ rspec \e
        !            75: examine register \fIrspec\fP where \fIrspec\fP is one of:
        !            76: .RS
        !            77: .TP
        !            78: .B d0-d7
        !            79: data registers 0-7
        !            80: .TP
        !            81: .B a0-a7
        !            82: address registers 0-7
        !            83: .TP
        !            84: .B fp
        !            85: frame pointer (synonym for \fIa6\fP)
        !            86: .TP
        !            87: .B sp
        !            88: stack pointer (synonym for \fIa7\fP)
        !            89: .TP
        !            90: .B pc
        !            91: program counter
        !            92: .TP
        !            93: .B sr
        !            94: status register
        !            95: .RE
        !            96: .TP
        !            97: .IB expression $=
        !            98: type out \fIexpression\fP in current output radix.
        !            99: .TP
        !           100: .IB lowlimit < highlimit > pattern ?
        !           101: search for \fIpattern\fP in the range \fIlowlimit\fP (inclusive) to
        !           102: \fIhighlimit\fP (exclusive).
        !           103: The pattern is interpreted as an object of the type in force as
        !           104: the current typeout mode, with instructions and strings being treated as
        !           105: 2-byte words.  Objects are assumed to be aligned on word (2-byte)
        !           106: boundaries except for 1-byte types and strings which are aligned on byte
        !           107: boundaries.  A mask (set with the following command) determines how much of
        !           108: the pattern is
        !           109: significant in the search, except that if the pattern is a string constant a
        !           110: separate mask matched to the length of the string is used.
        !           111: The three arguments to the search command are
        !           112: sticky; thus if \fIlowlimit<\fP (resp. \fIhighlimit\fP>) is omitted, the
        !           113: most recent lowlimit (resp. highlimit) applies.  While \fIpattern\fP may be
        !           114: omitted, the final ? may not be omitted.
        !           115: .TP
        !           116: .IB expression $m
        !           117: set the search mask to \fIexpression\fP.  \fI-1$m\fP forces a complete match,
        !           118: \fIf$m\fP checks only the low order 4 bits, \fI0$m\fP will make the search
        !           119: pattern match anything.
        !           120: .TP
        !           121: .IB base $ir
        !           122: set input radix to \fIbase\fP. (Note \fI10$i\fP can never change the radix.)
        !           123: If \fIbase\fP is omitted hexadecimal is assumed.
        !           124: .TP
        !           125: .IB base $or
        !           126: set output radix to \fIbase\fP.
        !           127: If \fIbase\fP is omitted hexadecimal is assumed.
        !           128: .TP
        !           129: .BI $ type t
        !           130: temporarily set typeout mode to \fItype\fP where \fItype\fP is one of:
        !           131: .RS
        !           132: .TP
        !           133: .B <space>
        !           134: deduce type from type of nearest symbol
        !           135: .TP
        !           136: .B c
        !           137: type out bytes as ascii characters.
        !           138: .TP
        !           139: .B h
        !           140: type out bytes in current output radix.
        !           141: .TP
        !           142: .B w
        !           143: type out words in current radix.
        !           144: .TP
        !           145: .B l
        !           146: type out longs in current radix.
        !           147: .TP
        !           148: .B s
        !           149: type out strings in current radix.  (In this mode new values cannot be
        !           150: entered.)
        !           151: .TP
        !           152: .B i
        !           153: type out as 68000 symbolic instructions.  (In this mode only the first
        !           154: two bytes of the opened location may be changed; the new value is typed in as
        !           155: a numeric expression rather than as a symbolic instruction.)
        !           156: .RE
        !           157: The new typeout mode stays in effect until a \fIreturn\fP is typed.
        !           158: .TP
        !           159: .BI $$ type t
        !           160: permanently set typeout mode to \fItype\fP.
        !           161: .PP
        !           162: An \fIexpression\fP is composed of symbols, numeric constants, string
        !           163: constants, and the operators \fI+\fP,
        !           164: \fI-\fP, and \fI|\fP representing 2's complement addition,
        !           165: subtraction, and inclusive bitwise or.
        !           166: Symbols are delimited by operators or \fI<esc>\fP.  A string constant has from
        !           167: 1 to 4 characters which are packed right justified into one long to form a
        !           168: numeric constant; thus "did"=646A64.  String constants are particularly
        !           169: useful in conjunction witht the search command for searching for a string.
        !           170: The single character \fI.\fP (dot) as a symbol on its own represents
        !           171: the address of the currently open memory location.
        !           172: All operations are carried out using 32 bit arithmetic and evaluated
        !           173: strictly left to right.
        !           174: .SH AUTHORS
        !           175: Jim Lawson and Vaughan Pratt

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.