17c478bd9Sstevel@tonic-gate /* 27c478bd9Sstevel@tonic-gate * CDDL HEADER START 37c478bd9Sstevel@tonic-gate * 47c478bd9Sstevel@tonic-gate * The contents of this file are subject to the terms of the 5bf5197d8Sjwadams * Common Development and Distribution License (the "License"). 6bf5197d8Sjwadams * You may not use this file except in compliance with the License. 77c478bd9Sstevel@tonic-gate * 87c478bd9Sstevel@tonic-gate * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 97c478bd9Sstevel@tonic-gate * or http://www.opensolaris.org/os/licensing. 107c478bd9Sstevel@tonic-gate * See the License for the specific language governing permissions 117c478bd9Sstevel@tonic-gate * and limitations under the License. 127c478bd9Sstevel@tonic-gate * 137c478bd9Sstevel@tonic-gate * When distributing Covered Code, include this CDDL HEADER in each 147c478bd9Sstevel@tonic-gate * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 157c478bd9Sstevel@tonic-gate * If applicable, add the following below this CDDL HEADER, with the 167c478bd9Sstevel@tonic-gate * fields enclosed by brackets "[]" replaced with your own identifying 177c478bd9Sstevel@tonic-gate * information: Portions Copyright [yyyy] [name of copyright owner] 187c478bd9Sstevel@tonic-gate * 197c478bd9Sstevel@tonic-gate * CDDL HEADER END 207c478bd9Sstevel@tonic-gate */ 217c478bd9Sstevel@tonic-gate /* 22cce40297SJonathan Adams * Copyright 2009 Sun Microsystems, Inc. All rights reserved. 237c478bd9Sstevel@tonic-gate * Use is subject to license terms. 247c478bd9Sstevel@tonic-gate */ 257c478bd9Sstevel@tonic-gate 267c478bd9Sstevel@tonic-gate #include <mdb/mdb_modapi.h> 277c478bd9Sstevel@tonic-gate #include <mdb/mdb_target.h> 287c478bd9Sstevel@tonic-gate #include <mdb/mdb_argvec.h> 297c478bd9Sstevel@tonic-gate #include <mdb/mdb_string.h> 307c478bd9Sstevel@tonic-gate #include <mdb/mdb_stdlib.h> 317c478bd9Sstevel@tonic-gate #include <mdb/mdb_err.h> 327c478bd9Sstevel@tonic-gate #include <mdb/mdb_debug.h> 337c478bd9Sstevel@tonic-gate #include <mdb/mdb_fmt.h> 347c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf.h> 357c478bd9Sstevel@tonic-gate #include <mdb/mdb_ctf_impl.h> 367c478bd9Sstevel@tonic-gate #include <mdb/mdb.h> 377c478bd9Sstevel@tonic-gate 387c478bd9Sstevel@tonic-gate #include <sys/isa_defs.h> 397c478bd9Sstevel@tonic-gate #include <sys/param.h> 407c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h> 417c478bd9Sstevel@tonic-gate #include <strings.h> 427c478bd9Sstevel@tonic-gate #include <libctf.h> 437c478bd9Sstevel@tonic-gate #include <ctype.h> 447c478bd9Sstevel@tonic-gate 457c478bd9Sstevel@tonic-gate typedef struct holeinfo { 467c478bd9Sstevel@tonic-gate ulong_t hi_offset; /* expected offset */ 477c478bd9Sstevel@tonic-gate uchar_t hi_isunion; /* represents a union */ 487c478bd9Sstevel@tonic-gate } holeinfo_t; 497c478bd9Sstevel@tonic-gate 507c478bd9Sstevel@tonic-gate typedef struct printarg { 517c478bd9Sstevel@tonic-gate mdb_tgt_t *pa_tgt; /* current target */ 527c478bd9Sstevel@tonic-gate mdb_tgt_t *pa_realtgt; /* real target (for -i) */ 537c478bd9Sstevel@tonic-gate mdb_tgt_t *pa_immtgt; /* immediate target (for -i) */ 547c478bd9Sstevel@tonic-gate mdb_tgt_as_t pa_as; /* address space to use for i/o */ 557c478bd9Sstevel@tonic-gate mdb_tgt_addr_t pa_addr; /* base address for i/o */ 567c478bd9Sstevel@tonic-gate ulong_t pa_armemlim; /* limit on array elements to print */ 577c478bd9Sstevel@tonic-gate ulong_t pa_arstrlim; /* limit on array chars to print */ 587c478bd9Sstevel@tonic-gate const char *pa_delim; /* element delimiter string */ 597c478bd9Sstevel@tonic-gate const char *pa_prefix; /* element prefix string */ 607c478bd9Sstevel@tonic-gate const char *pa_suffix; /* element suffix string */ 617c478bd9Sstevel@tonic-gate holeinfo_t *pa_holes; /* hole detection information */ 627c478bd9Sstevel@tonic-gate int pa_nholes; /* size of holes array */ 637c478bd9Sstevel@tonic-gate int pa_flags; /* formatting flags (see below) */ 647c478bd9Sstevel@tonic-gate int pa_depth; /* previous depth */ 657c478bd9Sstevel@tonic-gate int pa_nest; /* array nesting depth */ 667c478bd9Sstevel@tonic-gate int pa_tab; /* tabstop width */ 67bf5197d8Sjwadams uint_t pa_maxdepth; /* Limit max depth */ 687c478bd9Sstevel@tonic-gate } printarg_t; 697c478bd9Sstevel@tonic-gate 707c478bd9Sstevel@tonic-gate #define PA_SHOWTYPE 0x001 /* print type name */ 71cce40297SJonathan Adams #define PA_SHOWBASETYPE 0x002 /* print base type name */ 72cce40297SJonathan Adams #define PA_SHOWNAME 0x004 /* print member name */ 73cce40297SJonathan Adams #define PA_SHOWADDR 0x008 /* print address */ 74cce40297SJonathan Adams #define PA_SHOWVAL 0x010 /* print value */ 75cce40297SJonathan Adams #define PA_SHOWHOLES 0x020 /* print holes in structs */ 76cce40297SJonathan Adams #define PA_INTHEX 0x040 /* print integer values in hex */ 77cce40297SJonathan Adams #define PA_INTDEC 0x080 /* print integer values in decimal */ 78cce40297SJonathan Adams #define PA_NOSYMBOLIC 0x100 /* don't print ptrs as func+offset */ 797c478bd9Sstevel@tonic-gate 807c478bd9Sstevel@tonic-gate #define IS_CHAR(e) \ 817c478bd9Sstevel@tonic-gate (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == \ 827c478bd9Sstevel@tonic-gate (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) 837c478bd9Sstevel@tonic-gate 847c478bd9Sstevel@tonic-gate #define COMPOSITE_MASK ((1 << CTF_K_STRUCT) | \ 857c478bd9Sstevel@tonic-gate (1 << CTF_K_UNION) | (1 << CTF_K_ARRAY)) 867c478bd9Sstevel@tonic-gate #define IS_COMPOSITE(k) (((1 << k) & COMPOSITE_MASK) != 0) 877c478bd9Sstevel@tonic-gate 887c478bd9Sstevel@tonic-gate #define SOU_MASK ((1 << CTF_K_STRUCT) | (1 << CTF_K_UNION)) 897c478bd9Sstevel@tonic-gate #define IS_SOU(k) (((1 << k) & SOU_MASK) != 0) 907c478bd9Sstevel@tonic-gate 917c478bd9Sstevel@tonic-gate #define MEMBER_DELIM_ERR -1 927c478bd9Sstevel@tonic-gate #define MEMBER_DELIM_DONE 0 937c478bd9Sstevel@tonic-gate #define MEMBER_DELIM_PTR 1 947c478bd9Sstevel@tonic-gate #define MEMBER_DELIM_DOT 2 957c478bd9Sstevel@tonic-gate #define MEMBER_DELIM_LBR 3 967c478bd9Sstevel@tonic-gate 977c478bd9Sstevel@tonic-gate typedef int printarg_f(const char *, const char *, 987c478bd9Sstevel@tonic-gate mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, printarg_t *); 997c478bd9Sstevel@tonic-gate 100cce40297SJonathan Adams static int elt_print(const char *, mdb_ctf_id_t, mdb_ctf_id_t, ulong_t, int, 101cce40297SJonathan Adams void *); 1027c478bd9Sstevel@tonic-gate static void print_close_sou(printarg_t *, int); 1037c478bd9Sstevel@tonic-gate 1047c478bd9Sstevel@tonic-gate /* 1057c478bd9Sstevel@tonic-gate * Given an address, look up the symbol ID of the specified symbol in its 1067c478bd9Sstevel@tonic-gate * containing module. We only support lookups for exact matches. 1077c478bd9Sstevel@tonic-gate */ 1087c478bd9Sstevel@tonic-gate static const char * 1097c478bd9Sstevel@tonic-gate addr_to_sym(mdb_tgt_t *t, uintptr_t addr, char *name, size_t namelen, 1107c478bd9Sstevel@tonic-gate GElf_Sym *symp, mdb_syminfo_t *sip) 1117c478bd9Sstevel@tonic-gate { 1127c478bd9Sstevel@tonic-gate const mdb_map_t *mp; 1137c478bd9Sstevel@tonic-gate const char *p; 1147c478bd9Sstevel@tonic-gate 1157c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_addr(t, addr, MDB_TGT_SYM_EXACT, name, 1167c478bd9Sstevel@tonic-gate namelen, NULL, NULL) == -1) 1177c478bd9Sstevel@tonic-gate return (NULL); /* address does not exactly match a symbol */ 1187c478bd9Sstevel@tonic-gate 1197c478bd9Sstevel@tonic-gate if ((p = strrsplit(name, '`')) != NULL) { 1207c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_name(t, name, p, symp, sip) == -1) 1217c478bd9Sstevel@tonic-gate return (NULL); 1227c478bd9Sstevel@tonic-gate return (p); 1237c478bd9Sstevel@tonic-gate } 1247c478bd9Sstevel@tonic-gate 1257c478bd9Sstevel@tonic-gate if ((mp = mdb_tgt_addr_to_map(t, addr)) == NULL) 1267c478bd9Sstevel@tonic-gate return (NULL); /* address does not fall within a mapping */ 1277c478bd9Sstevel@tonic-gate 1287c478bd9Sstevel@tonic-gate if (mdb_tgt_lookup_by_name(t, mp->map_name, name, symp, sip) == -1) 1297c478bd9Sstevel@tonic-gate return (NULL); 1307c478bd9Sstevel@tonic-gate 1317c478bd9Sstevel@tonic-gate return (name); 1327c478bd9Sstevel@tonic-gate } 1337c478bd9Sstevel@tonic-gate 1347c478bd9Sstevel@tonic-gate /* 1357c478bd9Sstevel@tonic-gate * This lets dcmds be a little fancy with their processing of type arguments 1367c478bd9Sstevel@tonic-gate * while still treating them more or less as a single argument. 1377c478bd9Sstevel@tonic-gate * For example, if a command is invokes like this: 1387c478bd9Sstevel@tonic-gate * 1397c478bd9Sstevel@tonic-gate * ::<dcmd> proc_t ... 1407c478bd9Sstevel@tonic-gate * 1417c478bd9Sstevel@tonic-gate * this function will just copy "proc_t" into the provided buffer. If the 1427c478bd9Sstevel@tonic-gate * command is instead invoked like this: 1437c478bd9Sstevel@tonic-gate * 1447c478bd9Sstevel@tonic-gate * ::<dcmd> struct proc ... 1457c478bd9Sstevel@tonic-gate * 1467c478bd9Sstevel@tonic-gate * this function will place the string "struct proc" into the provided buffer 1477c478bd9Sstevel@tonic-gate * and increment the caller's argv and argc. This allows the caller to still 1487c478bd9Sstevel@tonic-gate * treat the type argument logically as it would an other atomic argument. 1497c478bd9Sstevel@tonic-gate */ 1507c478bd9Sstevel@tonic-gate int 1517c478bd9Sstevel@tonic-gate args_to_typename(int *argcp, const mdb_arg_t **argvp, char *buf, size_t len) 1527c478bd9Sstevel@tonic-gate { 1537c478bd9Sstevel@tonic-gate int argc = *argcp; 1547c478bd9Sstevel@tonic-gate const mdb_arg_t *argv = *argvp; 1557c478bd9Sstevel@tonic-gate 1567c478bd9Sstevel@tonic-gate if (argc < 1 || argv->a_type != MDB_TYPE_STRING) 1577c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1587c478bd9Sstevel@tonic-gate 1597c478bd9Sstevel@tonic-gate if (strcmp(argv->a_un.a_str, "struct") == 0 || 1607c478bd9Sstevel@tonic-gate strcmp(argv->a_un.a_str, "enum") == 0 || 1617c478bd9Sstevel@tonic-gate strcmp(argv->a_un.a_str, "union") == 0) { 1627c478bd9Sstevel@tonic-gate if (argc <= 1) { 1637c478bd9Sstevel@tonic-gate mdb_warn("%s is not a valid type\n", argv->a_un.a_str); 1647c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 1657c478bd9Sstevel@tonic-gate } 1667c478bd9Sstevel@tonic-gate 1677c478bd9Sstevel@tonic-gate if (argv[1].a_type != MDB_TYPE_STRING) 1687c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1697c478bd9Sstevel@tonic-gate 1707c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, len, "%s %s", 1717c478bd9Sstevel@tonic-gate argv[0].a_un.a_str, argv[1].a_un.a_str); 1727c478bd9Sstevel@tonic-gate 1737c478bd9Sstevel@tonic-gate *argcp = argc - 1; 1747c478bd9Sstevel@tonic-gate *argvp = argv + 1; 1757c478bd9Sstevel@tonic-gate } else { 1767c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, len, "%s", argv[0].a_un.a_str); 1777c478bd9Sstevel@tonic-gate } 1787c478bd9Sstevel@tonic-gate 1797c478bd9Sstevel@tonic-gate return (0); 1807c478bd9Sstevel@tonic-gate } 1817c478bd9Sstevel@tonic-gate 1827c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 1837c478bd9Sstevel@tonic-gate int 1847c478bd9Sstevel@tonic-gate cmd_sizeof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 1857c478bd9Sstevel@tonic-gate { 1867c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 1877c478bd9Sstevel@tonic-gate char tn[MDB_SYM_NAMLEN]; 1887c478bd9Sstevel@tonic-gate int ret; 1897c478bd9Sstevel@tonic-gate 1907c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) 1917c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1927c478bd9Sstevel@tonic-gate 1937c478bd9Sstevel@tonic-gate if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 1947c478bd9Sstevel@tonic-gate return (ret); 1957c478bd9Sstevel@tonic-gate 1967c478bd9Sstevel@tonic-gate if (argc != 1) 1977c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 1987c478bd9Sstevel@tonic-gate 1997c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 2007c478bd9Sstevel@tonic-gate mdb_warn("failed to look up type %s", tn); 2017c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2027c478bd9Sstevel@tonic-gate } 2037c478bd9Sstevel@tonic-gate 2047c478bd9Sstevel@tonic-gate if (flags & DCMD_PIPE_OUT) 2057c478bd9Sstevel@tonic-gate mdb_printf("%#lr\n", mdb_ctf_type_size(id)); 2067c478bd9Sstevel@tonic-gate else 2077c478bd9Sstevel@tonic-gate mdb_printf("sizeof (%s) = %#lr\n", tn, mdb_ctf_type_size(id)); 2087c478bd9Sstevel@tonic-gate 2097c478bd9Sstevel@tonic-gate return (DCMD_OK); 2107c478bd9Sstevel@tonic-gate } 2117c478bd9Sstevel@tonic-gate 2127c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 2137c478bd9Sstevel@tonic-gate int 2147c478bd9Sstevel@tonic-gate cmd_offsetof(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 2157c478bd9Sstevel@tonic-gate { 2167c478bd9Sstevel@tonic-gate const char *member; 2177c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 2187c478bd9Sstevel@tonic-gate ulong_t off; 2197c478bd9Sstevel@tonic-gate char tn[MDB_SYM_NAMLEN]; 220*e0ad97e3SJonathan Adams ssize_t sz; 2217c478bd9Sstevel@tonic-gate int ret; 2227c478bd9Sstevel@tonic-gate 2237c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) 2247c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 2257c478bd9Sstevel@tonic-gate 2267c478bd9Sstevel@tonic-gate if ((ret = args_to_typename(&argc, &argv, tn, sizeof (tn))) != 0) 2277c478bd9Sstevel@tonic-gate return (ret); 2287c478bd9Sstevel@tonic-gate 2297c478bd9Sstevel@tonic-gate if (argc != 2 || argv[1].a_type != MDB_TYPE_STRING) 2307c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 2317c478bd9Sstevel@tonic-gate 2327c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 2337c478bd9Sstevel@tonic-gate mdb_warn("failed to look up type %s", tn); 2347c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2357c478bd9Sstevel@tonic-gate } 2367c478bd9Sstevel@tonic-gate 2377c478bd9Sstevel@tonic-gate member = argv[1].a_un.a_str; 2387c478bd9Sstevel@tonic-gate 239*e0ad97e3SJonathan Adams if (mdb_ctf_member_info(id, member, &off, &id) != 0) { 2407c478bd9Sstevel@tonic-gate mdb_warn("failed to find member %s of type %s", member, tn); 2417c478bd9Sstevel@tonic-gate return (DCMD_ERR); 2427c478bd9Sstevel@tonic-gate } 2437c478bd9Sstevel@tonic-gate 244*e0ad97e3SJonathan Adams if (flags & DCMD_PIPE_OUT) { 245*e0ad97e3SJonathan Adams if (off % NBBY != 0) { 246*e0ad97e3SJonathan Adams mdb_warn("member %s of type %s is not byte-aligned\n", 247*e0ad97e3SJonathan Adams member, tn); 248*e0ad97e3SJonathan Adams return (DCMD_ERR); 249*e0ad97e3SJonathan Adams } 250*e0ad97e3SJonathan Adams mdb_printf("%#lr", off / NBBY); 251*e0ad97e3SJonathan Adams return (DCMD_OK); 252*e0ad97e3SJonathan Adams } 253*e0ad97e3SJonathan Adams 254*e0ad97e3SJonathan Adams mdb_printf("offsetof (%s, %s) = %#lr", 255*e0ad97e3SJonathan Adams tn, member, off / NBBY); 256*e0ad97e3SJonathan Adams if (off % NBBY != 0) 257*e0ad97e3SJonathan Adams mdb_printf(".%lr", off % NBBY); 258*e0ad97e3SJonathan Adams 259*e0ad97e3SJonathan Adams if ((sz = mdb_ctf_type_size(id)) > 0) 260*e0ad97e3SJonathan Adams mdb_printf(", sizeof (...->%s) = %#lr", member, sz); 261*e0ad97e3SJonathan Adams 262*e0ad97e3SJonathan Adams mdb_printf("\n"); 2637c478bd9Sstevel@tonic-gate 2647c478bd9Sstevel@tonic-gate return (DCMD_OK); 2657c478bd9Sstevel@tonic-gate } 2667c478bd9Sstevel@tonic-gate 267*e0ad97e3SJonathan Adams /*ARGSUSED*/ 268*e0ad97e3SJonathan Adams static int 269*e0ad97e3SJonathan Adams enum_prefix_scan_cb(const char *name, int value, void *arg) 270*e0ad97e3SJonathan Adams { 271*e0ad97e3SJonathan Adams char *str = arg; 272*e0ad97e3SJonathan Adams 273*e0ad97e3SJonathan Adams /* 274*e0ad97e3SJonathan Adams * This function is called with every name in the enum. We make 275*e0ad97e3SJonathan Adams * "arg" be the common prefix, if any. 276*e0ad97e3SJonathan Adams */ 277*e0ad97e3SJonathan Adams if (str[0] == 0) { 278*e0ad97e3SJonathan Adams if (strlcpy(arg, name, MDB_SYM_NAMLEN) >= MDB_SYM_NAMLEN) 279*e0ad97e3SJonathan Adams return (1); 280*e0ad97e3SJonathan Adams return (0); 281*e0ad97e3SJonathan Adams } 282*e0ad97e3SJonathan Adams 283*e0ad97e3SJonathan Adams while (*name == *str) { 284*e0ad97e3SJonathan Adams if (*str == 0) { 285*e0ad97e3SJonathan Adams if (str != arg) { 286*e0ad97e3SJonathan Adams str--; /* don't smother a name completely */ 287*e0ad97e3SJonathan Adams } 288*e0ad97e3SJonathan Adams break; 289*e0ad97e3SJonathan Adams } 290*e0ad97e3SJonathan Adams name++; 291*e0ad97e3SJonathan Adams str++; 292*e0ad97e3SJonathan Adams } 293*e0ad97e3SJonathan Adams *str = 0; 294*e0ad97e3SJonathan Adams 295*e0ad97e3SJonathan Adams return (str == arg); /* only continue if prefix is non-empty */ 296*e0ad97e3SJonathan Adams } 297*e0ad97e3SJonathan Adams 298cce40297SJonathan Adams struct enum_p2_info { 299*e0ad97e3SJonathan Adams intmax_t e_value; /* value we're processing */ 300*e0ad97e3SJonathan Adams char *e_buf; /* buffer for holding names */ 301*e0ad97e3SJonathan Adams size_t e_size; /* size of buffer */ 302*e0ad97e3SJonathan Adams size_t e_prefix; /* length of initial prefix */ 303*e0ad97e3SJonathan Adams uint_t e_allprefix; /* apply prefix to first guy, too */ 304*e0ad97e3SJonathan Adams uint_t e_bits; /* bits seen */ 305*e0ad97e3SJonathan Adams uint8_t e_found; /* have we seen anything? */ 306*e0ad97e3SJonathan Adams uint8_t e_first; /* does buf contain the first one? */ 307*e0ad97e3SJonathan Adams uint8_t e_zero; /* have we seen a zero value? */ 308cce40297SJonathan Adams }; 309cce40297SJonathan Adams 310cce40297SJonathan Adams static int 311cce40297SJonathan Adams enum_p2_cb(const char *name, int bit_arg, void *arg) 312cce40297SJonathan Adams { 313cce40297SJonathan Adams struct enum_p2_info *eiip = arg; 314*e0ad97e3SJonathan Adams uintmax_t bit = bit_arg; 315cce40297SJonathan Adams 316cce40297SJonathan Adams if (bit != 0 && !ISP2(bit)) 317cce40297SJonathan Adams return (1); /* non-power-of-2; abort processing */ 318cce40297SJonathan Adams 319cce40297SJonathan Adams if ((bit == 0 && eiip->e_zero) || 320cce40297SJonathan Adams (bit != 0 && (eiip->e_bits & bit) != 0)) { 321cce40297SJonathan Adams return (0); /* already seen this value */ 322cce40297SJonathan Adams } 323cce40297SJonathan Adams 324cce40297SJonathan Adams if (bit == 0) 325cce40297SJonathan Adams eiip->e_zero = 1; 326cce40297SJonathan Adams else 327cce40297SJonathan Adams eiip->e_bits |= bit; 328cce40297SJonathan Adams 329cce40297SJonathan Adams if (eiip->e_buf != NULL && (eiip->e_value & bit) != 0) { 330*e0ad97e3SJonathan Adams char *buf = eiip->e_buf; 331*e0ad97e3SJonathan Adams size_t prefix = eiip->e_prefix; 332*e0ad97e3SJonathan Adams 333*e0ad97e3SJonathan Adams if (eiip->e_found) { 334*e0ad97e3SJonathan Adams (void) strlcat(buf, "|", eiip->e_size); 335*e0ad97e3SJonathan Adams 336*e0ad97e3SJonathan Adams if (eiip->e_first && !eiip->e_allprefix && prefix > 0) { 337*e0ad97e3SJonathan Adams char c1 = buf[prefix]; 338*e0ad97e3SJonathan Adams char c2 = buf[prefix + 1]; 339*e0ad97e3SJonathan Adams buf[prefix] = '{'; 340*e0ad97e3SJonathan Adams buf[prefix + 1] = 0; 341*e0ad97e3SJonathan Adams mdb_printf("%s", buf); 342*e0ad97e3SJonathan Adams buf[prefix] = c1; 343*e0ad97e3SJonathan Adams buf[prefix + 1] = c2; 344*e0ad97e3SJonathan Adams mdb_printf("%s", buf + prefix); 345*e0ad97e3SJonathan Adams } else { 346*e0ad97e3SJonathan Adams mdb_printf("%s", buf); 347*e0ad97e3SJonathan Adams } 348cce40297SJonathan Adams 349*e0ad97e3SJonathan Adams } 350*e0ad97e3SJonathan Adams /* skip the common prefix as necessary */ 351*e0ad97e3SJonathan Adams if ((eiip->e_found || eiip->e_allprefix) && 352*e0ad97e3SJonathan Adams strlen(name) > prefix) 353*e0ad97e3SJonathan Adams name += prefix; 354cce40297SJonathan Adams 355*e0ad97e3SJonathan Adams (void) strlcpy(eiip->e_buf, name, eiip->e_size); 356*e0ad97e3SJonathan Adams eiip->e_first = !eiip->e_found; 357cce40297SJonathan Adams eiip->e_found = 1; 358cce40297SJonathan Adams } 359cce40297SJonathan Adams return (0); 360cce40297SJonathan Adams } 361cce40297SJonathan Adams 362cce40297SJonathan Adams static int 363*e0ad97e3SJonathan Adams enum_is_p2(mdb_ctf_id_t id) 364cce40297SJonathan Adams { 365cce40297SJonathan Adams struct enum_p2_info eii; 366*e0ad97e3SJonathan Adams bzero(&eii, sizeof (eii)); 367*e0ad97e3SJonathan Adams 368*e0ad97e3SJonathan Adams return (mdb_ctf_type_kind(id) == CTF_K_ENUM && 369*e0ad97e3SJonathan Adams mdb_ctf_enum_iter(id, enum_p2_cb, &eii) == 0 && 370*e0ad97e3SJonathan Adams eii.e_bits != 0); 371*e0ad97e3SJonathan Adams } 372*e0ad97e3SJonathan Adams 373*e0ad97e3SJonathan Adams static int 374*e0ad97e3SJonathan Adams enum_value_print_p2(mdb_ctf_id_t id, intmax_t value, uint_t allprefix) 375*e0ad97e3SJonathan Adams { 376*e0ad97e3SJonathan Adams struct enum_p2_info eii; 377*e0ad97e3SJonathan Adams char prefix[MDB_SYM_NAMLEN + 2]; 378*e0ad97e3SJonathan Adams intmax_t missed; 379cce40297SJonathan Adams 380cce40297SJonathan Adams bzero(&eii, sizeof (eii)); 381cce40297SJonathan Adams 382*e0ad97e3SJonathan Adams eii.e_value = value; 383*e0ad97e3SJonathan Adams eii.e_buf = prefix; 384*e0ad97e3SJonathan Adams eii.e_size = sizeof (prefix); 385*e0ad97e3SJonathan Adams eii.e_allprefix = allprefix; 386cce40297SJonathan Adams 387*e0ad97e3SJonathan Adams prefix[0] = 0; 388*e0ad97e3SJonathan Adams if (mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0) 389*e0ad97e3SJonathan Adams eii.e_prefix = strlen(prefix); 390cce40297SJonathan Adams 391*e0ad97e3SJonathan Adams if (mdb_ctf_enum_iter(id, enum_p2_cb, &eii) != 0 || eii.e_bits == 0) 392cce40297SJonathan Adams return (-1); 393cce40297SJonathan Adams 394*e0ad97e3SJonathan Adams missed = (value & ~(intmax_t)eii.e_bits); 395cce40297SJonathan Adams 396*e0ad97e3SJonathan Adams if (eii.e_found) { 397*e0ad97e3SJonathan Adams /* push out any final value, with a | if we missed anything */ 398*e0ad97e3SJonathan Adams if (!eii.e_first) 399*e0ad97e3SJonathan Adams (void) strlcat(prefix, "}", sizeof (prefix)); 400*e0ad97e3SJonathan Adams if (missed != 0) 401*e0ad97e3SJonathan Adams (void) strlcat(prefix, "|", sizeof (prefix)); 402cce40297SJonathan Adams 403*e0ad97e3SJonathan Adams mdb_printf("%s", prefix); 404*e0ad97e3SJonathan Adams } 405*e0ad97e3SJonathan Adams 406*e0ad97e3SJonathan Adams if (!eii.e_found || missed) { 407*e0ad97e3SJonathan Adams mdb_printf("%#llx", missed); 408cce40297SJonathan Adams } 409cce40297SJonathan Adams 410cce40297SJonathan Adams return (0); 411cce40297SJonathan Adams } 412cce40297SJonathan Adams 4137c478bd9Sstevel@tonic-gate struct enum_cbinfo { 4147c478bd9Sstevel@tonic-gate uint_t e_flags; 4157c478bd9Sstevel@tonic-gate const char *e_string; /* NULL for value searches */ 416*e0ad97e3SJonathan Adams size_t e_prefix; 417*e0ad97e3SJonathan Adams intmax_t e_value; 4187c478bd9Sstevel@tonic-gate uint_t e_found; 419*e0ad97e3SJonathan Adams mdb_ctf_id_t e_id; 4207c478bd9Sstevel@tonic-gate }; 421*e0ad97e3SJonathan Adams #define E_PRETTY 0x01 422*e0ad97e3SJonathan Adams #define E_HEX 0x02 423*e0ad97e3SJonathan Adams #define E_SEARCH_STRING 0x04 424*e0ad97e3SJonathan Adams #define E_SEARCH_VALUE 0x08 425*e0ad97e3SJonathan Adams #define E_ELIDE_PREFIX 0x10 4267c478bd9Sstevel@tonic-gate 427cce40297SJonathan Adams static void 428cce40297SJonathan Adams enum_print(struct enum_cbinfo *info, const char *name, int value) 429cce40297SJonathan Adams { 430cce40297SJonathan Adams uint_t flags = info->e_flags; 431*e0ad97e3SJonathan Adams uint_t elide_prefix = (info->e_flags & E_ELIDE_PREFIX); 432*e0ad97e3SJonathan Adams 433*e0ad97e3SJonathan Adams if (name != NULL && info->e_prefix && strlen(name) > info->e_prefix) 434*e0ad97e3SJonathan Adams name += info->e_prefix; 435cce40297SJonathan Adams 436cce40297SJonathan Adams if (flags & E_PRETTY) { 437*e0ad97e3SJonathan Adams uint_t indent = 5 + ((flags & E_HEX) ? 8 : 11); 438*e0ad97e3SJonathan Adams 439*e0ad97e3SJonathan Adams mdb_printf((flags & E_HEX)? "%8x " : "%11d ", value); 440*e0ad97e3SJonathan Adams (void) mdb_inc_indent(indent); 441*e0ad97e3SJonathan Adams if (name != NULL) { 442*e0ad97e3SJonathan Adams mdb_iob_puts(mdb.m_out, name); 443*e0ad97e3SJonathan Adams } else { 444*e0ad97e3SJonathan Adams (void) enum_value_print_p2(info->e_id, value, 445*e0ad97e3SJonathan Adams elide_prefix); 446*e0ad97e3SJonathan Adams } 447*e0ad97e3SJonathan Adams (void) mdb_dec_indent(indent); 448*e0ad97e3SJonathan Adams mdb_printf("\n"); 449cce40297SJonathan Adams } else { 450cce40297SJonathan Adams mdb_printf("%#r\n", value); 451cce40297SJonathan Adams } 452cce40297SJonathan Adams } 453cce40297SJonathan Adams 4547c478bd9Sstevel@tonic-gate static int 4557c478bd9Sstevel@tonic-gate enum_cb(const char *name, int value, void *arg) 4567c478bd9Sstevel@tonic-gate { 4577c478bd9Sstevel@tonic-gate struct enum_cbinfo *info = arg; 4587c478bd9Sstevel@tonic-gate uint_t flags = info->e_flags; 4597c478bd9Sstevel@tonic-gate 4607c478bd9Sstevel@tonic-gate if (flags & E_SEARCH_STRING) { 4617c478bd9Sstevel@tonic-gate if (strcmp(name, info->e_string) != 0) 4627c478bd9Sstevel@tonic-gate return (0); 4637c478bd9Sstevel@tonic-gate 4647c478bd9Sstevel@tonic-gate } else if (flags & E_SEARCH_VALUE) { 4657c478bd9Sstevel@tonic-gate if (value != info->e_value) 4667c478bd9Sstevel@tonic-gate return (0); 4677c478bd9Sstevel@tonic-gate } 4687c478bd9Sstevel@tonic-gate 469cce40297SJonathan Adams enum_print(info, name, value); 4707c478bd9Sstevel@tonic-gate 4717c478bd9Sstevel@tonic-gate info->e_found = 1; 4727c478bd9Sstevel@tonic-gate return (0); 4737c478bd9Sstevel@tonic-gate } 4747c478bd9Sstevel@tonic-gate 475*e0ad97e3SJonathan Adams void 476*e0ad97e3SJonathan Adams enum_help(void) 477*e0ad97e3SJonathan Adams { 478*e0ad97e3SJonathan Adams mdb_printf("%s", 479*e0ad97e3SJonathan Adams "Without an address and name, print all values for the enumeration \"enum\".\n" 480*e0ad97e3SJonathan Adams "With an address, look up a particular value in \"enum\". With a name, look\n" 481*e0ad97e3SJonathan Adams "up a particular name in \"enum\".\n"); 482*e0ad97e3SJonathan Adams 483*e0ad97e3SJonathan Adams (void) mdb_dec_indent(2); 484*e0ad97e3SJonathan Adams mdb_printf("\n%<b>OPTIONS%</b>\n"); 485*e0ad97e3SJonathan Adams (void) mdb_inc_indent(2); 486*e0ad97e3SJonathan Adams 487*e0ad97e3SJonathan Adams mdb_printf("%s", 488*e0ad97e3SJonathan Adams " -e remove common prefixes from enum names\n" 489*e0ad97e3SJonathan Adams " -x report enum values in hexadecimal\n"); 490*e0ad97e3SJonathan Adams } 491*e0ad97e3SJonathan Adams 4927c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 4937c478bd9Sstevel@tonic-gate int 4947c478bd9Sstevel@tonic-gate cmd_enum(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 4957c478bd9Sstevel@tonic-gate { 4967c478bd9Sstevel@tonic-gate struct enum_cbinfo info; 4977c478bd9Sstevel@tonic-gate 498cce40297SJonathan Adams char type[MDB_SYM_NAMLEN + sizeof ("enum ")]; 4997c478bd9Sstevel@tonic-gate char tn2[MDB_SYM_NAMLEN + sizeof ("enum ")]; 500*e0ad97e3SJonathan Adams char prefix[MDB_SYM_NAMLEN]; 5017c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 5027c478bd9Sstevel@tonic-gate mdb_ctf_id_t idr; 5037c478bd9Sstevel@tonic-gate 5047c478bd9Sstevel@tonic-gate int i; 5057c478bd9Sstevel@tonic-gate intmax_t search; 506*e0ad97e3SJonathan Adams uint_t isp2; 5077c478bd9Sstevel@tonic-gate 5087c478bd9Sstevel@tonic-gate info.e_flags = (flags & DCMD_PIPE_OUT)? 0 : E_PRETTY; 5097c478bd9Sstevel@tonic-gate info.e_string = NULL; 5107c478bd9Sstevel@tonic-gate info.e_value = 0; 5117c478bd9Sstevel@tonic-gate info.e_found = 0; 5127c478bd9Sstevel@tonic-gate 5137c478bd9Sstevel@tonic-gate i = mdb_getopts(argc, argv, 514*e0ad97e3SJonathan Adams 'e', MDB_OPT_SETBITS, E_ELIDE_PREFIX, &info.e_flags, 5157c478bd9Sstevel@tonic-gate 'x', MDB_OPT_SETBITS, E_HEX, &info.e_flags, 5167c478bd9Sstevel@tonic-gate NULL); 5177c478bd9Sstevel@tonic-gate 5187c478bd9Sstevel@tonic-gate argc -= i; 5197c478bd9Sstevel@tonic-gate argv += i; 5207c478bd9Sstevel@tonic-gate 521cce40297SJonathan Adams if ((i = args_to_typename(&argc, &argv, type, MDB_SYM_NAMLEN)) != 0) 5227c478bd9Sstevel@tonic-gate return (i); 5237c478bd9Sstevel@tonic-gate 524cce40297SJonathan Adams if (strchr(type, ' ') == NULL) { 5257c478bd9Sstevel@tonic-gate /* 5267c478bd9Sstevel@tonic-gate * Check as an enumeration tag first, and fall back 5277c478bd9Sstevel@tonic-gate * to checking for a typedef. Yes, this means that 5287c478bd9Sstevel@tonic-gate * anonymous enumerations whose typedefs conflict with 5297c478bd9Sstevel@tonic-gate * an enum tag can't be accessed. Don't do that. 5307c478bd9Sstevel@tonic-gate */ 531cce40297SJonathan Adams (void) mdb_snprintf(tn2, sizeof (tn2), "enum %s", type); 5327c478bd9Sstevel@tonic-gate 5337c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(tn2, &id) == 0) { 534cce40297SJonathan Adams strcpy(type, tn2); 535cce40297SJonathan Adams } else if (mdb_ctf_lookup_by_name(type, &id) != 0) { 536cce40297SJonathan Adams mdb_warn("types '%s', '%s'", tn2, type); 5377c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5387c478bd9Sstevel@tonic-gate } 5397c478bd9Sstevel@tonic-gate } else { 540cce40297SJonathan Adams if (mdb_ctf_lookup_by_name(type, &id) != 0) { 541cce40297SJonathan Adams mdb_warn("'%s'", type); 5427c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5437c478bd9Sstevel@tonic-gate } 5447c478bd9Sstevel@tonic-gate } 5457c478bd9Sstevel@tonic-gate 5467c478bd9Sstevel@tonic-gate /* resolve it, and make sure we're looking at an enumeration */ 5477c478bd9Sstevel@tonic-gate if (mdb_ctf_type_resolve(id, &idr) == -1) { 5487c478bd9Sstevel@tonic-gate mdb_warn("unable to resolve '%s'", type); 5497c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5507c478bd9Sstevel@tonic-gate } 5517c478bd9Sstevel@tonic-gate if (mdb_ctf_type_kind(idr) != CTF_K_ENUM) { 5527c478bd9Sstevel@tonic-gate mdb_warn("'%s': not an enumeration\n", type); 5537c478bd9Sstevel@tonic-gate return (DCMD_ERR); 5547c478bd9Sstevel@tonic-gate } 5557c478bd9Sstevel@tonic-gate 556*e0ad97e3SJonathan Adams info.e_id = idr; 557*e0ad97e3SJonathan Adams 5587c478bd9Sstevel@tonic-gate if (argc > 2) 5597c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 5607c478bd9Sstevel@tonic-gate 5617c478bd9Sstevel@tonic-gate if (argc == 2) { 5627c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) { 5637c478bd9Sstevel@tonic-gate mdb_warn("may only specify one of: name, address\n"); 5647c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 5657c478bd9Sstevel@tonic-gate } 5667c478bd9Sstevel@tonic-gate 5677c478bd9Sstevel@tonic-gate if (argv[1].a_type == MDB_TYPE_STRING) { 5687c478bd9Sstevel@tonic-gate info.e_flags |= E_SEARCH_STRING; 5697c478bd9Sstevel@tonic-gate info.e_string = argv[1].a_un.a_str; 5707c478bd9Sstevel@tonic-gate } else if (argv[1].a_type == MDB_TYPE_IMMEDIATE) { 5717c478bd9Sstevel@tonic-gate info.e_flags |= E_SEARCH_VALUE; 5727c478bd9Sstevel@tonic-gate search = argv[1].a_un.a_val; 5737c478bd9Sstevel@tonic-gate } else { 5747c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 5757c478bd9Sstevel@tonic-gate } 5767c478bd9Sstevel@tonic-gate } 5777c478bd9Sstevel@tonic-gate 5787c478bd9Sstevel@tonic-gate if (flags & DCMD_ADDRSPEC) { 5797c478bd9Sstevel@tonic-gate info.e_flags |= E_SEARCH_VALUE; 5807c478bd9Sstevel@tonic-gate search = mdb_get_dot(); 5817c478bd9Sstevel@tonic-gate } 5827c478bd9Sstevel@tonic-gate 5837c478bd9Sstevel@tonic-gate if (info.e_flags & E_SEARCH_VALUE) { 5847c478bd9Sstevel@tonic-gate if ((int)search != search) { 5857c478bd9Sstevel@tonic-gate mdb_warn("value '%lld' out of enumeration range\n", 5867c478bd9Sstevel@tonic-gate search); 5877c478bd9Sstevel@tonic-gate } 5887c478bd9Sstevel@tonic-gate info.e_value = search; 5897c478bd9Sstevel@tonic-gate } 5907c478bd9Sstevel@tonic-gate 591*e0ad97e3SJonathan Adams isp2 = enum_is_p2(idr); 592*e0ad97e3SJonathan Adams if (isp2) 593*e0ad97e3SJonathan Adams info.e_flags |= E_HEX; 594*e0ad97e3SJonathan Adams 5957c478bd9Sstevel@tonic-gate if (DCMD_HDRSPEC(flags) && (info.e_flags & E_PRETTY)) { 5967c478bd9Sstevel@tonic-gate if (info.e_flags & E_HEX) 597*e0ad97e3SJonathan Adams mdb_printf("%<u>%8s %-64s%</u>\n", "VALUE", "NAME"); 5987c478bd9Sstevel@tonic-gate else 599*e0ad97e3SJonathan Adams mdb_printf("%<u>%11s %-64s%</u>\n", "VALUE", "NAME"); 6007c478bd9Sstevel@tonic-gate } 6017c478bd9Sstevel@tonic-gate 602cce40297SJonathan Adams /* if the enum is a power-of-two one, process it that way */ 603*e0ad97e3SJonathan Adams if ((info.e_flags & E_SEARCH_VALUE) && isp2) { 604*e0ad97e3SJonathan Adams enum_print(&info, NULL, info.e_value); 605cce40297SJonathan Adams return (DCMD_OK); 606cce40297SJonathan Adams } 607cce40297SJonathan Adams 608*e0ad97e3SJonathan Adams prefix[0] = 0; 609*e0ad97e3SJonathan Adams if ((info.e_flags & E_ELIDE_PREFIX) && 610*e0ad97e3SJonathan Adams mdb_ctf_enum_iter(id, enum_prefix_scan_cb, prefix) == 0) 611*e0ad97e3SJonathan Adams info.e_prefix = strlen(prefix); 612*e0ad97e3SJonathan Adams 6137c478bd9Sstevel@tonic-gate if (mdb_ctf_enum_iter(idr, enum_cb, &info) == -1) { 6147c478bd9Sstevel@tonic-gate mdb_warn("cannot walk '%s' as enum", type); 6157c478bd9Sstevel@tonic-gate return (DCMD_ERR); 6167c478bd9Sstevel@tonic-gate } 6177c478bd9Sstevel@tonic-gate 6187c478bd9Sstevel@tonic-gate if (info.e_found == 0 && 6197c478bd9Sstevel@tonic-gate (info.e_flags & (E_SEARCH_STRING | E_SEARCH_VALUE)) != 0) { 6207c478bd9Sstevel@tonic-gate if (info.e_flags & E_SEARCH_STRING) 6217c478bd9Sstevel@tonic-gate mdb_warn("name \"%s\" not in '%s'\n", info.e_string, 6227c478bd9Sstevel@tonic-gate type); 6237c478bd9Sstevel@tonic-gate else 624*e0ad97e3SJonathan Adams mdb_warn("value %#lld not in '%s'\n", info.e_value, 625*e0ad97e3SJonathan Adams type); 6267c478bd9Sstevel@tonic-gate 6277c478bd9Sstevel@tonic-gate return (DCMD_ERR); 6287c478bd9Sstevel@tonic-gate } 6297c478bd9Sstevel@tonic-gate 6307c478bd9Sstevel@tonic-gate return (DCMD_OK); 6317c478bd9Sstevel@tonic-gate } 6327c478bd9Sstevel@tonic-gate 6337c478bd9Sstevel@tonic-gate static int 6347c478bd9Sstevel@tonic-gate setup_vcb(const char *name, uintptr_t addr) 6357c478bd9Sstevel@tonic-gate { 6367c478bd9Sstevel@tonic-gate const char *p; 6377c478bd9Sstevel@tonic-gate mdb_var_t *v; 6387c478bd9Sstevel@tonic-gate 6397c478bd9Sstevel@tonic-gate if ((v = mdb_nv_lookup(&mdb.m_nv, name)) == NULL) { 6407c478bd9Sstevel@tonic-gate if ((p = strbadid(name)) != NULL) { 6417c478bd9Sstevel@tonic-gate mdb_warn("'%c' may not be used in a variable " 6427c478bd9Sstevel@tonic-gate "name\n", *p); 6437c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 6447c478bd9Sstevel@tonic-gate } 6457c478bd9Sstevel@tonic-gate 6467c478bd9Sstevel@tonic-gate if ((v = mdb_nv_insert(&mdb.m_nv, name, NULL, addr, 0)) == NULL) 6477c478bd9Sstevel@tonic-gate return (DCMD_ERR); 6487c478bd9Sstevel@tonic-gate } else { 6497c478bd9Sstevel@tonic-gate if (v->v_flags & MDB_NV_RDONLY) { 6507c478bd9Sstevel@tonic-gate mdb_warn("variable %s is read-only\n", name); 6517c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 6527c478bd9Sstevel@tonic-gate } 6537c478bd9Sstevel@tonic-gate } 6547c478bd9Sstevel@tonic-gate 6557c478bd9Sstevel@tonic-gate /* 6567c478bd9Sstevel@tonic-gate * If there already exists a vcb for this variable, we may be 6577c478bd9Sstevel@tonic-gate * calling the dcmd in a loop. We only create a vcb for this 6587c478bd9Sstevel@tonic-gate * variable on the first invocation. 6597c478bd9Sstevel@tonic-gate */ 6607c478bd9Sstevel@tonic-gate if (mdb_vcb_find(v, mdb.m_frame) == NULL) 6617c478bd9Sstevel@tonic-gate mdb_vcb_insert(mdb_vcb_create(v), mdb.m_frame); 6627c478bd9Sstevel@tonic-gate 6637c478bd9Sstevel@tonic-gate return (0); 6647c478bd9Sstevel@tonic-gate } 6657c478bd9Sstevel@tonic-gate 6667c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 6677c478bd9Sstevel@tonic-gate int 6687c478bd9Sstevel@tonic-gate cmd_list(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 6697c478bd9Sstevel@tonic-gate { 6707c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 6717c478bd9Sstevel@tonic-gate ulong_t offset; 6727c478bd9Sstevel@tonic-gate uintptr_t a, tmp; 6737c478bd9Sstevel@tonic-gate int ret; 6747c478bd9Sstevel@tonic-gate 6757c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC) || argc == 0) 6767c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 6777c478bd9Sstevel@tonic-gate 6787c478bd9Sstevel@tonic-gate if (argv->a_type != MDB_TYPE_STRING) { 6797c478bd9Sstevel@tonic-gate /* 6807c478bd9Sstevel@tonic-gate * We are being given a raw offset in lieu of a type and 6817c478bd9Sstevel@tonic-gate * member; confirm the arguments. 6827c478bd9Sstevel@tonic-gate */ 6837c478bd9Sstevel@tonic-gate if (argv->a_type != MDB_TYPE_IMMEDIATE) 6847c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 6857c478bd9Sstevel@tonic-gate 6867c478bd9Sstevel@tonic-gate offset = argv->a_un.a_val; 6877c478bd9Sstevel@tonic-gate 6887c478bd9Sstevel@tonic-gate argv++; 6897c478bd9Sstevel@tonic-gate argc--; 6907c478bd9Sstevel@tonic-gate 6917c478bd9Sstevel@tonic-gate if (offset % sizeof (uintptr_t)) { 6927c478bd9Sstevel@tonic-gate mdb_warn("offset must fall on a word boundary\n"); 6937c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 6947c478bd9Sstevel@tonic-gate } 6957c478bd9Sstevel@tonic-gate } else { 6967c478bd9Sstevel@tonic-gate const char *member; 6977c478bd9Sstevel@tonic-gate char buf[MDB_SYM_NAMLEN]; 6987c478bd9Sstevel@tonic-gate int ret; 6997c478bd9Sstevel@tonic-gate 7007c478bd9Sstevel@tonic-gate ret = args_to_typename(&argc, &argv, buf, sizeof (buf)); 7017c478bd9Sstevel@tonic-gate if (ret != 0) 7027c478bd9Sstevel@tonic-gate return (ret); 7037c478bd9Sstevel@tonic-gate 7047c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(buf, &id) != 0) { 7057c478bd9Sstevel@tonic-gate mdb_warn("failed to look up type %s", buf); 7067c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 7077c478bd9Sstevel@tonic-gate } 7087c478bd9Sstevel@tonic-gate 7097c478bd9Sstevel@tonic-gate argv++; 7107c478bd9Sstevel@tonic-gate argc--; 7117c478bd9Sstevel@tonic-gate 7127c478bd9Sstevel@tonic-gate if (argc < 1 || argv->a_type != MDB_TYPE_STRING) 7137c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 7147c478bd9Sstevel@tonic-gate 7157c478bd9Sstevel@tonic-gate member = argv->a_un.a_str; 7167c478bd9Sstevel@tonic-gate 7177c478bd9Sstevel@tonic-gate argv++; 7187c478bd9Sstevel@tonic-gate argc--; 7197c478bd9Sstevel@tonic-gate 7207c478bd9Sstevel@tonic-gate if (mdb_ctf_offsetof(id, member, &offset) != 0) { 7217c478bd9Sstevel@tonic-gate mdb_warn("failed to find member %s of type %s", 7227c478bd9Sstevel@tonic-gate member, buf); 7237c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 7247c478bd9Sstevel@tonic-gate } 7257c478bd9Sstevel@tonic-gate 7267c478bd9Sstevel@tonic-gate if (offset % (sizeof (uintptr_t) * NBBY) != 0) { 7277c478bd9Sstevel@tonic-gate mdb_warn("%s is not a word-aligned member\n", member); 7287c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 7297c478bd9Sstevel@tonic-gate } 7307c478bd9Sstevel@tonic-gate 7317c478bd9Sstevel@tonic-gate offset /= NBBY; 7327c478bd9Sstevel@tonic-gate } 7337c478bd9Sstevel@tonic-gate 7347c478bd9Sstevel@tonic-gate /* 7357c478bd9Sstevel@tonic-gate * If we have any unchewed arguments, a variable name must be present. 7367c478bd9Sstevel@tonic-gate */ 7377c478bd9Sstevel@tonic-gate if (argc == 1) { 7387c478bd9Sstevel@tonic-gate if (argv->a_type != MDB_TYPE_STRING) 7397c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 7407c478bd9Sstevel@tonic-gate 7417c478bd9Sstevel@tonic-gate if ((ret = setup_vcb(argv->a_un.a_str, addr)) != 0) 7427c478bd9Sstevel@tonic-gate return (ret); 7437c478bd9Sstevel@tonic-gate 7447c478bd9Sstevel@tonic-gate } else if (argc != 0) { 7457c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 7467c478bd9Sstevel@tonic-gate } 7477c478bd9Sstevel@tonic-gate 7487c478bd9Sstevel@tonic-gate a = addr; 7497c478bd9Sstevel@tonic-gate 7507c478bd9Sstevel@tonic-gate do { 7517c478bd9Sstevel@tonic-gate mdb_printf("%lr\n", a); 7527c478bd9Sstevel@tonic-gate 7537c478bd9Sstevel@tonic-gate if (mdb_vread(&tmp, sizeof (tmp), a + offset) == -1) { 7547c478bd9Sstevel@tonic-gate mdb_warn("failed to read next pointer from object %p", 7557c478bd9Sstevel@tonic-gate a); 7567c478bd9Sstevel@tonic-gate return (DCMD_ERR); 7577c478bd9Sstevel@tonic-gate } 7587c478bd9Sstevel@tonic-gate 7597c478bd9Sstevel@tonic-gate a = tmp; 7607c478bd9Sstevel@tonic-gate } while (a != addr && a != NULL); 7617c478bd9Sstevel@tonic-gate 7627c478bd9Sstevel@tonic-gate return (DCMD_OK); 7637c478bd9Sstevel@tonic-gate } 7647c478bd9Sstevel@tonic-gate 7657c478bd9Sstevel@tonic-gate int 7667c478bd9Sstevel@tonic-gate cmd_array(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 7677c478bd9Sstevel@tonic-gate { 7687c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 7697c478bd9Sstevel@tonic-gate ssize_t elemsize = 0; 7707c478bd9Sstevel@tonic-gate char tn[MDB_SYM_NAMLEN]; 7717c478bd9Sstevel@tonic-gate int ret, nelem = -1; 7727c478bd9Sstevel@tonic-gate 7737c478bd9Sstevel@tonic-gate mdb_tgt_t *t = mdb.m_target; 7747c478bd9Sstevel@tonic-gate GElf_Sym sym; 7757c478bd9Sstevel@tonic-gate mdb_ctf_arinfo_t ar; 7767c478bd9Sstevel@tonic-gate mdb_syminfo_t s_info; 7777c478bd9Sstevel@tonic-gate 7787c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC)) 7797c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 7807c478bd9Sstevel@tonic-gate 7817c478bd9Sstevel@tonic-gate if (argc >= 2) { 7827c478bd9Sstevel@tonic-gate ret = args_to_typename(&argc, &argv, tn, sizeof (tn)); 7837c478bd9Sstevel@tonic-gate if (ret != 0) 7847c478bd9Sstevel@tonic-gate return (ret); 7857c478bd9Sstevel@tonic-gate 7867c478bd9Sstevel@tonic-gate if (argc == 1) /* unquoted compound type without count */ 7877c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 7887c478bd9Sstevel@tonic-gate 7897c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(tn, &id) != 0) { 7907c478bd9Sstevel@tonic-gate mdb_warn("failed to look up type %s", tn); 7917c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 7927c478bd9Sstevel@tonic-gate } 7937c478bd9Sstevel@tonic-gate 7947c478bd9Sstevel@tonic-gate if (argv[1].a_type == MDB_TYPE_IMMEDIATE) 7957c478bd9Sstevel@tonic-gate nelem = argv[1].a_un.a_val; 7967c478bd9Sstevel@tonic-gate else 7977c478bd9Sstevel@tonic-gate nelem = mdb_strtoull(argv[1].a_un.a_str); 7987c478bd9Sstevel@tonic-gate 7997c478bd9Sstevel@tonic-gate elemsize = mdb_ctf_type_size(id); 8007c478bd9Sstevel@tonic-gate } else if (addr_to_sym(t, addr, tn, sizeof (tn), &sym, &s_info) 801cce40297SJonathan Adams != NULL && mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) 802cce40297SJonathan Adams == 0 && mdb_ctf_type_kind(id) == CTF_K_ARRAY && 803cce40297SJonathan Adams mdb_ctf_array_info(id, &ar) != -1) { 804cce40297SJonathan Adams elemsize = mdb_ctf_type_size(id) / ar.mta_nelems; 805cce40297SJonathan Adams nelem = ar.mta_nelems; 8067c478bd9Sstevel@tonic-gate } else { 8077c478bd9Sstevel@tonic-gate mdb_warn("no symbol information for %a", addr); 8087c478bd9Sstevel@tonic-gate return (DCMD_ERR); 8097c478bd9Sstevel@tonic-gate } 8107c478bd9Sstevel@tonic-gate 8117c478bd9Sstevel@tonic-gate if (argc == 3 || argc == 1) { 8127c478bd9Sstevel@tonic-gate if (argv[argc - 1].a_type != MDB_TYPE_STRING) 8137c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 8147c478bd9Sstevel@tonic-gate 8157c478bd9Sstevel@tonic-gate if ((ret = setup_vcb(argv[argc - 1].a_un.a_str, addr)) != 0) 8167c478bd9Sstevel@tonic-gate return (ret); 8177c478bd9Sstevel@tonic-gate 8187c478bd9Sstevel@tonic-gate } else if (argc > 3) { 8197c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 8207c478bd9Sstevel@tonic-gate } 8217c478bd9Sstevel@tonic-gate 8227c478bd9Sstevel@tonic-gate for (; nelem > 0; nelem--) { 8237c478bd9Sstevel@tonic-gate mdb_printf("%lr\n", addr); 8247c478bd9Sstevel@tonic-gate addr = addr + elemsize; 8257c478bd9Sstevel@tonic-gate } 8267c478bd9Sstevel@tonic-gate 8277c478bd9Sstevel@tonic-gate return (DCMD_OK); 8287c478bd9Sstevel@tonic-gate } 8297c478bd9Sstevel@tonic-gate 8307c478bd9Sstevel@tonic-gate /* 8317c478bd9Sstevel@tonic-gate * Print an integer bitfield in hexadecimal by reading the enclosing byte(s) 8327c478bd9Sstevel@tonic-gate * and then shifting and masking the data in the lower bits of a uint64_t. 8337c478bd9Sstevel@tonic-gate */ 8347c478bd9Sstevel@tonic-gate static int 8357c478bd9Sstevel@tonic-gate print_bitfield(ulong_t off, printarg_t *pap, ctf_encoding_t *ep) 8367c478bd9Sstevel@tonic-gate { 8377c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 8387c478bd9Sstevel@tonic-gate size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY; 8397c478bd9Sstevel@tonic-gate uint64_t mask = (1ULL << ep->cte_bits) - 1; 8407c478bd9Sstevel@tonic-gate uint64_t value = 0; 8417c478bd9Sstevel@tonic-gate uint8_t *buf = (uint8_t *)&value; 8427c478bd9Sstevel@tonic-gate uint8_t shift; 8437c478bd9Sstevel@tonic-gate 8447c478bd9Sstevel@tonic-gate const char *format; 8457c478bd9Sstevel@tonic-gate 8467c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 8477c478bd9Sstevel@tonic-gate return (0); 8487c478bd9Sstevel@tonic-gate 8497c478bd9Sstevel@tonic-gate if (ep->cte_bits > sizeof (value) * NBBY - 1) { 8507c478bd9Sstevel@tonic-gate mdb_printf("??? (invalid bitfield size %u)", ep->cte_bits); 8517c478bd9Sstevel@tonic-gate return (0); 8527c478bd9Sstevel@tonic-gate } 8537c478bd9Sstevel@tonic-gate 8547c478bd9Sstevel@tonic-gate /* 8557c478bd9Sstevel@tonic-gate * On big-endian machines, we need to adjust the buf pointer to refer 8567c478bd9Sstevel@tonic-gate * to the lowest 'size' bytes in 'value', and we need shift based on 8577c478bd9Sstevel@tonic-gate * the offset from the end of the data, not the offset of the start. 8587c478bd9Sstevel@tonic-gate */ 8597c478bd9Sstevel@tonic-gate #ifdef _BIG_ENDIAN 8607c478bd9Sstevel@tonic-gate buf += sizeof (value) - size; 8617c478bd9Sstevel@tonic-gate off += ep->cte_bits; 8627c478bd9Sstevel@tonic-gate #endif 8637c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, buf, size, addr) != size) { 8647c478bd9Sstevel@tonic-gate mdb_warn("failed to read %lu bytes at %llx", 8657c478bd9Sstevel@tonic-gate (ulong_t)size, addr); 8667c478bd9Sstevel@tonic-gate return (1); 8677c478bd9Sstevel@tonic-gate } 8687c478bd9Sstevel@tonic-gate 8697c478bd9Sstevel@tonic-gate shift = off % NBBY; 8707c478bd9Sstevel@tonic-gate 8717c478bd9Sstevel@tonic-gate /* 8727c478bd9Sstevel@tonic-gate * Offsets are counted from opposite ends on little- and 8737c478bd9Sstevel@tonic-gate * big-endian machines. 8747c478bd9Sstevel@tonic-gate */ 8757c478bd9Sstevel@tonic-gate #ifdef _BIG_ENDIAN 8767c478bd9Sstevel@tonic-gate shift = NBBY - shift; 8777c478bd9Sstevel@tonic-gate #endif 8787c478bd9Sstevel@tonic-gate 8797c478bd9Sstevel@tonic-gate /* 8807c478bd9Sstevel@tonic-gate * If the bits we want do not begin on a byte boundary, shift the data 8817c478bd9Sstevel@tonic-gate * right so that the value is in the lowest 'cte_bits' of 'value'. 8827c478bd9Sstevel@tonic-gate */ 8837c478bd9Sstevel@tonic-gate if (off % NBBY != 0) 8847c478bd9Sstevel@tonic-gate value >>= shift; 8857c478bd9Sstevel@tonic-gate value &= mask; 8867c478bd9Sstevel@tonic-gate 8877c478bd9Sstevel@tonic-gate /* 8887c478bd9Sstevel@tonic-gate * We default to printing signed bitfields as decimals, 8897c478bd9Sstevel@tonic-gate * and unsigned bitfields in hexadecimal. If they specify 8907c478bd9Sstevel@tonic-gate * hexadecimal, we treat the field as unsigned. 8917c478bd9Sstevel@tonic-gate */ 8927c478bd9Sstevel@tonic-gate if ((pap->pa_flags & PA_INTHEX) || 8937c478bd9Sstevel@tonic-gate !(ep->cte_format & CTF_INT_SIGNED)) { 8947c478bd9Sstevel@tonic-gate format = (pap->pa_flags & PA_INTDEC)? "%#llu" : "%#llx"; 8957c478bd9Sstevel@tonic-gate } else { 8967c478bd9Sstevel@tonic-gate int sshift = sizeof (value) * NBBY - ep->cte_bits; 8977c478bd9Sstevel@tonic-gate 8987c478bd9Sstevel@tonic-gate /* sign-extend value, and print as a signed decimal */ 8997c478bd9Sstevel@tonic-gate value = ((int64_t)value << sshift) >> sshift; 9007c478bd9Sstevel@tonic-gate format = "%#lld"; 9017c478bd9Sstevel@tonic-gate } 9027c478bd9Sstevel@tonic-gate mdb_printf(format, value); 9037c478bd9Sstevel@tonic-gate 9047c478bd9Sstevel@tonic-gate return (0); 9057c478bd9Sstevel@tonic-gate } 9067c478bd9Sstevel@tonic-gate 9077c478bd9Sstevel@tonic-gate /* 9087c478bd9Sstevel@tonic-gate * Print out a character or integer value. We use some simple heuristics, 9097c478bd9Sstevel@tonic-gate * described below, to determine the appropriate radix to use for output. 9107c478bd9Sstevel@tonic-gate */ 9117c478bd9Sstevel@tonic-gate static int 9127c478bd9Sstevel@tonic-gate print_int_val(const char *type, ctf_encoding_t *ep, ulong_t off, 9137c478bd9Sstevel@tonic-gate printarg_t *pap) 9147c478bd9Sstevel@tonic-gate { 9157c478bd9Sstevel@tonic-gate static const char *const sformat[] = { "%#d", "%#d", "%#d", "%#lld" }; 9167c478bd9Sstevel@tonic-gate static const char *const uformat[] = { "%#u", "%#u", "%#u", "%#llu" }; 9177c478bd9Sstevel@tonic-gate static const char *const xformat[] = { "%#x", "%#x", "%#x", "%#llx" }; 9187c478bd9Sstevel@tonic-gate 9197c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 9207c478bd9Sstevel@tonic-gate const char *const *fsp; 9217c478bd9Sstevel@tonic-gate size_t size; 9227c478bd9Sstevel@tonic-gate 9237c478bd9Sstevel@tonic-gate union { 9247c478bd9Sstevel@tonic-gate uint64_t i8; 9257c478bd9Sstevel@tonic-gate uint32_t i4; 9267c478bd9Sstevel@tonic-gate uint16_t i2; 9277c478bd9Sstevel@tonic-gate uint8_t i1; 9287c478bd9Sstevel@tonic-gate time_t t; 9297c478bd9Sstevel@tonic-gate } u; 9307c478bd9Sstevel@tonic-gate 9317c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 9327c478bd9Sstevel@tonic-gate return (0); 9337c478bd9Sstevel@tonic-gate 9347c478bd9Sstevel@tonic-gate if (ep->cte_format & CTF_INT_VARARGS) { 9357c478bd9Sstevel@tonic-gate mdb_printf("...\n"); 9367c478bd9Sstevel@tonic-gate return (0); 9377c478bd9Sstevel@tonic-gate } 9387c478bd9Sstevel@tonic-gate 9397c478bd9Sstevel@tonic-gate /* 9407c478bd9Sstevel@tonic-gate * If the size is not a power-of-two number of bytes in the range 1-8 9417c478bd9Sstevel@tonic-gate * then we assume it is a bitfield and print it as such. 9427c478bd9Sstevel@tonic-gate */ 9437c478bd9Sstevel@tonic-gate size = ep->cte_bits / NBBY; 9447c478bd9Sstevel@tonic-gate if (size > 8 || (ep->cte_bits % NBBY) != 0 || (size & (size - 1)) != 0) 9457c478bd9Sstevel@tonic-gate return (print_bitfield(off, pap, ep)); 9467c478bd9Sstevel@tonic-gate 9477c478bd9Sstevel@tonic-gate if (IS_CHAR(*ep)) { 9487c478bd9Sstevel@tonic-gate mdb_printf("'"); 9497c478bd9Sstevel@tonic-gate if (mdb_fmt_print(pap->pa_tgt, pap->pa_as, 9507c478bd9Sstevel@tonic-gate addr, 1, 'C') == addr) 9517c478bd9Sstevel@tonic-gate return (1); 9527c478bd9Sstevel@tonic-gate mdb_printf("'"); 9537c478bd9Sstevel@tonic-gate return (0); 9547c478bd9Sstevel@tonic-gate } 9557c478bd9Sstevel@tonic-gate 9567c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, addr) != size) { 9577c478bd9Sstevel@tonic-gate mdb_warn("failed to read %lu bytes at %llx", 9587c478bd9Sstevel@tonic-gate (ulong_t)size, addr); 9597c478bd9Sstevel@tonic-gate return (1); 9607c478bd9Sstevel@tonic-gate } 9617c478bd9Sstevel@tonic-gate 9627c478bd9Sstevel@tonic-gate /* 9637c478bd9Sstevel@tonic-gate * We pretty-print time_t values as a calendar date and time. 9647c478bd9Sstevel@tonic-gate */ 965bf5197d8Sjwadams if (!(pap->pa_flags & (PA_INTHEX | PA_INTDEC)) && 9667c478bd9Sstevel@tonic-gate strcmp(type, "time_t") == 0 && u.t != 0) { 9677c478bd9Sstevel@tonic-gate mdb_printf("%Y", u.t); 9687c478bd9Sstevel@tonic-gate return (0); 9697c478bd9Sstevel@tonic-gate } 9707c478bd9Sstevel@tonic-gate 9717c478bd9Sstevel@tonic-gate /* 9727c478bd9Sstevel@tonic-gate * The default format is hexadecimal. 9737c478bd9Sstevel@tonic-gate */ 9747c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_INTDEC)) 9757c478bd9Sstevel@tonic-gate fsp = xformat; 9767c478bd9Sstevel@tonic-gate else if (ep->cte_format & CTF_INT_SIGNED) 9777c478bd9Sstevel@tonic-gate fsp = sformat; 9787c478bd9Sstevel@tonic-gate else 9797c478bd9Sstevel@tonic-gate fsp = uformat; 9807c478bd9Sstevel@tonic-gate 9817c478bd9Sstevel@tonic-gate switch (size) { 9827c478bd9Sstevel@tonic-gate case sizeof (uint8_t): 9837c478bd9Sstevel@tonic-gate mdb_printf(fsp[0], u.i1); 9847c478bd9Sstevel@tonic-gate break; 9857c478bd9Sstevel@tonic-gate case sizeof (uint16_t): 9867c478bd9Sstevel@tonic-gate mdb_printf(fsp[1], u.i2); 9877c478bd9Sstevel@tonic-gate break; 9887c478bd9Sstevel@tonic-gate case sizeof (uint32_t): 9897c478bd9Sstevel@tonic-gate mdb_printf(fsp[2], u.i4); 9907c478bd9Sstevel@tonic-gate break; 9917c478bd9Sstevel@tonic-gate case sizeof (uint64_t): 9927c478bd9Sstevel@tonic-gate mdb_printf(fsp[3], u.i8); 9937c478bd9Sstevel@tonic-gate break; 9947c478bd9Sstevel@tonic-gate } 9957c478bd9Sstevel@tonic-gate return (0); 9967c478bd9Sstevel@tonic-gate } 9977c478bd9Sstevel@tonic-gate 9987c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 9997c478bd9Sstevel@tonic-gate static int 10007c478bd9Sstevel@tonic-gate print_int(const char *type, const char *name, mdb_ctf_id_t id, 10017c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 10027c478bd9Sstevel@tonic-gate { 10037c478bd9Sstevel@tonic-gate ctf_encoding_t e; 10047c478bd9Sstevel@tonic-gate 10057c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 10067c478bd9Sstevel@tonic-gate return (0); 10077c478bd9Sstevel@tonic-gate 10087c478bd9Sstevel@tonic-gate if (mdb_ctf_type_encoding(base, &e) != 0) { 10097c478bd9Sstevel@tonic-gate mdb_printf("??? (%s)", mdb_strerror(errno)); 10107c478bd9Sstevel@tonic-gate return (0); 10117c478bd9Sstevel@tonic-gate } 10127c478bd9Sstevel@tonic-gate 10137c478bd9Sstevel@tonic-gate return (print_int_val(type, &e, off, pap)); 10147c478bd9Sstevel@tonic-gate } 10157c478bd9Sstevel@tonic-gate 10167c478bd9Sstevel@tonic-gate /* 10177c478bd9Sstevel@tonic-gate * Print out a floating point value. We only provide support for floats in 10187c478bd9Sstevel@tonic-gate * the ANSI-C float, double, and long double formats. 10197c478bd9Sstevel@tonic-gate */ 10207c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10217c478bd9Sstevel@tonic-gate static int 10227c478bd9Sstevel@tonic-gate print_float(const char *type, const char *name, mdb_ctf_id_t id, 10237c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 10247c478bd9Sstevel@tonic-gate { 10257c478bd9Sstevel@tonic-gate #ifndef _KMDB 10267c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 10277c478bd9Sstevel@tonic-gate ctf_encoding_t e; 10287c478bd9Sstevel@tonic-gate 10297c478bd9Sstevel@tonic-gate union { 10307c478bd9Sstevel@tonic-gate float f; 10317c478bd9Sstevel@tonic-gate double d; 10327c478bd9Sstevel@tonic-gate long double ld; 10337c478bd9Sstevel@tonic-gate } u; 10347c478bd9Sstevel@tonic-gate 10357c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 10367c478bd9Sstevel@tonic-gate return (0); 10377c478bd9Sstevel@tonic-gate 10387c478bd9Sstevel@tonic-gate if (mdb_ctf_type_encoding(base, &e) == 0) { 10397c478bd9Sstevel@tonic-gate if (e.cte_format == CTF_FP_SINGLE && 10407c478bd9Sstevel@tonic-gate e.cte_bits == sizeof (float) * NBBY) { 10417c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.f, 10427c478bd9Sstevel@tonic-gate sizeof (u.f), addr) != sizeof (u.f)) { 10437c478bd9Sstevel@tonic-gate mdb_warn("failed to read float at %llx", addr); 10447c478bd9Sstevel@tonic-gate return (1); 10457c478bd9Sstevel@tonic-gate } 10467c478bd9Sstevel@tonic-gate mdb_printf("%s", doubletos(u.f, 7, 'e')); 10477c478bd9Sstevel@tonic-gate 10487c478bd9Sstevel@tonic-gate } else if (e.cte_format == CTF_FP_DOUBLE && 10497c478bd9Sstevel@tonic-gate e.cte_bits == sizeof (double) * NBBY) { 10507c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.d, 10517c478bd9Sstevel@tonic-gate sizeof (u.d), addr) != sizeof (u.d)) { 10527c478bd9Sstevel@tonic-gate mdb_warn("failed to read float at %llx", addr); 10537c478bd9Sstevel@tonic-gate return (1); 10547c478bd9Sstevel@tonic-gate } 10557c478bd9Sstevel@tonic-gate mdb_printf("%s", doubletos(u.d, 7, 'e')); 10567c478bd9Sstevel@tonic-gate 10577c478bd9Sstevel@tonic-gate } else if (e.cte_format == CTF_FP_LDOUBLE && 10587c478bd9Sstevel@tonic-gate e.cte_bits == sizeof (long double) * NBBY) { 10597c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.ld, 10607c478bd9Sstevel@tonic-gate sizeof (u.ld), addr) != sizeof (u.ld)) { 10617c478bd9Sstevel@tonic-gate mdb_warn("failed to read float at %llx", addr); 10627c478bd9Sstevel@tonic-gate return (1); 10637c478bd9Sstevel@tonic-gate } 10647c478bd9Sstevel@tonic-gate mdb_printf("%s", longdoubletos(&u.ld, 16, 'e')); 10657c478bd9Sstevel@tonic-gate 10667c478bd9Sstevel@tonic-gate } else { 10677c478bd9Sstevel@tonic-gate mdb_printf("??? (unsupported FP format %u / %u bits\n", 10687c478bd9Sstevel@tonic-gate e.cte_format, e.cte_bits); 10697c478bd9Sstevel@tonic-gate } 10707c478bd9Sstevel@tonic-gate } else 10717c478bd9Sstevel@tonic-gate mdb_printf("??? (%s)", mdb_strerror(errno)); 10727c478bd9Sstevel@tonic-gate #else 10737c478bd9Sstevel@tonic-gate mdb_printf("<FLOAT>"); 10747c478bd9Sstevel@tonic-gate #endif 10757c478bd9Sstevel@tonic-gate return (0); 10767c478bd9Sstevel@tonic-gate } 10777c478bd9Sstevel@tonic-gate 10787c478bd9Sstevel@tonic-gate 10797c478bd9Sstevel@tonic-gate /* 10807c478bd9Sstevel@tonic-gate * Print out a pointer value as a symbol name + offset or a hexadecimal value. 10817c478bd9Sstevel@tonic-gate * If the pointer itself is a char *, we attempt to read a bit of the data 10827c478bd9Sstevel@tonic-gate * referenced by the pointer and display it if it is a printable ASCII string. 10837c478bd9Sstevel@tonic-gate */ 10847c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 10857c478bd9Sstevel@tonic-gate static int 10867c478bd9Sstevel@tonic-gate print_ptr(const char *type, const char *name, mdb_ctf_id_t id, 10877c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 10887c478bd9Sstevel@tonic-gate { 10897c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 10907c478bd9Sstevel@tonic-gate ctf_encoding_t e; 10917c478bd9Sstevel@tonic-gate uintptr_t value; 10927c478bd9Sstevel@tonic-gate char buf[256]; 10937c478bd9Sstevel@tonic-gate ssize_t len; 10947c478bd9Sstevel@tonic-gate 10957c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 10967c478bd9Sstevel@tonic-gate return (0); 10977c478bd9Sstevel@tonic-gate 10987c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 10997c478bd9Sstevel@tonic-gate &value, sizeof (value), addr) != sizeof (value)) { 11007c478bd9Sstevel@tonic-gate mdb_warn("failed to read %s pointer at %llx", name, addr); 11017c478bd9Sstevel@tonic-gate return (1); 11027c478bd9Sstevel@tonic-gate } 11037c478bd9Sstevel@tonic-gate 11047c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_NOSYMBOLIC) { 11057c478bd9Sstevel@tonic-gate mdb_printf("%#lx", value); 11067c478bd9Sstevel@tonic-gate return (0); 11077c478bd9Sstevel@tonic-gate } 11087c478bd9Sstevel@tonic-gate 11097c478bd9Sstevel@tonic-gate mdb_printf("%a", value); 11107c478bd9Sstevel@tonic-gate 11117c478bd9Sstevel@tonic-gate if (value == NULL || strcmp(type, "caddr_t") == 0) 11127c478bd9Sstevel@tonic-gate return (0); 11137c478bd9Sstevel@tonic-gate 11147c478bd9Sstevel@tonic-gate if (mdb_ctf_type_kind(base) == CTF_K_POINTER && 11157c478bd9Sstevel@tonic-gate mdb_ctf_type_reference(base, &base) != -1 && 11167c478bd9Sstevel@tonic-gate mdb_ctf_type_resolve(base, &base) != -1 && 11177c478bd9Sstevel@tonic-gate mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e)) { 11187c478bd9Sstevel@tonic-gate if ((len = mdb_tgt_readstr(pap->pa_realtgt, pap->pa_as, 11197c478bd9Sstevel@tonic-gate buf, sizeof (buf), value)) >= 0 && strisprint(buf)) { 11207c478bd9Sstevel@tonic-gate if (len == sizeof (buf)) 11217c478bd9Sstevel@tonic-gate (void) strabbr(buf, sizeof (buf)); 11227c478bd9Sstevel@tonic-gate mdb_printf(" \"%s\"", buf); 11237c478bd9Sstevel@tonic-gate } 11247c478bd9Sstevel@tonic-gate } 11257c478bd9Sstevel@tonic-gate 11267c478bd9Sstevel@tonic-gate return (0); 11277c478bd9Sstevel@tonic-gate } 11287c478bd9Sstevel@tonic-gate 11297c478bd9Sstevel@tonic-gate 11307c478bd9Sstevel@tonic-gate /* 11317c478bd9Sstevel@tonic-gate * Print out a fixed-size array. We special-case arrays of characters 11327c478bd9Sstevel@tonic-gate * and attempt to print them out as ASCII strings if possible. For other 11337c478bd9Sstevel@tonic-gate * arrays, we iterate over a maximum of pa_armemlim members and call 11347c478bd9Sstevel@tonic-gate * mdb_ctf_type_visit() again on each element to print its value. 11357c478bd9Sstevel@tonic-gate */ 11367c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 11377c478bd9Sstevel@tonic-gate static int 11387c478bd9Sstevel@tonic-gate print_array(const char *type, const char *name, mdb_ctf_id_t id, 11397c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 11407c478bd9Sstevel@tonic-gate { 11417c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 11427c478bd9Sstevel@tonic-gate printarg_t pa = *pap; 11437c478bd9Sstevel@tonic-gate ssize_t eltsize; 11447c478bd9Sstevel@tonic-gate mdb_ctf_arinfo_t r; 11457c478bd9Sstevel@tonic-gate ctf_encoding_t e; 11467c478bd9Sstevel@tonic-gate uint_t i, kind, limit; 11477c478bd9Sstevel@tonic-gate int d, sou; 11487c478bd9Sstevel@tonic-gate char buf[8]; 11497c478bd9Sstevel@tonic-gate char *str; 11507c478bd9Sstevel@tonic-gate 11517c478bd9Sstevel@tonic-gate if (!(pap->pa_flags & PA_SHOWVAL)) 11527c478bd9Sstevel@tonic-gate return (0); 11537c478bd9Sstevel@tonic-gate 1154bf5197d8Sjwadams if (pap->pa_depth == pap->pa_maxdepth) { 1155bf5197d8Sjwadams mdb_printf("[ ... ]"); 1156bf5197d8Sjwadams return (0); 1157bf5197d8Sjwadams } 1158bf5197d8Sjwadams 11597c478bd9Sstevel@tonic-gate /* 11607c478bd9Sstevel@tonic-gate * Determine the base type and size of the array's content. If this 11617c478bd9Sstevel@tonic-gate * fails, we cannot print anything and just give up. 11627c478bd9Sstevel@tonic-gate */ 11637c478bd9Sstevel@tonic-gate if (mdb_ctf_array_info(base, &r) == -1 || 11647c478bd9Sstevel@tonic-gate mdb_ctf_type_resolve(r.mta_contents, &base) == -1 || 11657c478bd9Sstevel@tonic-gate (eltsize = mdb_ctf_type_size(base)) == -1) { 11667c478bd9Sstevel@tonic-gate mdb_printf("[ ??? ] (%s)", mdb_strerror(errno)); 11677c478bd9Sstevel@tonic-gate return (0); 11687c478bd9Sstevel@tonic-gate } 11697c478bd9Sstevel@tonic-gate 11707c478bd9Sstevel@tonic-gate /* 11717c478bd9Sstevel@tonic-gate * Read a few bytes and determine if the content appears to be 11727c478bd9Sstevel@tonic-gate * printable ASCII characters. If so, read the entire array and 11737c478bd9Sstevel@tonic-gate * attempt to display it as a string if it is printable. 11747c478bd9Sstevel@tonic-gate */ 11757c478bd9Sstevel@tonic-gate if ((pap->pa_arstrlim == MDB_ARR_NOLIMIT || 11767c478bd9Sstevel@tonic-gate r.mta_nelems <= pap->pa_arstrlim) && 11777c478bd9Sstevel@tonic-gate mdb_ctf_type_encoding(base, &e) == 0 && IS_CHAR(e) && 11787c478bd9Sstevel@tonic-gate mdb_tgt_readstr(pap->pa_tgt, pap->pa_as, buf, 11797c478bd9Sstevel@tonic-gate MIN(sizeof (buf), r.mta_nelems), addr) > 0 && strisprint(buf)) { 11807c478bd9Sstevel@tonic-gate 11817c478bd9Sstevel@tonic-gate str = mdb_alloc(r.mta_nelems + 1, UM_SLEEP | UM_GC); 11827c478bd9Sstevel@tonic-gate str[r.mta_nelems] = '\0'; 11837c478bd9Sstevel@tonic-gate 11847c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, str, 11857c478bd9Sstevel@tonic-gate r.mta_nelems, addr) != r.mta_nelems) { 11867c478bd9Sstevel@tonic-gate mdb_warn("failed to read char array at %llx", addr); 11877c478bd9Sstevel@tonic-gate return (1); 11887c478bd9Sstevel@tonic-gate } 11897c478bd9Sstevel@tonic-gate 11907c478bd9Sstevel@tonic-gate if (strisprint(str)) { 11917c478bd9Sstevel@tonic-gate mdb_printf("[ \"%s\" ]", str); 11927c478bd9Sstevel@tonic-gate return (0); 11937c478bd9Sstevel@tonic-gate } 11947c478bd9Sstevel@tonic-gate } 11957c478bd9Sstevel@tonic-gate 11967c478bd9Sstevel@tonic-gate if (pap->pa_armemlim != MDB_ARR_NOLIMIT) 11977c478bd9Sstevel@tonic-gate limit = MIN(r.mta_nelems, pap->pa_armemlim); 11987c478bd9Sstevel@tonic-gate else 11997c478bd9Sstevel@tonic-gate limit = r.mta_nelems; 12007c478bd9Sstevel@tonic-gate 12017c478bd9Sstevel@tonic-gate if (limit == 0) { 12027c478bd9Sstevel@tonic-gate mdb_printf("[ ... ]"); 12037c478bd9Sstevel@tonic-gate return (0); 12047c478bd9Sstevel@tonic-gate } 12057c478bd9Sstevel@tonic-gate 12067c478bd9Sstevel@tonic-gate kind = mdb_ctf_type_kind(base); 12077c478bd9Sstevel@tonic-gate sou = IS_COMPOSITE(kind); 12087c478bd9Sstevel@tonic-gate 12097c478bd9Sstevel@tonic-gate pa.pa_addr = addr; /* set base address to start of array */ 1210cce40297SJonathan Adams pa.pa_maxdepth = pa.pa_maxdepth - pa.pa_depth - 1; 12117c478bd9Sstevel@tonic-gate pa.pa_nest += pa.pa_depth + 1; /* nesting level is current depth + 1 */ 12127c478bd9Sstevel@tonic-gate pa.pa_depth = 0; /* reset depth to 0 for new scope */ 12137c478bd9Sstevel@tonic-gate pa.pa_prefix = NULL; 12147c478bd9Sstevel@tonic-gate 12157c478bd9Sstevel@tonic-gate if (sou) { 12167c478bd9Sstevel@tonic-gate pa.pa_delim = "\n"; 12177c478bd9Sstevel@tonic-gate mdb_printf("[\n"); 12187c478bd9Sstevel@tonic-gate } else { 12197c478bd9Sstevel@tonic-gate pa.pa_flags &= ~(PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR); 12207c478bd9Sstevel@tonic-gate pa.pa_delim = ", "; 12217c478bd9Sstevel@tonic-gate mdb_printf("[ "); 12227c478bd9Sstevel@tonic-gate } 12237c478bd9Sstevel@tonic-gate 12247c478bd9Sstevel@tonic-gate for (i = 0; i < limit; i++, pa.pa_addr += eltsize) { 12257c478bd9Sstevel@tonic-gate if (i == limit - 1 && !sou) { 12267c478bd9Sstevel@tonic-gate if (limit < r.mta_nelems) 12277c478bd9Sstevel@tonic-gate pa.pa_delim = ", ... ]"; 12287c478bd9Sstevel@tonic-gate else 12297c478bd9Sstevel@tonic-gate pa.pa_delim = " ]"; 12307c478bd9Sstevel@tonic-gate } 12317c478bd9Sstevel@tonic-gate 12327c478bd9Sstevel@tonic-gate if (mdb_ctf_type_visit(r.mta_contents, elt_print, &pa) == -1) { 12337c478bd9Sstevel@tonic-gate mdb_warn("failed to print array data"); 12347c478bd9Sstevel@tonic-gate return (1); 12357c478bd9Sstevel@tonic-gate } 12367c478bd9Sstevel@tonic-gate } 12377c478bd9Sstevel@tonic-gate 12387c478bd9Sstevel@tonic-gate if (sou) { 12397c478bd9Sstevel@tonic-gate for (d = pa.pa_depth - 1; d >= 0; d--) 12407c478bd9Sstevel@tonic-gate print_close_sou(&pa, d); 12417c478bd9Sstevel@tonic-gate 12427c478bd9Sstevel@tonic-gate if (limit < r.mta_nelems) { 12437c478bd9Sstevel@tonic-gate mdb_printf("%*s... ]", 12447c478bd9Sstevel@tonic-gate (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 12457c478bd9Sstevel@tonic-gate } else { 12467c478bd9Sstevel@tonic-gate mdb_printf("%*s]", 12477c478bd9Sstevel@tonic-gate (pap->pa_depth + pap->pa_nest) * pap->pa_tab, ""); 12487c478bd9Sstevel@tonic-gate } 12497c478bd9Sstevel@tonic-gate } 12507c478bd9Sstevel@tonic-gate 12517c478bd9Sstevel@tonic-gate /* copy the hole array info, since it may have been grown */ 12527c478bd9Sstevel@tonic-gate pap->pa_holes = pa.pa_holes; 12537c478bd9Sstevel@tonic-gate pap->pa_nholes = pa.pa_nholes; 12547c478bd9Sstevel@tonic-gate 12557c478bd9Sstevel@tonic-gate return (0); 12567c478bd9Sstevel@tonic-gate } 12577c478bd9Sstevel@tonic-gate 12587c478bd9Sstevel@tonic-gate /* 12597c478bd9Sstevel@tonic-gate * Print out a struct or union header. We need only print the open brace 12607c478bd9Sstevel@tonic-gate * because mdb_ctf_type_visit() itself will automatically recurse through 12617c478bd9Sstevel@tonic-gate * all members of the given struct or union. 12627c478bd9Sstevel@tonic-gate */ 12637c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12647c478bd9Sstevel@tonic-gate static int 12657c478bd9Sstevel@tonic-gate print_sou(const char *type, const char *name, mdb_ctf_id_t id, 12667c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 12677c478bd9Sstevel@tonic-gate { 1268bf5197d8Sjwadams if (pap->pa_depth == pap->pa_maxdepth) 1269bf5197d8Sjwadams mdb_printf("{ ... }"); 1270bf5197d8Sjwadams else 1271bf5197d8Sjwadams mdb_printf("{"); 12727c478bd9Sstevel@tonic-gate pap->pa_delim = "\n"; 12737c478bd9Sstevel@tonic-gate return (0); 12747c478bd9Sstevel@tonic-gate } 12757c478bd9Sstevel@tonic-gate 12767c478bd9Sstevel@tonic-gate /* 12777c478bd9Sstevel@tonic-gate * Print an enum value. We attempt to convert the value to the corresponding 12787c478bd9Sstevel@tonic-gate * enum name and print that if possible. 12797c478bd9Sstevel@tonic-gate */ 12807c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 12817c478bd9Sstevel@tonic-gate static int 12827c478bd9Sstevel@tonic-gate print_enum(const char *type, const char *name, mdb_ctf_id_t id, 12837c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 12847c478bd9Sstevel@tonic-gate { 12857c478bd9Sstevel@tonic-gate mdb_tgt_addr_t addr = pap->pa_addr + off / NBBY; 12867c478bd9Sstevel@tonic-gate const char *ename; 12877c478bd9Sstevel@tonic-gate int value; 1288*e0ad97e3SJonathan Adams int isp2 = enum_is_p2(base); 1289*e0ad97e3SJonathan Adams int flags = pap->pa_flags | (isp2 ? PA_INTHEX : 0); 12907c478bd9Sstevel@tonic-gate 1291*e0ad97e3SJonathan Adams if (!(flags & PA_SHOWVAL)) 12927c478bd9Sstevel@tonic-gate return (0); 12937c478bd9Sstevel@tonic-gate 12947c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 12957c478bd9Sstevel@tonic-gate &value, sizeof (value), addr) != sizeof (value)) { 12967c478bd9Sstevel@tonic-gate mdb_warn("failed to read %s integer at %llx", name, addr); 12977c478bd9Sstevel@tonic-gate return (1); 12987c478bd9Sstevel@tonic-gate } 12997c478bd9Sstevel@tonic-gate 1300*e0ad97e3SJonathan Adams if (flags & PA_INTHEX) 13017c478bd9Sstevel@tonic-gate mdb_printf("%#x", value); 13027c478bd9Sstevel@tonic-gate else 13037c478bd9Sstevel@tonic-gate mdb_printf("%#d", value); 13047c478bd9Sstevel@tonic-gate 1305*e0ad97e3SJonathan Adams (void) mdb_inc_indent(8); 1306*e0ad97e3SJonathan Adams mdb_printf(" ("); 1307cce40297SJonathan Adams 1308*e0ad97e3SJonathan Adams if (!isp2 || enum_value_print_p2(base, value, 0) != 0) { 1309*e0ad97e3SJonathan Adams ename = mdb_ctf_enum_name(base, value); 1310*e0ad97e3SJonathan Adams if (ename == NULL) { 1311*e0ad97e3SJonathan Adams ename = "???"; 1312*e0ad97e3SJonathan Adams } 1313*e0ad97e3SJonathan Adams mdb_printf("%s", ename); 1314*e0ad97e3SJonathan Adams } 1315*e0ad97e3SJonathan Adams mdb_printf(")"); 1316*e0ad97e3SJonathan Adams (void) mdb_dec_indent(8); 13177c478bd9Sstevel@tonic-gate 13187c478bd9Sstevel@tonic-gate return (0); 13197c478bd9Sstevel@tonic-gate } 13207c478bd9Sstevel@tonic-gate 13217c478bd9Sstevel@tonic-gate /* 1322cce40297SJonathan Adams * This will only get called if the structure isn't found in any available CTF 1323cce40297SJonathan Adams * data. 13247c478bd9Sstevel@tonic-gate */ 13257c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 13267c478bd9Sstevel@tonic-gate static int 13277c478bd9Sstevel@tonic-gate print_tag(const char *type, const char *name, mdb_ctf_id_t id, 13287c478bd9Sstevel@tonic-gate mdb_ctf_id_t base, ulong_t off, printarg_t *pap) 13297c478bd9Sstevel@tonic-gate { 1330cce40297SJonathan Adams char basename[MDB_SYM_NAMLEN]; 1331cce40297SJonathan Adams 13327c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_SHOWVAL) 13337c478bd9Sstevel@tonic-gate mdb_printf("; "); 13347c478bd9Sstevel@tonic-gate 1335cce40297SJonathan Adams if (mdb_ctf_type_name(base, basename, sizeof (basename)) != NULL) 1336cce40297SJonathan Adams mdb_printf("<forward declaration of %s>", basename); 1337cce40297SJonathan Adams else 1338cce40297SJonathan Adams mdb_printf("<forward declaration of unknown type>"); 1339cce40297SJonathan Adams 13407c478bd9Sstevel@tonic-gate return (0); 13417c478bd9Sstevel@tonic-gate } 13427c478bd9Sstevel@tonic-gate 13437c478bd9Sstevel@tonic-gate static void 13447c478bd9Sstevel@tonic-gate print_hole(printarg_t *pap, int depth, ulong_t off, ulong_t endoff) 13457c478bd9Sstevel@tonic-gate { 13467c478bd9Sstevel@tonic-gate ulong_t bits = endoff - off; 13477c478bd9Sstevel@tonic-gate ulong_t size = bits / NBBY; 13487c478bd9Sstevel@tonic-gate ctf_encoding_t e; 13497c478bd9Sstevel@tonic-gate 13507c478bd9Sstevel@tonic-gate static const char *const name = "<<HOLE>>"; 13517c478bd9Sstevel@tonic-gate char type[MDB_SYM_NAMLEN]; 13527c478bd9Sstevel@tonic-gate 13537c478bd9Sstevel@tonic-gate int bitfield = 13547c478bd9Sstevel@tonic-gate (off % NBBY != 0 || 13557c478bd9Sstevel@tonic-gate bits % NBBY != 0 || 13567c478bd9Sstevel@tonic-gate size > 8 || 13577c478bd9Sstevel@tonic-gate (size & (size - 1)) != 0); 13587c478bd9Sstevel@tonic-gate 13597c478bd9Sstevel@tonic-gate ASSERT(off < endoff); 13607c478bd9Sstevel@tonic-gate 13617c478bd9Sstevel@tonic-gate if (bits > NBBY * sizeof (uint64_t)) { 13627c478bd9Sstevel@tonic-gate ulong_t end; 13637c478bd9Sstevel@tonic-gate 13647c478bd9Sstevel@tonic-gate /* 13657c478bd9Sstevel@tonic-gate * The hole is larger than the largest integer type. To 13667c478bd9Sstevel@tonic-gate * handle this, we split up the hole at 8-byte-aligned 13677c478bd9Sstevel@tonic-gate * boundaries, recursing to print each subsection. For 13687c478bd9Sstevel@tonic-gate * normal C structures, we'll loop at most twice. 13697c478bd9Sstevel@tonic-gate */ 13707c478bd9Sstevel@tonic-gate for (; off < endoff; off = end) { 13717c478bd9Sstevel@tonic-gate end = P2END(off, NBBY * sizeof (uint64_t)); 13727c478bd9Sstevel@tonic-gate if (end > endoff) 13737c478bd9Sstevel@tonic-gate end = endoff; 13747c478bd9Sstevel@tonic-gate 13757c478bd9Sstevel@tonic-gate ASSERT((end - off) <= NBBY * sizeof (uint64_t)); 13767c478bd9Sstevel@tonic-gate print_hole(pap, depth, off, end); 13777c478bd9Sstevel@tonic-gate } 13787c478bd9Sstevel@tonic-gate ASSERT(end == endoff); 13797c478bd9Sstevel@tonic-gate 13807c478bd9Sstevel@tonic-gate return; 13817c478bd9Sstevel@tonic-gate } 13827c478bd9Sstevel@tonic-gate 13837c478bd9Sstevel@tonic-gate if (bitfield) 13847c478bd9Sstevel@tonic-gate (void) mdb_snprintf(type, sizeof (type), "unsigned"); 13857c478bd9Sstevel@tonic-gate else 13867c478bd9Sstevel@tonic-gate (void) mdb_snprintf(type, sizeof (type), "uint%d_t", bits); 13877c478bd9Sstevel@tonic-gate 13887c478bd9Sstevel@tonic-gate if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 13897c478bd9Sstevel@tonic-gate mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 13907c478bd9Sstevel@tonic-gate 13917c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_SHOWADDR) { 1392bf5197d8Sjwadams if (off % NBBY == 0) 13937c478bd9Sstevel@tonic-gate mdb_printf("%llx ", pap->pa_addr + off / NBBY); 13947c478bd9Sstevel@tonic-gate else 13957c478bd9Sstevel@tonic-gate mdb_printf("%llx.%lx ", 13967c478bd9Sstevel@tonic-gate pap->pa_addr + off / NBBY, off % NBBY); 13977c478bd9Sstevel@tonic-gate } 13987c478bd9Sstevel@tonic-gate 13997c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_SHOWTYPE) 14007c478bd9Sstevel@tonic-gate mdb_printf("%s ", type); 14017c478bd9Sstevel@tonic-gate 14027c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_SHOWNAME) 14037c478bd9Sstevel@tonic-gate mdb_printf("%s", name); 14047c478bd9Sstevel@tonic-gate 14057c478bd9Sstevel@tonic-gate if (bitfield && (pap->pa_flags & PA_SHOWTYPE)) 14067c478bd9Sstevel@tonic-gate mdb_printf(" :%d", bits); 14077c478bd9Sstevel@tonic-gate 14087c478bd9Sstevel@tonic-gate mdb_printf("%s ", (pap->pa_flags & PA_SHOWVAL)? " =" : ""); 14097c478bd9Sstevel@tonic-gate 14107c478bd9Sstevel@tonic-gate /* 14117c478bd9Sstevel@tonic-gate * We fake up a ctf_encoding_t, and use print_int_val() to print 14127c478bd9Sstevel@tonic-gate * the value. Holes are always processed as unsigned integers. 14137c478bd9Sstevel@tonic-gate */ 14147c478bd9Sstevel@tonic-gate bzero(&e, sizeof (e)); 14157c478bd9Sstevel@tonic-gate e.cte_format = 0; 14167c478bd9Sstevel@tonic-gate e.cte_offset = 0; 14177c478bd9Sstevel@tonic-gate e.cte_bits = bits; 14187c478bd9Sstevel@tonic-gate 14197c478bd9Sstevel@tonic-gate if (print_int_val(type, &e, off, pap) != 0) 14207c478bd9Sstevel@tonic-gate mdb_iob_discard(mdb.m_out); 14217c478bd9Sstevel@tonic-gate else 14227c478bd9Sstevel@tonic-gate mdb_iob_puts(mdb.m_out, pap->pa_delim); 14237c478bd9Sstevel@tonic-gate } 14247c478bd9Sstevel@tonic-gate 14257c478bd9Sstevel@tonic-gate /* 14267c478bd9Sstevel@tonic-gate * The print_close_sou() function is called for each structure or union 14277c478bd9Sstevel@tonic-gate * which has been completed. For structures, we detect and print any holes 14287c478bd9Sstevel@tonic-gate * before printing the closing brace. 14297c478bd9Sstevel@tonic-gate */ 14307c478bd9Sstevel@tonic-gate static void 14317c478bd9Sstevel@tonic-gate print_close_sou(printarg_t *pap, int newdepth) 14327c478bd9Sstevel@tonic-gate { 14337c478bd9Sstevel@tonic-gate int d = newdepth + pap->pa_nest; 14347c478bd9Sstevel@tonic-gate 14357c478bd9Sstevel@tonic-gate if ((pap->pa_flags & PA_SHOWHOLES) && !pap->pa_holes[d].hi_isunion) { 14367c478bd9Sstevel@tonic-gate ulong_t end = pap->pa_holes[d + 1].hi_offset; 14377c478bd9Sstevel@tonic-gate ulong_t expected = pap->pa_holes[d].hi_offset; 14387c478bd9Sstevel@tonic-gate 14397c478bd9Sstevel@tonic-gate if (end < expected) 14407c478bd9Sstevel@tonic-gate print_hole(pap, newdepth + 1, end, expected); 14417c478bd9Sstevel@tonic-gate } 1442cce40297SJonathan Adams /* if the struct is an array element, print a comma after the } */ 1443cce40297SJonathan Adams mdb_printf("%*s}%s\n", d * pap->pa_tab, "", 1444cce40297SJonathan Adams (newdepth == 0 && pap->pa_nest > 0)? "," : ""); 14457c478bd9Sstevel@tonic-gate } 14467c478bd9Sstevel@tonic-gate 14477c478bd9Sstevel@tonic-gate static printarg_f *const printfuncs[] = { 14487c478bd9Sstevel@tonic-gate print_int, /* CTF_K_INTEGER */ 14497c478bd9Sstevel@tonic-gate print_float, /* CTF_K_FLOAT */ 14507c478bd9Sstevel@tonic-gate print_ptr, /* CTF_K_POINTER */ 14517c478bd9Sstevel@tonic-gate print_array, /* CTF_K_ARRAY */ 14527c478bd9Sstevel@tonic-gate print_ptr, /* CTF_K_FUNCTION */ 14537c478bd9Sstevel@tonic-gate print_sou, /* CTF_K_STRUCT */ 14547c478bd9Sstevel@tonic-gate print_sou, /* CTF_K_UNION */ 14557c478bd9Sstevel@tonic-gate print_enum, /* CTF_K_ENUM */ 14567c478bd9Sstevel@tonic-gate print_tag /* CTF_K_FORWARD */ 14577c478bd9Sstevel@tonic-gate }; 14587c478bd9Sstevel@tonic-gate 14597c478bd9Sstevel@tonic-gate /* 14607c478bd9Sstevel@tonic-gate * The elt_print function is used as the mdb_ctf_type_visit callback. For 14617c478bd9Sstevel@tonic-gate * each element, we print an appropriate name prefix and then call the 14627c478bd9Sstevel@tonic-gate * print subroutine for this type class in the array above. 14637c478bd9Sstevel@tonic-gate */ 14647c478bd9Sstevel@tonic-gate static int 1465cce40297SJonathan Adams elt_print(const char *name, mdb_ctf_id_t id, mdb_ctf_id_t base, 1466cce40297SJonathan Adams ulong_t off, int depth, void *data) 14677c478bd9Sstevel@tonic-gate { 1468cce40297SJonathan Adams char type[MDB_SYM_NAMLEN + sizeof (" <<12345678...>>")]; 14697c478bd9Sstevel@tonic-gate int kind, rc, d; 14707c478bd9Sstevel@tonic-gate printarg_t *pap = data; 14717c478bd9Sstevel@tonic-gate 14727c478bd9Sstevel@tonic-gate for (d = pap->pa_depth - 1; d >= depth; d--) 14737c478bd9Sstevel@tonic-gate print_close_sou(pap, d); 14747c478bd9Sstevel@tonic-gate 1475bf5197d8Sjwadams if (depth > pap->pa_maxdepth) 1476bf5197d8Sjwadams return (0); 1477bf5197d8Sjwadams 1478cce40297SJonathan Adams if (!mdb_ctf_type_valid(base) || 14797c478bd9Sstevel@tonic-gate (kind = mdb_ctf_type_kind(base)) == -1) 14807c478bd9Sstevel@tonic-gate return (-1); /* errno is set for us */ 14817c478bd9Sstevel@tonic-gate 1482cce40297SJonathan Adams if (mdb_ctf_type_name(id, type, MDB_SYM_NAMLEN) == NULL) 14837c478bd9Sstevel@tonic-gate (void) strcpy(type, "(?)"); 14847c478bd9Sstevel@tonic-gate 1485cce40297SJonathan Adams if (pap->pa_flags & PA_SHOWBASETYPE) { 1486cce40297SJonathan Adams /* 1487cce40297SJonathan Adams * If basetype is different and informative, concatenate 1488cce40297SJonathan Adams * <<basetype>> (or <<baset...>> if it doesn't fit) 1489cce40297SJonathan Adams * 1490cce40297SJonathan Adams * We just use the end of the buffer to store the type name, and 1491cce40297SJonathan Adams * only connect it up if that's necessary. 1492cce40297SJonathan Adams */ 1493cce40297SJonathan Adams 1494cce40297SJonathan Adams char *type_end = type + strlen(type); 1495cce40297SJonathan Adams char *basetype; 1496cce40297SJonathan Adams size_t sz; 1497cce40297SJonathan Adams 1498cce40297SJonathan Adams (void) strlcat(type, " <<", sizeof (type)); 1499cce40297SJonathan Adams 1500cce40297SJonathan Adams basetype = type + strlen(type); 1501cce40297SJonathan Adams sz = sizeof (type) - (basetype - type); 1502cce40297SJonathan Adams 1503cce40297SJonathan Adams *type_end = '\0'; /* restore the end of type for strcmp() */ 1504cce40297SJonathan Adams 1505cce40297SJonathan Adams if (mdb_ctf_type_name(base, basetype, sz) != NULL && 1506cce40297SJonathan Adams strcmp(basetype, type) != 0 && 1507cce40297SJonathan Adams strcmp(basetype, "struct ") != 0 && 1508cce40297SJonathan Adams strcmp(basetype, "enum ") != 0 && 1509cce40297SJonathan Adams strcmp(basetype, "union ") != 0) { 1510cce40297SJonathan Adams type_end[0] = ' '; /* reconnect */ 1511cce40297SJonathan Adams if (strlcat(type, ">>", sizeof (type)) >= sizeof (type)) 1512cce40297SJonathan Adams (void) strlcpy( 1513cce40297SJonathan Adams type + sizeof (type) - 6, "...>>", 6); 1514cce40297SJonathan Adams } 1515cce40297SJonathan Adams } 1516cce40297SJonathan Adams 15177c478bd9Sstevel@tonic-gate if (pap->pa_flags & PA_SHOWHOLES) { 15187c478bd9Sstevel@tonic-gate ctf_encoding_t e; 15197c478bd9Sstevel@tonic-gate ssize_t nsize; 15207c478bd9Sstevel@tonic-gate ulong_t newoff; 15217c478bd9Sstevel@tonic-gate holeinfo_t *hole; 15227c478bd9Sstevel@tonic-gate int extra = IS_COMPOSITE(kind)? 1 : 0; 15237c478bd9Sstevel@tonic-gate 15247c478bd9Sstevel@tonic-gate /* 15257c478bd9Sstevel@tonic-gate * grow the hole array, if necessary 15267c478bd9Sstevel@tonic-gate */ 15277c478bd9Sstevel@tonic-gate if (pap->pa_nest + depth + extra >= pap->pa_nholes) { 15287c478bd9Sstevel@tonic-gate int new = MAX(MAX(8, pap->pa_nholes * 2), 15297c478bd9Sstevel@tonic-gate pap->pa_nest + depth + extra + 1); 15307c478bd9Sstevel@tonic-gate 15317c478bd9Sstevel@tonic-gate holeinfo_t *nhi = mdb_zalloc( 15327c478bd9Sstevel@tonic-gate sizeof (*nhi) * new, UM_NOSLEEP | UM_GC); 15337c478bd9Sstevel@tonic-gate 15347c478bd9Sstevel@tonic-gate bcopy(pap->pa_holes, nhi, 15357c478bd9Sstevel@tonic-gate pap->pa_nholes * sizeof (*nhi)); 15367c478bd9Sstevel@tonic-gate 15377c478bd9Sstevel@tonic-gate pap->pa_holes = nhi; 15387c478bd9Sstevel@tonic-gate pap->pa_nholes = new; 15397c478bd9Sstevel@tonic-gate } 15407c478bd9Sstevel@tonic-gate 15417c478bd9Sstevel@tonic-gate hole = &pap->pa_holes[depth + pap->pa_nest]; 15427c478bd9Sstevel@tonic-gate 15437c478bd9Sstevel@tonic-gate if (depth != 0 && off > hole->hi_offset) 15447c478bd9Sstevel@tonic-gate print_hole(pap, depth, hole->hi_offset, off); 15457c478bd9Sstevel@tonic-gate 15467c478bd9Sstevel@tonic-gate /* compute the next expected offset */ 15477c478bd9Sstevel@tonic-gate if (kind == CTF_K_INTEGER && 15487c478bd9Sstevel@tonic-gate mdb_ctf_type_encoding(base, &e) == 0) 15497c478bd9Sstevel@tonic-gate newoff = off + e.cte_bits; 15507c478bd9Sstevel@tonic-gate else if ((nsize = mdb_ctf_type_size(base)) >= 0) 15517c478bd9Sstevel@tonic-gate newoff = off + nsize * NBBY; 15527c478bd9Sstevel@tonic-gate else { 15537c478bd9Sstevel@tonic-gate /* something bad happened, disable hole checking */ 15547c478bd9Sstevel@tonic-gate newoff = -1UL; /* ULONG_MAX */ 15557c478bd9Sstevel@tonic-gate } 15567c478bd9Sstevel@tonic-gate 15577c478bd9Sstevel@tonic-gate hole->hi_offset = newoff; 15587c478bd9Sstevel@tonic-gate 15597c478bd9Sstevel@tonic-gate if (IS_COMPOSITE(kind)) { 15607c478bd9Sstevel@tonic-gate hole->hi_isunion = (kind == CTF_K_UNION); 15617c478bd9Sstevel@tonic-gate hole++; 15627c478bd9Sstevel@tonic-gate hole->hi_offset = off; 15637c478bd9Sstevel@tonic-gate } 15647c478bd9Sstevel@tonic-gate } 15657c478bd9Sstevel@tonic-gate 15667c478bd9Sstevel@tonic-gate if (pap->pa_flags & (PA_SHOWTYPE | PA_SHOWNAME | PA_SHOWADDR)) 15677c478bd9Sstevel@tonic-gate mdb_printf("%*s", (depth + pap->pa_nest) * pap->pa_tab, ""); 15687c478bd9Sstevel@tonic-gate 1569cce40297SJonathan Adams if (pap->pa_flags & PA_SHOWADDR) { 1570cce40297SJonathan Adams if (off % NBBY == 0) 1571cce40297SJonathan Adams mdb_printf("%llx ", pap->pa_addr + off / NBBY); 1572cce40297SJonathan Adams else 1573cce40297SJonathan Adams mdb_printf("%llx.%lx ", 1574cce40297SJonathan Adams pap->pa_addr + off / NBBY, off % NBBY); 1575cce40297SJonathan Adams } 15767c478bd9Sstevel@tonic-gate 1577cce40297SJonathan Adams if ((pap->pa_flags & PA_SHOWTYPE)) { 1578cce40297SJonathan Adams mdb_printf("%s", type); 1579cce40297SJonathan Adams /* 1580cce40297SJonathan Adams * We want to avoid printing a trailing space when 1581cce40297SJonathan Adams * dealing with pointers in a structure, so we end 1582cce40297SJonathan Adams * up with: 1583cce40297SJonathan Adams * 1584cce40297SJonathan Adams * label_t *t_onfault = 0 1585cce40297SJonathan Adams * 1586cce40297SJonathan Adams * If depth is zero, always print the trailing space unless 1587cce40297SJonathan Adams * we also have a prefix. 1588cce40297SJonathan Adams */ 1589cce40297SJonathan Adams if (type[strlen(type) - 1] != '*' || 1590cce40297SJonathan Adams (depth == 0 && (!(pap->pa_flags & PA_SHOWNAME) || 1591cce40297SJonathan Adams pap->pa_prefix == NULL))) 1592cce40297SJonathan Adams mdb_printf(" "); 1593cce40297SJonathan Adams } 15947c478bd9Sstevel@tonic-gate 1595cce40297SJonathan Adams if (pap->pa_flags & PA_SHOWNAME) { 1596cce40297SJonathan Adams if (pap->pa_prefix != NULL && depth <= 1) 1597cce40297SJonathan Adams mdb_printf("%s%s", pap->pa_prefix, 1598cce40297SJonathan Adams (depth == 0) ? "" : pap->pa_suffix); 1599cce40297SJonathan Adams mdb_printf("%s", name); 1600cce40297SJonathan Adams } 16017c478bd9Sstevel@tonic-gate 1602cce40297SJonathan Adams if ((pap->pa_flags & PA_SHOWTYPE) && kind == CTF_K_INTEGER) { 1603cce40297SJonathan Adams ctf_encoding_t e; 16047c478bd9Sstevel@tonic-gate 1605cce40297SJonathan Adams if (mdb_ctf_type_encoding(base, &e) == 0) { 1606cce40297SJonathan Adams ulong_t bits = e.cte_bits; 1607cce40297SJonathan Adams ulong_t size = bits / NBBY; 16087c478bd9Sstevel@tonic-gate 1609cce40297SJonathan Adams if (bits % NBBY != 0 || 1610cce40297SJonathan Adams off % NBBY != 0 || 1611cce40297SJonathan Adams size > 8 || 1612cce40297SJonathan Adams size != mdb_ctf_type_size(base)) 1613cce40297SJonathan Adams mdb_printf(" :%d", bits); 16147c478bd9Sstevel@tonic-gate } 1615cce40297SJonathan Adams } 16167c478bd9Sstevel@tonic-gate 1617cce40297SJonathan Adams if (depth != 0 || 1618cce40297SJonathan Adams ((pap->pa_flags & PA_SHOWNAME) && pap->pa_prefix != NULL)) 16197c478bd9Sstevel@tonic-gate mdb_printf("%s ", pap->pa_flags & PA_SHOWVAL ? " =" : ""); 16207c478bd9Sstevel@tonic-gate 1621cce40297SJonathan Adams if (depth == 0 && pap->pa_prefix != NULL) 1622cce40297SJonathan Adams name = pap->pa_prefix; 16237c478bd9Sstevel@tonic-gate 16247c478bd9Sstevel@tonic-gate pap->pa_depth = depth; 16258a6a72fdSaf if (kind <= CTF_K_UNKNOWN || kind >= CTF_K_TYPEDEF) { 16268a6a72fdSaf mdb_warn("unknown ctf for %s type %s kind %d\n", 1627cce40297SJonathan Adams name, type, kind); 16288a6a72fdSaf return (-1); 16298a6a72fdSaf } 16307c478bd9Sstevel@tonic-gate rc = printfuncs[kind - 1](type, name, id, base, off, pap); 16317c478bd9Sstevel@tonic-gate 16327c478bd9Sstevel@tonic-gate if (rc != 0) 16337c478bd9Sstevel@tonic-gate mdb_iob_discard(mdb.m_out); 16347c478bd9Sstevel@tonic-gate else 16357c478bd9Sstevel@tonic-gate mdb_iob_puts(mdb.m_out, pap->pa_delim); 16367c478bd9Sstevel@tonic-gate 16377c478bd9Sstevel@tonic-gate return (rc); 16387c478bd9Sstevel@tonic-gate } 16397c478bd9Sstevel@tonic-gate 1640bf5197d8Sjwadams /* 1641bf5197d8Sjwadams * Special semantics for pipelines. 1642bf5197d8Sjwadams */ 1643bf5197d8Sjwadams static int 1644bf5197d8Sjwadams pipe_print(mdb_ctf_id_t id, ulong_t off, void *data) 1645bf5197d8Sjwadams { 1646bf5197d8Sjwadams printarg_t *pap = data; 1647bf5197d8Sjwadams ssize_t size; 1648bf5197d8Sjwadams static const char *const fsp[] = { "%#r", "%#r", "%#r", "%#llr" }; 1649bf5197d8Sjwadams uintptr_t value; 1650bf5197d8Sjwadams uintptr_t addr = pap->pa_addr + off / NBBY; 1651bf5197d8Sjwadams mdb_ctf_id_t base; 1652bf5197d8Sjwadams ctf_encoding_t e; 1653bf5197d8Sjwadams 1654bf5197d8Sjwadams union { 1655bf5197d8Sjwadams uint64_t i8; 1656bf5197d8Sjwadams uint32_t i4; 1657bf5197d8Sjwadams uint16_t i2; 1658bf5197d8Sjwadams uint8_t i1; 1659bf5197d8Sjwadams } u; 1660bf5197d8Sjwadams 1661bf5197d8Sjwadams if (mdb_ctf_type_resolve(id, &base) == -1) { 1662bf5197d8Sjwadams mdb_warn("could not resolve type\n"); 1663bf5197d8Sjwadams return (-1); 1664bf5197d8Sjwadams } 1665bf5197d8Sjwadams 1666bf5197d8Sjwadams /* 1667bf5197d8Sjwadams * If the user gives -a, then always print out the address of the 1668bf5197d8Sjwadams * member. 1669bf5197d8Sjwadams */ 1670bf5197d8Sjwadams if ((pap->pa_flags & PA_SHOWADDR)) { 1671bf5197d8Sjwadams mdb_printf("%#lr\n", addr); 1672bf5197d8Sjwadams return (0); 1673bf5197d8Sjwadams } 1674bf5197d8Sjwadams 1675bf5197d8Sjwadams again: 1676bf5197d8Sjwadams switch (mdb_ctf_type_kind(base)) { 1677bf5197d8Sjwadams case CTF_K_POINTER: 1678bf5197d8Sjwadams if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, 1679bf5197d8Sjwadams &value, sizeof (value), addr) != sizeof (value)) { 1680bf5197d8Sjwadams mdb_warn("failed to read pointer at %p", addr); 1681bf5197d8Sjwadams return (-1); 1682bf5197d8Sjwadams } 1683bf5197d8Sjwadams mdb_printf("%#lr\n", value); 1684bf5197d8Sjwadams break; 1685bf5197d8Sjwadams 1686bf5197d8Sjwadams case CTF_K_INTEGER: 1687bf5197d8Sjwadams case CTF_K_ENUM: 1688bf5197d8Sjwadams if (mdb_ctf_type_encoding(base, &e) != 0) { 1689bf5197d8Sjwadams mdb_printf("could not get type encoding\n"); 1690bf5197d8Sjwadams return (-1); 1691bf5197d8Sjwadams } 1692bf5197d8Sjwadams 1693bf5197d8Sjwadams /* 1694bf5197d8Sjwadams * For immediate values, we just print out the value. 1695bf5197d8Sjwadams */ 1696bf5197d8Sjwadams size = e.cte_bits / NBBY; 1697bf5197d8Sjwadams if (size > 8 || (e.cte_bits % NBBY) != 0 || 1698bf5197d8Sjwadams (size & (size - 1)) != 0) { 1699bf5197d8Sjwadams return (print_bitfield(off, pap, &e)); 1700bf5197d8Sjwadams } 1701bf5197d8Sjwadams 1702bf5197d8Sjwadams if (mdb_tgt_aread(pap->pa_tgt, pap->pa_as, &u.i8, size, 1703bf5197d8Sjwadams addr) != size) { 1704bf5197d8Sjwadams mdb_warn("failed to read %lu bytes at %p", 1705bf5197d8Sjwadams (ulong_t)size, pap->pa_addr); 1706bf5197d8Sjwadams return (-1); 1707bf5197d8Sjwadams } 1708bf5197d8Sjwadams 1709bf5197d8Sjwadams switch (size) { 1710bf5197d8Sjwadams case sizeof (uint8_t): 1711bf5197d8Sjwadams mdb_printf(fsp[0], u.i1); 1712bf5197d8Sjwadams break; 1713bf5197d8Sjwadams case sizeof (uint16_t): 1714bf5197d8Sjwadams mdb_printf(fsp[1], u.i2); 1715bf5197d8Sjwadams break; 1716bf5197d8Sjwadams case sizeof (uint32_t): 1717bf5197d8Sjwadams mdb_printf(fsp[2], u.i4); 1718bf5197d8Sjwadams break; 1719bf5197d8Sjwadams case sizeof (uint64_t): 1720bf5197d8Sjwadams mdb_printf(fsp[3], u.i8); 1721bf5197d8Sjwadams break; 1722bf5197d8Sjwadams } 1723bf5197d8Sjwadams mdb_printf("\n"); 1724bf5197d8Sjwadams break; 1725bf5197d8Sjwadams 1726bf5197d8Sjwadams case CTF_K_FUNCTION: 1727bf5197d8Sjwadams case CTF_K_FLOAT: 1728bf5197d8Sjwadams case CTF_K_ARRAY: 1729bf5197d8Sjwadams case CTF_K_UNKNOWN: 1730bf5197d8Sjwadams case CTF_K_STRUCT: 1731bf5197d8Sjwadams case CTF_K_UNION: 1732bf5197d8Sjwadams case CTF_K_FORWARD: 1733bf5197d8Sjwadams /* 1734bf5197d8Sjwadams * For these types, always print the address of the member 1735bf5197d8Sjwadams */ 1736bf5197d8Sjwadams mdb_printf("%#lr\n", addr); 1737bf5197d8Sjwadams break; 1738bf5197d8Sjwadams 1739bf5197d8Sjwadams default: 1740bf5197d8Sjwadams mdb_warn("unknown type %d", mdb_ctf_type_kind(base)); 1741bf5197d8Sjwadams break; 1742bf5197d8Sjwadams } 1743bf5197d8Sjwadams 1744bf5197d8Sjwadams return (0); 1745bf5197d8Sjwadams } 1746bf5197d8Sjwadams 17477c478bd9Sstevel@tonic-gate static int 17487c478bd9Sstevel@tonic-gate parse_delimiter(char **strp) 17497c478bd9Sstevel@tonic-gate { 17507c478bd9Sstevel@tonic-gate switch (**strp) { 17517c478bd9Sstevel@tonic-gate case '\0': 17527c478bd9Sstevel@tonic-gate return (MEMBER_DELIM_DONE); 17537c478bd9Sstevel@tonic-gate 17547c478bd9Sstevel@tonic-gate case '.': 17557c478bd9Sstevel@tonic-gate *strp = *strp + 1; 17567c478bd9Sstevel@tonic-gate return (MEMBER_DELIM_DOT); 17577c478bd9Sstevel@tonic-gate 17587c478bd9Sstevel@tonic-gate case '[': 17597c478bd9Sstevel@tonic-gate *strp = *strp + 1; 17607c478bd9Sstevel@tonic-gate return (MEMBER_DELIM_LBR); 17617c478bd9Sstevel@tonic-gate 17627c478bd9Sstevel@tonic-gate case '-': 17637c478bd9Sstevel@tonic-gate *strp = *strp + 1; 17647c478bd9Sstevel@tonic-gate if (**strp == '>') { 17657c478bd9Sstevel@tonic-gate *strp = *strp + 1; 17667c478bd9Sstevel@tonic-gate return (MEMBER_DELIM_PTR); 17677c478bd9Sstevel@tonic-gate } 17687c478bd9Sstevel@tonic-gate *strp = *strp - 1; 17697c478bd9Sstevel@tonic-gate /*FALLTHROUGH*/ 17707c478bd9Sstevel@tonic-gate default: 17717c478bd9Sstevel@tonic-gate return (MEMBER_DELIM_ERR); 17727c478bd9Sstevel@tonic-gate } 17737c478bd9Sstevel@tonic-gate } 17747c478bd9Sstevel@tonic-gate 17757c478bd9Sstevel@tonic-gate static int 17767c478bd9Sstevel@tonic-gate deref(printarg_t *pap, size_t size) 17777c478bd9Sstevel@tonic-gate { 17787c478bd9Sstevel@tonic-gate uint32_t a32; 17797c478bd9Sstevel@tonic-gate mdb_tgt_as_t as = pap->pa_as; 17807c478bd9Sstevel@tonic-gate mdb_tgt_addr_t *ap = &pap->pa_addr; 17817c478bd9Sstevel@tonic-gate 17827c478bd9Sstevel@tonic-gate if (size == sizeof (mdb_tgt_addr_t)) { 17837c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(mdb.m_target, as, ap, size, *ap) == -1) { 17847c478bd9Sstevel@tonic-gate mdb_warn("could not dereference pointer %llx\n", *ap); 17857c478bd9Sstevel@tonic-gate return (-1); 17867c478bd9Sstevel@tonic-gate } 17877c478bd9Sstevel@tonic-gate } else { 17887c478bd9Sstevel@tonic-gate if (mdb_tgt_aread(mdb.m_target, as, &a32, size, *ap) == -1) { 17897c478bd9Sstevel@tonic-gate mdb_warn("could not dereference pointer %x\n", *ap); 17907c478bd9Sstevel@tonic-gate return (-1); 17917c478bd9Sstevel@tonic-gate } 17927c478bd9Sstevel@tonic-gate 17937c478bd9Sstevel@tonic-gate *ap = (mdb_tgt_addr_t)a32; 17947c478bd9Sstevel@tonic-gate } 17957c478bd9Sstevel@tonic-gate 17967c478bd9Sstevel@tonic-gate /* 17977c478bd9Sstevel@tonic-gate * We've dereferenced at least once, we must be on the real 17987c478bd9Sstevel@tonic-gate * target. If we were in the immediate target, reset to the real 17997c478bd9Sstevel@tonic-gate * target; it's reset as needed when we return to the print 18007c478bd9Sstevel@tonic-gate * routines. 18017c478bd9Sstevel@tonic-gate */ 18027c478bd9Sstevel@tonic-gate if (pap->pa_tgt == pap->pa_immtgt) 18037c478bd9Sstevel@tonic-gate pap->pa_tgt = pap->pa_realtgt; 18047c478bd9Sstevel@tonic-gate 18057c478bd9Sstevel@tonic-gate return (0); 18067c478bd9Sstevel@tonic-gate } 18077c478bd9Sstevel@tonic-gate 18087c478bd9Sstevel@tonic-gate static int 18097c478bd9Sstevel@tonic-gate parse_member(printarg_t *pap, const char *str, mdb_ctf_id_t id, 18107c478bd9Sstevel@tonic-gate mdb_ctf_id_t *idp, ulong_t *offp, int *last_deref) 18117c478bd9Sstevel@tonic-gate { 18127c478bd9Sstevel@tonic-gate int delim; 18137c478bd9Sstevel@tonic-gate char member[64]; 18147c478bd9Sstevel@tonic-gate char buf[128]; 18157c478bd9Sstevel@tonic-gate uint_t index; 18167c478bd9Sstevel@tonic-gate char *start = (char *)str; 18177c478bd9Sstevel@tonic-gate char *end; 18187c478bd9Sstevel@tonic-gate ulong_t off = 0; 18197c478bd9Sstevel@tonic-gate mdb_ctf_arinfo_t ar; 18207c478bd9Sstevel@tonic-gate mdb_ctf_id_t rid; 18217c478bd9Sstevel@tonic-gate int kind; 18227c478bd9Sstevel@tonic-gate ssize_t size; 18237c478bd9Sstevel@tonic-gate int non_array = FALSE; 18247c478bd9Sstevel@tonic-gate 18257c478bd9Sstevel@tonic-gate /* 18267c478bd9Sstevel@tonic-gate * id always has the unresolved type for printing error messages 18277c478bd9Sstevel@tonic-gate * that include the type; rid always has the resolved type for 18287c478bd9Sstevel@tonic-gate * use in mdb_ctf_* calls. It is possible for this command to fail, 18297c478bd9Sstevel@tonic-gate * however, if the resolved type is in the parent and it is currently 18307c478bd9Sstevel@tonic-gate * unavailable. Note that we also can't print out the name of the 18317c478bd9Sstevel@tonic-gate * type, since that would also rely on looking up the resolved name. 18327c478bd9Sstevel@tonic-gate */ 18337c478bd9Sstevel@tonic-gate if (mdb_ctf_type_resolve(id, &rid) != 0) { 18347c478bd9Sstevel@tonic-gate mdb_warn("failed to resolve type"); 18357c478bd9Sstevel@tonic-gate return (-1); 18367c478bd9Sstevel@tonic-gate } 18377c478bd9Sstevel@tonic-gate 18387c478bd9Sstevel@tonic-gate delim = parse_delimiter(&start); 18397c478bd9Sstevel@tonic-gate /* 18407c478bd9Sstevel@tonic-gate * If the user fails to specify an initial delimiter, guess -> for 18417c478bd9Sstevel@tonic-gate * pointer types and . for non-pointer types. 18427c478bd9Sstevel@tonic-gate */ 18437c478bd9Sstevel@tonic-gate if (delim == MEMBER_DELIM_ERR) 18447c478bd9Sstevel@tonic-gate delim = (mdb_ctf_type_kind(rid) == CTF_K_POINTER) ? 18457c478bd9Sstevel@tonic-gate MEMBER_DELIM_PTR : MEMBER_DELIM_DOT; 18467c478bd9Sstevel@tonic-gate 18477c478bd9Sstevel@tonic-gate *last_deref = FALSE; 18487c478bd9Sstevel@tonic-gate 18497c478bd9Sstevel@tonic-gate while (delim != MEMBER_DELIM_DONE) { 18507c478bd9Sstevel@tonic-gate switch (delim) { 18517c478bd9Sstevel@tonic-gate case MEMBER_DELIM_PTR: 18527c478bd9Sstevel@tonic-gate kind = mdb_ctf_type_kind(rid); 18537c478bd9Sstevel@tonic-gate if (kind != CTF_K_POINTER) { 18547c478bd9Sstevel@tonic-gate mdb_warn("%s is not a pointer type\n", 18557c478bd9Sstevel@tonic-gate mdb_ctf_type_name(id, buf, sizeof (buf))); 18567c478bd9Sstevel@tonic-gate return (-1); 18577c478bd9Sstevel@tonic-gate } 18587c478bd9Sstevel@tonic-gate 18597c478bd9Sstevel@tonic-gate size = mdb_ctf_type_size(id); 18607c478bd9Sstevel@tonic-gate if (deref(pap, size) != 0) 18617c478bd9Sstevel@tonic-gate return (-1); 18627c478bd9Sstevel@tonic-gate 18637c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_reference(rid, &id); 18647c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_resolve(id, &rid); 18657c478bd9Sstevel@tonic-gate 18667c478bd9Sstevel@tonic-gate off = 0; 18677c478bd9Sstevel@tonic-gate break; 18687c478bd9Sstevel@tonic-gate 18697c478bd9Sstevel@tonic-gate case MEMBER_DELIM_DOT: 18707c478bd9Sstevel@tonic-gate kind = mdb_ctf_type_kind(rid); 18717c478bd9Sstevel@tonic-gate if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 18727c478bd9Sstevel@tonic-gate mdb_warn("%s is not a struct or union type\n", 18737c478bd9Sstevel@tonic-gate mdb_ctf_type_name(id, buf, sizeof (buf))); 18747c478bd9Sstevel@tonic-gate return (-1); 18757c478bd9Sstevel@tonic-gate } 18767c478bd9Sstevel@tonic-gate break; 18777c478bd9Sstevel@tonic-gate 18787c478bd9Sstevel@tonic-gate case MEMBER_DELIM_LBR: 18797c478bd9Sstevel@tonic-gate end = strchr(start, ']'); 18807c478bd9Sstevel@tonic-gate if (end == NULL) { 18817c478bd9Sstevel@tonic-gate mdb_warn("no trailing ']'\n"); 18827c478bd9Sstevel@tonic-gate return (-1); 18837c478bd9Sstevel@tonic-gate } 18847c478bd9Sstevel@tonic-gate 18857c478bd9Sstevel@tonic-gate (void) mdb_snprintf(member, end - start + 1, start); 18867c478bd9Sstevel@tonic-gate 18877c478bd9Sstevel@tonic-gate index = mdb_strtoull(member); 18887c478bd9Sstevel@tonic-gate 18897c478bd9Sstevel@tonic-gate switch (mdb_ctf_type_kind(rid)) { 18907c478bd9Sstevel@tonic-gate case CTF_K_POINTER: 18917c478bd9Sstevel@tonic-gate size = mdb_ctf_type_size(rid); 18927c478bd9Sstevel@tonic-gate 18937c478bd9Sstevel@tonic-gate if (deref(pap, size) != 0) 18947c478bd9Sstevel@tonic-gate return (-1); 18957c478bd9Sstevel@tonic-gate 18967c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_reference(rid, &id); 18977c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_resolve(id, &rid); 18987c478bd9Sstevel@tonic-gate 18997c478bd9Sstevel@tonic-gate size = mdb_ctf_type_size(id); 19007c478bd9Sstevel@tonic-gate if (size <= 0) { 19017c478bd9Sstevel@tonic-gate mdb_warn("cannot dereference void " 19027c478bd9Sstevel@tonic-gate "type\n"); 19037c478bd9Sstevel@tonic-gate return (-1); 19047c478bd9Sstevel@tonic-gate } 19057c478bd9Sstevel@tonic-gate 19067c478bd9Sstevel@tonic-gate pap->pa_addr += index * size; 19077c478bd9Sstevel@tonic-gate off = 0; 19087c478bd9Sstevel@tonic-gate 19097c478bd9Sstevel@tonic-gate if (index == 0 && non_array) 19107c478bd9Sstevel@tonic-gate *last_deref = TRUE; 19117c478bd9Sstevel@tonic-gate break; 19127c478bd9Sstevel@tonic-gate 19137c478bd9Sstevel@tonic-gate case CTF_K_ARRAY: 19147c478bd9Sstevel@tonic-gate (void) mdb_ctf_array_info(rid, &ar); 19157c478bd9Sstevel@tonic-gate 19167c478bd9Sstevel@tonic-gate if (index >= ar.mta_nelems) { 19177c478bd9Sstevel@tonic-gate mdb_warn("index %r is outside of " 19187c478bd9Sstevel@tonic-gate "array bounds [0 .. %r]\n", 19197c478bd9Sstevel@tonic-gate index, ar.mta_nelems - 1); 19207c478bd9Sstevel@tonic-gate } 19217c478bd9Sstevel@tonic-gate 19227c478bd9Sstevel@tonic-gate id = ar.mta_contents; 19237c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_resolve(id, &rid); 19247c478bd9Sstevel@tonic-gate 19257c478bd9Sstevel@tonic-gate size = mdb_ctf_type_size(id); 19267c478bd9Sstevel@tonic-gate if (size <= 0) { 19277c478bd9Sstevel@tonic-gate mdb_warn("cannot dereference void " 19287c478bd9Sstevel@tonic-gate "type\n"); 19297c478bd9Sstevel@tonic-gate return (-1); 19307c478bd9Sstevel@tonic-gate } 19317c478bd9Sstevel@tonic-gate 19327c478bd9Sstevel@tonic-gate pap->pa_addr += index * size; 19337c478bd9Sstevel@tonic-gate off = 0; 19347c478bd9Sstevel@tonic-gate break; 19357c478bd9Sstevel@tonic-gate 19367c478bd9Sstevel@tonic-gate default: 19377c478bd9Sstevel@tonic-gate mdb_warn("cannot index into non-array, " 19387c478bd9Sstevel@tonic-gate "non-pointer type\n"); 19397c478bd9Sstevel@tonic-gate return (-1); 19407c478bd9Sstevel@tonic-gate } 19417c478bd9Sstevel@tonic-gate 19427c478bd9Sstevel@tonic-gate start = end + 1; 19437c478bd9Sstevel@tonic-gate delim = parse_delimiter(&start); 19447c478bd9Sstevel@tonic-gate continue; 19457c478bd9Sstevel@tonic-gate 19467c478bd9Sstevel@tonic-gate case MEMBER_DELIM_ERR: 19477c478bd9Sstevel@tonic-gate default: 19487c478bd9Sstevel@tonic-gate mdb_warn("'%c' is not a valid delimiter\n", *start); 19497c478bd9Sstevel@tonic-gate return (-1); 19507c478bd9Sstevel@tonic-gate } 19517c478bd9Sstevel@tonic-gate 19527c478bd9Sstevel@tonic-gate *last_deref = FALSE; 19537c478bd9Sstevel@tonic-gate non_array = TRUE; 19547c478bd9Sstevel@tonic-gate 19557c478bd9Sstevel@tonic-gate /* 19567c478bd9Sstevel@tonic-gate * Find the end of the member name; assume that a member 19577c478bd9Sstevel@tonic-gate * name is at least one character long. 19587c478bd9Sstevel@tonic-gate */ 19597c478bd9Sstevel@tonic-gate for (end = start + 1; isalnum(*end) || *end == '_'; end++) 19607c478bd9Sstevel@tonic-gate continue; 19617c478bd9Sstevel@tonic-gate 19627c478bd9Sstevel@tonic-gate (void) mdb_snprintf(member, end - start + 1, start); 19637c478bd9Sstevel@tonic-gate 19647c478bd9Sstevel@tonic-gate if (mdb_ctf_member_info(rid, member, &off, &id) != 0) { 19657c478bd9Sstevel@tonic-gate mdb_warn("failed to find member %s of %s", member, 19667c478bd9Sstevel@tonic-gate mdb_ctf_type_name(id, buf, sizeof (buf))); 19677c478bd9Sstevel@tonic-gate return (-1); 19687c478bd9Sstevel@tonic-gate } 19697c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_resolve(id, &rid); 19707c478bd9Sstevel@tonic-gate 19717c478bd9Sstevel@tonic-gate pap->pa_addr += off / NBBY; 19727c478bd9Sstevel@tonic-gate 19737c478bd9Sstevel@tonic-gate start = end; 19747c478bd9Sstevel@tonic-gate delim = parse_delimiter(&start); 19757c478bd9Sstevel@tonic-gate } 19767c478bd9Sstevel@tonic-gate 19777c478bd9Sstevel@tonic-gate 19787c478bd9Sstevel@tonic-gate *idp = id; 19797c478bd9Sstevel@tonic-gate *offp = off; 19807c478bd9Sstevel@tonic-gate 19817c478bd9Sstevel@tonic-gate return (0); 19827c478bd9Sstevel@tonic-gate } 19837c478bd9Sstevel@tonic-gate 19847c478bd9Sstevel@tonic-gate /* 19857c478bd9Sstevel@tonic-gate * Recursively descend a print a given data structure. We create a struct of 19867c478bd9Sstevel@tonic-gate * the relevant print arguments and then call mdb_ctf_type_visit() to do the 19877c478bd9Sstevel@tonic-gate * traversal, using elt_print() as the callback for each element. 19887c478bd9Sstevel@tonic-gate */ 19897c478bd9Sstevel@tonic-gate /*ARGSUSED*/ 19907c478bd9Sstevel@tonic-gate int 19917c478bd9Sstevel@tonic-gate cmd_print(uintptr_t addr, uint_t flags, int argc, const mdb_arg_t *argv) 19927c478bd9Sstevel@tonic-gate { 19937c478bd9Sstevel@tonic-gate uintptr_t opt_c = MDB_ARR_NOLIMIT, opt_l = MDB_ARR_NOLIMIT; 19947c478bd9Sstevel@tonic-gate uint_t opt_C = FALSE, opt_L = FALSE, opt_p = FALSE, opt_i = FALSE; 1995bf5197d8Sjwadams uintptr_t opt_s = (uintptr_t)-1ul; 19967c478bd9Sstevel@tonic-gate int uflags = (flags & DCMD_ADDRSPEC) ? PA_SHOWVAL : 0; 19977c478bd9Sstevel@tonic-gate mdb_ctf_id_t id; 19987c478bd9Sstevel@tonic-gate int err = DCMD_OK; 19997c478bd9Sstevel@tonic-gate 20007c478bd9Sstevel@tonic-gate mdb_tgt_t *t = mdb.m_target; 20017c478bd9Sstevel@tonic-gate printarg_t pa; 20027c478bd9Sstevel@tonic-gate int d, i; 20037c478bd9Sstevel@tonic-gate 20047c478bd9Sstevel@tonic-gate char s_name[MDB_SYM_NAMLEN]; 20057c478bd9Sstevel@tonic-gate mdb_syminfo_t s_info; 20067c478bd9Sstevel@tonic-gate GElf_Sym sym; 20077c478bd9Sstevel@tonic-gate 20087c478bd9Sstevel@tonic-gate i = mdb_getopts(argc, argv, 20097c478bd9Sstevel@tonic-gate 'a', MDB_OPT_SETBITS, PA_SHOWADDR, &uflags, 20107c478bd9Sstevel@tonic-gate 'C', MDB_OPT_SETBITS, TRUE, &opt_C, 2011cce40297SJonathan Adams 'c', MDB_OPT_UINTPTR, &opt_c, 20127c478bd9Sstevel@tonic-gate 'd', MDB_OPT_SETBITS, PA_INTDEC, &uflags, 20137c478bd9Sstevel@tonic-gate 'h', MDB_OPT_SETBITS, PA_SHOWHOLES, &uflags, 2014cce40297SJonathan Adams 'i', MDB_OPT_SETBITS, TRUE, &opt_i, 20157c478bd9Sstevel@tonic-gate 'L', MDB_OPT_SETBITS, TRUE, &opt_L, 2016cce40297SJonathan Adams 'l', MDB_OPT_UINTPTR, &opt_l, 20177c478bd9Sstevel@tonic-gate 'n', MDB_OPT_SETBITS, PA_NOSYMBOLIC, &uflags, 20187c478bd9Sstevel@tonic-gate 'p', MDB_OPT_SETBITS, TRUE, &opt_p, 2019cce40297SJonathan Adams 's', MDB_OPT_UINTPTR, &opt_s, 2020cce40297SJonathan Adams 'T', MDB_OPT_SETBITS, PA_SHOWTYPE | PA_SHOWBASETYPE, &uflags, 20217c478bd9Sstevel@tonic-gate 't', MDB_OPT_SETBITS, PA_SHOWTYPE, &uflags, 20227c478bd9Sstevel@tonic-gate 'x', MDB_OPT_SETBITS, PA_INTHEX, &uflags, 20237c478bd9Sstevel@tonic-gate NULL); 20247c478bd9Sstevel@tonic-gate 20257c478bd9Sstevel@tonic-gate if (uflags & PA_INTHEX) 20267c478bd9Sstevel@tonic-gate uflags &= ~PA_INTDEC; /* -x and -d are mutually exclusive */ 20277c478bd9Sstevel@tonic-gate 2028bf5197d8Sjwadams uflags |= PA_SHOWNAME; 20297c478bd9Sstevel@tonic-gate 20307c478bd9Sstevel@tonic-gate if (opt_p && opt_i) { 20317c478bd9Sstevel@tonic-gate mdb_warn("-p and -i options are incompatible\n"); 20327c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20337c478bd9Sstevel@tonic-gate } 20347c478bd9Sstevel@tonic-gate 20357c478bd9Sstevel@tonic-gate argc -= i; 20367c478bd9Sstevel@tonic-gate argv += i; 20377c478bd9Sstevel@tonic-gate 20387c478bd9Sstevel@tonic-gate if (argc != 0 && argv->a_type == MDB_TYPE_STRING) { 20397c478bd9Sstevel@tonic-gate const char *t_name = s_name; 20407c478bd9Sstevel@tonic-gate int ret; 20417c478bd9Sstevel@tonic-gate 20427c478bd9Sstevel@tonic-gate if (strchr("+-", argv->a_un.a_str[0]) != NULL) 20437c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 20447c478bd9Sstevel@tonic-gate 20457c478bd9Sstevel@tonic-gate if ((ret = args_to_typename(&argc, &argv, s_name, 20467c478bd9Sstevel@tonic-gate sizeof (s_name))) != 0) 20477c478bd9Sstevel@tonic-gate return (ret); 20487c478bd9Sstevel@tonic-gate 20497c478bd9Sstevel@tonic-gate if (mdb_ctf_lookup_by_name(t_name, &id) != 0) { 20507c478bd9Sstevel@tonic-gate if (!(flags & DCMD_ADDRSPEC) || opt_i || 20517c478bd9Sstevel@tonic-gate addr_to_sym(t, addr, s_name, sizeof (s_name), 2052cce40297SJonathan Adams &sym, &s_info) == NULL || 20537c478bd9Sstevel@tonic-gate mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 20547c478bd9Sstevel@tonic-gate 20557c478bd9Sstevel@tonic-gate mdb_warn("failed to look up type %s", t_name); 20567c478bd9Sstevel@tonic-gate return (DCMD_ABORT); 20577c478bd9Sstevel@tonic-gate } 20587c478bd9Sstevel@tonic-gate } else { 20597c478bd9Sstevel@tonic-gate argc--; 20607c478bd9Sstevel@tonic-gate argv++; 20617c478bd9Sstevel@tonic-gate } 20627c478bd9Sstevel@tonic-gate 20637c478bd9Sstevel@tonic-gate } else if (!(flags & DCMD_ADDRSPEC) || opt_i) { 20647c478bd9Sstevel@tonic-gate return (DCMD_USAGE); 20657c478bd9Sstevel@tonic-gate 20667c478bd9Sstevel@tonic-gate } else if (addr_to_sym(t, addr, s_name, sizeof (s_name), 20677c478bd9Sstevel@tonic-gate &sym, &s_info) == NULL) { 20687c478bd9Sstevel@tonic-gate mdb_warn("no symbol information for %a", addr); 20697c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20707c478bd9Sstevel@tonic-gate 20717c478bd9Sstevel@tonic-gate } else if (mdb_ctf_lookup_by_symbol(&sym, &s_info, &id) != 0) { 20727c478bd9Sstevel@tonic-gate mdb_warn("no type data available for %a [%u]", addr, 20737c478bd9Sstevel@tonic-gate s_info.sym_id); 20747c478bd9Sstevel@tonic-gate return (DCMD_ERR); 20757c478bd9Sstevel@tonic-gate } 20767c478bd9Sstevel@tonic-gate 20777c478bd9Sstevel@tonic-gate pa.pa_tgt = mdb.m_target; 20787c478bd9Sstevel@tonic-gate pa.pa_realtgt = pa.pa_tgt; 20797c478bd9Sstevel@tonic-gate pa.pa_immtgt = NULL; 20807c478bd9Sstevel@tonic-gate pa.pa_as = opt_p ? MDB_TGT_AS_PHYS : MDB_TGT_AS_VIRT; 20817c478bd9Sstevel@tonic-gate pa.pa_armemlim = mdb.m_armemlim; 20827c478bd9Sstevel@tonic-gate pa.pa_arstrlim = mdb.m_arstrlim; 20837c478bd9Sstevel@tonic-gate pa.pa_delim = "\n"; 20847c478bd9Sstevel@tonic-gate pa.pa_flags = uflags; 20857c478bd9Sstevel@tonic-gate pa.pa_nest = 0; 20867c478bd9Sstevel@tonic-gate pa.pa_tab = 4; 20877c478bd9Sstevel@tonic-gate pa.pa_prefix = NULL; 20887c478bd9Sstevel@tonic-gate pa.pa_suffix = NULL; 20897c478bd9Sstevel@tonic-gate pa.pa_holes = NULL; 20907c478bd9Sstevel@tonic-gate pa.pa_nholes = 0; 20917c478bd9Sstevel@tonic-gate pa.pa_depth = 0; 2092bf5197d8Sjwadams pa.pa_maxdepth = opt_s; 20937c478bd9Sstevel@tonic-gate 20947c478bd9Sstevel@tonic-gate if ((flags & DCMD_ADDRSPEC) && !opt_i) 20957c478bd9Sstevel@tonic-gate pa.pa_addr = opt_p ? mdb_get_dot() : addr; 20967c478bd9Sstevel@tonic-gate else 20977c478bd9Sstevel@tonic-gate pa.pa_addr = NULL; 20987c478bd9Sstevel@tonic-gate 20997c478bd9Sstevel@tonic-gate if (opt_i) { 21007c478bd9Sstevel@tonic-gate const char *vargv[2]; 21017c478bd9Sstevel@tonic-gate uintmax_t dot = mdb_get_dot(); 21027c478bd9Sstevel@tonic-gate size_t outsize = mdb_ctf_type_size(id); 21037c478bd9Sstevel@tonic-gate vargv[0] = (const char *)˙ 21047c478bd9Sstevel@tonic-gate vargv[1] = (const char *)&outsize; 21057c478bd9Sstevel@tonic-gate pa.pa_immtgt = mdb_tgt_create(mdb_value_tgt_create, 2106cce40297SJonathan Adams 0, 2, vargv); 21077c478bd9Sstevel@tonic-gate pa.pa_tgt = pa.pa_immtgt; 21087c478bd9Sstevel@tonic-gate } 21097c478bd9Sstevel@tonic-gate 21107c478bd9Sstevel@tonic-gate if (opt_c != MDB_ARR_NOLIMIT) 21117c478bd9Sstevel@tonic-gate pa.pa_arstrlim = opt_c; 21127c478bd9Sstevel@tonic-gate if (opt_C) 21137c478bd9Sstevel@tonic-gate pa.pa_arstrlim = MDB_ARR_NOLIMIT; 21147c478bd9Sstevel@tonic-gate if (opt_l != MDB_ARR_NOLIMIT) 21157c478bd9Sstevel@tonic-gate pa.pa_armemlim = opt_l; 21167c478bd9Sstevel@tonic-gate if (opt_L) 21177c478bd9Sstevel@tonic-gate pa.pa_armemlim = MDB_ARR_NOLIMIT; 21187c478bd9Sstevel@tonic-gate 21197c478bd9Sstevel@tonic-gate if (argc > 0) { 21207c478bd9Sstevel@tonic-gate for (i = 0; i < argc; i++) { 21217c478bd9Sstevel@tonic-gate mdb_ctf_id_t mid; 21227c478bd9Sstevel@tonic-gate int last_deref; 21237c478bd9Sstevel@tonic-gate ulong_t off; 21247c478bd9Sstevel@tonic-gate int kind; 21257c478bd9Sstevel@tonic-gate char buf[MDB_SYM_NAMLEN]; 21267c478bd9Sstevel@tonic-gate 21277c478bd9Sstevel@tonic-gate mdb_tgt_t *oldtgt = pa.pa_tgt; 21287c478bd9Sstevel@tonic-gate mdb_tgt_as_t oldas = pa.pa_as; 21297c478bd9Sstevel@tonic-gate mdb_tgt_addr_t oldaddr = pa.pa_addr; 21307c478bd9Sstevel@tonic-gate 21317c478bd9Sstevel@tonic-gate if (argv->a_type == MDB_TYPE_STRING) { 21327c478bd9Sstevel@tonic-gate const char *member = argv[i].a_un.a_str; 21337c478bd9Sstevel@tonic-gate mdb_ctf_id_t rid; 21347c478bd9Sstevel@tonic-gate 21357c478bd9Sstevel@tonic-gate if (parse_member(&pa, member, id, &mid, 21367c478bd9Sstevel@tonic-gate &off, &last_deref) != 0) { 21377c478bd9Sstevel@tonic-gate err = DCMD_ABORT; 21387c478bd9Sstevel@tonic-gate goto out; 21397c478bd9Sstevel@tonic-gate } 21407c478bd9Sstevel@tonic-gate 21417c478bd9Sstevel@tonic-gate /* 21427c478bd9Sstevel@tonic-gate * If the member string ends with a "[0]" 21437c478bd9Sstevel@tonic-gate * (last_deref * is true) and the type is a 21447c478bd9Sstevel@tonic-gate * structure or union, * print "->" rather 21457c478bd9Sstevel@tonic-gate * than "[0]." in elt_print. 21467c478bd9Sstevel@tonic-gate */ 21477c478bd9Sstevel@tonic-gate (void) mdb_ctf_type_resolve(mid, &rid); 21487c478bd9Sstevel@tonic-gate kind = mdb_ctf_type_kind(rid); 21497c478bd9Sstevel@tonic-gate if (last_deref && IS_SOU(kind)) { 21507c478bd9Sstevel@tonic-gate char *end; 21517c478bd9Sstevel@tonic-gate (void) mdb_snprintf(buf, sizeof (buf), 21527c478bd9Sstevel@tonic-gate "%s", member); 21537c478bd9Sstevel@tonic-gate end = strrchr(buf, '['); 21547c478bd9Sstevel@tonic-gate *end = '\0'; 21557c478bd9Sstevel@tonic-gate pa.pa_suffix = "->"; 21567c478bd9Sstevel@tonic-gate member = &buf[0]; 21577c478bd9Sstevel@tonic-gate } else if (IS_SOU(kind)) { 21587c478bd9Sstevel@tonic-gate pa.pa_suffix = "."; 21597c478bd9Sstevel@tonic-gate } else { 21607c478bd9Sstevel@tonic-gate pa.pa_suffix = ""; 21617c478bd9Sstevel@tonic-gate } 21627c478bd9Sstevel@tonic-gate 21637c478bd9Sstevel@tonic-gate pa.pa_prefix = member; 21647c478bd9Sstevel@tonic-gate } else { 21657c478bd9Sstevel@tonic-gate ulong_t moff; 21667c478bd9Sstevel@tonic-gate 21677c478bd9Sstevel@tonic-gate moff = (ulong_t)argv[i].a_un.a_val; 21687c478bd9Sstevel@tonic-gate 21697c478bd9Sstevel@tonic-gate if (mdb_ctf_offset_to_name(id, moff * NBBY, 21707c478bd9Sstevel@tonic-gate buf, sizeof (buf), 0, &mid, &off) == -1) { 21717c478bd9Sstevel@tonic-gate mdb_warn("invalid offset %lx\n", moff); 21727c478bd9Sstevel@tonic-gate err = DCMD_ABORT; 21737c478bd9Sstevel@tonic-gate goto out; 21747c478bd9Sstevel@tonic-gate } 21757c478bd9Sstevel@tonic-gate 21767c478bd9Sstevel@tonic-gate pa.pa_prefix = buf; 21777c478bd9Sstevel@tonic-gate pa.pa_addr += moff - off / NBBY; 21787c478bd9Sstevel@tonic-gate pa.pa_suffix = strlen(buf) == 0 ? "" : "."; 21797c478bd9Sstevel@tonic-gate } 21807c478bd9Sstevel@tonic-gate 21817c478bd9Sstevel@tonic-gate off %= NBBY; 2182bf5197d8Sjwadams if (flags & DCMD_PIPE_OUT) { 2183bf5197d8Sjwadams if (pipe_print(mid, off, &pa) != 0) { 2184bf5197d8Sjwadams mdb_warn("failed to print type"); 2185bf5197d8Sjwadams err = DCMD_ERR; 2186bf5197d8Sjwadams goto out; 2187bf5197d8Sjwadams } 2188bf5197d8Sjwadams } else if (off != 0) { 2189cce40297SJonathan Adams mdb_ctf_id_t base; 2190cce40297SJonathan Adams (void) mdb_ctf_type_resolve(mid, &base); 2191cce40297SJonathan Adams 2192cce40297SJonathan Adams if (elt_print("", mid, base, off, 0, 2193cce40297SJonathan Adams &pa) != 0) { 21947c478bd9Sstevel@tonic-gate mdb_warn("failed to print type"); 21957c478bd9Sstevel@tonic-gate err = DCMD_ERR; 21967c478bd9Sstevel@tonic-gate goto out; 21977c478bd9Sstevel@tonic-gate } 21987c478bd9Sstevel@tonic-gate } else { 21997c478bd9Sstevel@tonic-gate if (mdb_ctf_type_visit(mid, elt_print, 22007c478bd9Sstevel@tonic-gate &pa) == -1) { 22017c478bd9Sstevel@tonic-gate mdb_warn("failed to print type"); 22027c478bd9Sstevel@tonic-gate err = DCMD_ERR; 22037c478bd9Sstevel@tonic-gate goto out; 22047c478bd9Sstevel@tonic-gate } 22057c478bd9Sstevel@tonic-gate 22067c478bd9Sstevel@tonic-gate for (d = pa.pa_depth - 1; d >= 0; d--) 22077c478bd9Sstevel@tonic-gate print_close_sou(&pa, d); 22087c478bd9Sstevel@tonic-gate } 22097c478bd9Sstevel@tonic-gate 22107c478bd9Sstevel@tonic-gate pa.pa_depth = 0; 22117c478bd9Sstevel@tonic-gate pa.pa_tgt = oldtgt; 22127c478bd9Sstevel@tonic-gate pa.pa_as = oldas; 22137c478bd9Sstevel@tonic-gate pa.pa_addr = oldaddr; 22147c478bd9Sstevel@tonic-gate pa.pa_delim = "\n"; 22157c478bd9Sstevel@tonic-gate } 22167c478bd9Sstevel@tonic-gate 2217bf5197d8Sjwadams } else if (flags & DCMD_PIPE_OUT) { 2218bf5197d8Sjwadams if (pipe_print(id, 0, &pa) != 0) { 2219bf5197d8Sjwadams mdb_warn("failed to print type"); 2220bf5197d8Sjwadams err = DCMD_ERR; 2221bf5197d8Sjwadams goto out; 2222bf5197d8Sjwadams } 22237c478bd9Sstevel@tonic-gate } else { 22247c478bd9Sstevel@tonic-gate if (mdb_ctf_type_visit(id, elt_print, &pa) == -1) { 22257c478bd9Sstevel@tonic-gate mdb_warn("failed to print type"); 22267c478bd9Sstevel@tonic-gate err = DCMD_ERR; 22277c478bd9Sstevel@tonic-gate goto out; 22287c478bd9Sstevel@tonic-gate } 22297c478bd9Sstevel@tonic-gate 22307c478bd9Sstevel@tonic-gate for (d = pa.pa_depth - 1; d >= 0; d--) 22317c478bd9Sstevel@tonic-gate print_close_sou(&pa, d); 22327c478bd9Sstevel@tonic-gate } 22337c478bd9Sstevel@tonic-gate 22347c478bd9Sstevel@tonic-gate mdb_set_dot(addr + mdb_ctf_type_size(id)); 22357c478bd9Sstevel@tonic-gate err = DCMD_OK; 22367c478bd9Sstevel@tonic-gate out: 22377c478bd9Sstevel@tonic-gate if (pa.pa_immtgt) 22387c478bd9Sstevel@tonic-gate mdb_tgt_destroy(pa.pa_immtgt); 22397c478bd9Sstevel@tonic-gate return (err); 22407c478bd9Sstevel@tonic-gate } 22417c478bd9Sstevel@tonic-gate 22427c478bd9Sstevel@tonic-gate void 22437c478bd9Sstevel@tonic-gate print_help(void) 22447c478bd9Sstevel@tonic-gate { 2245cce40297SJonathan Adams mdb_printf( 2246cce40297SJonathan Adams "-a show address of object\n" 22477c478bd9Sstevel@tonic-gate "-C unlimit the length of character arrays\n" 2248cce40297SJonathan Adams "-c limit limit the length of character arrays\n" 22497c478bd9Sstevel@tonic-gate "-d output values in decimal\n" 22507c478bd9Sstevel@tonic-gate "-h print holes in structures\n" 2251cce40297SJonathan Adams "-i interpret address as data of the given type\n" 22527c478bd9Sstevel@tonic-gate "-L unlimit the length of standard arrays\n" 2253cce40297SJonathan Adams "-l limit limit the length of standard arrays\n" 2254cace7e23Seschrock "-n don't print pointers as symbol offsets\n" 22557c478bd9Sstevel@tonic-gate "-p interpret address as a physical memory address\n" 2256cce40297SJonathan Adams "-s depth limit the recursion depth\n" 2257cce40297SJonathan Adams "-T show type and <<base type>> of object\n" 22587c478bd9Sstevel@tonic-gate "-t show type of object\n" 22597c478bd9Sstevel@tonic-gate "-x output values in hexadecimal\n" 22607c478bd9Sstevel@tonic-gate "\n" 22617c478bd9Sstevel@tonic-gate "type may be omitted if the C type of addr can be inferred.\n" 22627c478bd9Sstevel@tonic-gate "\n" 22637c478bd9Sstevel@tonic-gate "Members may be specified with standard C syntax using the\n" 22647c478bd9Sstevel@tonic-gate "array indexing operator \"[index]\", structure member\n" 22657c478bd9Sstevel@tonic-gate "operator \".\", or structure pointer operator \"->\".\n" 22667c478bd9Sstevel@tonic-gate "\n" 22677c478bd9Sstevel@tonic-gate "Offsets must use the $[ expression ] syntax\n"); 22687c478bd9Sstevel@tonic-gate } 2269