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 2005 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 <sys/types.h>
30#include <strings.h>
31#include <stdlib.h>
32#include <assert.h>
33
34#include <dt_impl.h>
35#include <dt_parser.h>
36#include <dt_as.h>
37
38void
39dt_irlist_create(dt_irlist_t *dlp)
40{
41	bzero(dlp, sizeof (dt_irlist_t));
42	dlp->dl_label = 1;
43}
44
45void
46dt_irlist_destroy(dt_irlist_t *dlp)
47{
48	dt_irnode_t *dip, *nip;
49
50	for (dip = dlp->dl_list; dip != NULL; dip = nip) {
51		nip = dip->di_next;
52		free(dip);
53	}
54}
55
56void
57dt_irlist_append(dt_irlist_t *dlp, dt_irnode_t *dip)
58{
59	if (dlp->dl_last != NULL)
60		dlp->dl_last->di_next = dip;
61	else
62		dlp->dl_list = dip;
63
64	dlp->dl_last = dip;
65
66	if (dip->di_label == DT_LBL_NONE || dip->di_instr != DIF_INSTR_NOP)
67		dlp->dl_len++; /* don't count forward refs in instr count */
68}
69
70uint_t
71dt_irlist_label(dt_irlist_t *dlp)
72{
73	return (dlp->dl_label++);
74}
75
76/*ARGSUSED*/
77static int
78dt_countvar(dt_idhash_t *dhp, dt_ident_t *idp, void *data)
79{
80	size_t *np = data;
81
82	if (idp->di_flags & (DT_IDFLG_DIFR | DT_IDFLG_DIFW))
83		(*np)++; /* include variable in vartab */
84
85	return (0);
86}
87
88/*ARGSUSED*/
89static int
90dt_copyvar(dt_idhash_t *dhp, dt_ident_t *idp, void *data)
91{
92	dt_pcb_t *pcb = data;
93	dtrace_difv_t *dvp;
94	ssize_t stroff;
95	dt_node_t dn;
96
97	if (!(idp->di_flags & (DT_IDFLG_DIFR | DT_IDFLG_DIFW)))
98		return (0); /* omit variable from vartab */
99
100	dvp = &pcb->pcb_difo->dtdo_vartab[pcb->pcb_asvidx++];
101	stroff = dt_strtab_insert(pcb->pcb_strtab, idp->di_name);
102
103	if (stroff == -1L)
104		longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
105	if (stroff > DIF_STROFF_MAX)
106		longjmp(pcb->pcb_jmpbuf, EDT_STR2BIG);
107
108	dvp->dtdv_name = (uint_t)stroff;
109	dvp->dtdv_id = idp->di_id;
110	dvp->dtdv_flags = 0;
111
112	dvp->dtdv_kind = (idp->di_kind == DT_IDENT_ARRAY) ?
113	    DIFV_KIND_ARRAY : DIFV_KIND_SCALAR;
114
115	if (idp->di_flags & DT_IDFLG_LOCAL)
116		dvp->dtdv_scope = DIFV_SCOPE_LOCAL;
117	else if (idp->di_flags & DT_IDFLG_TLS)
118		dvp->dtdv_scope = DIFV_SCOPE_THREAD;
119	else
120		dvp->dtdv_scope = DIFV_SCOPE_GLOBAL;
121
122	if (idp->di_flags & DT_IDFLG_DIFR)
123		dvp->dtdv_flags |= DIFV_F_REF;
124	if (idp->di_flags & DT_IDFLG_DIFW)
125		dvp->dtdv_flags |= DIFV_F_MOD;
126
127	bzero(&dn, sizeof (dn));
128	dt_node_type_assign(&dn, idp->di_ctfp, idp->di_type);
129	dt_node_diftype(pcb->pcb_hdl, &dn, &dvp->dtdv_type);
130
131	idp->di_flags &= ~(DT_IDFLG_DIFR | DT_IDFLG_DIFW);
132	return (0);
133}
134
135static ssize_t
136dt_copystr(const char *s, size_t n, size_t off, dt_pcb_t *pcb)
137{
138	bcopy(s, pcb->pcb_difo->dtdo_strtab + off, n);
139	return (n);
140}
141
142/*
143 * Rewrite the xlate/xlarg instruction at dtdo_buf[i] so that the instruction's
144 * xltab index reflects the offset 'xi' of the assigned dtdo_xlmtab[] location.
145 * We track the cumulative references to translators and members in the pcb's
146 * pcb_asxrefs[] array, a two-dimensional array of bitmaps indexed by the
147 * global translator id and then by the corresponding translator member id.
148 */
149static void
150dt_as_xlate(dt_pcb_t *pcb, dtrace_difo_t *dp,
151    uint_t i, uint_t xi, dt_node_t *dnp)
152{
153	dtrace_hdl_t *dtp = pcb->pcb_hdl;
154	dt_xlator_t *dxp = dnp->dn_membexpr->dn_xlator;
155
156	assert(i < dp->dtdo_len);
157	assert(xi < dp->dtdo_xlmlen);
158
159	assert(dnp->dn_kind == DT_NODE_MEMBER);
160	assert(dnp->dn_membexpr->dn_kind == DT_NODE_XLATOR);
161
162	assert(dxp->dx_id < dtp->dt_xlatorid);
163	assert(dnp->dn_membid < dxp->dx_nmembers);
164
165	if (pcb->pcb_asxrefs == NULL) {
166		pcb->pcb_asxreflen = dtp->dt_xlatorid;
167		pcb->pcb_asxrefs =
168		    dt_zalloc(dtp, sizeof (ulong_t *) * pcb->pcb_asxreflen);
169		if (pcb->pcb_asxrefs == NULL)
170			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
171	}
172
173	if (pcb->pcb_asxrefs[dxp->dx_id] == NULL) {
174		pcb->pcb_asxrefs[dxp->dx_id] =
175		    dt_zalloc(dtp, BT_SIZEOFMAP(dxp->dx_nmembers));
176		if (pcb->pcb_asxrefs[dxp->dx_id] == NULL)
177			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
178	}
179
180	dp->dtdo_buf[i] = DIF_INSTR_XLATE(
181	    DIF_INSTR_OP(dp->dtdo_buf[i]), xi, DIF_INSTR_RD(dp->dtdo_buf[i]));
182
183	BT_SET(pcb->pcb_asxrefs[dxp->dx_id], dnp->dn_membid);
184	dp->dtdo_xlmtab[xi] = dnp;
185}
186
187static void
188dt_as_undef(const dt_ident_t *idp, uint_t offset)
189{
190	const char *kind, *mark = (idp->di_flags & DT_IDFLG_USER) ? "``" : "`";
191	const dtrace_syminfo_t *dts = idp->di_data;
192
193	if (idp->di_flags & DT_IDFLG_USER)
194		kind = "user";
195	else if (idp->di_flags & DT_IDFLG_PRIM)
196		kind = "primary kernel";
197	else
198		kind = "loadable kernel";
199
200	yylineno = idp->di_lineno;
201
202	xyerror(D_ASRELO, "relocation remains against %s symbol %s%s%s (offset "
203	    "0x%x)\n", kind, dts->dts_object, mark, dts->dts_name, offset);
204}
205
206dtrace_difo_t *
207dt_as(dt_pcb_t *pcb)
208{
209	dtrace_hdl_t *dtp = pcb->pcb_hdl;
210	dt_irlist_t *dlp = &pcb->pcb_ir;
211	uint_t *labels = NULL;
212	dt_irnode_t *dip;
213	dtrace_difo_t *dp;
214	dt_ident_t *idp;
215
216	size_t n = 0;
217	uint_t i;
218
219	uint_t kmask, kbits, umask, ubits;
220	uint_t krel = 0, urel = 0, xlrefs = 0;
221
222	/*
223	 * Select bitmasks based upon the desired symbol linking policy.  We
224	 * test (di_extern->di_flags & xmask) == xbits to determine if the
225	 * symbol should have a relocation entry generated in the loop below.
226	 *
227	 * DT_LINK_KERNEL = kernel symbols static, user symbols dynamic
228	 * DT_LINK_PRIMARY = primary kernel symbols static, others dynamic
229	 * DT_LINK_DYNAMIC = all symbols dynamic
230	 * DT_LINK_STATIC = all symbols static
231	 *
232	 * By 'static' we mean that we use the symbol's value at compile-time
233	 * in the final DIF.  By 'dynamic' we mean that we create a relocation
234	 * table entry for the symbol's value so it can be relocated later.
235	 */
236	switch (dtp->dt_linkmode) {
237	case DT_LINK_KERNEL:
238		kmask = 0;
239		kbits = -1u;
240		umask = DT_IDFLG_USER;
241		ubits = DT_IDFLG_USER;
242		break;
243	case DT_LINK_PRIMARY:
244		kmask = DT_IDFLG_USER | DT_IDFLG_PRIM;
245		kbits = 0;
246		umask = DT_IDFLG_USER;
247		ubits = DT_IDFLG_USER;
248		break;
249	case DT_LINK_DYNAMIC:
250		kmask = DT_IDFLG_USER;
251		kbits = 0;
252		umask = DT_IDFLG_USER;
253		ubits = DT_IDFLG_USER;
254		break;
255	case DT_LINK_STATIC:
256		kmask = umask = 0;
257		kbits = ubits = -1u;
258		break;
259	default:
260		xyerror(D_UNKNOWN, "internal error -- invalid link mode %u\n",
261		    dtp->dt_linkmode);
262	}
263
264	assert(pcb->pcb_difo == NULL);
265	pcb->pcb_difo = dt_zalloc(dtp, sizeof (dtrace_difo_t));
266
267	if ((dp = pcb->pcb_difo) == NULL)
268		longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
269
270	dp->dtdo_buf = dt_alloc(dtp, sizeof (dif_instr_t) * dlp->dl_len);
271
272	if (dp->dtdo_buf == NULL)
273		longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
274
275	if ((labels = dt_alloc(dtp, sizeof (uint_t) * dlp->dl_label)) == NULL)
276		longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
277
278	/*
279	 * Make an initial pass through the instruction list, filling in the
280	 * instruction buffer with valid instructions and skipping labeled nops.
281	 * While doing this, we also fill in our labels[] translation table
282	 * and we count up the number of relocation table entries we will need.
283	 */
284	for (i = 0, dip = dlp->dl_list; dip != NULL; dip = dip->di_next) {
285		if (dip->di_label != DT_LBL_NONE)
286			labels[dip->di_label] = i;
287
288		if (dip->di_label == DT_LBL_NONE ||
289		    dip->di_instr != DIF_INSTR_NOP)
290			dp->dtdo_buf[i++] = dip->di_instr;
291
292		if (dip->di_extern == NULL)
293			continue; /* no external references needed */
294
295		switch (DIF_INSTR_OP(dip->di_instr)) {
296		case DIF_OP_SETX:
297			idp = dip->di_extern;
298			if ((idp->di_flags & kmask) == kbits)
299				krel++;
300			else if ((idp->di_flags & umask) == ubits)
301				urel++;
302			break;
303		case DIF_OP_XLATE:
304		case DIF_OP_XLARG:
305			xlrefs++;
306			break;
307		default:
308			xyerror(D_UNKNOWN, "unexpected assembler relocation "
309			    "for opcode 0x%x\n", DIF_INSTR_OP(dip->di_instr));
310		}
311	}
312
313	assert(i == dlp->dl_len);
314	dp->dtdo_len = dlp->dl_len;
315
316	/*
317	 * Make a second pass through the instructions, relocating each branch
318	 * label to the index of the final instruction in the buffer and noting
319	 * any other instruction-specific DIFO flags such as dtdo_destructive.
320	 */
321	for (i = 0; i < dp->dtdo_len; i++) {
322		dif_instr_t instr = dp->dtdo_buf[i];
323		uint_t op = DIF_INSTR_OP(instr);
324
325		if (op == DIF_OP_CALL) {
326			if (DIF_INSTR_SUBR(instr) == DIF_SUBR_COPYOUT ||
327			    DIF_INSTR_SUBR(instr) == DIF_SUBR_COPYOUTSTR)
328				dp->dtdo_destructive = 1;
329			continue;
330		}
331
332		if (op >= DIF_OP_BA && op <= DIF_OP_BLEU) {
333			assert(DIF_INSTR_LABEL(instr) < dlp->dl_label);
334			dp->dtdo_buf[i] = DIF_INSTR_BRANCH(op,
335			    labels[DIF_INSTR_LABEL(instr)]);
336		}
337	}
338
339	dt_free(dtp, labels);
340	pcb->pcb_asvidx = 0;
341
342	/*
343	 * Allocate memory for the appropriate number of variable records and
344	 * then fill in each variable record.  As we populate the variable
345	 * table we insert the corresponding variable names into the strtab.
346	 */
347	(void) dt_idhash_iter(dtp->dt_tls, dt_countvar, &n);
348	(void) dt_idhash_iter(dtp->dt_globals, dt_countvar, &n);
349	(void) dt_idhash_iter(pcb->pcb_locals, dt_countvar, &n);
350
351	if (n != 0) {
352		dp->dtdo_vartab = dt_alloc(dtp, n * sizeof (dtrace_difv_t));
353		dp->dtdo_varlen = (uint32_t)n;
354
355		if (dp->dtdo_vartab == NULL)
356			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
357
358		(void) dt_idhash_iter(dtp->dt_tls, dt_copyvar, pcb);
359		(void) dt_idhash_iter(dtp->dt_globals, dt_copyvar, pcb);
360		(void) dt_idhash_iter(pcb->pcb_locals, dt_copyvar, pcb);
361	}
362
363	/*
364	 * Allocate memory for the appropriate number of relocation table
365	 * entries based upon our kernel and user counts from the first pass.
366	 */
367	if (krel != 0) {
368		dp->dtdo_kreltab = dt_alloc(dtp,
369		    krel * sizeof (dof_relodesc_t));
370		dp->dtdo_krelen = krel;
371
372		if (dp->dtdo_kreltab == NULL)
373			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
374	}
375
376	if (urel != 0) {
377		dp->dtdo_ureltab = dt_alloc(dtp,
378		    urel * sizeof (dof_relodesc_t));
379		dp->dtdo_urelen = urel;
380
381		if (dp->dtdo_ureltab == NULL)
382			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
383	}
384
385	if (xlrefs != 0) {
386		dp->dtdo_xlmtab = dt_zalloc(dtp, sizeof (dt_node_t *) * xlrefs);
387		dp->dtdo_xlmlen = xlrefs;
388
389		if (dp->dtdo_xlmtab == NULL)
390			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
391	}
392
393	/*
394	 * If any relocations are needed, make another pass through the
395	 * instruction list and fill in the relocation table entries.
396	 */
397	if (krel + urel + xlrefs != 0) {
398		uint_t knodef = pcb->pcb_cflags & DTRACE_C_KNODEF;
399		uint_t unodef = pcb->pcb_cflags & DTRACE_C_UNODEF;
400
401		dof_relodesc_t *krp = dp->dtdo_kreltab;
402		dof_relodesc_t *urp = dp->dtdo_ureltab;
403		dt_node_t **xlp = dp->dtdo_xlmtab;
404
405		i = 0; /* dtdo_buf[] index */
406
407		for (dip = dlp->dl_list; dip != NULL; dip = dip->di_next) {
408			dof_relodesc_t *rp;
409			ssize_t soff;
410			uint_t nodef;
411
412			if (dip->di_label != DT_LBL_NONE &&
413			    dip->di_instr == DIF_INSTR_NOP)
414				continue; /* skip label declarations */
415
416			i++; /* advance dtdo_buf[] index */
417
418			if (DIF_INSTR_OP(dip->di_instr) == DIF_OP_XLATE ||
419			    DIF_INSTR_OP(dip->di_instr) == DIF_OP_XLARG) {
420				assert(dp->dtdo_buf[i - 1] == dip->di_instr);
421				dt_as_xlate(pcb, dp, i - 1, (uint_t)
422				    (xlp++ - dp->dtdo_xlmtab), dip->di_extern);
423				continue;
424			}
425
426			if ((idp = dip->di_extern) == NULL)
427				continue; /* no relocation entry needed */
428
429			if ((idp->di_flags & kmask) == kbits) {
430				nodef = knodef;
431				rp = krp++;
432			} else if ((idp->di_flags & umask) == ubits) {
433				nodef = unodef;
434				rp = urp++;
435			} else
436				continue;
437
438			if (!nodef)
439				dt_as_undef(idp, i);
440
441			assert(DIF_INSTR_OP(dip->di_instr) == DIF_OP_SETX);
442			soff = dt_strtab_insert(pcb->pcb_strtab, idp->di_name);
443
444			if (soff == -1L)
445				longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
446			if (soff > DIF_STROFF_MAX)
447				longjmp(pcb->pcb_jmpbuf, EDT_STR2BIG);
448
449			rp->dofr_name = (dof_stridx_t)soff;
450			rp->dofr_type = DOF_RELO_SETX;
451			rp->dofr_offset = DIF_INSTR_INTEGER(dip->di_instr) *
452			    sizeof (uint64_t);
453			rp->dofr_data = 0;
454		}
455
456		assert(krp == dp->dtdo_kreltab + dp->dtdo_krelen);
457		assert(urp == dp->dtdo_ureltab + dp->dtdo_urelen);
458		assert(xlp == dp->dtdo_xlmtab + dp->dtdo_xlmlen);
459		assert(i == dp->dtdo_len);
460	}
461
462	/*
463	 * Allocate memory for the compiled string table and then copy the
464	 * chunks from the string table into the final string buffer.
465	 */
466	if ((n = dt_strtab_size(pcb->pcb_strtab)) != 0) {
467		if ((dp->dtdo_strtab = dt_alloc(dtp, n)) == NULL)
468			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
469
470		(void) dt_strtab_write(pcb->pcb_strtab,
471		    (dt_strtab_write_f *)dt_copystr, pcb);
472		dp->dtdo_strlen = (uint32_t)n;
473	}
474
475	/*
476	 * Allocate memory for the compiled integer table and then copy the
477	 * integer constants from the table into the final integer buffer.
478	 */
479	if ((n = dt_inttab_size(pcb->pcb_inttab)) != 0) {
480		if ((dp->dtdo_inttab = dt_alloc(dtp,
481		    n * sizeof (uint64_t))) == NULL)
482			longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
483
484		dt_inttab_write(pcb->pcb_inttab, dp->dtdo_inttab);
485		dp->dtdo_intlen = (uint32_t)n;
486	}
487
488	/*
489	 * Fill in the DIFO return type from the type associated with the
490	 * node saved in pcb_dret, and then clear pcb_difo and pcb_dret
491	 * now that the assembler has completed successfully.
492	 */
493	dt_node_diftype(dtp, pcb->pcb_dret, &dp->dtdo_rtype);
494	pcb->pcb_difo = NULL;
495	pcb->pcb_dret = NULL;
496
497	if (pcb->pcb_cflags & DTRACE_C_DIFV)
498		dt_dis(dp, stderr);
499
500	return (dp);
501}
502