mirror of
https://github.com/nim-lang/Nim.git
synced 2026-02-19 01:18:32 +00:00
debugger improvements
This commit is contained in:
Araq
@@ -892,6 +892,12 @@ proc getFileHeader(cfilenoext: string): PRope =
|
||||
result = getCopyright(cfilenoext)
|
||||
addIntTypes(result)
|
||||
|
||||
proc genFilenames(m: BModule): PRope =
|
||||
discard cgsym(m, "dbgRegisterFilename")
|
||||
result = nil
|
||||
for i in 0.. <fileInfos.len:
|
||||
result.appf("dbgRegisterFilename($1);$n", fileInfos[i].projPath.makeCString)
|
||||
|
||||
proc genMainProc(m: BModule) =
|
||||
const
|
||||
CommonMainBody =
|
||||
@@ -950,6 +956,8 @@ proc genMainProc(m: BModule) =
|
||||
nimMain = PosixNimMain
|
||||
otherMain = PosixCMain
|
||||
if gBreakpoints != nil: discard cgsym(m, "dbgRegisterBreakpoint")
|
||||
if optEndb in gOptions:
|
||||
gBreakpoints.app(m.genFilenames)
|
||||
|
||||
let initStackBottomCall = if emulatedThreadVars() or
|
||||
platform.targetOS == osStandalone: "".toRope
|
||||
|
||||
12
doc/endb.txt
12
doc/endb.txt
@@ -61,8 +61,8 @@ Executing Commands
|
||||
Breakpoint Commands
|
||||
===================
|
||||
|
||||
``b``, ``setbreak`` <identifier> [fromline [toline]] [file]
|
||||
Set a new breakpoint named 'identifier' for the given file
|
||||
``b``, ``setbreak`` [fromline [toline]] [file]
|
||||
Set a new breakpoint for the given file
|
||||
and line numbers. If no file is given, the current execution point's
|
||||
filename is used. If the filename has no extension, ``.nim`` is
|
||||
appended for your convenience.
|
||||
@@ -71,16 +71,16 @@ Breakpoint Commands
|
||||
breakpoint contains a line number range. Some examples if it is still
|
||||
unclear:
|
||||
|
||||
* ``b br1 12 15 thallo`` creates a breakpoint named ``br1`` that
|
||||
* ``b 12 15 thallo`` creates a breakpoint that
|
||||
will be triggered if the instruction pointer reaches one of the
|
||||
lines 12-15 in the file ``thallo.nim``.
|
||||
* ``b br1 12 thallo`` creates a breakpoint named ``br1`` that
|
||||
* ``b 12 thallo`` creates a breakpoint that
|
||||
will be triggered if the instruction pointer reaches the
|
||||
line 12 in the file ``thallo.nim``.
|
||||
* ``b br1 12`` creates a breakpoint named ``br1`` that
|
||||
* ``b 12`` creates a breakpoint that
|
||||
will be triggered if the instruction pointer reaches the
|
||||
line 12 in the current file.
|
||||
* ``b br1`` creates a breakpoint named ``br1`` that
|
||||
* ``b`` creates a breakpoint that
|
||||
will be triggered if the instruction pointer reaches the
|
||||
current line in the current file again.
|
||||
|
||||
|
||||
@@ -102,6 +102,16 @@ proc newAny(value: pointer, rawType: PNimType): TAny =
|
||||
result.value = value
|
||||
result.rawType = rawType
|
||||
|
||||
when defined(system.TVarSlot):
|
||||
proc toAny*(x: TVarSlot): TAny {.inline.} =
|
||||
## constructs a ``TAny`` object from a variable slot ``x``.
|
||||
## This captures `x`'s address, so `x` can be modified with its
|
||||
## ``TAny`` wrapper! The client needs to ensure that the wrapper
|
||||
## **does not** live longer than `x`!
|
||||
## This is provided for easier reflection capabilities of a debugger.
|
||||
result.value = x.address
|
||||
result.rawType = x.typ
|
||||
|
||||
proc toAny*[T](x: var T): TAny {.inline.} =
|
||||
## constructs a ``TAny`` object from `x`. This captures `x`'s address, so
|
||||
## `x` can be modified with its ``TAny`` wrapper! The client needs to ensure
|
||||
|
||||
@@ -1650,10 +1650,6 @@ const nimrodStackTrace = compileOption("stacktrace")
|
||||
# of the code
|
||||
|
||||
var
|
||||
dbgLineHook*: proc () {.nimcall.}
|
||||
## set this variable to provide a procedure that should be called before
|
||||
## each executed instruction. This should only be used by debuggers!
|
||||
## Only code compiled with the ``debugger:on`` switch calls this hook.
|
||||
globalRaiseHook*: proc (e: ref E_Base): bool {.nimcall.}
|
||||
## with this hook you can influence exception handling on a global level.
|
||||
## If not nil, every 'raise' statement ends up calling this hook. Ordinary
|
||||
@@ -1691,13 +1687,14 @@ var
|
||||
## continues and the program is terminated.
|
||||
|
||||
type
|
||||
PFrame = ptr TFrame
|
||||
TFrame {.importc, nodecl, final.} = object
|
||||
prev: PFrame
|
||||
procname: CString
|
||||
line: int # current line number
|
||||
filename: CString
|
||||
len: int # length of slots (when not debugging always zero)
|
||||
PFrame* = ptr TFrame ## represents a runtime frame of the call stack;
|
||||
## part of the debugger API.
|
||||
TFrame* {.importc, nodecl, final.} = object ## the frame itself
|
||||
prev*: PFrame ## previous frame; used for chaining the call stack
|
||||
procname*: cstring ## name of the proc that is currently executing
|
||||
line*: int ## line number of the proc that is currently executing
|
||||
filename*: cstring ## filename of the proc that is currently executing
|
||||
len*: int ## length of the inspectable slots
|
||||
|
||||
when not defined(JS):
|
||||
{.push stack_trace:off, profiler:off.}
|
||||
|
||||
@@ -7,187 +7,95 @@
|
||||
# distribution, for details about the copyright.
|
||||
#
|
||||
|
||||
# This file implements the embedded debugger that can be linked
|
||||
# with the application. Mostly we do not use dynamic memory here as that
|
||||
# would interfere with the GC and trigger ON/OFF errors if the
|
||||
# user program corrupts memory. Unfortunately, for dispaying
|
||||
# variables we use the ``system.repr()`` proc which uses Nimrod
|
||||
# strings and thus allocates memory from the heap. Pity, but
|
||||
# I do not want to implement ``repr()`` twice.
|
||||
## This file implements basic features for any debugger.
|
||||
|
||||
type
|
||||
TStaticStr {.pure, final.} = object
|
||||
len: int
|
||||
data: array[0..100, char]
|
||||
|
||||
TDbgState = enum
|
||||
dbOff, # debugger is turned off
|
||||
dbStepInto, # debugger is in tracing mode
|
||||
dbStepOver,
|
||||
dbSkipCurrent,
|
||||
dbQuiting, # debugger wants to quit
|
||||
dbBreakpoints # debugger is only interested in breakpoints
|
||||
|
||||
TDbgBreakpoint {.final.} = object
|
||||
low, high: int # range from low to high; if disabled
|
||||
# both low and high are set to their negative values
|
||||
# this makes the check faster and safes memory
|
||||
filename: cstring
|
||||
name: TStaticStr # name of breakpoint
|
||||
|
||||
TVarSlot {.compilerproc, final.} = object # variable slots used for debugger:
|
||||
address: pointer
|
||||
typ: PNimType
|
||||
name: cstring # for globals this is "module.name"
|
||||
TVarSlot* {.compilerproc, final.} = object ## a slot in a frame
|
||||
address*: pointer ## the variable's address
|
||||
typ*: PNimType ## the variable's type
|
||||
name*: cstring ## the variable's name; for globals this is "module.name"
|
||||
|
||||
PExtendedFrame = ptr TExtendedFrame
|
||||
TExtendedFrame {.final.} = object # If the debugger is enabled the compiler
|
||||
# provides an extended frame. Of course
|
||||
# only slots that are
|
||||
# needed are allocated and not 10_000,
|
||||
# except for the global data description.
|
||||
TExtendedFrame = object # If the debugger is enabled the compiler
|
||||
# provides an extended frame. Of course
|
||||
# only slots that are
|
||||
# needed are allocated and not 10_000,
|
||||
# except for the global data description.
|
||||
f: TFrame
|
||||
slots: array[0..10_000, TVarSlot]
|
||||
|
||||
var
|
||||
dbgUser: TStaticStr # buffer for user input; first command is ``step_into``
|
||||
# needs to be global cause we store the last command
|
||||
# in it
|
||||
dbgState: TDbgState # state of debugger
|
||||
dbgBP: array[0..127, TDbgBreakpoint] # breakpoints
|
||||
dbgBPlen: int
|
||||
dbgBPbloom: int64 # we use a bloom filter to speed up breakpoint checking
|
||||
dbgSkipToFrame: PFrame # frame to be skipped to
|
||||
|
||||
dbgGlobalData: TExtendedFrame # this reserves much space, but
|
||||
# for now it is the most practical way
|
||||
|
||||
maxDisplayRecDepth: int = 5 # do not display too much data!
|
||||
proc dbgRegisterGlobal(name: cstring, address: pointer,
|
||||
typ: PNimType) {.compilerproc.} =
|
||||
let i = dbgGlobalData.f.len
|
||||
if i >= high(dbgGlobalData.slots):
|
||||
#debugOut("[Warning] cannot register global ")
|
||||
return
|
||||
dbgGlobalData.slots[i].name = name
|
||||
dbgGlobalData.slots[i].typ = typ
|
||||
dbgGlobalData.slots[i].address = address
|
||||
inc(dbgGlobalData.f.len)
|
||||
|
||||
proc setLen(s: var TStaticStr, newLen=0) =
|
||||
s.len = newLen
|
||||
s.data[newLen] = '\0'
|
||||
proc getLocal*(frame: PFrame; slot: int): TVarSlot {.inline.} =
|
||||
## retrieves the meta data for the local variable at `slot`. CAUTION: An
|
||||
## invalid `slot` value causes a corruption!
|
||||
result = cast[PExtendedFrame](frame).slots[slot]
|
||||
|
||||
proc add(s: var TStaticStr, c: char) =
|
||||
if s.len < high(s.data)-1:
|
||||
s.data[s.len] = c
|
||||
s.data[s.len+1] = '\0'
|
||||
inc s.len
|
||||
proc getGlobalLen*(): int {.inline.} =
|
||||
## gets the number of registered globals.
|
||||
result = dbgGlobalData.f.len
|
||||
|
||||
proc add(s: var TStaticStr, c: cstring) =
|
||||
var i = 0
|
||||
while c[i] != '\0':
|
||||
add s, c[i]
|
||||
inc i
|
||||
proc getGlobal*(slot: int): TVarSlot {.inline.} =
|
||||
## retrieves the meta data for the global variable at `slot`. CAUTION: An
|
||||
## invalid `slot` value causes a corruption!
|
||||
result = dbgGlobalData.slots[slot]
|
||||
|
||||
proc assign(s: var TStaticStr, c: cstring) =
|
||||
setLen(s)
|
||||
add s, c
|
||||
# ------------------- breakpoint support ------------------------------------
|
||||
|
||||
proc `==`(a, b: TStaticStr): bool =
|
||||
if a.len == b.len:
|
||||
for i in 0 .. a.len-1:
|
||||
if a.data[i] != b.data[i]: return false
|
||||
return true
|
||||
type
|
||||
TBreakpoint* = object ## represents a break point
|
||||
low*, high*: int ## range from low to high; if disabled
|
||||
## both low and high are set to their negative values
|
||||
filename*: cstring ## the filename of the breakpoint
|
||||
|
||||
proc `==`(a: TStaticStr, b: cstring): bool =
|
||||
result = c_strcmp(a.data, b) == 0
|
||||
var
|
||||
dbgBP: array[0..127, TBreakpoint] # breakpoints
|
||||
dbgBPlen: int
|
||||
dbgBPbloom: int64 # we use a bloom filter to speed up breakpoint checking
|
||||
|
||||
dbgFilenames*: array[0..300, cstring] ## registered filenames;
|
||||
## 'nil' terminated
|
||||
dbgFilenameLen: int
|
||||
|
||||
proc findBreakpoint(name: TStaticStr): int =
|
||||
# returns -1 if not found
|
||||
for i in countdown(dbgBPlen-1, 0):
|
||||
if name == dbgBP[i].name: return i
|
||||
return -1
|
||||
proc dbgRegisterFilename(filename: cstring) {.compilerproc.} =
|
||||
# XXX we could check for duplicates here for DLL support
|
||||
dbgFilenames[dbgFilenameLen] = filename
|
||||
inc dbgFilenameLen
|
||||
|
||||
proc write(f: TFile, s: TStaticStr) =
|
||||
write(f, cstring(s.data))
|
||||
proc dbgRegisterBreakpoint(line: int,
|
||||
filename, name: cstring) {.compilerproc.} =
|
||||
let x = dbgBPlen
|
||||
if x >= high(dbgBP):
|
||||
#debugOut("[Warning] cannot register breakpoint")
|
||||
return
|
||||
inc(dbgBPlen)
|
||||
dbgBP[x].filename = filename
|
||||
dbgBP[x].low = line
|
||||
dbgBP[x].high = line
|
||||
dbgBPbloom = dbgBPbloom or line
|
||||
|
||||
proc ListBreakPoints() =
|
||||
write(stdout, "*** endb| Breakpoints:\n")
|
||||
for i in 0 .. dbgBPlen-1:
|
||||
write(stdout, dbgBP[i].name)
|
||||
write(stdout, ": ")
|
||||
write(stdout, abs(dbgBP[i].low))
|
||||
write(stdout, "..")
|
||||
write(stdout, abs(dbgBP[i].high))
|
||||
write(stdout, dbgBP[i].filename)
|
||||
if dbgBP[i].low < 0:
|
||||
write(stdout, " [disabled]\n")
|
||||
else:
|
||||
write(stdout, "\n")
|
||||
write(stdout, "***\n")
|
||||
|
||||
proc openAppend(filename: cstring): TFile =
|
||||
var p: pointer = fopen(filename, "ab")
|
||||
if p != nil:
|
||||
result = cast[TFile](p)
|
||||
write(result, "----------------------------------------\n")
|
||||
|
||||
proc dbgRepr(p: pointer, typ: PNimType): string =
|
||||
var cl: TReprClosure
|
||||
initReprClosure(cl)
|
||||
cl.recDepth = maxDisplayRecDepth
|
||||
# locks for the GC turned out to be a bad idea...
|
||||
# inc(recGcLock)
|
||||
result = ""
|
||||
reprAux(result, p, typ, cl)
|
||||
# dec(recGcLock)
|
||||
deinitReprClosure(cl)
|
||||
|
||||
proc writeVariable(stream: TFile, slot: TVarSlot) =
|
||||
write(stream, slot.name)
|
||||
write(stream, " = ")
|
||||
writeln(stream, dbgRepr(slot.address, slot.typ))
|
||||
|
||||
proc ListFrame(stream: TFile, f: PExtendedFrame) =
|
||||
write(stream, "*** endb| Frame (")
|
||||
write(stream, f.f.len)
|
||||
write(stream, " slots):\n")
|
||||
for i in 0 .. f.f.len-1:
|
||||
writeVariable(stream, f.slots[i])
|
||||
write(stream, "***\n")
|
||||
|
||||
proc ListVariables(stream: TFile, f: PExtendedFrame) =
|
||||
write(stream, "*** endb| Frame (")
|
||||
write(stream, f.f.len)
|
||||
write(stream, " slots):\n")
|
||||
for i in 0 .. f.f.len-1:
|
||||
writeln(stream, f.slots[i].name)
|
||||
write(stream, "***\n")
|
||||
|
||||
proc debugOut(msg: cstring) =
|
||||
# the *** *** markers are for easy recognition of debugger
|
||||
# output for external frontends.
|
||||
write(stdout, "*** endb| ")
|
||||
write(stdout, msg)
|
||||
write(stdout, "***\n")
|
||||
|
||||
proc dbgFatal(msg: cstring) =
|
||||
debugOut(msg)
|
||||
dbgAborting = True # the debugger wants to abort
|
||||
quit(1)
|
||||
|
||||
proc findVariable(frame: PExtendedFrame, varname: cstring): int =
|
||||
for i in 0 .. frame.f.len - 1:
|
||||
if c_strcmp(frame.slots[i].name, varname) == 0: return i
|
||||
return -1
|
||||
|
||||
proc dbgShowCurrentProc(dbgFramePointer: PFrame) =
|
||||
if dbgFramePointer != nil:
|
||||
write(stdout, "*** endb| now in proc: ")
|
||||
write(stdout, dbgFramePointer.procname)
|
||||
write(stdout, " ***\n")
|
||||
else:
|
||||
write(stdout, "*** endb| (proc name not available) ***\n")
|
||||
|
||||
proc dbgShowExecutionPoint() =
|
||||
write(stdout, "*** endb| ")
|
||||
write(stdout, framePtr.filename)
|
||||
write(stdout, "(")
|
||||
write(stdout, framePtr.line)
|
||||
write(stdout, ") ")
|
||||
write(stdout, framePtr.procname)
|
||||
write(stdout, " ***\n")
|
||||
proc addBreakpoint*(filename: cstring, lo, hi: int): bool =
|
||||
let x = dbgBPlen
|
||||
if x >= high(dbgBP): return false
|
||||
inc(dbgBPlen)
|
||||
result = true
|
||||
dbgBP[x].filename = filename
|
||||
dbgBP[x].low = lo
|
||||
dbgBP[x].high = hi
|
||||
for line in lo..hi: dbgBPbloom = dbgBPbloom or line
|
||||
|
||||
const
|
||||
FileSystemCaseInsensitive = defined(windows) or defined(dos) or defined(os2)
|
||||
@@ -216,337 +124,29 @@ proc fileMatches(c, bp: cstring): bool =
|
||||
inc(i)
|
||||
return true
|
||||
|
||||
proc dbgBreakpointReached(line: int): int =
|
||||
for i in 0..dbgBPlen-1:
|
||||
if line >= dbgBP[i].low and line <= dbgBP[i].high and
|
||||
fileMatches(framePtr.filename, dbgBP[i].filename): return i
|
||||
return -1
|
||||
proc canonFilename*(filename: cstring): cstring =
|
||||
## returns 'nil' if the filename cannot be found.
|
||||
for i in 0 .. <dbgFilenameLen:
|
||||
result = dbgFilenames[i]
|
||||
if fileMatches(result, filename): return result
|
||||
result = nil
|
||||
|
||||
proc scanAndAppendWord(src: cstring, a: var TStaticStr, start: int): int =
|
||||
result = start
|
||||
# skip whitespace:
|
||||
while src[result] in {'\t', ' '}: inc(result)
|
||||
while True:
|
||||
case src[result]
|
||||
of 'a'..'z', '0'..'9': add(a, src[result])
|
||||
of '_': nil # just skip it
|
||||
of 'A'..'Z': add(a, chr(ord(src[result]) - ord('A') + ord('a')))
|
||||
else: break
|
||||
inc(result)
|
||||
iterator listBreakpoints*(): ptr TBreakpoint =
|
||||
## lists all breakpoints.
|
||||
for i in 0..dbgBPlen-1: yield addr(dbgBP[i])
|
||||
|
||||
proc scanWord(src: cstring, a: var TStaticStr, start: int): int =
|
||||
setlen(a)
|
||||
result = scanAndAppendWord(src, a, start)
|
||||
proc isActive*(b: ptr TBreakpoint): bool = b.low > 0
|
||||
proc flip*(b: ptr TBreakpoint) =
|
||||
## enables or disables 'b' depending on its current state.
|
||||
b.low = -b.low; b.high = -b.high
|
||||
|
||||
proc scanFilename(src: cstring, a: var TStaticStr, start: int): int =
|
||||
result = start
|
||||
setLen a
|
||||
# skip whitespace:
|
||||
while src[result] in {'\t', ' '}: inc(result)
|
||||
while src[result] notin {'\t', ' ', '\0'}:
|
||||
add(a, src[result])
|
||||
inc(result)
|
||||
proc checkBreakpoints*(filename: cstring, line: int): ptr TBreakpoint =
|
||||
## in which breakpoint (if any) we are.
|
||||
if (dbgBPbloom and line) != line: return nil
|
||||
for b in listBreakpoints():
|
||||
if line >= b.low and line <= b.high and filename == b.filename: return b
|
||||
|
||||
proc scanNumber(src: cstring, a: var int, start: int): int =
|
||||
result = start
|
||||
a = 0
|
||||
while src[result] in {'\t', ' '}: inc(result)
|
||||
while true:
|
||||
case src[result]
|
||||
of '0'..'9': a = a * 10 + ord(src[result]) - ord('0')
|
||||
of '_': nil # skip underscores (nice for long line numbers)
|
||||
else: break
|
||||
inc(result)
|
||||
|
||||
proc dbgHelp() =
|
||||
debugOut("""
|
||||
list of commands (see the manual for further help):
|
||||
GENERAL
|
||||
h, help display this help message
|
||||
q, quit quit the debugger and the program
|
||||
<ENTER> repeat the previous debugger command
|
||||
EXECUTING
|
||||
s, step single step, stepping into routine calls
|
||||
n, next single step, without stepping into routine calls
|
||||
f, skipcurrent continue execution until the current routine finishes
|
||||
c, continue, r, run continue execution until the next breakpoint
|
||||
i, ignore continue execution, ignore all breakpoints
|
||||
BREAKPOINTS
|
||||
b, break <name> [fromline [toline]] [file]
|
||||
set a new breakpoint named 'name' for line and file
|
||||
if line or file are omitted the current one is used
|
||||
breakpoints display the entire breakpoint list
|
||||
disable <name> disable a breakpoint
|
||||
enable <name> enable a breakpoint
|
||||
DATA DISPLAY
|
||||
e, eval <expr> evaluate the expression <expr>
|
||||
o, out <file> <expr> evaluate <expr> and write it to <file>
|
||||
w, where display the current execution point
|
||||
stackframe [file] display current stack frame [and write it to file]
|
||||
u, up go up in the call stack
|
||||
d, down go down in the call stack
|
||||
bt, backtrace display the entire call stack
|
||||
l, locals display available local variables
|
||||
g, globals display available global variables
|
||||
maxdisplay <integer> set the display's recursion maximum
|
||||
""")
|
||||
|
||||
proc InvalidCommand() =
|
||||
debugOut("[Warning] invalid command ignored (type 'h' for help) ")
|
||||
|
||||
proc hasExt(s: cstring): bool =
|
||||
# returns true if s has a filename extension
|
||||
var i = 0
|
||||
while s[i] != '\0':
|
||||
if s[i] == '.': return true
|
||||
inc i
|
||||
|
||||
proc setBreakPoint(s: cstring, start: int) =
|
||||
var dbgTemp: TStaticStr
|
||||
var i = scanWord(s, dbgTemp, start)
|
||||
if i <= start:
|
||||
InvalidCommand()
|
||||
return
|
||||
if dbgBPlen >= high(dbgBP):
|
||||
debugOut("[Warning] no breakpoint could be set; out of breakpoint space ")
|
||||
return
|
||||
var x = dbgBPlen
|
||||
inc(dbgBPlen)
|
||||
dbgBP[x].name = dbgTemp
|
||||
i = scanNumber(s, dbgBP[x].low, i)
|
||||
if dbgBP[x].low == 0:
|
||||
# set to current line:
|
||||
dbgBP[x].low = framePtr.line
|
||||
i = scanNumber(s, dbgBP[x].high, i)
|
||||
if dbgBP[x].high == 0: # set to low:
|
||||
dbgBP[x].high = dbgBP[x].low
|
||||
for line in dbgBP[x].low .. dbgBP[x].high: dbgBPbloom = dbgBPbloom or line
|
||||
i = scanFilename(s, dbgTemp, i)
|
||||
if dbgTemp.len != 0:
|
||||
debugOut("[Warning] explicit filename for breakpoint not supported")
|
||||
when false:
|
||||
if not hasExt(dbgTemp.data): add(dbgTemp, ".nim")
|
||||
dbgBP[x].filename = dbgTemp
|
||||
dbgBP[x].filename = framePtr.filename
|
||||
else: # use current filename
|
||||
dbgBP[x].filename = framePtr.filename
|
||||
# skip whitespace:
|
||||
while s[i] in {' ', '\t'}: inc(i)
|
||||
if s[i] != '\0':
|
||||
dec(dbgBPLen) # remove buggy breakpoint
|
||||
InvalidCommand()
|
||||
|
||||
proc BreakpointSetEnabled(s: cstring, start, enabled: int) =
|
||||
var dbgTemp: TStaticStr
|
||||
var i = scanWord(s, dbgTemp, start)
|
||||
if i <= start:
|
||||
InvalidCommand()
|
||||
return
|
||||
var x = findBreakpoint(dbgTemp)
|
||||
if x < 0: debugOut("[Warning] breakpoint does not exist ")
|
||||
elif enabled * dbgBP[x].low < 0: # signs are different?
|
||||
dbgBP[x].low = -dbgBP[x].low
|
||||
dbgBP[x].high = -dbgBP[x].high
|
||||
|
||||
proc dbgEvaluate(stream: TFile, s: cstring, start: int,
|
||||
currFrame: PExtendedFrame) =
|
||||
var dbgTemp: tstaticstr
|
||||
var i = scanWord(s, dbgTemp, start)
|
||||
while s[i] in {' ', '\t'}: inc(i)
|
||||
var f = currFrame
|
||||
if s[i] == '.':
|
||||
inc(i) # skip '.'
|
||||
add(dbgTemp, '.')
|
||||
i = scanAndAppendWord(s, dbgTemp, i)
|
||||
# search for global var:
|
||||
f = addr(dbgGlobalData)
|
||||
if s[i] != '\0':
|
||||
debugOut("[Warning] could not parse expr ")
|
||||
return
|
||||
var j = findVariable(f, dbgTemp.data)
|
||||
if j < 0:
|
||||
debugOut("[Warning] could not find variable ")
|
||||
return
|
||||
writeVariable(stream, f.slots[j])
|
||||
|
||||
proc dbgOut(s: cstring, start: int, currFrame: PExtendedFrame) =
|
||||
var dbgTemp: tstaticstr
|
||||
var i = scanFilename(s, dbgTemp, start)
|
||||
if dbgTemp.len == 0:
|
||||
InvalidCommand()
|
||||
return
|
||||
var stream = openAppend(dbgTemp.data)
|
||||
if stream == nil:
|
||||
debugOut("[Warning] could not open or create file ")
|
||||
return
|
||||
dbgEvaluate(stream, s, i, currFrame)
|
||||
close(stream)
|
||||
|
||||
proc dbgStackFrame(s: cstring, start: int, currFrame: PExtendedFrame) =
|
||||
var dbgTemp: TStaticStr
|
||||
var i = scanFilename(s, dbgTemp, start)
|
||||
if dbgTemp.len == 0:
|
||||
# just write it to stdout:
|
||||
ListFrame(stdout, currFrame)
|
||||
else:
|
||||
var stream = openAppend(dbgTemp.data)
|
||||
if stream == nil:
|
||||
debugOut("[Warning] could not open or create file ")
|
||||
return
|
||||
ListFrame(stream, currFrame)
|
||||
close(stream)
|
||||
|
||||
proc readLine(f: TFile, line: var TStaticStr): bool =
|
||||
while True:
|
||||
var c = fgetc(f)
|
||||
if c < 0'i32:
|
||||
if line.len > 0: break
|
||||
else: return false
|
||||
if c == 10'i32: break # LF
|
||||
if c == 13'i32: # CR
|
||||
c = fgetc(f) # is the next char LF?
|
||||
if c != 10'i32: ungetc(c, f) # no, put the character back
|
||||
break
|
||||
add line, chr(int(c))
|
||||
result = true
|
||||
|
||||
proc dbgWriteStackTrace(f: PFrame)
|
||||
proc CommandPrompt() =
|
||||
# if we return from this routine, user code executes again
|
||||
var
|
||||
again = True
|
||||
dbgFramePtr = framePtr # for going down and up the stack
|
||||
dbgDown = 0 # how often we did go down
|
||||
dbgTemp: TStaticStr
|
||||
|
||||
while again:
|
||||
write(stdout, "*** endb| >>")
|
||||
let oldLen = dbgUser.len
|
||||
dbgUser.len = 0
|
||||
if not readLine(stdin, dbgUser): break
|
||||
if dbgUser.len == 0: dbgUser.len = oldLen
|
||||
# now look what we have to do:
|
||||
var i = scanWord(dbgUser.data, dbgTemp, 0)
|
||||
template `?`(x: expr): expr = dbgTemp == cstring(x)
|
||||
if ?"s" or ?"step":
|
||||
dbgState = dbStepInto
|
||||
again = false
|
||||
elif ?"n" or ?"next":
|
||||
dbgState = dbStepOver
|
||||
dbgSkipToFrame = framePtr
|
||||
again = false
|
||||
elif ?"f" or ?"skipcurrent":
|
||||
dbgState = dbSkipCurrent
|
||||
dbgSkipToFrame = framePtr.prev
|
||||
again = false
|
||||
elif ?"c" or ?"continue" or ?"r" or ?"run":
|
||||
dbgState = dbBreakpoints
|
||||
again = false
|
||||
elif ?"i" or ?"ignore":
|
||||
dbgState = dbOff
|
||||
again = false
|
||||
elif ?"h" or ?"help":
|
||||
dbgHelp()
|
||||
elif ?"q" or ?"quit":
|
||||
dbgState = dbQuiting
|
||||
dbgAborting = True
|
||||
again = false
|
||||
quit(1) # BUGFIX: quit with error code > 0
|
||||
elif ?"e" or ?"eval":
|
||||
dbgEvaluate(stdout, dbgUser.data, i, cast[PExtendedFrame](dbgFramePtr))
|
||||
elif ?"o" or ?"out":
|
||||
dbgOut(dbgUser.data, i, cast[PExtendedFrame](dbgFramePtr))
|
||||
elif ?"stackframe":
|
||||
dbgStackFrame(dbgUser.data, i, cast[PExtendedFrame](dbgFramePtr))
|
||||
elif ?"w" or ?"where":
|
||||
dbgShowExecutionPoint()
|
||||
elif ?"l" or ?"locals":
|
||||
ListVariables(stdout, cast[PExtendedFrame](dbgFramePtr))
|
||||
elif ?"g" or ?"globals":
|
||||
ListVariables(stdout, addr(dbgGlobalData))
|
||||
elif ?"u" or ?"up":
|
||||
if dbgDown <= 0:
|
||||
debugOut("[Warning] cannot go up any further ")
|
||||
else:
|
||||
dbgFramePtr = framePtr
|
||||
for j in 0 .. dbgDown-2: # BUGFIX
|
||||
dbgFramePtr = dbgFramePtr.prev
|
||||
dec(dbgDown)
|
||||
dbgShowCurrentProc(dbgFramePtr)
|
||||
elif ?"d" or ?"down":
|
||||
if dbgFramePtr != nil:
|
||||
inc(dbgDown)
|
||||
dbgFramePtr = dbgFramePtr.prev
|
||||
dbgShowCurrentProc(dbgFramePtr)
|
||||
else:
|
||||
debugOut("[Warning] cannot go down any further ")
|
||||
elif ?"bt" or ?"backtrace":
|
||||
dbgWriteStackTrace(framePtr)
|
||||
elif ?"b" or ?"break":
|
||||
setBreakPoint(dbgUser.data, i)
|
||||
elif ?"breakpoints":
|
||||
ListBreakPoints()
|
||||
elif ?"disable":
|
||||
BreakpointSetEnabled(dbgUser.data, i, -1)
|
||||
elif ?"enable":
|
||||
BreakpointSetEnabled(dbgUser.data, i, +1)
|
||||
elif ?"maxdisplay":
|
||||
var parsed: int
|
||||
i = scanNumber(dbgUser.data, parsed, i)
|
||||
if dbgUser.data[i-1] in {'0'..'9'}:
|
||||
if parsed == 0: maxDisplayRecDepth = -1
|
||||
else: maxDisplayRecDepth = parsed
|
||||
else:
|
||||
InvalidCommand()
|
||||
else: InvalidCommand()
|
||||
|
||||
proc endbStep() =
|
||||
# we get into here if an unhandled exception has been raised
|
||||
# XXX: do not allow the user to run the program any further?
|
||||
# XXX: BUG: the frame is lost here!
|
||||
dbgShowExecutionPoint()
|
||||
CommandPrompt()
|
||||
|
||||
proc checkForBreakpoint(line: int) =
|
||||
if (dbgBPbloom and line) != line: return
|
||||
let i = dbgBreakpointReached(line)
|
||||
if i >= 0:
|
||||
write(stdout, "*** endb| reached ")
|
||||
write(stdout, dbgBP[i].name)
|
||||
write(stdout, " in ")
|
||||
write(stdout, framePtr.filename)
|
||||
write(stdout, "(")
|
||||
write(stdout, framePtr.line)
|
||||
write(stdout, ") ")
|
||||
write(stdout, framePtr.procname)
|
||||
write(stdout, " ***\n")
|
||||
CommandPrompt()
|
||||
|
||||
# interface to the user program:
|
||||
|
||||
proc dbgRegisterBreakpoint(line: int,
|
||||
filename, name: cstring) {.compilerproc.} =
|
||||
let x = dbgBPlen
|
||||
if x >= high(dbgBP):
|
||||
debugOut("[Warning] cannot register breakpoint")
|
||||
return
|
||||
inc(dbgBPlen)
|
||||
dbgBP[x].name.assign(name)
|
||||
dbgBP[x].filename = filename
|
||||
dbgBP[x].low = line
|
||||
dbgBP[x].high = line
|
||||
dbgBPbloom = dbgBPbloom or line
|
||||
|
||||
proc dbgRegisterGlobal(name: cstring, address: pointer,
|
||||
typ: PNimType) {.compilerproc.} =
|
||||
let i = dbgGlobalData.f.len
|
||||
if i >= high(dbgGlobalData.slots):
|
||||
debugOut("[Warning] cannot register global ")
|
||||
return
|
||||
dbgGlobalData.slots[i].name = name
|
||||
dbgGlobalData.slots[i].typ = typ
|
||||
dbgGlobalData.slots[i].address = address
|
||||
inc(dbgGlobalData.f.len)
|
||||
# ------------------- watchpoint support ------------------------------------
|
||||
|
||||
type
|
||||
THash = int
|
||||
@@ -665,7 +265,7 @@ proc dbgRegisterWatchpoint(address: pointer, name: cstring,
|
||||
Watchpoints[i].address = address
|
||||
return
|
||||
if L >= watchPoints.high:
|
||||
debugOut("[Warning] cannot register watchpoint")
|
||||
#debugOut("[Warning] cannot register watchpoint")
|
||||
return
|
||||
Watchpoints[L].name = name
|
||||
Watchpoints[L].address = address
|
||||
@@ -676,99 +276,28 @@ proc dbgRegisterWatchpoint(address: pointer, name: cstring,
|
||||
proc dbgUnregisterWatchpoints*() =
|
||||
WatchpointsLen = 0
|
||||
|
||||
proc dbgWriteStackTrace(f: PFrame) =
|
||||
const
|
||||
firstCalls = 32
|
||||
var
|
||||
it = f
|
||||
i = 0
|
||||
total = 0
|
||||
tempFrames: array [0..127, PFrame]
|
||||
# setup long head:
|
||||
while it != nil and i <= high(tempFrames)-firstCalls:
|
||||
tempFrames[i] = it
|
||||
inc(i)
|
||||
inc(total)
|
||||
it = it.prev
|
||||
# go up the stack to count 'total':
|
||||
var b = it
|
||||
while it != nil:
|
||||
inc(total)
|
||||
it = it.prev
|
||||
var skipped = 0
|
||||
if total > len(tempFrames):
|
||||
# skip N
|
||||
skipped = total-i-firstCalls+1
|
||||
for j in 1..skipped:
|
||||
if b != nil: b = b.prev
|
||||
# create '...' entry:
|
||||
tempFrames[i] = nil
|
||||
inc(i)
|
||||
# setup short tail:
|
||||
while b != nil and i <= high(tempFrames):
|
||||
tempFrames[i] = b
|
||||
inc(i)
|
||||
b = b.prev
|
||||
for j in countdown(i-1, 0):
|
||||
if tempFrames[j] == nil:
|
||||
write(stdout, "(")
|
||||
write(stdout, skipped)
|
||||
write(stdout, " calls omitted) ...")
|
||||
else:
|
||||
write(stdout, tempFrames[j].filename)
|
||||
if tempFrames[j].line > 0:
|
||||
write(stdout, '(')
|
||||
write(stdout, tempFrames[j].line)
|
||||
write(stdout, ')')
|
||||
write(stdout, ' ')
|
||||
write(stdout, tempFrames[j].procname)
|
||||
write(stdout, "\n")
|
||||
|
||||
proc strstr(s1, s2: cstring): cstring {.importc, header: "<string.h>".}
|
||||
var
|
||||
dbgLineHook*: proc () {.nimcall.}
|
||||
## set this variable to provide a procedure that should be called before
|
||||
## each executed instruction. This should only be used by debuggers!
|
||||
## Only code compiled with the ``debugger:on`` switch calls this hook.
|
||||
|
||||
proc interestingFilename(filename: cstring): bool =
|
||||
#result = strstr(filename, "/rst.nim") == nil
|
||||
result = true
|
||||
dbgWatchpointHook*: proc (watchpointName: cstring) {.nimcall.}
|
||||
|
||||
proc checkWatchpoints =
|
||||
let L = WatchpointsLen
|
||||
for i in 0.. <L:
|
||||
let newHash = genericHash(Watchpoints[i].address, Watchpoints[i].typ)
|
||||
if newHash != Watchpoints[i].oldValue:
|
||||
if interestingFilename(framePtr.filename):
|
||||
dbgWriteStackTrace(framePtr)
|
||||
debugOut(Watchpoints[i].name)
|
||||
dbgWatchpointHook(Watchpoints[i].name)
|
||||
Watchpoints[i].oldValue = newHash
|
||||
|
||||
proc endb(line: int, file: cstring) {.compilerproc.} =
|
||||
proc endb(line: int, file: cstring) {.compilerproc, noinline.} =
|
||||
# This proc is called before every Nimrod code line!
|
||||
# Thus, it must have as few parameters as possible to keep the
|
||||
# code size small!
|
||||
# Check if we are at an enabled breakpoint or "in the mood"
|
||||
if framePtr == nil: return
|
||||
let oldState = dbgState
|
||||
checkWatchpoints()
|
||||
if dbgWatchpointHook != nil: checkWatchpoints()
|
||||
framePtr.line = line # this is done here for smaller code size!
|
||||
framePtr.filename = file
|
||||
if dbgLineHook != nil: dbgLineHook()
|
||||
case oldState
|
||||
of dbStepInto:
|
||||
# we really want the command prompt here:
|
||||
dbgShowExecutionPoint()
|
||||
CommandPrompt()
|
||||
of dbSkipCurrent, dbStepOver: # skip current routine
|
||||
if framePtr == dbgSkipToFrame:
|
||||
dbgShowExecutionPoint()
|
||||
CommandPrompt()
|
||||
else: # breakpoints are wanted though (I guess)
|
||||
checkForBreakpoint(line)
|
||||
of dbBreakpoints:
|
||||
# debugger is only interested in breakpoints
|
||||
checkForBreakpoint(line)
|
||||
else: nil
|
||||
|
||||
proc initDebugger {.inline.} =
|
||||
dbgState = dbStepInto
|
||||
dbgUser.len = 1
|
||||
dbgUser.data[0] = 's'
|
||||
|
||||
include "system/endb"
|
||||
|
||||
Reference in New Issue
Block a user