1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* 23 * Copyright 2004 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <stdio.h> 28 #include <string.h> 29 #include <floatingpoint.h> 30 #include <libctf.h> 31 #include <apptrace.h> 32 33 typedef struct printarg { 34 ulong_t pa_addr; 35 ctf_file_t *pa_ctfp; 36 int pa_depth; 37 int pa_nest; 38 } printarg_t; 39 40 typedef void printarg_f(ctf_id_t, ulong_t, printarg_t *); 41 42 static int elt_print(const char *, ctf_id_t, ulong_t, int, void *); 43 44 const char * 45 type_name(ctf_file_t *ctfp, ctf_id_t type, char *buf, size_t len) 46 { 47 if (ctf_type_name(ctfp, type, buf, len) == NULL) 48 (void) snprintf(buf, len, "<%ld>", type); 49 50 return (buf); 51 } 52 53 void 54 print_value(ctf_file_t *ctfp, ctf_id_t type, ulong_t value) 55 { 56 ctf_id_t rtype = ctf_type_resolve(ctfp, type); 57 ctf_encoding_t e; 58 59 (void) fprintf(ABISTREAM, "0x%p", (void *)value); 60 61 if (ctf_type_kind(ctfp, rtype) == CTF_K_POINTER) { 62 type = ctf_type_reference(ctfp, rtype); 63 rtype = ctf_type_resolve(ctfp, type); 64 65 if (ctf_type_encoding(ctfp, rtype, &e) == 0 && 66 (e.cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == 67 (CTF_INT_CHAR | CTF_INT_SIGNED) && e.cte_bits == NBBY) { 68 if ((char *)value != NULL) 69 (void) fprintf(ABISTREAM, 70 " \"%s\"", (char *)value); 71 else 72 (void) fprintf(ABISTREAM, " <NULL>"); 73 (void) fflush(ABISTREAM); 74 return; 75 } 76 77 if (ctf_type_kind(ctfp, rtype) == CTF_K_STRUCT) { 78 printarg_t pa; 79 80 (void) fprintf(ABISTREAM, " "); 81 82 pa.pa_addr = value; 83 pa.pa_ctfp = ctfp; 84 pa.pa_nest = 0; 85 pa.pa_depth = 0; 86 87 (void) ctf_type_visit(ctfp, rtype, elt_print, &pa); 88 (void) fprintf(ABISTREAM, "\t}"); 89 (void) fflush(ABISTREAM); 90 return; 91 } 92 } 93 (void) fflush(ABISTREAM); 94 } 95 96 static void 97 print_bitfield(ulong_t off, ctf_encoding_t *ep) 98 { 99 uint64_t mask = (1ULL << ep->cte_bits) - 1; 100 uint64_t value = 0; 101 #ifdef _BIG_ENDIAN 102 size_t size = (ep->cte_bits + (NBBY - 1)) / NBBY; 103 uint8_t *buf = (uint8_t *)&value; 104 #endif 105 uint8_t shift; 106 107 /* 108 * On big-endian machines, we need to adjust the buf pointer to refer 109 * to the lowest 'size' bytes in 'value', and we need shift based on 110 * the offset from the end of the data, not the offset of the start. 111 */ 112 #ifdef _BIG_ENDIAN 113 buf += sizeof (value) - size; 114 off += ep->cte_bits; 115 #endif 116 shift = off % NBBY; 117 118 /* 119 * Offsets are counted from opposite ends on little- and 120 * big-endian machines. 121 */ 122 #ifdef _BIG_ENDIAN 123 shift = NBBY - shift; 124 #endif 125 126 /* 127 * If the bits we want do not begin on a byte boundary, shift the data 128 * right so that the value is in the lowest 'cte_bits' of 'value'. 129 */ 130 if (off % NBBY != 0) 131 value >>= shift; 132 133 (void) fprintf(ABISTREAM, "%llu", (unsigned long long)(value & mask)); 134 (void) fflush(ABISTREAM); 135 } 136 137 /* ARGSUSED */ 138 static void 139 print_int(ctf_id_t base, ulong_t off, printarg_t *pap) 140 { 141 ctf_file_t *ctfp = pap->pa_ctfp; 142 ctf_encoding_t e; 143 size_t size; 144 ulong_t addr = pap->pa_addr + off / NBBY; 145 146 if (ctf_type_encoding(ctfp, base, &e) == CTF_ERR) { 147 (void) fprintf(ABISTREAM, "???"); 148 (void) fflush(ABISTREAM); 149 return; 150 } 151 152 if (e.cte_format & CTF_INT_VARARGS) { 153 (void) fprintf(ABISTREAM, "...\n"); 154 (void) fflush(ABISTREAM); 155 return; 156 } 157 158 size = e.cte_bits / NBBY; 159 if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1)) != 0) { 160 print_bitfield(off, &e); 161 return; 162 } 163 164 if (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == 165 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) { 166 (void) fprintf(ABISTREAM, "'%c'", *(char *)addr); 167 (void) fflush(ABISTREAM); 168 return; 169 } 170 171 switch (size) { 172 case sizeof (uint8_t): 173 (void) fprintf(ABISTREAM, "%#x", *(uint8_t *)addr); 174 break; 175 case sizeof (uint16_t): 176 (void) fprintf(ABISTREAM, "%#x", *(uint16_t *)addr); 177 break; 178 case sizeof (uint32_t): 179 (void) fprintf(ABISTREAM, "%#x", *(uint32_t *)addr); 180 break; 181 case sizeof (uint64_t): 182 (void) fprintf(ABISTREAM, "%#llx", 183 (unsigned long long)*(uint64_t *)addr); 184 break; 185 } 186 (void) fflush(ABISTREAM); 187 } 188 189 /* ARGSUSED */ 190 static void 191 print_float(ctf_id_t base, ulong_t off, printarg_t *pap) 192 { 193 ctf_file_t *ctfp = pap->pa_ctfp; 194 ctf_encoding_t e; 195 196 union { 197 float f; 198 double d; 199 long double ld; 200 } u; 201 202 u.f = 0; 203 if (ctf_type_encoding(ctfp, base, &e) == 0) { 204 if (e.cte_format == CTF_FP_SINGLE && 205 e.cte_bits == sizeof (float) * NBBY) { 206 (void) fprintf(ABISTREAM, "%+.7e", u.f); 207 } else if (e.cte_format == CTF_FP_DOUBLE && 208 e.cte_bits == sizeof (double) * NBBY) { 209 (void) fprintf(ABISTREAM, "%+.7e", u.d); 210 } else if (e.cte_format == CTF_FP_LDOUBLE && 211 e.cte_bits == sizeof (long double) * NBBY) { 212 (void) fprintf(ABISTREAM, 213 "%+.16LE", u.ld); 214 } 215 } 216 (void) fflush(ABISTREAM); 217 } 218 219 /* ARGSUSED */ 220 static void 221 print_ptr(ctf_id_t base, ulong_t off, printarg_t *pap) 222 { 223 ctf_file_t *ctfp = pap->pa_ctfp; 224 ulong_t addr = pap->pa_addr + off / NBBY; 225 ctf_encoding_t e; 226 227 if (ctf_type_kind(ctfp, base) != CTF_K_POINTER) 228 return; 229 230 if ((base = ctf_type_reference(ctfp, base)) == CTF_ERR) 231 return; 232 233 if ((base = ctf_type_resolve(ctfp, base)) == CTF_ERR) 234 return; 235 236 if (ctf_type_encoding(ctfp, base, &e) != 0) 237 return; 238 239 if (((e).cte_format & (CTF_INT_CHAR | CTF_INT_SIGNED)) == 240 (CTF_INT_CHAR | CTF_INT_SIGNED) && (e).cte_bits == NBBY) 241 (void) fprintf(ABISTREAM, "'%c'", *(char *)addr); 242 (void) fflush(ABISTREAM); 243 } 244 245 /* ARGSUSED */ 246 static void 247 print_array(ctf_id_t base, ulong_t off, printarg_t *pap) 248 { 249 ulong_t addr = pap->pa_addr + off / NBBY; 250 251 (void) fprintf(ABISTREAM, "0x%p", (void *)addr); 252 (void) fflush(ABISTREAM); 253 } 254 255 /* ARGSUSED */ 256 static void 257 print_sou(ctf_id_t base, ulong_t off, printarg_t *pap) 258 { 259 (void) fprintf(ABISTREAM, "{"); 260 } 261 262 /* ARGSUSED */ 263 static void 264 print_enum(ctf_id_t base, ulong_t off, printarg_t *pap) 265 { 266 ctf_file_t *ctfp = pap->pa_ctfp; 267 const char *ename; 268 int value = 0; 269 270 if ((ename = ctf_enum_name(ctfp, base, value)) != NULL) 271 (void) fprintf(ABISTREAM, "%s", ename); 272 else 273 (void) fprintf(ABISTREAM, "%d", value); 274 (void) fflush(ABISTREAM); 275 } 276 277 /* ARGSUSED */ 278 static void 279 print_tag(ctf_id_t base, ulong_t off, printarg_t *pap) 280 { 281 (void) fprintf(ABISTREAM, "; "); 282 } 283 284 static printarg_f *const printfuncs[] = { 285 print_int, /* CTF_K_INTEGER */ 286 print_float, /* CTF_K_FLOAT */ 287 print_ptr, /* CTF_K_POINTER */ 288 print_array, /* CTF_K_ARRAY */ 289 print_ptr, /* CTF_K_FUNCTION */ 290 print_sou, /* CTF_K_STRUCT */ 291 print_sou, /* CTF_K_UNION */ 292 print_enum, /* CTF_K_ENUM */ 293 print_tag /* CTF_K_FORWARD */ 294 }; 295 296 static int 297 elt_print(const char *name, ctf_id_t id, ulong_t off, int depth, void *data) 298 { 299 char type[256]; 300 int kind, d; 301 ctf_id_t base; 302 printarg_t *pap = data; 303 ctf_file_t *ctfp = pap->pa_ctfp; 304 305 for (d = pap->pa_depth - 1; d >= depth; d--) { 306 (void) fprintf(ABISTREAM, "%*s}\n", 307 (depth + pap->pa_nest) * 4, ""); 308 } 309 310 if ((base = ctf_type_resolve(ctfp, id)) == CTF_ERR || 311 (kind = ctf_type_kind(ctfp, base)) == CTF_ERR) 312 return (-1); 313 314 if (ctf_type_name(ctfp, id, type, sizeof (type)) == NULL) 315 (void) snprintf(type, sizeof (type), "<%ld>", id); 316 317 (void) fprintf(ABISTREAM, "%*s", (depth + pap->pa_nest) * 4, ""); 318 if (name[0] != '\0') 319 (void) fprintf(ABISTREAM, "\t%s: ", name); 320 (void) fprintf(ABISTREAM, "(%s) ", type); 321 322 printfuncs[kind - 1](base, off, pap); 323 (void) fprintf(ABISTREAM, "\n"); 324 325 (void) fflush(ABISTREAM); 326 return (0); 327 } 328