dumper.py 46.2 KB
Newer Older
hjk's avatar
hjk committed
1 2 3 4 5 6 7

#Note: Keep name-type-value-numchild-extra order

#return

import sys
import gdb
8
import base64
9
import __builtin__
10

11 12 13 14 15 16 17

# Fails on Windows.
try:
    import curses.ascii
    def printableChar(ucs):
        return select(curses.ascii.isprint(ucs), ucs, '?')
except:
18 19 20 21
    def printableChar(ucs):
        if ucs >= 32 and ucs <= 126:
            return ucs
        return '?'
hjk's avatar
hjk committed
22

23 24 25 26
# Fails on SimulatorQt.
try:
    import tempfile
    def createTempFile():
27 28 29 30 31 32
        file = tempfile.NamedTemporaryFile(prefix="gdbpy_")
        return file.name, file

    def removeTempFile(name, file):
        file.close()

33 34 35 36
except:
    fileCounter = 0
    def createTempFile():
        fileCounter += 1
37
        return "gdbpy_tmp%d" % fileCounter, None
38

39 40
    def removeTempFile(name, file):
        pass
41

hjk's avatar
hjk committed
42 43 44
verbosity = 0
verbosity = 1

45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66
# Some "Enums"

# Encodings

Unencoded8Bit, \
    Base64Encoded8BitWithQuotes, \
    Base64Encoded16BitWithQuotes, \
    Base64Encoded32BitWithQuotes, \
    Base64Encoded16Bit, \
    Base64Encoded8Bit, \
    Hex2EncodedLatin1, \
    Hex4EncodedLittleEndian, \
    Hex8EncodedLittleEndian, \
    Hex2EncodedUtf8, \
    Hex8EncodedBigEndian, \
    Hex4EncodedBigEndian \
        = range(12)

# Display modes
StopDisplay, DisplayImage1, DisplayString, DisplayImage, DisplayProcess = range(5)


67 68 69 70 71
def select(condition, if_expr, else_expr):
    if condition:
        return if_expr
    return else_expr

72 73 74 75 76
def qmin(n, m):
    if n < m:
        return n
    return m

hjk's avatar
hjk committed
77
def isGoodGdb():
78 79
    #return gdb.VERSION.startswith("6.8.50.2009") \
    #   and gdb.VERSION != "6.8.50.20090630-cvs"
80
    return 'parse_and_eval' in __builtin__.dir(gdb)
hjk's avatar
hjk committed
81

82
def cleanAddress(addr):
83 84
    if addr is None:
        return "<no address>"
85 86
    # We cannot use str(addr) as it yields rubbish for char pointers
    # that might trigger Unicode encoding errors.
87
    return addr.cast(gdb.lookup_type("void").pointer())
88

hjk's avatar
hjk committed
89 90 91 92
# Workaround for gdb < 7.1
def numericTemplateArgument(type, position):
    try:
        return int(type.template_argument(position))
93
    except RuntimeError, error:
hjk's avatar
hjk committed
94 95 96 97
        # ": No type named 30."
        msg = str(error)
        return int(msg[14:-1])

98
def parseAndEvaluate(exp):
hjk's avatar
hjk committed
99
    if isGoodGdb():
100 101 102 103
        return gdb.parse_and_eval(exp)
    # Work around non-existing gdb.parse_and_eval as in released 7.0
    gdb.execute("set logging redirect on")
    gdb.execute("set logging on")
104 105 106 107
    try:
        gdb.execute("print %s" % exp)
    except:
        gdb.execute("set logging off")
108
        gdb.execute("set logging redirect off")
109
        return None
110
    gdb.execute("set logging off")
111
    gdb.execute("set logging redirect off")
112 113
    return gdb.history(0)

114

115
def catchCliOutput(command):
116
    file, filename = createTempFile()
117 118 119 120 121 122 123 124
    gdb.execute("set logging off")
    gdb.execute("set logging redirect off")
    gdb.execute("set logging file %s" % filename)
    gdb.execute("set logging redirect on")
    gdb.execute("set logging on")
    gdb.execute(command)
    gdb.execute("set logging off")
    gdb.execute("set logging redirect off")
125
    temp = open(filename, "r")
126
    lines = []
127
    for line in temp:
128
        lines.append(line)
129 130
    temp.close()
    removeTempFile(filename, file)
131 132 133
    return lines


134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
class Breakpoint:
    def __init__(self):
        self.number = None
        self.filename = None
        self.linenumber = None
        self.address = []
        self.function = None
        self.fullname = None
        self.condition = None
        self.times = None

def listOfBreakpoints(d):
    # [bkpt={number="1",type="breakpoint",disp="keep",enabled="y",
    #addr="0x0804da6d",func="testHidden()",file="../app.cpp",
    #fullname="...",line="1292",times="1",original-location="\"app.cpp\":1292"},
    # Num     Type           Disp Enb Address    What\n"
    #1       breakpoint     keep y   0x0804da6d in testHidden() at app.cpp:1292
    #\tbreakpoint already hit 1 time
    #2       breakpoint     keep y   0x080564d3 in espace::..doit(int) at ../app.cpp:1210\n"
    #3       breakpoint     keep y   <PENDING>  \"plugin.cpp\":38\n"
    #4       breakpoint     keep y   <MULTIPLE> \n"
    #4.1                         y     0x08056673 in Foo at ../app.cpp:126\n"
    #4.2                         y     0x0805678b in Foo at ../app.cpp:126\n"
    #5       hw watchpoint  keep y              &main\n"
158
    #6       breakpoint     keep y   0xb6cf18e5 <__cxa_throw+5>\n"
159
    lines = catchCliOutput("info break")
160 161 162 163

    lines.reverse()
    bp = Breakpoint()
    for line in lines:
164 165
        if len(line) == 0 or line.startswith(" "):
            continue
166 167 168 169 170 171 172 173 174 175
        if line[0] < '0' or line[0] > '9':
            continue
        if line.startswith("\tstop only if "):
            bp.condition = line[14:]
            continue
        if line.startswith("\tbreakpoint already hit "):
            bp.times = line[24:]
            continue
        number = line[0:5]
        pos0x = line.find(" 0x")
176
        posin = line.find(" in ", pos0x)
177
        poslt = line.find(" <", pos0x)
178
        posat = line.find(" at ", posin)
179
        poscol = line.find(":", posat)
180 181 182 183 184 185
        if pos0x != -1:
            if pos0x < posin:
                bp.address.append(line[pos0x + 1 : posin])
            elif pos0x < poslt:
                bp.address.append(line[pos0x + 1 : poslt])
                bp.function = line[poslt + 2 : line.find('>', poslt)]
186 187 188
        # Take "no address" as indication that the bp is pending.
        #if line.find("<PENDING>") >= 0:
        #    bp.address.append("<PENDING>")
189 190 191 192 193 194 195 196 197 198 199 200
        if posin < posat and posin != -1:
            bp.function = line[posin + 4 : posat]
        if posat < poscol and poscol != -1:
            bp.filename = line[posat + 4 : poscol]
        if poscol != -1:
            bp.linenumber = line[poscol + 1 : -1]

        if '.' in number: # Part of multiple breakpoint.
            continue

        # A breakpoint of its own
        bp.number = int(number)
hjk's avatar
hjk committed
201 202 203 204
        d.put('bkpt={number="%s",' % bp.number)
        d.put('type="breakpoint",')
        d.put('disp="keep",')
        d.put('enabled="y",')
205
        for address in bp.address:
hjk's avatar
hjk committed
206
            d.put('addr="%s",' % address)
207
        if not bp.function is None:
hjk's avatar
hjk committed
208
            d.put('func="%s",' % bp.function)
209
        if not bp.filename is None:
hjk's avatar
hjk committed
210
            d.put('file="%s",' % bp.filename)
211
        if not bp.fullname is None:
hjk's avatar
hjk committed
212
            d.put('fullname="%s",' % bp.fullname)
213
        if not bp.linenumber is None:
hjk's avatar
hjk committed
214
            d.put('line="%s",' % bp.linenumber)
215
        if not bp.condition is None:
hjk's avatar
hjk committed
216
            d.put('cond="%s",' % bp.condition)
217
        if not bp.fullname is None:
hjk's avatar
hjk committed
218
            d.put('fullname="%s",' % bt.fullname)
219
        if not bp.times is None:
hjk's avatar
hjk committed
220
            d.put('times="1",' % bp.times)
221
        #d.put('original-location="-"')
hjk's avatar
hjk committed
222
        d.put('},')
223 224 225
        bp = Breakpoint()


226 227 228 229 230 231 232 233 234 235 236
# Creates a list of field names of an anon union or struct
def listOfFields(type):
    fields = []
    for field in type.fields():
        if len(field.name) > 0:
            fields += field.name
        else:
            fields += listOfFields(field.type)
    return fields


237
def listOfLocals(varList):
238 239 240 241
    try:
        frame = gdb.selected_frame()
        #warn("FRAME %s: " % frame)
    except RuntimeError:
242
        warn("FRAME NOT ACCESSIBLE")
hjk's avatar
hjk committed
243
        return []
244

245
    # gdb-6.8-symbianelf fails here
246
    hasBlock = 'block' in __builtin__.dir(frame)
247

248
    items = []
249
    if hasBlock and isGoodGdb():
250
        #warn("IS GOOD: %s " % varList)
251 252 253 254 255 256 257
        try:
            block = frame.block()
            #warn("BLOCK: %s " % block)
        except:
            warn("BLOCK NOT ACCESSIBLE")
            return items

258 259 260 261 262 263
        while True:
            if block is None:
                warn("UNEXPECTED 'None' BLOCK")
                break
            for symbol in block:
                name = symbol.print_name
264

265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287
                if name == "__in_chrg":
                    continue

                # "NotImplementedError: Symbol type not yet supported in
                # Python scripts."
                #warn("SYMBOL %s: " % symbol.value)
                #warn("SYMBOL %s  (%s): " % (symbol, name))
                item = Item(0, "local", name, name)
                try:
                    item.value = frame.read_var(name)  # this is a gdb value
                except RuntimeError:
                    # happens for  void foo() { std::string s; std::wstring w; }
                    #warn("  FRAME READ VAR ERROR: %s (%s): " % (symbol, name))
                    continue
                #warn("ITEM %s: " % item.value)
                items.append(item)
            # The outermost block in a function has the function member
            # FIXME: check whether this is guaranteed.
            if not block.function is None:
                break

            block = block.superblock
    else:
hjk's avatar
hjk committed
288
        # Assuming gdb 7.0 release or 6.8-symbianelf.
289
        filename, file = createTempFile()
290 291
        #warn("VARLIST: %s " % varList)
        #warn("VARLIST: %s " % len(varList))
hjk's avatar
hjk committed
292 293
        gdb.execute("set logging off")
        gdb.execute("set logging redirect off")
294 295 296
        gdb.execute("set logging file %s" % filename)
        gdb.execute("set logging redirect on")
        gdb.execute("set logging on")
297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313
        try:
            gdb.execute("info args")
            # We cannot use "info locals" as at least 6.8-symbianelf
            # aborts as soon as we hit unreadable memory.
            # gdb.execute("interpreter mi '-stack-list-locals 0'")
            # results in &"Recursive internal problem.\n", so we have
            # the frontend pass us the list of locals.

            # There are two cases, either varList is empty, so we have
            # to fetch the list here, or it is not empty with the
            # first entry being a dummy.
            if len(varList) == 0:
                gdb.execute("info locals")
            else:
                varList = varList[1:]
        except:
            pass
314 315
        gdb.execute("set logging off")
        gdb.execute("set logging redirect off")
316

317 318
        temp = open(filename, "r")
        for line in temp:
319 320
            if len(line) == 0 or line.startswith(" "):
                continue
321
            # The function parameters
322 323 324
            pos = line.find(" = ")
            if pos < 0:
                continue
325
            varList.append(line[0:pos])
326 327
        temp.close()
        removeTempFile(filename, file)
328 329 330
        #warn("VARLIST: %s " % varList)
        for name in varList:
            #warn("NAME %s " % name)
331 332 333 334
            item = Item(0, "local", name, name)
            try:
                item.value = frame.read_var(name)  # this is a gdb value
            except RuntimeError:
335 336
                pass
                #continue
337 338 339 340 341 342 343 344
            except:
                # Something breaking the list, like intermediate gdb warnings
                # like 'Warning: can't find linker symbol for virtual table for
                # `std::less<char const*>' value\n\nwarning:  found
                # `myns::QHashData::shared_null' instead [...]
                # that break subsequent parsing. Chicken out and take the 
                # next "usable" line.
                continue
345 346 347 348 349
            items.append(item)

    return items


350
def value(expr):
351
    value = parseAndEvaluate(expr)
352 353 354 355 356
    try:
        return int(value)
    except:
        return str(value)

357

hjk's avatar
hjk committed
358
def isSimpleType(typeobj):
359 360
    if typeobj.code == gdb.TYPE_CODE_PTR:
        return False
hjk's avatar
hjk committed
361 362 363 364 365 366 367 368
    type = str(typeobj)
    return type == "bool" \
        or type == "char" \
        or type == "double" \
        or type == "float" \
        or type == "int" \
        or type == "long" or type.startswith("long ") \
        or type == "short" or type.startswith("short ") \
369
        or type == "signed" or type.startswith("signed ") \
hjk's avatar
hjk committed
370 371
        or type == "unsigned" or type.startswith("unsigned ")

372

hjk's avatar
hjk committed
373 374 375 376 377 378 379 380 381
def isStringType(d, typeobj):
    type = str(typeobj)
    return type == d.ns + "QString" \
        or type == d.ns + "QByteArray" \
        or type == "std::string" \
        or type == "std::wstring" \
        or type == "wstring"

def warn(message):
382 383
    if True or verbosity > 0:
        print "XXX: %s\n" % message.encode("latin1")
hjk's avatar
hjk committed
384 385 386 387 388 389
    pass

def check(exp):
    if not exp:
        raise RuntimeError("Check failed")

390 391 392 393 394
def checkRef(ref):
    count = ref["_q_value"]
    check(count > 0)
    check(count < 1000000) # assume there aren't a million references to any object

hjk's avatar
hjk committed
395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415
#def couldBePointer(p, align):
#    type = gdb.lookup_type("unsigned int")
#    ptr = gdb.Value(p).cast(type)
#    d = int(str(ptr))
#    warn("CHECKING : %s %d " % (p, ((d & 3) == 0 and (d > 1000 or d == 0))))
#    return (d & (align - 1)) and (d > 1000 or d == 0)


def checkAccess(p, align = 1):
    return p.dereference()

def checkContents(p, expected, align = 1):
    if int(p.dereference()) != expected:
        raise RuntimeError("Contents check failed")

def checkPointer(p, align = 1):
    if not isNull(p):
        p.dereference()


def isNull(p):
416 417 418 419
    # The following can cause evaluation to abort with "UnicodeEncodeError"
    # for invalid char *, as their "contents" is being examined
    #s = str(p)
    #return s == "0x0" or s.startswith("0x0 ")
420
    return p.cast(gdb.lookup_type("void").pointer()) == 0
hjk's avatar
hjk committed
421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446

movableTypes = set([
    "QBrush", "QBitArray", "QByteArray",
    "QCustomTypeInfo", "QChar",
    "QDate", "QDateTime",
    "QFileInfo", "QFixed", "QFixedPoint", "QFixedSize",
    "QHashDummyValue",
    "QIcon", "QImage",
    "QLine", "QLineF", "QLatin1Char", "QLocal",
    "QMatrix", "QModelIndex",
    "QPoint", "QPointF", "QPen", "QPersistentModelIndex",
    "QResourceRoot", "QRect", "QRectF", "QRegExp",
    "QSize", "QSizeF", "QString",
    "QTime", "QTextBlock",
    "QUrl",
    "QVariant",
    "QXmlStreamAttribute", "QXmlStreamNamespaceDeclaration",
    "QXmlStreamNotationDeclaration", "QXmlStreamEntityDeclaration"])


def stripClassTag(type):
    if type.startswith("class "):
        return type[6:]
    return type

def checkPointerRange(p, n):
447
    for i in xrange(n):
hjk's avatar
hjk committed
448 449 450 451 452 453
        checkPointer(p)
        ++p

def call(value, func):
    #warn("CALL: %s -> %s" % (value, func))
    type = stripClassTag(str(value.type))
454
    if type.find(":") >= 0:
hjk's avatar
hjk committed
455 456 457
        type = "'" + type + "'"
    exp = "((%s*)%s)->%s" % (type, value.address, func)
    #warn("CALL: %s" % exp)
458
    result = parseAndEvaluate(exp)
hjk's avatar
hjk committed
459 460 461
    #warn("  -> %s" % result)
    return result

462 463
def qtNamespace():
    try:
464
        type = str(parseAndEvaluate("&QString::null").type.target().unqualified())
465 466 467
        return type[0:len(type) - len("QString::null")]
    except RuntimeError:
        return ""
468 469 470
    except AttributeError:
        # Happens for none-Qt applications
        return ""
hjk's avatar
hjk committed
471

472 473 474 475 476 477 478
def findFirstZero(p, max):
    for i in xrange(max):
        if p.dereference() == 0:
            return i
        p = p + 1
    return -1

479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504

def extractCharArray(p, maxsize):
    t = gdb.lookup_type("unsigned char").pointer()
    p = p.cast(t)
    i = findFirstZero(p, maxsize)
    limit = select(i < 0, maxsize, i)
    s = ""
    for i in xrange(limit):
        s += "%c" % int(p.dereference())
        p += 1
    if i == maxsize:
        s += "..."
    return s

def extractByteArray(value):
    d_ptr = value['d'].dereference()
    data = d_ptr['data']
    size = d_ptr['size']
    alloc = d_ptr['alloc']
    check(0 <= size and size <= alloc and alloc <= 100*1000*1000)
    checkRef(d_ptr["ref"])
    if size > 0:
        checkAccess(data, 4)
        checkAccess(data + size) == 0
    return extractCharArray(data, 100)

505
def encodeCharArray(p, maxsize, size = -1):
506 507
    t = gdb.lookup_type("unsigned char").pointer()
    p = p.cast(t)
508 509 510 511
    if size == -1:
        i = findFirstZero(p, maxsize)
    else:
        i = size
512
    limit = select(i < 0, maxsize, i)
513
    s = ""
514
    for i in xrange(limit):
515 516
        s += "%02x" % int(p.dereference())
        p += 1
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544
    if i == maxsize:
        s += "2e2e2e"
    return s

def encodeChar2Array(p, maxsize):
    t = gdb.lookup_type("unsigned short").pointer()
    p = p.cast(t)
    i = findFirstZero(p, maxsize)
    limit = select(i < 0, maxsize, i)
    s = ""
    for i in xrange(limit):
        s += "%04x" % int(p.dereference())
        p += 1
    if i == maxsize:
        s += "2e002e002e00"
    return s

def encodeChar4Array(p, maxsize):
    t = gdb.lookup_type("unsigned int").pointer()
    p = p.cast(t)
    i = findFirstZero(p, maxsize)
    limit = select(i < 0, maxsize, i)
    s = ""
    for i in xrange(limit):
        s += "%08x" % int(p.dereference())
        p += 1
    if i == maxsize:
        s += "2e0000002e0000002e000000"
545 546
    return s

547 548 549 550 551 552
def encodeByteArray(value):
    d_ptr = value['d'].dereference()
    data = d_ptr['data']
    size = d_ptr['size']
    alloc = d_ptr['alloc']
    check(0 <= size and size <= alloc and alloc <= 100*1000*1000)
553
    checkRef(d_ptr["ref"])
554 555 556
    if size > 0:
        checkAccess(data, 4)
        checkAccess(data + size) == 0
557
    return encodeCharArray(data, size)
558 559 560 561 562 563 564 565 566 567

def encodeString(value):
    d_ptr = value['d'].dereference()
    data = d_ptr['data']
    size = d_ptr['size']
    alloc = d_ptr['alloc']
    check(0 <= size and size <= alloc and alloc <= 100*1000*1000)
    if size > 0:
        checkAccess(data, 4)
        checkAccess(data + size * 2) == 0
568
    checkRef(d_ptr["ref"])
569 570
    p = gdb.Value(d_ptr["data"])
    s = ""
571
    for i in xrange(size):
572 573 574 575 576 577
        val = int(p.dereference())
        s += "%02x" % (val % 256)
        s += "%02x" % (val / 256)
        p += 1
    return s

hjk's avatar
hjk committed
578 579 580 581 582 583 584
#######################################################################
#
# Item
#
#######################################################################

class Item:
585
    def __init__(self, value, parentiname, iname, name = None):
hjk's avatar
hjk committed
586
        self.value = value
587 588 589 590
        if iname is None:
            self.iname = parentiname
        else:
            self.iname = "%s.%s" % (parentiname, iname)
hjk's avatar
hjk committed
591 592 593 594 595 596 597 598 599 600 601 602 603 604 605
        self.name = name


#######################################################################
#
# FrameCommand
#
#######################################################################

class FrameCommand(gdb.Command):
    """Do fancy stuff. Usage bb --verbose expandedINames"""

    def __init__(self):
        super(FrameCommand, self).__init__("bb", gdb.COMMAND_OBSCURE)

606 607 608 609 610
    def invoke(self, args, from_tty):
        options = []
        varList = []
        typeformats = {}
        formats = {}
611
        watchers = ""
612
        expandedINames = ""
613 614 615 616 617
        for arg in args.split(' '):
            pos = arg.find(":") + 1
            if arg.startswith("options:"):
                options = arg[pos:].split(",")
            elif arg.startswith("vars:"):
618 619
                if len(arg[pos:]) > 0:
                    varList = arg[pos:].split(",")
620 621 622 623 624 625 626 627 628 629 630 631 632 633 634
            elif arg.startswith("expanded:"):
                expandedINames = set(arg[pos:].split(","))
            elif arg.startswith("typeformats:"):
                for f in arg[pos:].split(","):
                    pos = f.find("=")
                    if pos != -1:
                        type = base64.b16decode(f[0:pos], True)
                        typeformats[type] = int(f[pos+1:])
            elif arg.startswith("formats:"):
                for f in arg[pos:].split(","):
                    pos = f.find("=")
                    if pos != -1:
                        formats[f[0:pos]] = int(f[pos+1:])
            elif arg.startswith("watchers:"):
                watchers = base64.b16decode(arg[pos:], True)
635

636
        useFancy = "fancy" in options
637 638

        #warn("VARIABLES: %s" % varList)
hjk's avatar
hjk committed
639 640 641 642
        #warn("EXPANDED INAMES: %s" % expandedINames)
        module = sys.modules[__name__]
        self.dumpers = {}

643 644 645
        if False:
            dumpers = ""
            typeformats = ""
hjk's avatar
hjk committed
646
            for key, value in module.__dict__.items():
647
                if key.startswith("qdump__"):
648 649
                    dumpers += '"' + key[7:] + '",'
            output = "dumpers=[%s]," % dumpers
hjk's avatar
hjk committed
650
            #output += "qtversion=[%d,%d,%d]"
651
            #output += "qtversion=[4,6,0],"
hjk's avatar
hjk committed
652 653 654 655 656 657 658
            output += "namespace=\"%s\"," % qtNamespace()
            output += "dumperversion=\"2.0\","
            output += "sizes=[],"
            output += "expressions=[]"
            output += "]"
            print output
            return
659

660

hjk's avatar
hjk committed
661 662
        if useFancy:
            for key, value in module.__dict__.items():
663 664
                if key.startswith("qdump__"):
                    self.dumpers[key[7:]] = value
hjk's avatar
hjk committed
665 666 667

        d = Dumper()
        d.dumpers = self.dumpers
668 669
        d.typeformats = typeformats
        d.formats = formats
670 671 672
        d.useFancy = useFancy
        d.passExceptions = "passexceptions" in options
        d.autoDerefPointers = "autoderef" in options
673
        d.ns = qtNamespace()
674
        d.expandedINames = expandedINames
hjk's avatar
hjk committed
675 676
        #warn(" NAMESPACE IS: '%s'" % d.ns)

677 678 679
        #
        # Locals
        #
680
        for item in listOfLocals(varList):
681
            d.anonNumber = -1
682
            #warn("ITEM NAME %s: " % item.name)
683 684 685
            try:
                #warn("ITEM VALUE %s: " % item.value)
                # Throw on funny stuff, catch below.
hjk's avatar
hjk committed
686 687 688 689
                # Unfortunately, this fails also with a "Unicode encoding error"
                # in testArray().
                #dummy = str(item.value)
                pass
690 691 692 693 694 695 696 697 698 699 700
            except:
                # Locals with failing memory access.
                d.beginHash()
                d.put('iname="%s",' % item.iname)
                d.put('name="%s",' % item.name)
                d.put('addr="<not accessible>",')
                d.put('value="<not accessible>",')
                d.put('type="%s",' % item.value.type)
                d.put('numchild="0"');
                d.endHash()
                continue
701 702 703 704

            type = item.value.type
            if type.code == gdb.TYPE_CODE_PTR \
                    and item.name == "argv" and str(type) == "char **":
705
                # Special handling for char** argv.
706 707
                n = 0
                p = item.value
708 709 710 711 712
                # p is 0 for "optimized out" cases.
                if not isNull(p):
                    while not isNull(p.dereference()) and n <= 100:
                        p += 1
                        n += 1
713 714 715 716 717 718 719 720

                d.beginHash()
                d.put('iname="%s",' % item.iname)
                d.putName(item.name)
                d.putItemCount(select(n <= 100, n, "> 100"))
                d.putType(type)
                d.putNumChild(n)
                if d.isExpanded(item):
721
                    p = item.value
722
                    d.beginChildren(n)
723
                    for i in xrange(n):
724 725
                        value = p.dereference()
                        d.putItem(Item(value, item.iname, i, None))
726
                        p += 1
727 728 729 730 731 732
                    if n > 100:
                        d.putEllipsis()
                    d.endChildren()
                d.endHash()

            else:
733
                # A "normal" local variable or parameter.
734
                try:
735 736 737 738 739 740
                   addr = cleanAddress(item.value.address)
                   d.beginHash()
                   d.put('iname="%s",' % item.iname)
                   d.put('addr="%s",' % addr)
                   d.safePutItemHelper(item)
                   d.endHash()
741
                except AttributeError:
742 743
                    # Thrown by cleanAddress with message "'NoneType' object
                    # has no attribute 'cast'" for optimized-out values.
744 745 746 747 748 749 750
                    d.beginHash()
                    d.put('iname="%s",' % item.iname)
                    d.put('name="%s",' % item.name)
                    d.put('addr="<optimized out>",')
                    d.put('value="<optimized out>",')
                    d.put('type="%s"' % item.value.type)
                    d.endHash()
hjk's avatar
hjk committed
751

752 753 754 755
        d.pushOutput()
        locals = d.safeoutput


756 757 758
        #
        # Watchers
        #
759
        d.safeoutput = ""
760
        if len(watchers) > 0:
761
            for watcher in watchers.split("##"):
762 763
                (exp, iname) = watcher.split("#")
                self.handleWatch(d, exp, iname)
764 765 766
        d.pushOutput()
        watchers = d.safeoutput

hjk's avatar
hjk committed
767 768 769 770
        sep = ""
        if len(locals) and len(watchers):
            sep = ","

771 772 773
        #
        # Breakpoints
        #
774 775 776 777 778 779 780 781
        #breakpoints = ""
        #d.safeoutput = ""
        #listOfBreakpoints(d)
        #d.pushOutput()
        #breakpoints = d.safeoutput

        #print('data=[' + locals + sep + watchers + '],bkpts=[' + breakpoints + ']\n')
        print('data=[' + locals + sep + watchers + ']\n')
782

783

784
    def handleWatch(self, d, exp, iname):
785
        exp = str(exp)
786
        escapedExp = exp.replace('"', '\\"');
787
        #warn("HANDLING WATCH %s, INAME: '%s'" % (exp, iname))
788 789
        if exp.startswith("[") and exp.endswith("]"):
            #warn("EVAL: EXP: %s" % exp)
790
            d.beginHash()
791
            d.putField("iname", iname)
792 793
            d.putField("name", escapedExp)
            d.putField("exp", escapedExp)
794 795
            try:
                list = eval(exp)
796 797 798
                d.putValue("")
                d.putType(" ")
                d.putNumChild(len(list))
799 800 801 802
                # This is a list of expressions to evaluate
                d.beginChildren(len(list))
                itemNumber = 0
                for item in list:
803
                    self.handleWatch(d, item, "%s.%d" % (iname, itemNumber))
804 805
                    itemNumber += 1
                d.endChildren()
806 807
            except RuntimeError, error:
                warn("EVAL: ERROR CAUGHT %s" % error)
808 809 810
                d.putValue("<syntax error>")
                d.putType(" ")
                d.putNumChild(0)
811 812 813 814 815 816
                d.beginChildren(0)
                d.endChildren()
            d.endHash()
            return

        d.beginHash()
817
        d.putField("iname", iname)
818 819
        d.putField("name", escapedExp)
        d.putField("exp", escapedExp)
820
        handled = False
821 822
        if exp == "<Edit>" or len(exp) == 0:
            d.put('value=" ",type=" ",numchild="0",')
823
        else:
824
            try:
825
                value = parseAndEvaluate(exp)
826
                item = Item(value, iname, None, None)
827 828
                if not value is None:
                    d.putAddress(value.address)
829
                d.putItemHelper(item)
830 831
            except RuntimeError:
                d.put('value="<invalid>",type="<unknown>",numchild="0",')
832
        d.endHash()
833

hjk's avatar
hjk committed
834 835 836 837

FrameCommand()


838 839 840 841 842 843 844 845 846 847 848 849 850 851
#######################################################################
#
# Step Command
#
#######################################################################


class SalCommand(gdb.Command):
    """Do fancy stuff."""

    def __init__(self):
        super(SalCommand, self).__init__("sal", gdb.COMMAND_OBSCURE)

    def invoke(self, arg, from_tty):
852 853
        (cmd, addr) = arg.split(",")
        lines = catchCliOutput("info line *" + addr)
854 855 856 857 858 859 860 861 862 863
        fromAddr = "0x0"
        toAddr = "0x0"
        for line in lines:
            pos0from = line.find(" starts at address") + 19
            pos1from = line.find(" ", pos0from)
            pos0to = line.find(" ends at", pos1from) + 9
            pos1to = line.find(" ", pos0to)
            if pos1to > 0:
                fromAddr = line[pos0from : pos1from]
                toAddr = line[pos0to : pos1to]
864
        gdb.execute("maint packet sal%s,%s,%s" % (cmd,fromAddr, toAddr))
865 866

SalCommand()
hjk's avatar
hjk committed
867

868

hjk's avatar
hjk committed
869 870 871 872 873 874
#######################################################################
#
# The Dumper Class
#
#######################################################################

875

hjk's avatar
hjk committed
876 877 878 879 880 881
class Dumper:
    def __init__(self):
        self.output = ""
        self.safeoutput = ""
        self.childTypes = [""]
        self.childNumChilds = [-1]
882 883
        self.maxNumChilds = [-1]
        self.numChilds = [-1]
hjk's avatar
hjk committed
884 885 886 887 888

    def put(self, value):
        self.output += value

    def putField(self, name, value):
hjk's avatar
hjk committed
889
        self.put('%s="%s",' % (name, value))
hjk's avatar
hjk committed
890 891 892 893 894

    def beginHash(self):
        self.put('{')

    def endHash(self):
hjk's avatar
hjk committed
895
        self.put('},')
hjk's avatar
hjk committed
896 897

    def beginItem(self, name):
898
        self.put('%s="' % name)
hjk's avatar
hjk committed
899 900

    def endItem(self):
hjk's avatar
hjk committed
901
        self.put('",')
hjk's avatar
hjk committed
902

903
    def beginChildren(self, numChild_ = 1, childType_ = None, childNumChild_ = None):
hjk's avatar
hjk committed
904 905
        childType = ""
        childNumChild = -1
906 907 908 909 910 911
        if type(numChild_) is list:
            numChild = numChild_[0]
            maxNumChild = numChild_[1]
        else:
            numChild = numChild_
            maxNumChild = numChild_
912
        if numChild == 0:
913 914 915
            childType_ = None
        if not childType_ is None:
            childType = stripClassTag(str(childType_))
916
            self.put('childtype="%s",' % childType)
917
            if isSimpleType(childType_) or isStringType(self, childType_):
918
                self.put('childnumchild="0",')
hjk's avatar
hjk committed
919
                childNumChild = 0
920
            elif childType_.code == gdb.TYPE_CODE_PTR:
921
                self.put('childnumchild="1",')
hjk's avatar
hjk committed
922
                childNumChild = 1
923 924 925
        if not childNumChild_ is None:
            self.put('childnumchild="%s",' % childNumChild_)
            childNumChild = childNumChild_
hjk's avatar
hjk committed
926 927
        self.childTypes.append(childType)
        self.childNumChilds.append(childNumChild)
928 929
        self.numChilds.append(numChild)
        self.maxNumChilds.append(maxNumChild)
hjk's avatar
hjk committed
930 931 932 933 934
        #warn("BEGIN: %s" % self.childTypes)
        self.put("children=[")

    def endChildren(self):
        #warn("END: %s" % self.childTypes)
935 936 937 938
        numChild = self.numChilds.pop()
        maxNumChild = self.maxNumChilds.pop()
        if maxNumChild < numChild:
            self.putEllipsis();
hjk's avatar
hjk committed
939 940
        self.childTypes.pop()
        self.childNumChilds.pop()
hjk's avatar
hjk committed
941
        self.put('],')
hjk's avatar
hjk committed
942

943 944 945
    def childRange(self):
        return xrange(qmin(self.maxNumChilds[-1], self.numChilds[-1]))

hjk's avatar
hjk committed
946 947
    # convenience
    def putItemCount(self, count):
hjk's avatar
hjk committed
948
        self.put('value="<%s items>",' % count)
hjk's avatar
hjk committed
949 950

    def putEllipsis(self):
hjk's avatar
hjk committed
951
        self.put('{name="<incomplete>",value="",type="",numchild="0"},')
hjk's avatar
hjk committed
952 953 954 955 956 957

    def putType(self, type):
        #warn("TYPES: '%s' '%s'" % (type, self.childTypes))
        #warn("  EQUAL 2: %s " % (str(type) == self.childTypes[-1]))
        type = stripClassTag(str(type))
        if len(type) > 0 and type != self.childTypes[-1]:
hjk's avatar
hjk committed
958
            self.put('type="%s",' % type) # str(type.unqualified()) ?
hjk's avatar
hjk committed
959

960 961 962
    def putAddress(self, addr):
        self.put('addr="%s",' % cleanAddress(addr))

hjk's avatar
hjk committed
963 964
    def putNumChild(self, numchild):
        #warn("NUM CHILD: '%s' '%s'" % (numchild, self.childNumChilds[-1]))
965
        if numchild != self.childNumChilds[-1]:
hjk's avatar
hjk committed
966
            self.put('numchild="%s",' % numchild)
hjk's avatar
hjk committed
967

968 969 970 971 972 973
    def putValue(self, value, encoding = None):
        if not encoding is None:
            self.putField("valueencoded", encoding)
        self.putField("value", value)

    def putStringValue(self, value):
974
        if value is None:
hjk's avatar
hjk committed
975
            self.put('value="<not available>",')
976 977
        else:
            str = encodeString(value)
978
            self.put('valueencoded="%d",value="%s",' % (Hex4EncodedLittleEndian, str))
979

980 981 982 983 984 985 986 987
    def putDisplay(self, format, value = None, cmd = None):
        self.put('editformat="%s",' % format)
        if cmd is None:
            if not value is None:
                self.put('editvalue="%s",' % value)
        else:
            self.put('editvalue="%s|%s",' % (cmd, value))

988 989
    def putByteArrayValue(self, value):
        str = encodeByteArray(value)
990
        self.put('valueencoded="%d",value="%s",' % (Hex2EncodedLatin1, str))
991

992
    def putName(self, name):
hjk's avatar
hjk committed
993
        self.put('name="%s",' % name)
994

hjk's avatar
hjk committed
995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012
    def isExpanded(self, item):
        #warn("IS EXPANDED: %s in %s" % (item.iname, self.expandedINames))
        if item.iname is None:
            raise "Illegal iname 'None'"
        if item.iname.startswith("None"):
            raise "Illegal iname '%s'" % item.iname
        #warn("   --> %s" % (item.iname in self.expandedINames))
        return item.iname in self.expandedINames

    def isExpandedIName(self, iname):
        return iname in self.expandedINames

    def unputField(self, name):
        pos = self.output.rfind(",")
        if self.output[pos + 1:].startswith(name):
            self.output = self.output[0:pos]

    def stripNamespaceFromType(self, typeobj):
1013 1014 1015 1016 1017
        # This breaks for dumpers type names containing '__star'.
        # But this should not happen as identifiers containing two
        # subsequent underscores are reserved for the implemention.
        if typeobj.code == gdb.TYPE_CODE_PTR:
            return self.stripNamespaceFromType(typeobj.target()) + "__star"
hjk's avatar
hjk committed
1018 1019 1020 1021
        type = stripClassTag(str(typeobj))
        if len(self.ns) > 0 and type.startswith(self.ns):
            type = type[len(self.ns):]
        pos = type.find("<")
1022 1023 1024 1025 1026
        # FIXME: make it recognize  foo<A>::bar<B>::iterator?
        while pos != -1:
            pos1 = type.rfind(">", pos)
            type = type[0:pos] + type[pos1+1:]
            pos = type.find("<")
hjk's avatar
hjk committed
1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037
        return type

    def isMovableType(self, type):
        if type.code == gdb.TYPE_CODE_PTR:
            return True
        if isSimpleType(type):
            return True
        return self.stripNamespaceFromType(type) in movableTypes

    def putIntItem(self, name, value):
        self.beginHash()
1038 1039
        self.putName(name)
        self.putValue(value)
hjk's avatar
hjk committed
1040 1041 1042 1043 1044 1045
        self.putType("int")
        self.putNumChild(0)
        self.endHash()

    def putBoolItem(self, name, value):
        self.beginHash()
1046 1047
        self.putName(name)
        self.putValue(value)
hjk's avatar
hjk committed
1048 1049 1050 1051 1052 1053 1054 1055 1056
        self.putType("bool")
        self.putNumChild(0)
        self.endHash()

    def pushOutput(self):
        #warn("PUSH OUTPUT: %s " % self.output)
        self.safeoutput += self.output
        self.output = ""

1057
    def dumpInnerValueHelper(self, item):
hjk's avatar
hjk committed
1058
        if isSimpleType(item.value.type):
1059
            self.safePutItemHelper(item)
hjk's avatar
hjk committed
1060

1061
    def itemFormat(self, item):
1062
        format = self.formats.get(str(cleanAddress(item.value.address)))
1063 1064 1065 1066
        if format is None:
            format = self.typeformats.get(stripClassTag(str(item.value.type)))
        return format

1067 1068 1069 1070 1071
    def safePutItem(self, item):
        self.beginHash()
        self.safePutItemHelper(item)
        self.endHash()

hjk's avatar
hjk committed
1072 1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083
    def safePutItemHelper(self, item):
        self.pushOutput()
        # This is only used at the top level to ensure continuation
        # after failures due to uninitialized or corrupted data.
        if self.passExceptions:
            # for debugging reasons propagate errors.
            self.putItemHelper(item)

        else:
            try:
                self.putItemHelper(item)

1084
            except RuntimeError:
hjk's avatar
hjk committed
1085 1086 1087 1088
                self.output = ""
                # FIXME: Only catch debugger related exceptions
                #exType, exValue, exTraceback = sys.exc_info()
                #tb = traceback.format_exception(exType, exValue, exTraceback)
1089
                #warn("Exception: %s" % ex.message)
hjk's avatar
hjk committed
1090 1091