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