1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2006 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 #include <mdb/mdb_modapi.h> 29 #include <mdb/mdb_target.h> 30 #include <mdb/mdb_argvec.h> 31 #include <mdb/mdb_string.h> 32 #include <mdb/mdb_stdlib.h> 33 #include <mdb/mdb_err.h> 34 #include <mdb/mdb_debug.h> 35 #include <mdb/mdb_fmt.h> 36 #include <mdb/mdb_ctf.h> 37 #include <mdb/mdb_ctf_impl.h> 38 #include <mdb/mdb.h> 39 40 #include <sys/isa_defs.h> 41 #include <sys/param.h> 42 #include <sys/sysmacros.h> 43 #include <strings.h> 44 #include <libctf.h> 45 #include <ctype.h> 46 47 typedef struct holeinfo { 48 ulong_t hi_offset; /* expected offset */ 49 uchar_t hi_isunion; /* represents a union */ 50 } holeinfo_t; 51 52 typedef struct printarg { 53 mdb_tgt_t *pa_tgt; /* current target */ 54 mdb_tgt_t *pa_realtgt; /* real target (for -i) */ 55 mdb_tgt_t *pa_immtgt; /* immediate target (for -i) */ 56 mdb_tgt_as_t pa_as; /* address space to use for i/o */ 57 mdb_tgt_addr_t pa_addr; /* base address for i/o */ 58 ulong_t pa_armemlim; /* limit on array elements to print */ 59 ulong_t pa_arstrlim; /* limit on array chars to print */ 60 const char *pa_delim; /* element delimiter string */ 61 const char *pa_prefix; /* element prefix string */ 62 const char *pa_suffix; /* element suffix string */ 63 holeinfo_t *pa_holes; /* hole detection information */ 64 int pa_nholes; /* size of holes array */ 65 int pa_flags; /* formatting flags (see below) */ 66 int pa_depth; /* previous depth */ 67 int pa_nest; /* array nesting depth */ 68 int pa_tab; /* tabstop width */ 69 uint_t pa_maxdepth; /* Limit max depth */ 70 } printarg_t; 71 72 #define PA_SHOWTYPE 0x001 /* print type name */ 73 #define PA_SHOWNAME 0x002 /* print member name */ 74 #define PA_SHOWADDR 0x004 /* print address */ 75 #define PA_SHOWVAL 0x008 /* print value */ 76 #define PA_SHOWHOLES 0x010 /* print holes in structs */ 77 #define PA_INTHEX 0x020 /* print integer values in hex */ 78 #define PA_INTDEC 0x040 /* print integer values in decimal */ 79 #define PA_NOSYMBOLIC 0x080 /* don't print ptrs as func+offset */ 80 81 #define IS_CHAR(e) \ 82 (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \ 83 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) 84 85 #define SCALAR_MASK ((1 << CTF_K_INTEGER) | (1 << CTF_K_FLOAT) | \ 86 (1 << CTF_K_POINTER) | (1 << CTF_K_ENUM) | \ 87 (1 << CTF_K_ARRAY)) 88 #define IS_SCALAR(k) (((1 << k) & SCALAR_MASK) != 0) 89 90 #define COMPOSITE_MASK ((1 << CTF_K_STRUCT) | \ 91 (1 << CTF_K_UNION) | (1 << CTF_K_ARRAY)) 92 #define IS_COMPOSITE(k) (((1 << k) & COMPOSITE_MASK) != 0) 93 94 #define SOU_MASK ((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION)) 95 #define IS_SOU(k) (((1 << k) & SOU_MASK) != 0) 96 97 #define MEMBER_DELIM_ERR -1 98 #define MEMBER_DELIM_DONE 0 99 #define MEMBER_DELIM_PTR 1 100 #define MEMBER_DELIM_DOT 2 101 #define MEMBER_DELIM_LBR 3 102 103 typedef int printarg_f(const char *, const char *, 104 mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *); 105 106 static int elt_print(const char *, mdb_ctf_id_t, ulong_t, int, void *); 107 static void print_close_sou(printarg_t *, int); 108 109 /* 110 * Given an address, look up the symbol ID of the specified symbol in its 111 * containing module. We only support lookups for exact matches. 112 */ 113 static const char * 114 addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen, 115 GElf_Sym *symp, mdb_syminfo_t *sip) 116 { 117 const mdb_map_t *mp; 118 const char *p; 119 120 if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name, 121 namelen, NULL, NULL) == -1) 122 return (NULL); /* address does not exactly match a symbol */ 123 124 if ((p = strrsplit(name, '`')) != NULL) { 125 if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1) 126 return (NULL); 127 return (p); 128 } 129 130 if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL) 131 return (NULL); /* address does not fall within a mapping */ 132 133 if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1) 134 return (NULL); 135 136 return (name); 137 } 138 139 /* 140 * This lets dcmds be a little fancy with their processing of type arguments 141 * while still treating them more or less as a single argument. 142 * For example, if a command is invokes like this: 143 * 144 * ::<dcmd> proc_t ... 145 * 146 * this function will just copy "proc_t" into the provided buffer. If the 147 * command is instead invoked like this: 148 * 149 * ::<dcmd> struct proc ... 150 * 151 * this function will place the string "struct proc" into the provided buffer 152 * and increment the caller's argv and argc. This allows the caller to still 153 * treat the type argument logically as it would an other atomic argument. 154 */ 155 int 156 args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len) 157 { 158 int argc = *argcp; 159 const mdb_arg_t *argv = *argvp; 160 161 if (argc < 1 || argv->a_type != MDB_TYPE_STRING) 162 return (DCMD_USAGE); 163 164 if (strcmp(argv->a_un.a_str, "struct") == 0 || 165 strcmp(argv->a_un.a_str, "enum") == 0 || 166 strcmp(argv->a_un.a_str, "union") == 0) { 167 if (argc <= 1) { 168 mdb_warn("%s is not a valid type\n", argv->a_un.a_str); 169 return (DCMD_ABORT); 170 } 171 172 if (argv[1].a_type != MDB_TYPE_STRING) 173 return (DCMD_USAGE); 174 175 (void) mdb_snprintf(buf, len, "%s %s", 176 argv[0].a_un.a_str, argv[1].a_un.a_str); 177 178 *argcp = argc - 1; 179 *argvp = argv + 1; 180 } else { 181 (void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str); 182 } 183 184 return (0); 185 } 186 187 /*ARGSUSED*/ 188 int 189 cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 190 { 191 mdb_ctf_id_t id; 192 char tn[MDB_SYM_NAMLEN]; 193 int ret; 194 195 if (flags & DCMD_ADDRSPEC) 196 return (DCMD_USAGE); 197 198 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 199 return (ret); 200 201 if (argc != 1) 202 return (DCMD_USAGE); 203 204 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 205 mdb_warn("failed to look up type %s", tn); 206 return (DCMD_ERR); 207 } 208 209 if (flags & DCMD_PIPE_OUT) 210 mdb_printf("%#lr\n", mdb_ctf_type_size(id)); 211 else 212 mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id)); 213 214 return (DCMD_OK); 215 } 216 217 /*ARGSUSED*/ 218 int 219 cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 220 { 221 const char *member; 222 mdb_ctf_id_t id; 223 ulong_t off; 224 char tn[MDB_SYM_NAMLEN]; 225 int ret; 226 227 if (flags & DCMD_ADDRSPEC) 228 return (DCMD_USAGE); 229 230 if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 231 return (ret); 232 233 if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING) 234 return (DCMD_USAGE); 235 236 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 237 mdb_warn("failed to look up type %s", tn); 238 return (DCMD_ERR); 239 } 240 241 member = argv[1].a_un.a_str; 242 243 if (mdb_ctf_offsetof(id, member, &off) != 0) { 244 mdb_warn("failed to find member %s of type %s", member, tn); 245 return (DCMD_ERR); 246 } 247 248 if (off % NBBY == 0) 249 mdb_printf("offsetof (%s, %s) = %#lr\n", 250 tn, member, off / NBBY); 251 else 252 mdb_printf("offsetof (%s, %s) = %#lr bits\n", 253 tn, member, off); 254 255 return (DCMD_OK); 256 } 257 258 struct enum_cbinfo { 259 uint_t e_flags; 260 const char *e_string; /* NULL for value searches */ 261 int e_value; 262 uint_t e_found; 263 }; 264 #define E_PRETTY 0x1 265 #define E_HEX 0x2 266 #define E_SEARCH_STRING 0x4 267 #define E_SEARCH_VALUE 0x8 268 269 static int 270 enum_cb(const char *name, int value, void *arg) 271 { 272 struct enum_cbinfo *info = arg; 273 uint_t flags = info->e_flags; 274 275 if (flags & E_SEARCH_STRING) { 276 if (strcmp(name, info->e_string) != 0) 277 return (0); 278 279 } else if (flags & E_SEARCH_VALUE) { 280 if (value != info->e_value) 281 return (0); 282 } 283 284 if (flags & E_PRETTY) { 285 if (flags & E_HEX) 286 mdb_printf("%-8x %s\n", value, name); 287 else 288 mdb_printf("%-11d %s\n", value, name); 289 } else { 290 mdb_printf("%#r\n", value); 291 } 292 293 info->e_found = 1; 294 return (0); 295 } 296 297 /*ARGSUSED*/ 298 int 299 cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 300 { 301 struct enum_cbinfo info; 302 303 const char *type; /* type name we are using */ 304 char tn[MDB_SYM_NAMLEN]; 305 char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")]; 306 mdb_ctf_id_t id; 307 mdb_ctf_id_t idr; 308 309 int i; 310 intmax_t search; 311 312 info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY; 313 info.e_string = NULL; 314 info.e_value = 0; 315 info.e_found = 0; 316 317 i = mdb_getopts(argc, argv, 318 'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags, 319 NULL); 320 321 argc -= i; 322 argv += i; 323 324 if ((i = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 325 return (i); 326 327 type = NULL; 328 if (strchr(tn, ' ') == NULL) { 329 /* 330 * Check as an enumeration tag first, and fall back 331 * to checking for a typedef. Yes, this means that 332 * anonymous enumerations whose typedefs conflict with 333 * an enum tag can't be accessed. Don't do that. 334 */ 335 (void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", tn); 336 337 if (mdb_ctf_lookup_by_name(tn2, &id) == 0) { 338 type = tn2; 339 } else if (mdb_ctf_lookup_by_name(tn, &id) == 0) { 340 type = tn; 341 } else { 342 mdb_warn("types '%s', '%s'", tn2, tn); 343 return (DCMD_ERR); 344 } 345 } else { 346 if (mdb_ctf_lookup_by_name(tn, &id) == 0) { 347 type = tn; 348 } else { 349 mdb_warn("'%s'", tn); 350 return (DCMD_ERR); 351 } 352 } 353 354 /* resolve it, and make sure we're looking at an enumeration */ 355 if (mdb_ctf_type_resolve(id, &idr) == -1) { 356 mdb_warn("unable to resolve '%s'", type); 357 return (DCMD_ERR); 358 } 359 if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) { 360 mdb_warn("'%s': not an enumeration\n", type); 361 return (DCMD_ERR); 362 } 363 364 if (argc > 2) 365 return (DCMD_USAGE); 366 367 if (argc == 2) { 368 if (flags & DCMD_ADDRSPEC) { 369 mdb_warn("may only specify one of: name, address\n"); 370 return (DCMD_USAGE); 371 } 372 373 if (argv[1].a_type == MDB_TYPE_STRING) { 374 info.e_flags |= E_SEARCH_STRING; 375 info.e_string = argv[1].a_un.a_str; 376 } else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) { 377 info.e_flags |= E_SEARCH_VALUE; 378 search = argv[1].a_un.a_val; 379 } else { 380 return (DCMD_USAGE); 381 } 382 } 383 384 if (flags & DCMD_ADDRSPEC) { 385 info.e_flags |= E_SEARCH_VALUE; 386 search = mdb_get_dot(); 387 } 388 389 if (info.e_flags & E_SEARCH_VALUE) { 390 if ((int)search != search) { 391 mdb_warn("value '%lld' out of enumeration range\n", 392 search); 393 return (DCMD_ERR); 394 } 395 info.e_value = search; 396 } 397 398 if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) { 399 if (info.e_flags & E_HEX) 400 mdb_printf("%<b>%-8s %s%</b>\n", "VALUE", "NAME"); 401 else 402 mdb_printf("%<b>%-11s %s%</b>\n", "VALUE", "NAME"); 403 } 404 405 if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) { 406 mdb_warn("cannot walk '%s' as enum", type); 407 return (DCMD_ERR); 408 } 409 410 if (info.e_found == 0 && 411 (info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) { 412 if (info.e_flags & E_SEARCH_STRING) 413 mdb_warn("name \"%s\" not in '%s'\n", info.e_string, 414 type); 415 else 416 mdb_warn("value %#d not in '%s'\n", info.e_value, type); 417 418 return (DCMD_ERR); 419 } 420 421 return (DCMD_OK); 422 } 423 424 static int 425 setup_vcb(const char *name, uintptr_t addr) 426 { 427 const char *p; 428 mdb_var_t *v; 429 430 if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) { 431 if ((p = strbadid(name)) != NULL) { 432 mdb_warn("'%c' may not be used in a variable " 433 "name\n", *p); 434 return (DCMD_ABORT); 435 } 436 437 if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL) 438 return (DCMD_ERR); 439 } else { 440 if (v->v_flags & MDB_NV_RDONLY) { 441 mdb_warn("variable %s is read-only\n", name); 442 return (DCMD_ABORT); 443 } 444 } 445 446 /* 447 * If there already exists a vcb for this variable, we may be 448 * calling the dcmd in a loop. We only create a vcb for this 449 * variable on the first invocation. 450 */ 451 if (mdb_vcb_find(v, mdb.m_frame) == NULL) 452 mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame); 453 454 return (0); 455 } 456 457 /*ARGSUSED*/ 458 int 459 cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 460 { 461 mdb_ctf_id_t id; 462 ulong_t offset; 463 uintptr_t a, tmp; 464 int ret; 465 466 if (!(flags & DCMD_ADDRSPEC) || argc == 0) 467 return (DCMD_USAGE); 468 469 if (argv->a_type != MDB_TYPE_STRING) { 470 /* 471 * We are being given a raw offset in lieu of a type and 472 * member; confirm the arguments. 473 */ 474 if (argv->a_type != MDB_TYPE_IMMEDIATE) 475 return (DCMD_USAGE); 476 477 offset = argv->a_un.a_val; 478 479 argv++; 480 argc--; 481 482 if (offset % sizeof (uintptr_t)) { 483 mdb_warn("offset must fall on a word boundary\n"); 484 return (DCMD_ABORT); 485 } 486 } else { 487 const char *member; 488 char buf[MDB_SYM_NAMLEN]; 489 int ret; 490 491 ret = args_to_typename(&argc, &argv, buf, sizeof (buf)); 492 if (ret != 0) 493 return (ret); 494 495 if (mdb_ctf_lookup_by_name(buf, &id) != 0) { 496 mdb_warn("failed to look up type %s", buf); 497 return (DCMD_ABORT); 498 } 499 500 argv++; 501 argc--; 502 503 if (argc < 1 || argv->a_type != MDB_TYPE_STRING) 504 return (DCMD_USAGE); 505 506 member = argv->a_un.a_str; 507 508 argv++; 509 argc--; 510 511 if (mdb_ctf_offsetof(id, member, &offset) != 0) { 512 mdb_warn("failed to find member %s of type %s", 513 member, buf); 514 return (DCMD_ABORT); 515 } 516 517 if (offset % (sizeof (uintptr_t) * NBBY) != 0) { 518 mdb_warn("%s is not a word-aligned member\n", member); 519 return (DCMD_ABORT); 520 } 521 522 offset /= NBBY; 523 } 524 525 /* 526 * If we have any unchewed arguments, a variable name must be present. 527 */ 528 if (argc == 1) { 529 if (argv->a_type != MDB_TYPE_STRING) 530 return (DCMD_USAGE); 531 532 if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0) 533 return (ret); 534 535 } else if (argc != 0) { 536 return (DCMD_USAGE); 537 } 538 539 a = addr; 540 541 do { 542 mdb_printf("%lr\n", a); 543 544 if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) { 545 mdb_warn("failed to read next pointer from object %p", 546 a); 547 return (DCMD_ERR); 548 } 549 550 a = tmp; 551 } while (a != addr && a != NULL); 552 553 return (DCMD_OK); 554 } 555 556 int 557 cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 558 { 559 mdb_ctf_id_t id; 560 ssize_t elemsize = 0; 561 char tn[MDB_SYM_NAMLEN]; 562 int ret, nelem = -1; 563 564 mdb_tgt_t *t = mdb.m_target; 565 GElf_Sym sym; 566 mdb_ctf_arinfo_t ar; 567 mdb_syminfo_t s_info; 568 569 if (!(flags & DCMD_ADDRSPEC)) 570 return (DCMD_USAGE); 571 572 if (argc >= 2) { 573 ret = args_to_typename(&argc, &argv, tn, sizeof (tn)); 574 if (ret != 0) 575 return (ret); 576 577 if (argc == 1) /* unquoted compound type without count */ 578 return (DCMD_USAGE); 579 580 if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 581 mdb_warn("failed to look up type %s", tn); 582 return (DCMD_ABORT); 583 } 584 585 if (argv[1].a_type == MDB_TYPE_IMMEDIATE) 586 nelem = argv[1].a_un.a_val; 587 else 588 nelem = mdb_strtoull(argv[1].a_un.a_str); 589 590 elemsize = mdb_ctf_type_size(id); 591 } else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info) 592 != NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) 593 == 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY && 594 mdb_ctf_array_info(id, &ar) != -1) { 595 elemsize = mdb_ctf_type_size(id) / ar.mta_nelems; 596 nelem = ar.mta_nelems; 597 } else { 598 mdb_warn("no symbol information for %a", addr); 599 return (DCMD_ERR); 600 } 601 602 if (argc == 3 || argc == 1) { 603 if (argv[argc - 1].a_type != MDB_TYPE_STRING) 604 return (DCMD_USAGE); 605 606 if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0) 607 return (ret); 608 609 } else if (argc > 3) { 610 return (DCMD_USAGE); 611 } 612 613 for (; nelem > 0; nelem--) { 614 mdb_printf("%lr\n", addr); 615 addr = addr + elemsize; 616 } 617 618 return (DCMD_OK); 619 } 620 621 /* 622 * Print an integer bitfield in hexadecimal by reading the enclosing byte(s) 623 * and then shifting and masking the data in the lower bits of a uint64_t. 624 */ 625 static int 626 print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep) 627 { 628 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 629 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY; 630 uint64_t mask = (1ULL << ep->cte_bits) - 1; 631 uint64_t value = 0; 632 uint8_t *buf = (uint8_t *)&value; 633 uint8_t shift; 634 635 const char *format; 636 637 if (!(pap->pa_flags & PA_SHOWVAL)) 638 return (0); 639 640 if (ep->cte_bits > sizeof (value) * NBBY - 1) { 641 mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits); 642 return (0); 643 } 644 645 /* 646 * On big-endian machines, we need to adjust the buf pointer to refer 647 * to the lowest 'size' bytes in 'value', and we need shift based on 648 * the offset from the end of the data, not the offset of the start. 649 */ 650 #ifdef _BIG_ENDIAN 651 buf += sizeof (value) - size; 652 off += ep->cte_bits; 653 #endif 654 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) { 655 mdb_warn("failed to read %lu bytes at %llx", 656 (ulong_t)size, addr); 657 return (1); 658 } 659 660 shift = off % NBBY; 661 662 /* 663 * Offsets are counted from opposite ends on little- and 664 * big-endian machines. 665 */ 666 #ifdef _BIG_ENDIAN 667 shift = NBBY - shift; 668 #endif 669 670 /* 671 * If the bits we want do not begin on a byte boundary, shift the data 672 * right so that the value is in the lowest 'cte_bits' of 'value'. 673 */ 674 if (off % NBBY != 0) 675 value >>= shift; 676 value &= mask; 677 678 /* 679 * We default to printing signed bitfields as decimals, 680 * and unsigned bitfields in hexadecimal. If they specify 681 * hexadecimal, we treat the field as unsigned. 682 */ 683 if ((pap->pa_flags & PA_INTHEX) || 684 !(ep->cte_format & CTF_INT_SIGNED)) { 685 format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx"; 686 } else { 687 int sshift = sizeof (value) * NBBY - ep->cte_bits; 688 689 /* sign-extend value, and print as a signed decimal */ 690 value = ((int64_t)value << sshift) >> sshift; 691 format = "%#lld"; 692 } 693 mdb_printf(format, value); 694 695 return (0); 696 } 697 698 /* 699 * Print out a character or integer value. We use some simple heuristics, 700 * described below, to determine the appropriate radix to use for output. 701 */ 702 static int 703 print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off, 704 printarg_t *pap) 705 { 706 static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" }; 707 static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" }; 708 static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" }; 709 710 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 711 const char *const *fsp; 712 size_t size; 713 714 union { 715 uint64_t i8; 716 uint32_t i4; 717 uint16_t i2; 718 uint8_t i1; 719 time_t t; 720 } u; 721 722 if (!(pap->pa_flags & PA_SHOWVAL)) 723 return (0); 724 725 if (ep->cte_format & CTF_INT_VARARGS) { 726 mdb_printf("...\n"); 727 return (0); 728 } 729 730 /* 731 * If the size is not a power-of-two number of bytes in the range 1-8 732 * then we assume it is a bitfield and print it as such. 733 */ 734 size = ep->cte_bits / NBBY; 735 if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1)) != 0) 736 return (print_bitfield(off, pap, ep)); 737 738 if (IS_CHAR(*ep)) { 739 mdb_printf("'"); 740 if (mdb_fmt_print(pap->pa_tgt, pap->pa_as, 741 addr, 1, 'C') == addr) 742 return (1); 743 mdb_printf("'"); 744 return (0); 745 } 746 747 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) { 748 mdb_warn("failed to read %lu bytes at %llx", 749 (ulong_t)size, addr); 750 return (1); 751 } 752 753 /* 754 * We pretty-print time_t values as a calendar date and time. 755 */ 756 if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC)) && 757 strcmp(type, "time_t") == 0 && u.t != 0) { 758 mdb_printf("%Y", u.t); 759 return (0); 760 } 761 762 /* 763 * The default format is hexadecimal. 764 */ 765 if (!(pap->pa_flags & PA_INTDEC)) 766 fsp = xformat; 767 else if (ep->cte_format & CTF_INT_SIGNED) 768 fsp = sformat; 769 else 770 fsp = uformat; 771 772 switch (size) { 773 case sizeof (uint8_t): 774 mdb_printf(fsp[0], u.i1); 775 break; 776 case sizeof (uint16_t): 777 mdb_printf(fsp[1], u.i2); 778 break; 779 case sizeof (uint32_t): 780 mdb_printf(fsp[2], u.i4); 781 break; 782 case sizeof (uint64_t): 783 mdb_printf(fsp[3], u.i8); 784 break; 785 } 786 return (0); 787 } 788 789 /*ARGSUSED*/ 790 static int 791 print_int(const char *type, const char *name, mdb_ctf_id_t id, 792 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 793 { 794 ctf_encoding_t e; 795 796 if (!(pap->pa_flags & PA_SHOWVAL)) 797 return (0); 798 799 if (mdb_ctf_type_encoding(base, &e) != 0) { 800 mdb_printf("??? (%s)", mdb_strerror(errno)); 801 return (0); 802 } 803 804 return (print_int_val(type, &e, off, pap)); 805 } 806 807 /* 808 * Print out a floating point value. We only provide support for floats in 809 * the ANSI-C float, double, and long double formats. 810 */ 811 /*ARGSUSED*/ 812 static int 813 print_float(const char *type, const char *name, mdb_ctf_id_t id, 814 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 815 { 816 #ifndef _KMDB 817 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 818 ctf_encoding_t e; 819 820 union { 821 float f; 822 double d; 823 long double ld; 824 } u; 825 826 if (!(pap->pa_flags & PA_SHOWVAL)) 827 return (0); 828 829 if (mdb_ctf_type_encoding(base, &e) == 0) { 830 if (e.cte_format == CTF_FP_SINGLE && 831 e.cte_bits == sizeof (float) * NBBY) { 832 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f, 833 sizeof (u.f), addr) != sizeof (u.f)) { 834 mdb_warn("failed to read float at %llx", addr); 835 return (1); 836 } 837 mdb_printf("%s", doubletos(u.f, 7, 'e')); 838 839 } else if (e.cte_format == CTF_FP_DOUBLE && 840 e.cte_bits == sizeof (double) * NBBY) { 841 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d, 842 sizeof (u.d), addr) != sizeof (u.d)) { 843 mdb_warn("failed to read float at %llx", addr); 844 return (1); 845 } 846 mdb_printf("%s", doubletos(u.d, 7, 'e')); 847 848 } else if (e.cte_format == CTF_FP_LDOUBLE && 849 e.cte_bits == sizeof (long double) * NBBY) { 850 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld, 851 sizeof (u.ld), addr) != sizeof (u.ld)) { 852 mdb_warn("failed to read float at %llx", addr); 853 return (1); 854 } 855 mdb_printf("%s", longdoubletos(&u.ld, 16, 'e')); 856 857 } else { 858 mdb_printf("??? (unsupported FP format %u / %u bits\n", 859 e.cte_format, e.cte_bits); 860 } 861 } else 862 mdb_printf("??? (%s)", mdb_strerror(errno)); 863 #else 864 mdb_printf("<FLOAT>"); 865 #endif 866 return (0); 867 } 868 869 870 /* 871 * Print out a pointer value as a symbol name + offset or a hexadecimal value. 872 * If the pointer itself is a char *, we attempt to read a bit of the data 873 * referenced by the pointer and display it if it is a printable ASCII string. 874 */ 875 /*ARGSUSED*/ 876 static int 877 print_ptr(const char *type, const char *name, mdb_ctf_id_t id, 878 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 879 { 880 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 881 ctf_encoding_t e; 882 uintptr_t value; 883 char buf[256]; 884 ssize_t len; 885 886 if (!(pap->pa_flags & PA_SHOWVAL)) 887 return (0); 888 889 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 890 &value, sizeof (value), addr) != sizeof (value)) { 891 mdb_warn("failed to read %s pointer at %llx", name, addr); 892 return (1); 893 } 894 895 if (pap->pa_flags & PA_NOSYMBOLIC) { 896 mdb_printf("%#lx", value); 897 return (0); 898 } 899 900 mdb_printf("%a", value); 901 902 if (value == NULL || strcmp(type, "caddr_t") == 0) 903 return (0); 904 905 if (mdb_ctf_type_kind(base) == CTF_K_POINTER && 906 mdb_ctf_type_reference(base, &base) != -1 && 907 mdb_ctf_type_resolve(base, &base) != -1 && 908 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) { 909 if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as, 910 buf, sizeof (buf), value)) >= 0 && strisprint(buf)) { 911 if (len == sizeof (buf)) 912 (void) strabbr(buf, sizeof (buf)); 913 mdb_printf(" \"%s\"", buf); 914 } 915 } 916 917 return (0); 918 } 919 920 921 /* 922 * Print out a fixed-size array. We special-case arrays of characters 923 * and attempt to print them out as ASCII strings if possible. For other 924 * arrays, we iterate over a maximum of pa_armemlim members and call 925 * mdb_ctf_type_visit() again on each element to print its value. 926 */ 927 /*ARGSUSED*/ 928 static int 929 print_array(const char *type, const char *name, mdb_ctf_id_t id, 930 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 931 { 932 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 933 printarg_t pa = *pap; 934 ssize_t eltsize; 935 mdb_ctf_arinfo_t r; 936 ctf_encoding_t e; 937 uint_t i, kind, limit; 938 int d, sou; 939 char buf[8]; 940 char *str; 941 942 if (!(pap->pa_flags & PA_SHOWVAL)) 943 return (0); 944 945 if (pap->pa_depth == pap->pa_maxdepth) { 946 mdb_printf("[ ... ]"); 947 return (0); 948 } 949 950 /* 951 * Determine the base type and size of the array's content. If this 952 * fails, we cannot print anything and just give up. 953 */ 954 if (mdb_ctf_array_info(base, &r) == -1 || 955 mdb_ctf_type_resolve(r.mta_contents, &base) == -1 || 956 (eltsize = mdb_ctf_type_size(base)) == -1) { 957 mdb_printf("[ ??? ] (%s)", mdb_strerror(errno)); 958 return (0); 959 } 960 961 /* 962 * Read a few bytes and determine if the content appears to be 963 * printable ASCII characters. If so, read the entire array and 964 * attempt to display it as a string if it is printable. 965 */ 966 if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT || 967 r.mta_nelems <= pap->pa_arstrlim) && 968 mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) && 969 mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf, 970 MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) { 971 972 str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC); 973 str[r.mta_nelems] = '\0'; 974 975 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str, 976 r.mta_nelems, addr) != r.mta_nelems) { 977 mdb_warn("failed to read char array at %llx", addr); 978 return (1); 979 } 980 981 if (strisprint(str)) { 982 mdb_printf("[ \"%s\" ]", str); 983 return (0); 984 } 985 } 986 987 if (pap->pa_armemlim != MDB_ARR_NOLIMIT) 988 limit = MIN(r.mta_nelems, pap->pa_armemlim); 989 else 990 limit = r.mta_nelems; 991 992 if (limit == 0) { 993 mdb_printf("[ ... ]"); 994 return (0); 995 } 996 997 kind = mdb_ctf_type_kind(base); 998 sou = IS_COMPOSITE(kind); 999 1000 pa.pa_addr = addr; /* set base address to start of array */ 1001 pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth; 1002 pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */ 1003 pa.pa_depth = 0; /* reset depth to 0 for new scope */ 1004 pa.pa_prefix = NULL; 1005 1006 if (sou) { 1007 pa.pa_delim = "\n"; 1008 mdb_printf("[\n"); 1009 } else { 1010 pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR); 1011 pa.pa_delim = ", "; 1012 mdb_printf("[ "); 1013 } 1014 1015 for (i = 0; i < limit; i++, pa.pa_addr += eltsize) { 1016 if (i == limit - 1 && !sou) { 1017 if (limit < r.mta_nelems) 1018 pa.pa_delim = ", ... ]"; 1019 else 1020 pa.pa_delim = " ]"; 1021 } 1022 1023 if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) { 1024 mdb_warn("failed to print array data"); 1025 return (1); 1026 } 1027 } 1028 1029 if (sou) { 1030 for (d = pa.pa_depth - 1; d >= 0; d--) 1031 print_close_sou(&pa, d); 1032 1033 if (limit < r.mta_nelems) { 1034 mdb_printf("%*s... ]", 1035 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 1036 } else { 1037 mdb_printf("%*s]", 1038 (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 1039 } 1040 } 1041 1042 /* copy the hole array info, since it may have been grown */ 1043 pap->pa_holes = pa.pa_holes; 1044 pap->pa_nholes = pa.pa_nholes; 1045 1046 return (0); 1047 } 1048 1049 /* 1050 * Print out a struct or union header. We need only print the open brace 1051 * because mdb_ctf_type_visit() itself will automatically recurse through 1052 * all members of the given struct or union. 1053 */ 1054 /*ARGSUSED*/ 1055 static int 1056 print_sou(const char *type, const char *name, mdb_ctf_id_t id, 1057 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1058 { 1059 if (pap->pa_depth == pap->pa_maxdepth) 1060 mdb_printf("{ ... }"); 1061 else 1062 mdb_printf("{"); 1063 pap->pa_delim = "\n"; 1064 return (0); 1065 } 1066 1067 /* 1068 * Print an enum value. We attempt to convert the value to the corresponding 1069 * enum name and print that if possible. 1070 */ 1071 /*ARGSUSED*/ 1072 static int 1073 print_enum(const char *type, const char *name, mdb_ctf_id_t id, 1074 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1075 { 1076 mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 1077 const char *ename; 1078 int value; 1079 1080 if (!(pap->pa_flags & PA_SHOWVAL)) 1081 return (0); 1082 1083 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1084 &value, sizeof (value), addr) != sizeof (value)) { 1085 mdb_warn("failed to read %s integer at %llx", name, addr); 1086 return (1); 1087 } 1088 1089 if (pap->pa_flags & PA_INTHEX) 1090 mdb_printf("%#x", value); 1091 else 1092 mdb_printf("%#d", value); 1093 1094 ename = mdb_ctf_enum_name(base, value); 1095 mdb_printf(" (%s)", (ename != NULL)? ename : "???"); 1096 1097 return (0); 1098 } 1099 1100 /* 1101 * Just print a semicolon if we run into a forward tag. 1102 */ 1103 /*ARGSUSED*/ 1104 static int 1105 print_tag(const char *type, const char *name, mdb_ctf_id_t id, 1106 mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 1107 { 1108 if (pap->pa_flags & PA_SHOWVAL) 1109 mdb_printf("; "); 1110 1111 mdb_printf("(forward declaration)"); 1112 return (0); 1113 } 1114 1115 static void 1116 print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff) 1117 { 1118 ulong_t bits = endoff - off; 1119 ulong_t size = bits / NBBY; 1120 ctf_encoding_t e; 1121 1122 static const char *const name = "<<HOLE>>"; 1123 char type[MDB_SYM_NAMLEN]; 1124 1125 int bitfield = 1126 (off % NBBY != 0 || 1127 bits % NBBY != 0 || 1128 size > 8 || 1129 (size & (size - 1)) != 0); 1130 1131 ASSERT(off < endoff); 1132 1133 if (bits > NBBY * sizeof (uint64_t)) { 1134 ulong_t end; 1135 1136 /* 1137 * The hole is larger than the largest integer type. To 1138 * handle this, we split up the hole at 8-byte-aligned 1139 * boundaries, recursing to print each subsection. For 1140 * normal C structures, we'll loop at most twice. 1141 */ 1142 for (; off < endoff; off = end) { 1143 end = P2END(off, NBBY * sizeof (uint64_t)); 1144 if (end > endoff) 1145 end = endoff; 1146 1147 ASSERT((end - off) <= NBBY * sizeof (uint64_t)); 1148 print_hole(pap, depth, off, end); 1149 } 1150 ASSERT(end == endoff); 1151 1152 return; 1153 } 1154 1155 if (bitfield) 1156 (void) mdb_snprintf(type, sizeof (type), "unsigned"); 1157 else 1158 (void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits); 1159 1160 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 1161 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 1162 1163 if (pap->pa_flags & PA_SHOWADDR) { 1164 if (off % NBBY == 0) 1165 mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1166 else 1167 mdb_printf("%llx.%lx ", 1168 pap->pa_addr + off / NBBY, off % NBBY); 1169 } 1170 1171 if (pap->pa_flags & PA_SHOWTYPE) 1172 mdb_printf("%s ", type); 1173 1174 if (pap->pa_flags & PA_SHOWNAME) 1175 mdb_printf("%s", name); 1176 1177 if (bitfield && (pap->pa_flags & PA_SHOWTYPE)) 1178 mdb_printf(" :%d", bits); 1179 1180 mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : ""); 1181 1182 /* 1183 * We fake up a ctf_encoding_t, and use print_int_val() to print 1184 * the value. Holes are always processed as unsigned integers. 1185 */ 1186 bzero(&e, sizeof (e)); 1187 e.cte_format = 0; 1188 e.cte_offset = 0; 1189 e.cte_bits = bits; 1190 1191 if (print_int_val(type, &e, off, pap) != 0) 1192 mdb_iob_discard(mdb.m_out); 1193 else 1194 mdb_iob_puts(mdb.m_out, pap->pa_delim); 1195 } 1196 1197 /* 1198 * The print_close_sou() function is called for each structure or union 1199 * which has been completed. For structures, we detect and print any holes 1200 * before printing the closing brace. 1201 */ 1202 static void 1203 print_close_sou(printarg_t *pap, int newdepth) 1204 { 1205 int d = newdepth + pap->pa_nest; 1206 1207 if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) { 1208 ulong_t end = pap->pa_holes[d + 1].hi_offset; 1209 ulong_t expected = pap->pa_holes[d].hi_offset; 1210 1211 if (end < expected) 1212 print_hole(pap, newdepth + 1, end, expected); 1213 } 1214 mdb_printf("%*s}\n", d * pap->pa_tab, ""); 1215 } 1216 1217 static printarg_f *const printfuncs[] = { 1218 print_int, /* CTF_K_INTEGER */ 1219 print_float, /* CTF_K_FLOAT */ 1220 print_ptr, /* CTF_K_POINTER */ 1221 print_array, /* CTF_K_ARRAY */ 1222 print_ptr, /* CTF_K_FUNCTION */ 1223 print_sou, /* CTF_K_STRUCT */ 1224 print_sou, /* CTF_K_UNION */ 1225 print_enum, /* CTF_K_ENUM */ 1226 print_tag /* CTF_K_FORWARD */ 1227 }; 1228 1229 /* 1230 * The elt_print function is used as the mdb_ctf_type_visit callback. For 1231 * each element, we print an appropriate name prefix and then call the 1232 * print subroutine for this type class in the array above. 1233 */ 1234 static int 1235 elt_print(const char *name, mdb_ctf_id_t id, ulong_t off, int depth, void *data) 1236 { 1237 char type[MDB_SYM_NAMLEN]; 1238 int kind, rc, d; 1239 mdb_ctf_id_t base; 1240 printarg_t *pap = data; 1241 1242 for (d = pap->pa_depth - 1; d >= depth; d--) 1243 print_close_sou(pap, d); 1244 1245 if (depth > pap->pa_maxdepth) 1246 return (0); 1247 1248 if (mdb_ctf_type_resolve(id, &base) == -1 || 1249 (kind = mdb_ctf_type_kind(base)) == -1) 1250 return (-1); /* errno is set for us */ 1251 1252 if (mdb_ctf_type_name(id, type, sizeof (type)) == NULL) 1253 (void) strcpy(type, "(?)"); 1254 1255 if (pap->pa_flags & PA_SHOWHOLES) { 1256 ctf_encoding_t e; 1257 ssize_t nsize; 1258 ulong_t newoff; 1259 holeinfo_t *hole; 1260 int extra = IS_COMPOSITE(kind)? 1 : 0; 1261 1262 /* 1263 * grow the hole array, if necessary 1264 */ 1265 if (pap->pa_nest + depth + extra >= pap->pa_nholes) { 1266 int new = MAX(MAX(8, pap->pa_nholes * 2), 1267 pap->pa_nest + depth + extra + 1); 1268 1269 holeinfo_t *nhi = mdb_zalloc( 1270 sizeof (*nhi) * new, UM_NOSLEEP | UM_GC); 1271 1272 bcopy(pap->pa_holes, nhi, 1273 pap->pa_nholes * sizeof (*nhi)); 1274 1275 pap->pa_holes = nhi; 1276 pap->pa_nholes = new; 1277 } 1278 1279 hole = &pap->pa_holes[depth + pap->pa_nest]; 1280 1281 if (depth != 0 && off > hole->hi_offset) 1282 print_hole(pap, depth, hole->hi_offset, off); 1283 1284 /* compute the next expected offset */ 1285 if (kind == CTF_K_INTEGER && 1286 mdb_ctf_type_encoding(base, &e) == 0) 1287 newoff = off + e.cte_bits; 1288 else if ((nsize = mdb_ctf_type_size(base)) >= 0) 1289 newoff = off + nsize * NBBY; 1290 else { 1291 /* something bad happened, disable hole checking */ 1292 newoff = -1UL; /* ULONG_MAX */ 1293 } 1294 1295 hole->hi_offset = newoff; 1296 1297 if (IS_COMPOSITE(kind)) { 1298 hole->hi_isunion = (kind == CTF_K_UNION); 1299 hole++; 1300 hole->hi_offset = off; 1301 } 1302 } 1303 1304 if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 1305 mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 1306 1307 if (depth != 0) { 1308 if (pap->pa_flags & PA_SHOWADDR) { 1309 if (off % NBBY == 0) 1310 mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1311 else 1312 mdb_printf("%llx.%lx ", 1313 pap->pa_addr + off / NBBY, off % NBBY); 1314 } 1315 1316 if (pap->pa_flags & PA_SHOWTYPE) { 1317 mdb_printf("%s", type); 1318 /* 1319 * We want to avoid printing a trailing space when 1320 * dealing with pointers in a structure, so we end 1321 * up with: 1322 * 1323 * label_t *t_onfault = 0 1324 */ 1325 if (type[strlen(type) - 1] != '*') 1326 mdb_printf(" "); 1327 } 1328 1329 if (pap->pa_flags & PA_SHOWNAME) { 1330 if (depth == 1 && pap->pa_prefix != NULL) 1331 mdb_printf("%s%s", pap->pa_prefix, 1332 pap->pa_suffix); 1333 mdb_printf("%s", name); 1334 } 1335 1336 if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) { 1337 ctf_encoding_t e; 1338 1339 if (mdb_ctf_type_encoding(base, &e) == 0) { 1340 ulong_t bits = e.cte_bits; 1341 ulong_t size = bits / NBBY; 1342 1343 if (bits % NBBY != 0 || 1344 off % NBBY != 0 || 1345 size > 8 || 1346 size != mdb_ctf_type_size(base)) 1347 mdb_printf(" :%d", bits); 1348 } 1349 } 1350 1351 mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : ""); 1352 } else if (IS_SCALAR(kind) || pap->pa_maxdepth == 0) { 1353 if (pap->pa_flags & PA_SHOWADDR) { 1354 if (off % NBBY == 0) 1355 mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1356 else 1357 mdb_printf("%llx.%lx ", 1358 pap->pa_addr + off / NBBY, off % NBBY); 1359 } 1360 1361 if (pap->pa_flags & PA_SHOWTYPE) { 1362 mdb_printf("%s", type); 1363 /* 1364 * For the zero-depth case, we always print the trailing 1365 * space unless we also have a prefix. 1366 */ 1367 if (type[strlen(type) - 1] != '*' || 1368 !((pap->pa_flags & PA_SHOWNAME) && 1369 pap->pa_prefix != NULL)) 1370 mdb_printf(" ", type); 1371 } 1372 1373 if ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL) 1374 mdb_printf("%s", pap->pa_prefix); 1375 1376 if ((pap->pa_flags & PA_SHOWTYPE) && 1377 kind == CTF_K_INTEGER) { 1378 ctf_encoding_t e; 1379 1380 if (mdb_ctf_type_encoding(base, &e) == 0) { 1381 ulong_t bits = e.cte_bits; 1382 ulong_t size = bits / NBBY; 1383 1384 if (bits % NBBY != 0 || 1385 off % NBBY != 0 || 1386 size > 8 || 1387 size != mdb_ctf_type_size(base)) 1388 mdb_printf(" :%d", bits); 1389 } 1390 } 1391 1392 if ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL) 1393 mdb_printf("%s ", 1394 pap->pa_flags & PA_SHOWVAL ? " =" : ""); 1395 1396 if (pap->pa_prefix != NULL) 1397 name = pap->pa_prefix; 1398 } 1399 1400 pap->pa_depth = depth; 1401 if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) { 1402 mdb_warn("unknown ctf for %s type %s kind %d\n", 1403 name, type, kind); 1404 return (-1); 1405 } 1406 rc = printfuncs[kind - 1](type, name, id, base, off, pap); 1407 1408 if (rc != 0) 1409 mdb_iob_discard(mdb.m_out); 1410 else 1411 mdb_iob_puts(mdb.m_out, pap->pa_delim); 1412 1413 return (rc); 1414 } 1415 1416 /* 1417 * Special semantics for pipelines. 1418 */ 1419 static int 1420 pipe_print(mdb_ctf_id_t id, ulong_t off, void *data) 1421 { 1422 printarg_t *pap = data; 1423 ssize_t size; 1424 static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" }; 1425 uintptr_t value; 1426 uintptr_t addr = pap->pa_addr + off / NBBY; 1427 mdb_ctf_id_t base; 1428 ctf_encoding_t e; 1429 1430 union { 1431 uint64_t i8; 1432 uint32_t i4; 1433 uint16_t i2; 1434 uint8_t i1; 1435 } u; 1436 1437 if (mdb_ctf_type_resolve(id, &base) == -1) { 1438 mdb_warn("could not resolve type\n"); 1439 return (-1); 1440 } 1441 1442 /* 1443 * If the user gives -a, then always print out the address of the 1444 * member. 1445 */ 1446 if ((pap->pa_flags & PA_SHOWADDR)) { 1447 mdb_printf("%#lr\n", addr); 1448 return (0); 1449 } 1450 1451 again: 1452 switch (mdb_ctf_type_kind(base)) { 1453 case CTF_K_POINTER: 1454 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1455 &value, sizeof (value), addr) != sizeof (value)) { 1456 mdb_warn("failed to read pointer at %p", addr); 1457 return (-1); 1458 } 1459 mdb_printf("%#lr\n", value); 1460 break; 1461 1462 case CTF_K_INTEGER: 1463 case CTF_K_ENUM: 1464 if (mdb_ctf_type_encoding(base, &e) != 0) { 1465 mdb_printf("could not get type encoding\n"); 1466 return (-1); 1467 } 1468 1469 /* 1470 * For immediate values, we just print out the value. 1471 */ 1472 size = e.cte_bits / NBBY; 1473 if (size > 8 || (e.cte_bits % NBBY) != 0 || 1474 (size & (size - 1)) != 0) { 1475 return (print_bitfield(off, pap, &e)); 1476 } 1477 1478 if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, 1479 addr) != size) { 1480 mdb_warn("failed to read %lu bytes at %p", 1481 (ulong_t)size, pap->pa_addr); 1482 return (-1); 1483 } 1484 1485 switch (size) { 1486 case sizeof (uint8_t): 1487 mdb_printf(fsp[0], u.i1); 1488 break; 1489 case sizeof (uint16_t): 1490 mdb_printf(fsp[1], u.i2); 1491 break; 1492 case sizeof (uint32_t): 1493 mdb_printf(fsp[2], u.i4); 1494 break; 1495 case sizeof (uint64_t): 1496 mdb_printf(fsp[3], u.i8); 1497 break; 1498 } 1499 mdb_printf("\n"); 1500 break; 1501 1502 case CTF_K_FUNCTION: 1503 case CTF_K_FLOAT: 1504 case CTF_K_ARRAY: 1505 case CTF_K_UNKNOWN: 1506 case CTF_K_STRUCT: 1507 case CTF_K_UNION: 1508 case CTF_K_FORWARD: 1509 /* 1510 * For these types, always print the address of the member 1511 */ 1512 mdb_printf("%#lr\n", addr); 1513 break; 1514 1515 default: 1516 mdb_warn("unknown type %d", mdb_ctf_type_kind(base)); 1517 break; 1518 } 1519 1520 return (0); 1521 } 1522 1523 static int 1524 parse_delimiter(char **strp) 1525 { 1526 switch (**strp) { 1527 case '\0': 1528 return (MEMBER_DELIM_DONE); 1529 1530 case '.': 1531 *strp = *strp + 1; 1532 return (MEMBER_DELIM_DOT); 1533 1534 case '[': 1535 *strp = *strp + 1; 1536 return (MEMBER_DELIM_LBR); 1537 1538 case '-': 1539 *strp = *strp + 1; 1540 if (**strp == '>') { 1541 *strp = *strp + 1; 1542 return (MEMBER_DELIM_PTR); 1543 } 1544 *strp = *strp - 1; 1545 /*FALLTHROUGH*/ 1546 default: 1547 return (MEMBER_DELIM_ERR); 1548 } 1549 } 1550 1551 static int 1552 deref(printarg_t *pap, size_t size) 1553 { 1554 uint32_t a32; 1555 mdb_tgt_as_t as = pap->pa_as; 1556 mdb_tgt_addr_t *ap = &pap->pa_addr; 1557 1558 if (size == sizeof (mdb_tgt_addr_t)) { 1559 if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) { 1560 mdb_warn("could not dereference pointer %llx\n", *ap); 1561 return (-1); 1562 } 1563 } else { 1564 if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) { 1565 mdb_warn("could not dereference pointer %x\n", *ap); 1566 return (-1); 1567 } 1568 1569 *ap = (mdb_tgt_addr_t)a32; 1570 } 1571 1572 /* 1573 * We've dereferenced at least once, we must be on the real 1574 * target. If we were in the immediate target, reset to the real 1575 * target; it's reset as needed when we return to the print 1576 * routines. 1577 */ 1578 if (pap->pa_tgt == pap->pa_immtgt) 1579 pap->pa_tgt = pap->pa_realtgt; 1580 1581 return (0); 1582 } 1583 1584 static int 1585 parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id, 1586 mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref) 1587 { 1588 int delim; 1589 char member[64]; 1590 char buf[128]; 1591 uint_t index; 1592 char *start = (char *)str; 1593 char *end; 1594 ulong_t off = 0; 1595 mdb_ctf_arinfo_t ar; 1596 mdb_ctf_id_t rid; 1597 int kind; 1598 ssize_t size; 1599 int non_array = FALSE; 1600 1601 /* 1602 * id always has the unresolved type for printing error messages 1603 * that include the type; rid always has the resolved type for 1604 * use in mdb_ctf_* calls. It is possible for this command to fail, 1605 * however, if the resolved type is in the parent and it is currently 1606 * unavailable. Note that we also can't print out the name of the 1607 * type, since that would also rely on looking up the resolved name. 1608 */ 1609 if (mdb_ctf_type_resolve(id, &rid) != 0) { 1610 mdb_warn("failed to resolve type"); 1611 return (-1); 1612 } 1613 1614 delim = parse_delimiter(&start); 1615 /* 1616 * If the user fails to specify an initial delimiter, guess -> for 1617 * pointer types and . for non-pointer types. 1618 */ 1619 if (delim == MEMBER_DELIM_ERR) 1620 delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ? 1621 MEMBER_DELIM_PTR : MEMBER_DELIM_DOT; 1622 1623 *last_deref = FALSE; 1624 1625 while (delim != MEMBER_DELIM_DONE) { 1626 switch (delim) { 1627 case MEMBER_DELIM_PTR: 1628 kind = mdb_ctf_type_kind(rid); 1629 if (kind != CTF_K_POINTER) { 1630 mdb_warn("%s is not a pointer type\n", 1631 mdb_ctf_type_name(id, buf, sizeof (buf))); 1632 return (-1); 1633 } 1634 1635 size = mdb_ctf_type_size(id); 1636 if (deref(pap, size) != 0) 1637 return (-1); 1638 1639 (void) mdb_ctf_type_reference(rid, &id); 1640 (void) mdb_ctf_type_resolve(id, &rid); 1641 1642 off = 0; 1643 break; 1644 1645 case MEMBER_DELIM_DOT: 1646 kind = mdb_ctf_type_kind(rid); 1647 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 1648 mdb_warn("%s is not a struct or union type\n", 1649 mdb_ctf_type_name(id, buf, sizeof (buf))); 1650 return (-1); 1651 } 1652 break; 1653 1654 case MEMBER_DELIM_LBR: 1655 end = strchr(start, ']'); 1656 if (end == NULL) { 1657 mdb_warn("no trailing ']'\n"); 1658 return (-1); 1659 } 1660 1661 (void) mdb_snprintf(member, end - start + 1, start); 1662 1663 index = mdb_strtoull(member); 1664 1665 switch (mdb_ctf_type_kind(rid)) { 1666 case CTF_K_POINTER: 1667 size = mdb_ctf_type_size(rid); 1668 1669 if (deref(pap, size) != 0) 1670 return (-1); 1671 1672 (void) mdb_ctf_type_reference(rid, &id); 1673 (void) mdb_ctf_type_resolve(id, &rid); 1674 1675 size = mdb_ctf_type_size(id); 1676 if (size <= 0) { 1677 mdb_warn("cannot dereference void " 1678 "type\n"); 1679 return (-1); 1680 } 1681 1682 pap->pa_addr += index * size; 1683 off = 0; 1684 1685 if (index == 0 && non_array) 1686 *last_deref = TRUE; 1687 break; 1688 1689 case CTF_K_ARRAY: 1690 (void) mdb_ctf_array_info(rid, &ar); 1691 1692 if (index >= ar.mta_nelems) { 1693 mdb_warn("index %r is outside of " 1694 "array bounds [0 .. %r]\n", 1695 index, ar.mta_nelems - 1); 1696 } 1697 1698 id = ar.mta_contents; 1699 (void) mdb_ctf_type_resolve(id, &rid); 1700 1701 size = mdb_ctf_type_size(id); 1702 if (size <= 0) { 1703 mdb_warn("cannot dereference void " 1704 "type\n"); 1705 return (-1); 1706 } 1707 1708 pap->pa_addr += index * size; 1709 off = 0; 1710 break; 1711 1712 default: 1713 mdb_warn("cannot index into non-array, " 1714 "non-pointer type\n"); 1715 return (-1); 1716 } 1717 1718 start = end + 1; 1719 delim = parse_delimiter(&start); 1720 continue; 1721 1722 case MEMBER_DELIM_ERR: 1723 default: 1724 mdb_warn("'%c' is not a valid delimiter\n", *start); 1725 return (-1); 1726 } 1727 1728 *last_deref = FALSE; 1729 non_array = TRUE; 1730 1731 /* 1732 * Find the end of the member name; assume that a member 1733 * name is at least one character long. 1734 */ 1735 for (end = start + 1; isalnum(*end) || *end == '_'; end++) 1736 continue; 1737 1738 (void) mdb_snprintf(member, end - start + 1, start); 1739 1740 if (mdb_ctf_member_info(rid, member, &off, &id) != 0) { 1741 mdb_warn("failed to find member %s of %s", member, 1742 mdb_ctf_type_name(id, buf, sizeof (buf))); 1743 return (-1); 1744 } 1745 (void) mdb_ctf_type_resolve(id, &rid); 1746 1747 pap->pa_addr += off / NBBY; 1748 1749 start = end; 1750 delim = parse_delimiter(&start); 1751 } 1752 1753 1754 *idp = id; 1755 *offp = off; 1756 1757 return (0); 1758 } 1759 1760 /* 1761 * Recursively descend a print a given data structure. We create a struct of 1762 * the relevant print arguments and then call mdb_ctf_type_visit() to do the 1763 * traversal, using elt_print() as the callback for each element. 1764 */ 1765 /*ARGSUSED*/ 1766 int 1767 cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1768 { 1769 uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT; 1770 uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE; 1771 uintptr_t opt_s = (uintptr_t)-1ul; 1772 int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0; 1773 mdb_ctf_id_t id; 1774 int err = DCMD_OK; 1775 1776 mdb_tgt_t *t = mdb.m_target; 1777 printarg_t pa; 1778 int d, i; 1779 1780 char s_name[MDB_SYM_NAMLEN]; 1781 mdb_syminfo_t s_info; 1782 GElf_Sym sym; 1783 1784 i = mdb_getopts(argc, argv, 1785 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags, 1786 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 1787 'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags, 1788 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags, 1789 'L', MDB_OPT_SETBITS, TRUE, &opt_L, 1790 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags, 1791 'p', MDB_OPT_SETBITS, TRUE, &opt_p, 1792 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags, 1793 'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags, 1794 'c', MDB_OPT_UINTPTR, &opt_c, 1795 'l', MDB_OPT_UINTPTR, &opt_l, 1796 'i', MDB_OPT_SETBITS, TRUE, &opt_i, 1797 's', MDB_OPT_UINTPTR, &opt_s, 1798 NULL); 1799 1800 if (uflags & PA_INTHEX) 1801 uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */ 1802 1803 uflags |= PA_SHOWNAME; 1804 1805 if (opt_p && opt_i) { 1806 mdb_warn("-p and -i options are incompatible\n"); 1807 return (DCMD_ERR); 1808 } 1809 1810 argc -= i; 1811 argv += i; 1812 1813 if (argc != 0 && argv->a_type == MDB_TYPE_STRING) { 1814 const char *t_name = s_name; 1815 int ret; 1816 1817 if (strchr("+-", argv->a_un.a_str[0]) != NULL) 1818 return (DCMD_USAGE); 1819 1820 if ((ret = args_to_typename(&argc, &argv, s_name, 1821 sizeof (s_name))) != 0) 1822 return (ret); 1823 1824 if (mdb_ctf_lookup_by_name(t_name, &id) != 0) { 1825 if (!(flags & DCMD_ADDRSPEC) || opt_i || 1826 addr_to_sym(t, addr, s_name, sizeof (s_name), 1827 &sym, &s_info) == NULL || 1828 mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 1829 1830 mdb_warn("failed to look up type %s", t_name); 1831 return (DCMD_ABORT); 1832 } 1833 } else { 1834 argc--; 1835 argv++; 1836 } 1837 1838 } else if (!(flags & DCMD_ADDRSPEC) || opt_i) { 1839 return (DCMD_USAGE); 1840 1841 } else if (addr_to_sym(t, addr, s_name, sizeof (s_name), 1842 &sym, &s_info) == NULL) { 1843 mdb_warn("no symbol information for %a", addr); 1844 return (DCMD_ERR); 1845 1846 } else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 1847 mdb_warn("no type data available for %a [%u]", addr, 1848 s_info.sym_id); 1849 return (DCMD_ERR); 1850 } 1851 1852 pa.pa_tgt = mdb.m_target; 1853 pa.pa_realtgt = pa.pa_tgt; 1854 pa.pa_immtgt = NULL; 1855 pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT; 1856 pa.pa_armemlim = mdb.m_armemlim; 1857 pa.pa_arstrlim = mdb.m_arstrlim; 1858 pa.pa_delim = "\n"; 1859 pa.pa_flags = uflags; 1860 pa.pa_nest = 0; 1861 pa.pa_tab = 4; 1862 pa.pa_prefix = NULL; 1863 pa.pa_suffix = NULL; 1864 pa.pa_holes = NULL; 1865 pa.pa_nholes = 0; 1866 pa.pa_depth = 0; 1867 pa.pa_maxdepth = opt_s; 1868 1869 if ((flags & DCMD_ADDRSPEC) && !opt_i) 1870 pa.pa_addr = opt_p ? mdb_get_dot() : addr; 1871 else 1872 pa.pa_addr = NULL; 1873 1874 if (opt_i) { 1875 const char *vargv[2]; 1876 uintmax_t dot = mdb_get_dot(); 1877 size_t outsize = mdb_ctf_type_size(id); 1878 vargv[0] = (const char *)˙ 1879 vargv[1] = (const char *)&outsize; 1880 pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create, 1881 0, 2, vargv); 1882 pa.pa_tgt = pa.pa_immtgt; 1883 } 1884 1885 if (opt_c != MDB_ARR_NOLIMIT) 1886 pa.pa_arstrlim = opt_c; 1887 if (opt_C) 1888 pa.pa_arstrlim = MDB_ARR_NOLIMIT; 1889 if (opt_l != MDB_ARR_NOLIMIT) 1890 pa.pa_armemlim = opt_l; 1891 if (opt_L) 1892 pa.pa_armemlim = MDB_ARR_NOLIMIT; 1893 1894 if (argc > 0) { 1895 for (i = 0; i < argc; i++) { 1896 mdb_ctf_id_t mid; 1897 int last_deref; 1898 ulong_t off; 1899 int kind; 1900 char buf[MDB_SYM_NAMLEN]; 1901 1902 mdb_tgt_t *oldtgt = pa.pa_tgt; 1903 mdb_tgt_as_t oldas = pa.pa_as; 1904 mdb_tgt_addr_t oldaddr = pa.pa_addr; 1905 1906 if (argv->a_type == MDB_TYPE_STRING) { 1907 const char *member = argv[i].a_un.a_str; 1908 mdb_ctf_id_t rid; 1909 1910 if (parse_member(&pa, member, id, &mid, 1911 &off, &last_deref) != 0) { 1912 err = DCMD_ABORT; 1913 goto out; 1914 } 1915 1916 /* 1917 * If the member string ends with a "[0]" 1918 * (last_deref * is true) and the type is a 1919 * structure or union, * print "->" rather 1920 * than "[0]." in elt_print. 1921 */ 1922 (void) mdb_ctf_type_resolve(mid, &rid); 1923 kind = mdb_ctf_type_kind(rid); 1924 if (last_deref && IS_SOU(kind)) { 1925 char *end; 1926 (void) mdb_snprintf(buf, sizeof (buf), 1927 "%s", member); 1928 end = strrchr(buf, '['); 1929 *end = '\0'; 1930 pa.pa_suffix = "->"; 1931 member = &buf[0]; 1932 } else if (IS_SOU(kind)) { 1933 pa.pa_suffix = "."; 1934 } else { 1935 pa.pa_suffix = ""; 1936 } 1937 1938 pa.pa_prefix = member; 1939 } else { 1940 ulong_t moff; 1941 1942 moff = (ulong_t)argv[i].a_un.a_val; 1943 1944 if (mdb_ctf_offset_to_name(id, moff * NBBY, 1945 buf, sizeof (buf), 0, &mid, &off) == -1) { 1946 mdb_warn("invalid offset %lx\n", moff); 1947 err = DCMD_ABORT; 1948 goto out; 1949 } 1950 1951 pa.pa_prefix = buf; 1952 pa.pa_addr += moff - off / NBBY; 1953 pa.pa_suffix = strlen(buf) == 0 ? "" : "."; 1954 } 1955 1956 off %= NBBY; 1957 if (flags & DCMD_PIPE_OUT) { 1958 if (pipe_print(mid, off, &pa) != 0) { 1959 mdb_warn("failed to print type"); 1960 err = DCMD_ERR; 1961 goto out; 1962 } 1963 } else if (off != 0) { 1964 if (elt_print("", mid, off, 0, &pa) != 0) { 1965 mdb_warn("failed to print type"); 1966 err = DCMD_ERR; 1967 goto out; 1968 } 1969 } else { 1970 if (mdb_ctf_type_visit(mid, elt_print, 1971 &pa) == -1) { 1972 mdb_warn("failed to print type"); 1973 err = DCMD_ERR; 1974 goto out; 1975 } 1976 1977 for (d = pa.pa_depth - 1; d >= 0; d--) 1978 print_close_sou(&pa, d); 1979 } 1980 1981 pa.pa_depth = 0; 1982 pa.pa_tgt = oldtgt; 1983 pa.pa_as = oldas; 1984 pa.pa_addr = oldaddr; 1985 pa.pa_delim = "\n"; 1986 } 1987 1988 } else if (flags & DCMD_PIPE_OUT) { 1989 if (pipe_print(id, 0, &pa) != 0) { 1990 mdb_warn("failed to print type"); 1991 err = DCMD_ERR; 1992 goto out; 1993 } 1994 } else { 1995 if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) { 1996 mdb_warn("failed to print type"); 1997 err = DCMD_ERR; 1998 goto out; 1999 } 2000 2001 for (d = pa.pa_depth - 1; d >= 0; d--) 2002 print_close_sou(&pa, d); 2003 } 2004 2005 mdb_set_dot(addr + mdb_ctf_type_size(id)); 2006 err = DCMD_OK; 2007 out: 2008 if (pa.pa_immtgt) 2009 mdb_tgt_destroy(pa.pa_immtgt); 2010 return (err); 2011 } 2012 2013 void 2014 print_help(void) 2015 { 2016 mdb_printf("-a show address of object\n" 2017 "-c limit limit the length of character arrays\n" 2018 "-C unlimit the length of character arrays\n" 2019 "-d output values in decimal\n" 2020 "-h print holes in structures\n" 2021 "-l limit limit the length of standard arrays\n" 2022 "-L unlimit the length of standard arrays\n" 2023 "-n don't print pointers as symbol offsets\n" 2024 "-p interpret address as a physical memory address\n" 2025 "-t show type of object\n" 2026 "-i interpret address as data of the given type\n" 2027 "-x output values in hexadecimal\n" 2028 "-s depth limit the recursion depth\n" 2029 "\n" 2030 "type may be omitted if the C type of addr can be inferred.\n" 2031 "\n" 2032 "Members may be specified with standard C syntax using the\n" 2033 "array indexing operator \"[index]\", structure member\n" 2034 "operator \".\", or structure pointer operator \"->\".\n" 2035 "\n" 2036 "Offsets must use the $[ expression ] syntax\n"); 2037 } 2038