| OLD | NEW |
|---|
| (Empty) |
| 1 # Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file | |
| 2 # for details. All rights reserved. Use of this source code is governed by a | |
| 3 # BSD-style license that can be found in the LICENSE file. | |
| 4 # | |
| 5 # Set of GDB macros that aid in debugging dart internal data structures | |
| 6 # in a non intrusive manner (no need to execute code and hence can be | |
| 7 # used in a corefile or after a crash when debugging inside gdb). | |
| 8 # | |
| 9 # include this file into your gdb session using "source tools/gdb-macros" | |
| 10 # The command "help user-defined" dumps all the extended commands available | |
| 11 # for debugging the dart VM once this file is included. | |
| 12 # | |
| 13 | |
| 14 # | |
| 15 # ============== | |
| 16 # Generic macros | |
| 17 # ============== | |
| 18 # | |
| 19 define bi | |
| 20 set $SHOW_CONTEXT = 1 | |
| 21 break * $arg0 | |
| 22 end | |
| 23 document bi | |
| 24 Set a breakpoint on address | |
| 25 Usage: bi addr | |
| 26 end | |
| 27 | |
| 28 # Enable break points. | |
| 29 define be | |
| 30 enable $arg0 | |
| 31 end | |
| 32 document be | |
| 33 Enable breakpoint # | |
| 34 Usage: be num | |
| 35 end | |
| 36 | |
| 37 # Disable break points. | |
| 38 define bd | |
| 39 disable $arg0 | |
| 40 end | |
| 41 document bd | |
| 42 Disable breakpoint # | |
| 43 Usage: bd num | |
| 44 end | |
| 45 | |
| 46 # Print frame information. | |
| 47 define stack | |
| 48 info frame | |
| 49 info stack | |
| 50 info args | |
| 51 info locals | |
| 52 end | |
| 53 document stack | |
| 54 Print stack details | |
| 55 end | |
| 56 | |
| 57 | |
| 58 # | |
| 59 # ==================================== | |
| 60 # Object type and contents dump macros | |
| 61 # ==================================== | |
| 62 # | |
| 63 define printrawtype | |
| 64 if $argc == 1 | |
| 65 set $raw_object = (uword)$arg0 | |
| 66 if ($raw_object & dart::kSmiTagMask) == dart::kHeapObjectTag | |
| 67 set $raw_object = $raw_object - dart::kHeapObjectTag | |
| 68 set $raw_class = (uword)(((dart::RawObject*)$raw_object)->class_) - dart::
kHeapObjectTag | |
| 69 set $type = ((dart::RawClass*)$raw_class)->instance_kind_ | |
| 70 print $type | |
| 71 else | |
| 72 printf "dart::kSmi\n" | |
| 73 end | |
| 74 else | |
| 75 printf "Usage: printrawtype <address of rawobject>\n" | |
| 76 end | |
| 77 end | |
| 78 document printrawtype | |
| 79 Print the type of specified raw object | |
| 80 end | |
| 81 | |
| 82 define printtype | |
| 83 if $argc == 1 | |
| 84 set $handle = $arg0 | |
| 85 printrawtype $handle.raw_ | |
| 86 else | |
| 87 printf "Usage: printtype <handle reference>\n" | |
| 88 end | |
| 89 end | |
| 90 document printtype | |
| 91 Print the type of object pointed to by the handle | |
| 92 end | |
| 93 | |
| 94 define printname | |
| 95 if $argc == 1 | |
| 96 # TODO(asiva): Need to deal with generic strings. | |
| 97 set $raw_onebytestring = (dart::RawOneByteString*)((uword)$arg0 - dart::kHea
pObjectTag) | |
| 98 set $length = (uword)($raw_onebytestring->length_) >> dart::kSmiTagMask | |
| 99 set $offset = sizeof(dart::RawOneByteString) | |
| 100 while $length > 0 | |
| 101 printf "%c", *((char*)((uword)$raw_onebytestring + $offset)) | |
| 102 set $offset = $offset + 1 | |
| 103 set $length = $length - 1 | |
| 104 end | |
| 105 printf "\n" | |
| 106 else | |
| 107 printf "Null\n" | |
| 108 end | |
| 109 end | |
| 110 | |
| 111 define printfunctions | |
| 112 if $argc == 1 | |
| 113 set $raw_array = (dart::RawArray*)((uword)$arg0 - dart::kHeapObjectTag) | |
| 114 set $index = 0 | |
| 115 while $index < (uword)$raw_array->length_ >> dart::kSmiTagMask | |
| 116 set $temp = *(dart::RawObject*)((uword)$raw_array + \ | |
| 117 sizeof(dart::RawArray) + \ | |
| 118 ($index * sizeof(dart::RawObject*))) | |
| 119 set $temp = (uword)$temp - dart::kHeapObjectTag | |
| 120 printrawfunction $temp | |
| 121 set $index = $index + 1 | |
| 122 end | |
| 123 else | |
| 124 printf "Null\n" | |
| 125 end | |
| 126 end | |
| 127 | |
| 128 define printfields | |
| 129 if $argc == 1 | |
| 130 set $raw_array = (dart::RawArray*)((uword)$arg0 - dart::kHeapObjectTag) | |
| 131 set $index = 0 | |
| 132 while $index < (uword)$raw_array->length_ >> dart::kSmiTagMask | |
| 133 set $temp = *(dart::RawObject*)((uword)$raw_array + \ | |
| 134 sizeof(dart::RawArray) + \ | |
| 135 ($index * sizeof(dart::RawObject*))) | |
| 136 set $temp = (uword)$temp - dart::kHeapObjectTag | |
| 137 printrawfield $temp | |
| 138 set $index = $index + 1 | |
| 139 end | |
| 140 else | |
| 141 printf "Null\n" | |
| 142 end | |
| 143 end | |
| 144 | |
| 145 define printinterfaces | |
| 146 if $argc == 1 | |
| 147 set $raw_array = (dart::RawArray*)((uword)$arg0 - dart::kHeapObjectTag) | |
| 148 set $index = 0 | |
| 149 while $index < (uword)$raw_array->length_ >> dart::kSmiTagMask | |
| 150 set $temp = *(dart::RawObject*)((uword)$raw_array + \ | |
| 151 sizeof(dart::RawArray) + \ | |
| 152 ($index * sizeof(dart::RawObject*))) | |
| 153 set $raw_class = (dart::RawClass*)((uword)$temp - dart::kHeapObjectTag) | |
| 154 printname $raw_class->name_ | |
| 155 set $index = $index + 1 | |
| 156 end | |
| 157 else | |
| 158 printf "Null\n" | |
| 159 end | |
| 160 end | |
| 161 | |
| 162 define printrawclazz | |
| 163 if $argc == 1 | |
| 164 set $raw_class = (dart::RawClass*)$arg0 | |
| 165 set $is_interface = (uword)$raw_class->is_interface_ | |
| 166 if ($is_interface) | |
| 167 printf "Interface Name : " | |
| 168 else | |
| 169 printf "Class Name : " | |
| 170 end | |
| 171 printname $raw_class->name_ | |
| 172 printf "\nMethods :\n" | |
| 173 printfunctions $raw_class->functions_ | |
| 174 printf "\nFields :\n" | |
| 175 printfields $raw_class->fields_ | |
| 176 printf "\nInterfaces :\n" | |
| 177 printinterfaces $raw_class->interfaces_ | |
| 178 set $raw_closure_function = (uword)$raw_class->closure_function_ | |
| 179 if ($raw_closure_function != dart::Object::null()) | |
| 180 printf "\nClosure Function :\n" | |
| 181 printrawfunction $raw_closure_function | |
| 182 end | |
| 183 printf "\n" | |
| 184 else | |
| 185 printf "Usage: printrawclazz <address of rawobject>\n" | |
| 186 end | |
| 187 end | |
| 188 document printrawclazz | |
| 189 Print contents of RawClass | |
| 190 end | |
| 191 | |
| 192 define printrawfunction | |
| 193 if $argc == 1 | |
| 194 set $raw_function = (dart::RawFunction*)$arg0 | |
| 195 printf "Name : " | |
| 196 printname $raw_function->name_ | |
| 197 set $raw_code = (uword)$raw_function->code_ | |
| 198 printf "Code : \n" | |
| 199 if ($raw_code == dart::Object::null()) | |
| 200 printf " not been generated yet\n" | |
| 201 else | |
| 202 printrawcode $raw_code | |
| 203 end | |
| 204 else | |
| 205 printf "Usage: printrawfunction <address of rawobject>\n" | |
| 206 end | |
| 207 end | |
| 208 document printrawfunction | |
| 209 Print contents of RawFunction | |
| 210 end | |
| 211 | |
| 212 define printrawfield | |
| 213 if $argc == 1 | |
| 214 set $raw_field = (dart::RawField*)$arg0 | |
| 215 printf "Name : " | |
| 216 printname $raw_field->name_ | |
| 217 printf "Value : " | |
| 218 printrawobject (uword)$raw_field->value_ | |
| 219 else | |
| 220 printf "Usage: printrawfield <address of rawfield>\n" | |
| 221 end | |
| 222 end | |
| 223 document printrawfield | |
| 224 Print contents of RawField | |
| 225 end | |
| 226 | |
| 227 define printrawscript | |
| 228 if $argc == 1 | |
| 229 set $raw_script = (dart::RawScript*)$arg0 | |
| 230 printf "printrawscript is not implemented yet\n" | |
| 231 else | |
| 232 printf "Usage: printrawscript <address of rawobject>\n" | |
| 233 end | |
| 234 end | |
| 235 document printrawscript | |
| 236 Print contents of RawScript | |
| 237 end | |
| 238 | |
| 239 define printrawcode | |
| 240 if $argc == 1 | |
| 241 set $raw_code = (dart::RawCode*)$arg0 | |
| 242 set $instrs = (uword)$raw_code->instructions_ - dart::kHeapObjectTag | |
| 243 printrawinstructions $instrs | |
| 244 set $start = (uword)$raw_code + sizeof(dart::RawCode) | |
| 245 printf "Pointer Offsets :\n" | |
| 246 x/x $start, $start + $raw_code->pointer_offsets_length_ | |
| 247 else | |
| 248 printf "Usage: printrawcode <address of rawobject>\n" | |
| 249 end | |
| 250 end | |
| 251 document printrawcode | |
| 252 Print contents of RawCode | |
| 253 end | |
| 254 | |
| 255 define printrawinstructions | |
| 256 if $argc == 1 | |
| 257 set $raw_instrs = (dart::RawInstructions*)$arg0 | |
| 258 set $size = $raw_instrs->size_ | |
| 259 set $alignment = 16 | |
| 260 set $headersize = (sizeof(dart::RawInstructions) + $alignment -1) & -$alignm
ent | |
| 261 set $start = (uword)$raw_instrs + \ | |
| 262 (($headersize + $alignment - 1) & -$alignment) | |
| 263 printf "code_ = %p\n", $raw_instrs->code_ | |
| 264 printf "size_ = %d\n", $raw_instrs->size_ | |
| 265 disassemble $start, $start + ($size - $headersize) | |
| 266 else | |
| 267 printf "Usage: printrawinstructions <address of rawobject>\n" | |
| 268 end | |
| 269 end | |
| 270 document printrawinstructions | |
| 271 Print contents of RawInstructions | |
| 272 end | |
| 273 | |
| 274 define printrawinstance | |
| 275 if $argc == 1 | |
| 276 set $raw_instance = (dart::RawInstance*)$arg0 | |
| 277 set $raw_class = (uword)((dart::RawObject*)$raw_instance)->class_ - dart::kH
eapObjectTag | |
| 278 printf "Instance of class " | |
| 279 printname ((dart::RawClass*)$raw_class)->name_ | |
| 280 else | |
| 281 printf "Usage: printrawinstance <address of rawobject>\n" | |
| 282 end | |
| 283 end | |
| 284 document printrawinstance | |
| 285 Print contents of RawInstance | |
| 286 end | |
| 287 | |
| 288 define printrawinteger | |
| 289 if $argc == 1 | |
| 290 set $raw_integer = (dart::RawInteger*)$arg0 | |
| 291 printf "printrawinteger is not implemented yet\n" | |
| 292 else | |
| 293 printf "Usage: printrawinteger <address of rawobject>\n" | |
| 294 end | |
| 295 end | |
| 296 document printrawinteger | |
| 297 Print contents of RawInteger | |
| 298 end | |
| 299 | |
| 300 define printrawdouble | |
| 301 if $argc == 1 | |
| 302 set $raw_double = (dart::RawDouble*)$arg0 | |
| 303 printf "printrawdouble is not implemented yet\n" | |
| 304 else | |
| 305 printf "Usage: printrawdouble <address of rawobject>\n" | |
| 306 end | |
| 307 end | |
| 308 document printrawdouble | |
| 309 Print contents of RawDouble | |
| 310 end | |
| 311 | |
| 312 define printrawstring | |
| 313 if $argc == 1 | |
| 314 set $raw_string = (dart::RawString*)$arg0 | |
| 315 printf "printrawstring is not implemented yet\n" | |
| 316 else | |
| 317 printf "Usage: printrawstring <address of rawobject>\n" | |
| 318 end | |
| 319 end | |
| 320 document printrawstring | |
| 321 Print contents of RawString | |
| 322 end | |
| 323 | |
| 324 define printrawonebytestring | |
| 325 if $argc == 1 | |
| 326 set $raw_onebytestring = (dart::RawOneByteString*)$arg0 | |
| 327 set $length = (uword)($raw_onebytestring->length_) >> dart::kSmiTagMask | |
| 328 printf "Length = %d\n", $length | |
| 329 printf "Hash = %d\n", $raw_onebytestring->hash_ | |
| 330 set $offset = sizeof(dart::RawOneByteString) | |
| 331 while $length > 0 | |
| 332 printf "%c", *((char*)((uword)$raw_onebytestring + $offset)) | |
| 333 set $offset = $offset + 1 | |
| 334 set $length = $length - 1 | |
| 335 end | |
| 336 printf "\n" | |
| 337 else | |
| 338 printf "Usage: printrawonebytestring <address of rawobject>\n" | |
| 339 end | |
| 340 end | |
| 341 document printrawonebytestring | |
| 342 Print contents of RawString | |
| 343 end | |
| 344 | |
| 345 # TODO(asiva): This function can be called recursively when we are | |
| 346 # printing other objects so we need to save and restore variables. | |
| 347 define printrawarray | |
| 348 if $argc == 1 | |
| 349 set $raw_array = (dart::RawArray*)$arg0 | |
| 350 printf "Array Length = %d\n", (uword)$raw_array->length_ >> dart::kSmiTagMas
k | |
| 351 set $index = 0 | |
| 352 while $index < (uword)$raw_array->length_ >> dart::kSmiTagMask | |
| 353 printf "Element %d:\n", $index | |
| 354 set $temp = *(dart::RawObject*)((uword)$raw_array + \ | |
| 355 sizeof(dart::RawArray) + \ | |
| 356 ($index * sizeof(dart::RawObject*))) | |
| 357 printrawobject $temp | |
| 358 set $index = $index + 1 | |
| 359 end | |
| 360 else | |
| 361 printf "Usage: printrawarray <address of rawobject>\n" | |
| 362 end | |
| 363 end | |
| 364 document printrawarray | |
| 365 Print contents of RawArray | |
| 366 end | |
| 367 | |
| 368 define printrawclosure | |
| 369 if $argc == 1 | |
| 370 set $raw_closure = (dart::RawClosure*)$arg0 | |
| 371 printf "class_ = %p\n", $raw_closure->class_ | |
| 372 printf "context_ = %p\n", $raw_closure->context_ | |
| 373 else | |
| 374 printf "Usage: printrawclosure <address of rawobject>\n" | |
| 375 end | |
| 376 end | |
| 377 document printrawclosure | |
| 378 Print contents of RawClosure | |
| 379 end | |
| 380 | |
| 381 define printrawcontext | |
| 382 if $argc == 1 | |
| 383 set $raw_context = (dart::RawContext*)$arg0 | |
| 384 printf "parent_ = %p\n", $raw_context->parent_ | |
| 385 printf "isolate_ = %p\n", $raw_context->isolate_ | |
| 386 printf "num_variables_ = %d\n", $raw_context->num_variables_ | |
| 387 set $index = 0 | |
| 388 while $index < (uword)$raw_context->num_variables_ | |
| 389 printf "Variable %d:\n", $index | |
| 390 set $temp = *(dart::RawObject*)((uword)$raw_context + \ | |
| 391 sizeof(dart::RawContext) + \ | |
| 392 ($index * sizeof(dart::RawObject*))) | |
| 393 printrawobject $temp | |
| 394 set $index = $index + 1 | |
| 395 end | |
| 396 else | |
| 397 printf "Usage: printrawcontext <address of rawobject>\n" | |
| 398 end | |
| 399 end | |
| 400 document printrawcontext | |
| 401 Print contents of RawContext | |
| 402 end | |
| 403 | |
| 404 define printrawcontextscope | |
| 405 if $argc == 1 | |
| 406 set $raw_context_scope = (dart::RawContext*)$arg0 | |
| 407 printf "num_variables_ = %d\n", $raw_context_scope->num_variables_ | |
| 408 else | |
| 409 printf "Usage: printrawcontextscope <address of rawobject>\n" | |
| 410 end | |
| 411 end | |
| 412 document printrawcontextscope | |
| 413 Print contents of RawContextScope | |
| 414 end | |
| 415 | |
| 416 # TODO(asiva): This function can be called recursively when we are | |
| 417 # printing other objects so we need to save and restore variables. | |
| 418 define printrawobject | |
| 419 if $argc == 1 | |
| 420 set $raw_object = (uword)$arg0 | |
| 421 if ($raw_object & dart::kSmiTagMask) == dart::kHeapObjectTag | |
| 422 set $raw_object = (uword)$raw_object - dart::kHeapObjectTag | |
| 423 set $raw_class = (uword)((dart::RawObject*)$raw_object)->class_ - dart::kH
eapObjectTag | |
| 424 set $type = ((dart::RawClass*)$raw_class)->instance_kind_ | |
| 425 set $type_found = false | |
| 426 if $type == dart::kClass | |
| 427 printrawclazz $raw_object | |
| 428 set $type_found = true | |
| 429 end | |
| 430 if $type == dart::kFunction | |
| 431 printrawfunction $raw_object | |
| 432 set $type_found = true | |
| 433 end | |
| 434 if $type == dart::kScript | |
| 435 printrawscript $raw_object | |
| 436 set $type_found = true | |
| 437 end | |
| 438 if $type == dart::kCode | |
| 439 printrawcode $raw_object | |
| 440 set $type_found = true | |
| 441 end | |
| 442 if $type == dart::kInstructions | |
| 443 printrawinstructions $raw_object | |
| 444 set $type_found = true | |
| 445 end | |
| 446 if $type == dart::kInstance | |
| 447 printrawinstance $raw_object | |
| 448 set $type_found = true | |
| 449 end | |
| 450 if $type == dart::kNumber | |
| 451 printf "dump of RawNumber is not implemented yet\n" | |
| 452 set $type_found = true | |
| 453 end | |
| 454 if $type == dart::kInteger | |
| 455 printrawinteger $raw_object | |
| 456 set $type_found = true | |
| 457 end | |
| 458 if $type == dart::kDouble | |
| 459 printrawdouble $raw_object | |
| 460 set $type_found = true | |
| 461 end | |
| 462 if $type == dart::kString | |
| 463 printrawstring $raw_object | |
| 464 set $type_found = true | |
| 465 end | |
| 466 if $type == dart::kOneByteString | |
| 467 printrawonebytestring $raw_object | |
| 468 set $type_found = true | |
| 469 end | |
| 470 if $type == dart::kArray | |
| 471 printrawarray $raw_object | |
| 472 set $type_found = true | |
| 473 end | |
| 474 if $type == dart::kClosure | |
| 475 printrawclosure $raw_object | |
| 476 set $type_found = true | |
| 477 end | |
| 478 if $type == dart::kContext | |
| 479 printrawcontext $raw_object | |
| 480 set $type_found = true | |
| 481 end | |
| 482 if $type == dart::kContextScope | |
| 483 printrawcontextscope $raw_object | |
| 484 set $type_found = true | |
| 485 end | |
| 486 if $type_found == false | |
| 487 printf "unknown type %d\n", $type | |
| 488 end | |
| 489 else | |
| 490 print (uword)$raw_object >> dart::kSmiTagMask | |
| 491 end | |
| 492 else | |
| 493 printf "Usage: printrawobject <address of rawobject>\n" | |
| 494 end | |
| 495 end | |
| 496 document printrawobject | |
| 497 Print contents of specified raw object | |
| 498 end | |
| 499 | |
| 500 define printobject | |
| 501 if $argc == 1 | |
| 502 set $handle = $arg0 | |
| 503 set $raw_object = $handle.raw_ | |
| 504 printrawobject $raw_object | |
| 505 else | |
| 506 printf "Usage: printobject <handle reference>\n" | |
| 507 end | |
| 508 end | |
| 509 document printobject | |
| 510 Print contents of object pointed to by the handle | |
| 511 end | |
| 512 | |
| 513 | |
| 514 # | |
| 515 # ================================= | |
| 516 # Zone and Handle monitoring macros | |
| 517 # ================================= | |
| 518 # | |
| 519 | |
| 520 | |
| 521 # | |
| 522 # =================== | |
| 523 # Generic dump macros | |
| 524 # =================== | |
| 525 # | |
| 526 # Print as ascii characters. | |
| 527 define ascii_char | |
| 528 set $_c=*(unsigned char *)($arg0) | |
| 529 if ( $_c < 0x20 || $_c > 0x7E ) | |
| 530 printf "." | |
| 531 else | |
| 532 printf "%c", $_c | |
| 533 end | |
| 534 end | |
| 535 document ascii_char | |
| 536 Print the ASCII value of arg0 or '.' if value is unprintable | |
| 537 end | |
| 538 | |
| 539 # Hex dump (eight individual characters). | |
| 540 define hex_quad | |
| 541 printf "%02X %02X %02X %02X %02X %02X %02X %02X", \ | |
| 542 *(unsigned char*)($arg0), *(unsigned char*)($arg0 + 1), \ | |
| 543 *(unsigned char*)($arg0 + 2), *(unsigned char*)($arg0 + 3), \ | |
| 544 *(unsigned char*)($arg0 + 4), *(unsigned char*)($arg0 + 5), \ | |
| 545 *(unsigned char*)($arg0 + 6), *(unsigned char*)($arg0 + 7) | |
| 546 end | |
| 547 document hex_quad | |
| 548 Print eight hexadecimal bytes starting at arg0 | |
| 549 end | |
| 550 | |
| 551 # 16 byte hex dump. | |
| 552 define hexdump | |
| 553 printf "%08X : ", $arg0 | |
| 554 hex_quad $arg0 | |
| 555 printf " - " | |
| 556 hex_quad ($arg0+8) | |
| 557 printf " " | |
| 558 ascii_char ($arg0) | |
| 559 ascii_char ($arg0+1) | |
| 560 ascii_char ($arg0+2) | |
| 561 ascii_char ($arg0+3) | |
| 562 ascii_char ($arg0+4) | |
| 563 ascii_char ($arg0+5) | |
| 564 ascii_char ($arg0+6) | |
| 565 ascii_char ($arg0+7) | |
| 566 ascii_char ($arg0+8) | |
| 567 ascii_char ($arg0+9) | |
| 568 ascii_char ($arg0+0xA) | |
| 569 ascii_char ($arg0+0xB) | |
| 570 ascii_char ($arg0+0xC) | |
| 571 ascii_char ($arg0+0xD) | |
| 572 ascii_char ($arg0+0xE) | |
| 573 ascii_char ($arg0+0xF) | |
| 574 printf "\n" | |
| 575 end | |
| 576 document hexdump | |
| 577 Display a 16-byte hex/ASCII dump of arg0 | |
| 578 end | |
| 579 | |
| 580 # data dump. | |
| 581 define ddump | |
| 582 printf "[%04X:%08X]------------------------", $ds, $data_addr | |
| 583 printf "---------------------------------[ data]\n" | |
| 584 set $_count=0 | |
| 585 while ( $_count < $arg0 ) | |
| 586 set $_i=($_count*0x10) | |
| 587 hexdump ($data_addr+$_i) | |
| 588 set $_count++ | |
| 589 end | |
| 590 end | |
| 591 document ddump | |
| 592 Display $arg0 lines of hexdump for address $data_addr | |
| 593 end | |
| 594 | |
| 595 define dd | |
| 596 set $data_addr=$arg0 | |
| 597 ddump 0x10 | |
| 598 end | |
| 599 document dd | |
| 600 Display 16 lines of a hex dump for $arg0 | |
| 601 end | |
| 602 | |
| 603 define ddx | |
| 604 x/10x $arg0 | |
| 605 end | |
| 606 document ddx | |
| 607 Display 16 lines of a hex dump for $arg0 | |
| 608 end | |
| 609 | |
| 610 define ddi | |
| 611 x/10i $arg0 | |
| 612 end | |
| 613 document ddi | |
| 614 Display 16 lines of a instructions for $arg0 | |
| 615 end | |
| 616 | |
| 617 | |
| 618 # | |
| 619 # =============== | |
| 620 # Init parameters | |
| 621 # =============== | |
| 622 # | |
| 623 set print pretty on | |
| 624 #set disassembly-flavor intel | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 10800018:
Fix http://dartbug.com/4143 (Closed)
Base URL: http://dart.googlecode.com/svn/branches/bleeding_edge/dart/runtime/