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 /*
24 * Copyright 2005 Sun Microsystems, Inc. All rights reserved.
25 * Use is subject to license terms.
26 */
27
28 /*
29 * Copyright (c) 2012 by Delphix. All rights reserved.
30 */
31
32 #include <sys/types.h>
33 #include <sys/sysmacros.h>
34 #include <sys/isa_defs.h>
35
36 #include <strings.h>
37 #include <stdlib.h>
38 #include <setjmp.h>
39 #include <assert.h>
40 #include <errno.h>
41
42 #include <dt_impl.h>
43 #include <dt_grammar.h>
44 #include <dt_parser.h>
45 #include <dt_provider.h>
46
47 static void dt_cg_node(dt_node_t *, dt_irlist_t *, dt_regset_t *);
48
49 static dt_irnode_t *
dt_cg_node_alloc(uint_t label,dif_instr_t instr)50 dt_cg_node_alloc(uint_t label, dif_instr_t instr)
51 {
52 dt_irnode_t *dip = malloc(sizeof (dt_irnode_t));
53
54 if (dip == NULL)
55 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
56
57 dip->di_label = label;
58 dip->di_instr = instr;
59 dip->di_extern = NULL;
60 dip->di_next = NULL;
61
62 return (dip);
63 }
64
65 /*
66 * Code generator wrapper function for ctf_member_info. If we are given a
67 * reference to a forward declaration tag, search the entire type space for
68 * the actual definition and then call ctf_member_info on the result.
69 */
70 static ctf_file_t *
dt_cg_membinfo(ctf_file_t * fp,ctf_id_t type,const char * s,ctf_membinfo_t * mp)71 dt_cg_membinfo(ctf_file_t *fp, ctf_id_t type, const char *s, ctf_membinfo_t *mp)
72 {
73 while (ctf_type_kind(fp, type) == CTF_K_FORWARD) {
74 char n[DT_TYPE_NAMELEN];
75 dtrace_typeinfo_t dtt;
76
77 if (ctf_type_name(fp, type, n, sizeof (n)) == NULL ||
78 dt_type_lookup(n, &dtt) == -1 || (
79 dtt.dtt_ctfp == fp && dtt.dtt_type == type))
80 break; /* unable to improve our position */
81
82 fp = dtt.dtt_ctfp;
83 type = ctf_type_resolve(fp, dtt.dtt_type);
84 }
85
86 if (ctf_member_info(fp, type, s, mp) == CTF_ERR)
87 return (NULL); /* ctf_errno is set for us */
88
89 return (fp);
90 }
91
92 static void
dt_cg_xsetx(dt_irlist_t * dlp,dt_ident_t * idp,uint_t lbl,int reg,uint64_t x)93 dt_cg_xsetx(dt_irlist_t *dlp, dt_ident_t *idp, uint_t lbl, int reg, uint64_t x)
94 {
95 int flag = idp != NULL ? DT_INT_PRIVATE : DT_INT_SHARED;
96 int intoff = dt_inttab_insert(yypcb->pcb_inttab, x, flag);
97 dif_instr_t instr = DIF_INSTR_SETX((uint_t)intoff, reg);
98
99 if (intoff == -1)
100 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
101
102 if (intoff > DIF_INTOFF_MAX)
103 longjmp(yypcb->pcb_jmpbuf, EDT_INT2BIG);
104
105 dt_irlist_append(dlp, dt_cg_node_alloc(lbl, instr));
106
107 if (idp != NULL)
108 dlp->dl_last->di_extern = idp;
109 }
110
111 static void
dt_cg_setx(dt_irlist_t * dlp,int reg,uint64_t x)112 dt_cg_setx(dt_irlist_t *dlp, int reg, uint64_t x)
113 {
114 dt_cg_xsetx(dlp, NULL, DT_LBL_NONE, reg, x);
115 }
116
117 /*
118 * When loading bit-fields, we want to convert a byte count in the range
119 * 1-8 to the closest power of 2 (e.g. 3->4, 5->8, etc). The clp2() function
120 * is a clever implementation from "Hacker's Delight" by Henry Warren, Jr.
121 */
122 static size_t
clp2(size_t x)123 clp2(size_t x)
124 {
125 x--;
126
127 x |= (x >> 1);
128 x |= (x >> 2);
129 x |= (x >> 4);
130 x |= (x >> 8);
131 x |= (x >> 16);
132
133 return (x + 1);
134 }
135
136 /*
137 * Lookup the correct load opcode to use for the specified node and CTF type.
138 * We determine the size and convert it to a 3-bit index. Our lookup table
139 * is constructed to use a 5-bit index, consisting of the 3-bit size 0-7, a
140 * bit for the sign, and a bit for userland address. For example, a 4-byte
141 * signed load from userland would be at the following table index:
142 * user=1 sign=1 size=4 => binary index 11011 = decimal index 27
143 */
144 static uint_t
dt_cg_load(dt_node_t * dnp,ctf_file_t * ctfp,ctf_id_t type)145 dt_cg_load(dt_node_t *dnp, ctf_file_t *ctfp, ctf_id_t type)
146 {
147 static const uint_t ops[] = {
148 DIF_OP_LDUB, DIF_OP_LDUH, 0, DIF_OP_LDUW,
149 0, 0, 0, DIF_OP_LDX,
150 DIF_OP_LDSB, DIF_OP_LDSH, 0, DIF_OP_LDSW,
151 0, 0, 0, DIF_OP_LDX,
152 DIF_OP_ULDUB, DIF_OP_ULDUH, 0, DIF_OP_ULDUW,
153 0, 0, 0, DIF_OP_ULDX,
154 DIF_OP_ULDSB, DIF_OP_ULDSH, 0, DIF_OP_ULDSW,
155 0, 0, 0, DIF_OP_ULDX,
156 };
157
158 ctf_encoding_t e;
159 ssize_t size;
160
161 /*
162 * If we're loading a bit-field, the size of our load is found by
163 * rounding cte_bits up to a byte boundary and then finding the
164 * nearest power of two to this value (see clp2(), above).
165 */
166 if ((dnp->dn_flags & DT_NF_BITFIELD) &&
167 ctf_type_encoding(ctfp, type, &e) != CTF_ERR)
168 size = clp2(P2ROUNDUP(e.cte_bits, NBBY) / NBBY);
169 else
170 size = ctf_type_size(ctfp, type);
171
172 if (size < 1 || size > 8 || (size & (size - 1)) != 0) {
173 xyerror(D_UNKNOWN, "internal error -- cg cannot load "
174 "size %ld when passed by value\n", (long)size);
175 }
176
177 size--; /* convert size to 3-bit index */
178
179 if (dnp->dn_flags & DT_NF_SIGNED)
180 size |= 0x08;
181 if (dnp->dn_flags & DT_NF_USERLAND)
182 size |= 0x10;
183
184 return (ops[size]);
185 }
186
187 static void
dt_cg_ptrsize(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,uint_t op,int dreg)188 dt_cg_ptrsize(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp,
189 uint_t op, int dreg)
190 {
191 ctf_file_t *ctfp = dnp->dn_ctfp;
192 ctf_arinfo_t r;
193 dif_instr_t instr;
194 ctf_id_t type;
195 uint_t kind;
196 ssize_t size;
197 int sreg;
198
199 type = ctf_type_resolve(ctfp, dnp->dn_type);
200 kind = ctf_type_kind(ctfp, type);
201 assert(kind == CTF_K_POINTER || kind == CTF_K_ARRAY);
202
203 if (kind == CTF_K_ARRAY) {
204 if (ctf_array_info(ctfp, type, &r) != 0) {
205 yypcb->pcb_hdl->dt_ctferr = ctf_errno(ctfp);
206 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
207 }
208 type = r.ctr_contents;
209 } else
210 type = ctf_type_reference(ctfp, type);
211
212 if ((size = ctf_type_size(ctfp, type)) == 1)
213 return; /* multiply or divide by one can be omitted */
214
215 sreg = dt_regset_alloc(drp);
216 dt_cg_setx(dlp, sreg, size);
217 instr = DIF_INSTR_FMT(op, dreg, sreg, dreg);
218 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
219 dt_regset_free(drp, sreg);
220 }
221
222 /*
223 * If the result of a "." or "->" operation is a bit-field, we use this routine
224 * to generate an epilogue to the load instruction that extracts the value. In
225 * the diagrams below the "ld??" is the load instruction that is generated to
226 * load the containing word that is generating prior to calling this function.
227 *
228 * Epilogue for unsigned fields: Epilogue for signed fields:
229 *
230 * ldu? [r1], r1 lds? [r1], r1
231 * setx USHIFT, r2 setx 64 - SSHIFT, r2
232 * srl r1, r2, r1 sll r1, r2, r1
233 * setx (1 << bits) - 1, r2 setx 64 - bits, r2
234 * and r1, r2, r1 sra r1, r2, r1
235 *
236 * The *SHIFT constants above changes value depending on the endian-ness of our
237 * target architecture. Refer to the comments below for more details.
238 */
239 static void
dt_cg_field_get(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,ctf_file_t * fp,const ctf_membinfo_t * mp)240 dt_cg_field_get(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp,
241 ctf_file_t *fp, const ctf_membinfo_t *mp)
242 {
243 ctf_encoding_t e;
244 dif_instr_t instr;
245 uint64_t shift;
246 int r1, r2;
247
248 if (ctf_type_encoding(fp, mp->ctm_type, &e) != 0 || e.cte_bits > 64) {
249 xyerror(D_UNKNOWN, "cg: bad field: off %lu type <%ld> "
250 "bits %u\n", mp->ctm_offset, mp->ctm_type, e.cte_bits);
251 }
252
253 assert(dnp->dn_op == DT_TOK_PTR || dnp->dn_op == DT_TOK_DOT);
254 r1 = dnp->dn_left->dn_reg;
255 r2 = dt_regset_alloc(drp);
256
257 /*
258 * On little-endian architectures, ctm_offset counts from the right so
259 * ctm_offset % NBBY itself is the amount we want to shift right to
260 * move the value bits to the little end of the register to mask them.
261 * On big-endian architectures, ctm_offset counts from the left so we
262 * must subtract (ctm_offset % NBBY + cte_bits) from the size in bits
263 * we used for the load. The size of our load in turn is found by
264 * rounding cte_bits up to a byte boundary and then finding the
265 * nearest power of two to this value (see clp2(), above). These
266 * properties are used to compute shift as USHIFT or SSHIFT, below.
267 */
268 if (dnp->dn_flags & DT_NF_SIGNED) {
269 #if BYTE_ORDER == _BIG_ENDIAN
270 shift = clp2(P2ROUNDUP(e.cte_bits, NBBY) / NBBY) * NBBY -
271 mp->ctm_offset % NBBY;
272 #else
273 shift = mp->ctm_offset % NBBY + e.cte_bits;
274 #endif
275 dt_cg_setx(dlp, r2, 64 - shift);
276 instr = DIF_INSTR_FMT(DIF_OP_SLL, r1, r2, r1);
277 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
278
279 dt_cg_setx(dlp, r2, 64 - e.cte_bits);
280 instr = DIF_INSTR_FMT(DIF_OP_SRA, r1, r2, r1);
281 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
282 } else {
283 #if BYTE_ORDER == _BIG_ENDIAN
284 shift = clp2(P2ROUNDUP(e.cte_bits, NBBY) / NBBY) * NBBY -
285 (mp->ctm_offset % NBBY + e.cte_bits);
286 #else
287 shift = mp->ctm_offset % NBBY;
288 #endif
289 dt_cg_setx(dlp, r2, shift);
290 instr = DIF_INSTR_FMT(DIF_OP_SRL, r1, r2, r1);
291 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
292
293 dt_cg_setx(dlp, r2, (1ULL << e.cte_bits) - 1);
294 instr = DIF_INSTR_FMT(DIF_OP_AND, r1, r2, r1);
295 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
296 }
297
298 dt_regset_free(drp, r2);
299 }
300
301 /*
302 * If the destination of a store operation is a bit-field, we use this routine
303 * to generate a prologue to the store instruction that loads the surrounding
304 * bits, clears the destination field, and ORs in the new value of the field.
305 * In the diagram below the "st?" is the store instruction that is generated to
306 * store the containing word that is generating after calling this function.
307 *
308 * ld [dst->dn_reg], r1
309 * setx ~(((1 << cte_bits) - 1) << (ctm_offset % NBBY)), r2
310 * and r1, r2, r1
311 *
312 * setx (1 << cte_bits) - 1, r2
313 * and src->dn_reg, r2, r2
314 * setx ctm_offset % NBBY, r3
315 * sll r2, r3, r2
316 *
317 * or r1, r2, r1
318 * st? r1, [dst->dn_reg]
319 *
320 * This routine allocates a new register to hold the value to be stored and
321 * returns it. The caller is responsible for freeing this register later.
322 */
323 static int
dt_cg_field_set(dt_node_t * src,dt_irlist_t * dlp,dt_regset_t * drp,dt_node_t * dst)324 dt_cg_field_set(dt_node_t *src, dt_irlist_t *dlp,
325 dt_regset_t *drp, dt_node_t *dst)
326 {
327 uint64_t cmask, fmask, shift;
328 dif_instr_t instr;
329 int r1, r2, r3;
330
331 ctf_membinfo_t m;
332 ctf_encoding_t e;
333 ctf_file_t *fp, *ofp;
334 ctf_id_t type;
335
336 assert(dst->dn_op == DT_TOK_PTR || dst->dn_op == DT_TOK_DOT);
337 assert(dst->dn_right->dn_kind == DT_NODE_IDENT);
338
339 fp = dst->dn_left->dn_ctfp;
340 type = ctf_type_resolve(fp, dst->dn_left->dn_type);
341
342 if (dst->dn_op == DT_TOK_PTR) {
343 type = ctf_type_reference(fp, type);
344 type = ctf_type_resolve(fp, type);
345 }
346
347 if ((fp = dt_cg_membinfo(ofp = fp, type,
348 dst->dn_right->dn_string, &m)) == NULL) {
349 yypcb->pcb_hdl->dt_ctferr = ctf_errno(ofp);
350 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
351 }
352
353 if (ctf_type_encoding(fp, m.ctm_type, &e) != 0 || e.cte_bits > 64) {
354 xyerror(D_UNKNOWN, "cg: bad field: off %lu type <%ld> "
355 "bits %u\n", m.ctm_offset, m.ctm_type, e.cte_bits);
356 }
357
358 r1 = dt_regset_alloc(drp);
359 r2 = dt_regset_alloc(drp);
360 r3 = dt_regset_alloc(drp);
361
362 /*
363 * Compute shifts and masks. We need to compute "shift" as the amount
364 * we need to shift left to position our field in the containing word.
365 * Refer to the comments in dt_cg_field_get(), above, for more info.
366 * We then compute fmask as the mask that truncates the value in the
367 * input register to width cte_bits, and cmask as the mask used to
368 * pass through the containing bits and zero the field bits.
369 */
370 #if BYTE_ORDER == _BIG_ENDIAN
371 shift = clp2(P2ROUNDUP(e.cte_bits, NBBY) / NBBY) * NBBY -
372 (m.ctm_offset % NBBY + e.cte_bits);
373 #else
374 shift = m.ctm_offset % NBBY;
375 #endif
376 fmask = (1ULL << e.cte_bits) - 1;
377 cmask = ~(fmask << shift);
378
379 instr = DIF_INSTR_LOAD(
380 dt_cg_load(dst, fp, m.ctm_type), dst->dn_reg, r1);
381 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
382
383 dt_cg_setx(dlp, r2, cmask);
384 instr = DIF_INSTR_FMT(DIF_OP_AND, r1, r2, r1);
385 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
386
387 dt_cg_setx(dlp, r2, fmask);
388 instr = DIF_INSTR_FMT(DIF_OP_AND, src->dn_reg, r2, r2);
389 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
390
391 dt_cg_setx(dlp, r3, shift);
392 instr = DIF_INSTR_FMT(DIF_OP_SLL, r2, r3, r2);
393 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
394
395 instr = DIF_INSTR_FMT(DIF_OP_OR, r1, r2, r1);
396 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
397
398 dt_regset_free(drp, r3);
399 dt_regset_free(drp, r2);
400
401 return (r1);
402 }
403
404 static void
dt_cg_store(dt_node_t * src,dt_irlist_t * dlp,dt_regset_t * drp,dt_node_t * dst)405 dt_cg_store(dt_node_t *src, dt_irlist_t *dlp, dt_regset_t *drp, dt_node_t *dst)
406 {
407 ctf_encoding_t e;
408 dif_instr_t instr;
409 size_t size;
410 int reg;
411
412 /*
413 * If we're loading a bit-field, the size of our store is found by
414 * rounding dst's cte_bits up to a byte boundary and then finding the
415 * nearest power of two to this value (see clp2(), above).
416 */
417 if ((dst->dn_flags & DT_NF_BITFIELD) &&
418 ctf_type_encoding(dst->dn_ctfp, dst->dn_type, &e) != CTF_ERR)
419 size = clp2(P2ROUNDUP(e.cte_bits, NBBY) / NBBY);
420 else
421 size = dt_node_type_size(src);
422
423 if (src->dn_flags & DT_NF_REF) {
424 reg = dt_regset_alloc(drp);
425 dt_cg_setx(dlp, reg, size);
426 instr = DIF_INSTR_COPYS(src->dn_reg, reg, dst->dn_reg);
427 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
428 dt_regset_free(drp, reg);
429 } else {
430 if (dst->dn_flags & DT_NF_BITFIELD)
431 reg = dt_cg_field_set(src, dlp, drp, dst);
432 else
433 reg = src->dn_reg;
434
435 switch (size) {
436 case 1:
437 instr = DIF_INSTR_STORE(DIF_OP_STB, reg, dst->dn_reg);
438 break;
439 case 2:
440 instr = DIF_INSTR_STORE(DIF_OP_STH, reg, dst->dn_reg);
441 break;
442 case 4:
443 instr = DIF_INSTR_STORE(DIF_OP_STW, reg, dst->dn_reg);
444 break;
445 case 8:
446 instr = DIF_INSTR_STORE(DIF_OP_STX, reg, dst->dn_reg);
447 break;
448 default:
449 xyerror(D_UNKNOWN, "internal error -- cg cannot store "
450 "size %lu when passed by value\n", (ulong_t)size);
451 }
452 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
453
454 if (dst->dn_flags & DT_NF_BITFIELD)
455 dt_regset_free(drp, reg);
456 }
457 }
458
459 /*
460 * Generate code for a typecast or for argument promotion from the type of the
461 * actual to the type of the formal. We need to generate code for casts when
462 * a scalar type is being narrowed or changing signed-ness. We first shift the
463 * desired bits high (losing excess bits if narrowing) and then shift them down
464 * using logical shift (unsigned result) or arithmetic shift (signed result).
465 */
466 static void
dt_cg_typecast(const dt_node_t * src,const dt_node_t * dst,dt_irlist_t * dlp,dt_regset_t * drp)467 dt_cg_typecast(const dt_node_t *src, const dt_node_t *dst,
468 dt_irlist_t *dlp, dt_regset_t *drp)
469 {
470 size_t srcsize = dt_node_type_size(src);
471 size_t dstsize = dt_node_type_size(dst);
472
473 dif_instr_t instr;
474 int rg;
475
476 if (!dt_node_is_scalar(dst))
477 return; /* not a scalar */
478 if (dstsize == srcsize &&
479 ((src->dn_flags ^ dst->dn_flags) & DT_NF_SIGNED) != 0)
480 return; /* not narrowing or changing signed-ness */
481 if (dstsize > srcsize && (src->dn_flags & DT_NF_SIGNED) == 0)
482 return; /* nothing to do in this case */
483
484 rg = dt_regset_alloc(drp);
485
486 if (dstsize > srcsize) {
487 int n = sizeof (uint64_t) * NBBY - srcsize * NBBY;
488 int s = (dstsize - srcsize) * NBBY;
489
490 dt_cg_setx(dlp, rg, n);
491
492 instr = DIF_INSTR_FMT(DIF_OP_SLL, src->dn_reg, rg, dst->dn_reg);
493 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
494
495 if ((dst->dn_flags & DT_NF_SIGNED) || n == s) {
496 instr = DIF_INSTR_FMT(DIF_OP_SRA,
497 dst->dn_reg, rg, dst->dn_reg);
498 dt_irlist_append(dlp,
499 dt_cg_node_alloc(DT_LBL_NONE, instr));
500 } else {
501 dt_cg_setx(dlp, rg, s);
502 instr = DIF_INSTR_FMT(DIF_OP_SRA,
503 dst->dn_reg, rg, dst->dn_reg);
504 dt_irlist_append(dlp,
505 dt_cg_node_alloc(DT_LBL_NONE, instr));
506 dt_cg_setx(dlp, rg, n - s);
507 instr = DIF_INSTR_FMT(DIF_OP_SRL,
508 dst->dn_reg, rg, dst->dn_reg);
509 dt_irlist_append(dlp,
510 dt_cg_node_alloc(DT_LBL_NONE, instr));
511 }
512 } else if (dstsize != sizeof (uint64_t)) {
513 int n = sizeof (uint64_t) * NBBY - dstsize * NBBY;
514
515 dt_cg_setx(dlp, rg, n);
516
517 instr = DIF_INSTR_FMT(DIF_OP_SLL, src->dn_reg, rg, dst->dn_reg);
518 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
519
520 instr = DIF_INSTR_FMT((dst->dn_flags & DT_NF_SIGNED) ?
521 DIF_OP_SRA : DIF_OP_SRL, dst->dn_reg, rg, dst->dn_reg);
522 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
523 }
524
525 dt_regset_free(drp, rg);
526 }
527
528 /*
529 * Generate code to push the specified argument list on to the tuple stack.
530 * We use this routine for handling subroutine calls and associative arrays.
531 * We must first generate code for all subexpressions before loading the stack
532 * because any subexpression could itself require the use of the tuple stack.
533 * This holds a number of registers equal to the number of arguments, but this
534 * is not a huge problem because the number of arguments can't exceed the
535 * number of tuple register stack elements anyway. At most one extra register
536 * is required (either by dt_cg_typecast() or for dtdt_size, below). This
537 * implies that a DIF implementation should offer a number of general purpose
538 * registers at least one greater than the number of tuple registers.
539 */
540 static void
dt_cg_arglist(dt_ident_t * idp,dt_node_t * args,dt_irlist_t * dlp,dt_regset_t * drp)541 dt_cg_arglist(dt_ident_t *idp, dt_node_t *args,
542 dt_irlist_t *dlp, dt_regset_t *drp)
543 {
544 const dt_idsig_t *isp = idp->di_data;
545 dt_node_t *dnp;
546 int i = 0;
547
548 for (dnp = args; dnp != NULL; dnp = dnp->dn_list)
549 dt_cg_node(dnp, dlp, drp);
550
551 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, DIF_INSTR_FLUSHTS));
552
553 for (dnp = args; dnp != NULL; dnp = dnp->dn_list, i++) {
554 dtrace_diftype_t t;
555 dif_instr_t instr;
556 uint_t op;
557 int reg;
558
559 dt_node_diftype(yypcb->pcb_hdl, dnp, &t);
560
561 isp->dis_args[i].dn_reg = dnp->dn_reg; /* re-use register */
562 dt_cg_typecast(dnp, &isp->dis_args[i], dlp, drp);
563 isp->dis_args[i].dn_reg = -1;
564
565 if (t.dtdt_flags & DIF_TF_BYREF) {
566 op = DIF_OP_PUSHTR;
567 if (t.dtdt_size != 0) {
568 reg = dt_regset_alloc(drp);
569 dt_cg_setx(dlp, reg, t.dtdt_size);
570 } else {
571 reg = DIF_REG_R0;
572 }
573 } else {
574 op = DIF_OP_PUSHTV;
575 reg = DIF_REG_R0;
576 }
577
578 instr = DIF_INSTR_PUSHTS(op, t.dtdt_kind, reg, dnp->dn_reg);
579 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
580 dt_regset_free(drp, dnp->dn_reg);
581
582 if (reg != DIF_REG_R0)
583 dt_regset_free(drp, reg);
584 }
585
586 if (i > yypcb->pcb_hdl->dt_conf.dtc_diftupregs)
587 longjmp(yypcb->pcb_jmpbuf, EDT_NOTUPREG);
588 }
589
590 static void
dt_cg_arithmetic_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,uint_t op)591 dt_cg_arithmetic_op(dt_node_t *dnp, dt_irlist_t *dlp,
592 dt_regset_t *drp, uint_t op)
593 {
594 int is_ptr_op = (dnp->dn_op == DT_TOK_ADD || dnp->dn_op == DT_TOK_SUB ||
595 dnp->dn_op == DT_TOK_ADD_EQ || dnp->dn_op == DT_TOK_SUB_EQ);
596
597 int lp_is_ptr = dt_node_is_pointer(dnp->dn_left);
598 int rp_is_ptr = dt_node_is_pointer(dnp->dn_right);
599
600 dif_instr_t instr;
601
602 if (lp_is_ptr && rp_is_ptr) {
603 assert(dnp->dn_op == DT_TOK_SUB);
604 is_ptr_op = 0;
605 }
606
607 dt_cg_node(dnp->dn_left, dlp, drp);
608 if (is_ptr_op && rp_is_ptr)
609 dt_cg_ptrsize(dnp, dlp, drp, DIF_OP_MUL, dnp->dn_left->dn_reg);
610
611 dt_cg_node(dnp->dn_right, dlp, drp);
612 if (is_ptr_op && lp_is_ptr)
613 dt_cg_ptrsize(dnp, dlp, drp, DIF_OP_MUL, dnp->dn_right->dn_reg);
614
615 instr = DIF_INSTR_FMT(op, dnp->dn_left->dn_reg,
616 dnp->dn_right->dn_reg, dnp->dn_left->dn_reg);
617
618 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
619 dt_regset_free(drp, dnp->dn_right->dn_reg);
620 dnp->dn_reg = dnp->dn_left->dn_reg;
621
622 if (lp_is_ptr && rp_is_ptr)
623 dt_cg_ptrsize(dnp->dn_right,
624 dlp, drp, DIF_OP_UDIV, dnp->dn_reg);
625 }
626
627 static uint_t
dt_cg_stvar(const dt_ident_t * idp)628 dt_cg_stvar(const dt_ident_t *idp)
629 {
630 static const uint_t aops[] = { DIF_OP_STGAA, DIF_OP_STTAA, DIF_OP_NOP };
631 static const uint_t sops[] = { DIF_OP_STGS, DIF_OP_STTS, DIF_OP_STLS };
632
633 uint_t i = (((idp->di_flags & DT_IDFLG_LOCAL) != 0) << 1) |
634 ((idp->di_flags & DT_IDFLG_TLS) != 0);
635
636 return (idp->di_kind == DT_IDENT_ARRAY ? aops[i] : sops[i]);
637 }
638
639 static void
dt_cg_prearith_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,uint_t op)640 dt_cg_prearith_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp, uint_t op)
641 {
642 ctf_file_t *ctfp = dnp->dn_ctfp;
643 dif_instr_t instr;
644 ctf_id_t type;
645 ssize_t size = 1;
646 int reg;
647
648 if (dt_node_is_pointer(dnp)) {
649 type = ctf_type_resolve(ctfp, dnp->dn_type);
650 assert(ctf_type_kind(ctfp, type) == CTF_K_POINTER);
651 size = ctf_type_size(ctfp, ctf_type_reference(ctfp, type));
652 }
653
654 dt_cg_node(dnp->dn_child, dlp, drp);
655 dnp->dn_reg = dnp->dn_child->dn_reg;
656
657 reg = dt_regset_alloc(drp);
658 dt_cg_setx(dlp, reg, size);
659
660 instr = DIF_INSTR_FMT(op, dnp->dn_reg, reg, dnp->dn_reg);
661 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
662 dt_regset_free(drp, reg);
663
664 /*
665 * If we are modifying a variable, generate an stv instruction from
666 * the variable specified by the identifier. If we are storing to a
667 * memory address, generate code again for the left-hand side using
668 * DT_NF_REF to get the address, and then generate a store to it.
669 * In both paths, we store the value in dnp->dn_reg (the new value).
670 */
671 if (dnp->dn_child->dn_kind == DT_NODE_VAR) {
672 dt_ident_t *idp = dt_ident_resolve(dnp->dn_child->dn_ident);
673
674 idp->di_flags |= DT_IDFLG_DIFW;
675 instr = DIF_INSTR_STV(dt_cg_stvar(idp),
676 idp->di_id, dnp->dn_reg);
677 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
678 } else {
679 uint_t rbit = dnp->dn_child->dn_flags & DT_NF_REF;
680
681 assert(dnp->dn_child->dn_flags & DT_NF_WRITABLE);
682 assert(dnp->dn_child->dn_flags & DT_NF_LVALUE);
683
684 dnp->dn_child->dn_flags |= DT_NF_REF; /* force pass-by-ref */
685 dt_cg_node(dnp->dn_child, dlp, drp);
686
687 dt_cg_store(dnp, dlp, drp, dnp->dn_child);
688 dt_regset_free(drp, dnp->dn_child->dn_reg);
689
690 dnp->dn_left->dn_flags &= ~DT_NF_REF;
691 dnp->dn_left->dn_flags |= rbit;
692 }
693 }
694
695 static void
dt_cg_postarith_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,uint_t op)696 dt_cg_postarith_op(dt_node_t *dnp, dt_irlist_t *dlp,
697 dt_regset_t *drp, uint_t op)
698 {
699 ctf_file_t *ctfp = dnp->dn_ctfp;
700 dif_instr_t instr;
701 ctf_id_t type;
702 ssize_t size = 1;
703 int nreg;
704
705 if (dt_node_is_pointer(dnp)) {
706 type = ctf_type_resolve(ctfp, dnp->dn_type);
707 assert(ctf_type_kind(ctfp, type) == CTF_K_POINTER);
708 size = ctf_type_size(ctfp, ctf_type_reference(ctfp, type));
709 }
710
711 dt_cg_node(dnp->dn_child, dlp, drp);
712 dnp->dn_reg = dnp->dn_child->dn_reg;
713
714 nreg = dt_regset_alloc(drp);
715 dt_cg_setx(dlp, nreg, size);
716 instr = DIF_INSTR_FMT(op, dnp->dn_reg, nreg, nreg);
717 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
718
719 /*
720 * If we are modifying a variable, generate an stv instruction from
721 * the variable specified by the identifier. If we are storing to a
722 * memory address, generate code again for the left-hand side using
723 * DT_NF_REF to get the address, and then generate a store to it.
724 * In both paths, we store the value from 'nreg' (the new value).
725 */
726 if (dnp->dn_child->dn_kind == DT_NODE_VAR) {
727 dt_ident_t *idp = dt_ident_resolve(dnp->dn_child->dn_ident);
728
729 idp->di_flags |= DT_IDFLG_DIFW;
730 instr = DIF_INSTR_STV(dt_cg_stvar(idp), idp->di_id, nreg);
731 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
732 } else {
733 uint_t rbit = dnp->dn_child->dn_flags & DT_NF_REF;
734 int oreg = dnp->dn_reg;
735
736 assert(dnp->dn_child->dn_flags & DT_NF_WRITABLE);
737 assert(dnp->dn_child->dn_flags & DT_NF_LVALUE);
738
739 dnp->dn_child->dn_flags |= DT_NF_REF; /* force pass-by-ref */
740 dt_cg_node(dnp->dn_child, dlp, drp);
741
742 dnp->dn_reg = nreg;
743 dt_cg_store(dnp, dlp, drp, dnp->dn_child);
744 dnp->dn_reg = oreg;
745
746 dt_regset_free(drp, dnp->dn_child->dn_reg);
747 dnp->dn_left->dn_flags &= ~DT_NF_REF;
748 dnp->dn_left->dn_flags |= rbit;
749 }
750
751 dt_regset_free(drp, nreg);
752 }
753
754 /*
755 * Determine if we should perform signed or unsigned comparison for an OP2.
756 * If both operands are of arithmetic type, perform the usual arithmetic
757 * conversions to determine the common real type for comparison [ISOC 6.5.8.3].
758 */
759 static int
dt_cg_compare_signed(dt_node_t * dnp)760 dt_cg_compare_signed(dt_node_t *dnp)
761 {
762 dt_node_t dn;
763
764 if (dt_node_is_string(dnp->dn_left) ||
765 dt_node_is_string(dnp->dn_right))
766 return (1); /* strings always compare signed */
767 else if (!dt_node_is_arith(dnp->dn_left) ||
768 !dt_node_is_arith(dnp->dn_right))
769 return (0); /* non-arithmetic types always compare unsigned */
770
771 bzero(&dn, sizeof (dn));
772 dt_node_promote(dnp->dn_left, dnp->dn_right, &dn);
773 return (dn.dn_flags & DT_NF_SIGNED);
774 }
775
776 static void
dt_cg_compare_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp,uint_t op)777 dt_cg_compare_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp, uint_t op)
778 {
779 uint_t lbl_true = dt_irlist_label(dlp);
780 uint_t lbl_post = dt_irlist_label(dlp);
781
782 dif_instr_t instr;
783 uint_t opc;
784
785 dt_cg_node(dnp->dn_left, dlp, drp);
786 dt_cg_node(dnp->dn_right, dlp, drp);
787
788 if (dt_node_is_string(dnp->dn_left) || dt_node_is_string(dnp->dn_right))
789 opc = DIF_OP_SCMP;
790 else
791 opc = DIF_OP_CMP;
792
793 instr = DIF_INSTR_CMP(opc, dnp->dn_left->dn_reg, dnp->dn_right->dn_reg);
794 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
795 dt_regset_free(drp, dnp->dn_right->dn_reg);
796 dnp->dn_reg = dnp->dn_left->dn_reg;
797
798 instr = DIF_INSTR_BRANCH(op, lbl_true);
799 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
800
801 instr = DIF_INSTR_MOV(DIF_REG_R0, dnp->dn_reg);
802 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
803
804 instr = DIF_INSTR_BRANCH(DIF_OP_BA, lbl_post);
805 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
806
807 dt_cg_xsetx(dlp, NULL, lbl_true, dnp->dn_reg, 1);
808 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_post, DIF_INSTR_NOP));
809 }
810
811 /*
812 * Code generation for the ternary op requires some trickery with the assembler
813 * in order to conserve registers. We generate code for dn_expr and dn_left
814 * and free their registers so they do not have be consumed across codegen for
815 * dn_right. We insert a dummy MOV at the end of dn_left into the destination
816 * register, which is not yet known because we haven't done dn_right yet, and
817 * save the pointer to this instruction node. We then generate code for
818 * dn_right and use its register as our output. Finally, we reach back and
819 * patch the instruction for dn_left to move its output into this register.
820 */
821 static void
dt_cg_ternary_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)822 dt_cg_ternary_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
823 {
824 uint_t lbl_false = dt_irlist_label(dlp);
825 uint_t lbl_post = dt_irlist_label(dlp);
826
827 dif_instr_t instr;
828 dt_irnode_t *dip;
829
830 dt_cg_node(dnp->dn_expr, dlp, drp);
831 instr = DIF_INSTR_TST(dnp->dn_expr->dn_reg);
832 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
833 dt_regset_free(drp, dnp->dn_expr->dn_reg);
834
835 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_false);
836 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
837
838 dt_cg_node(dnp->dn_left, dlp, drp);
839 instr = DIF_INSTR_MOV(dnp->dn_left->dn_reg, DIF_REG_R0);
840 dip = dt_cg_node_alloc(DT_LBL_NONE, instr); /* save dip for below */
841 dt_irlist_append(dlp, dip);
842 dt_regset_free(drp, dnp->dn_left->dn_reg);
843
844 instr = DIF_INSTR_BRANCH(DIF_OP_BA, lbl_post);
845 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
846
847 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_false, DIF_INSTR_NOP));
848 dt_cg_node(dnp->dn_right, dlp, drp);
849 dnp->dn_reg = dnp->dn_right->dn_reg;
850
851 /*
852 * Now that dn_reg is assigned, reach back and patch the correct MOV
853 * instruction into the tail of dn_left. We know dn_reg was unused
854 * at that point because otherwise dn_right couldn't have allocated it.
855 */
856 dip->di_instr = DIF_INSTR_MOV(dnp->dn_left->dn_reg, dnp->dn_reg);
857 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_post, DIF_INSTR_NOP));
858 }
859
860 static void
dt_cg_logical_and(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)861 dt_cg_logical_and(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
862 {
863 uint_t lbl_false = dt_irlist_label(dlp);
864 uint_t lbl_post = dt_irlist_label(dlp);
865
866 dif_instr_t instr;
867
868 dt_cg_node(dnp->dn_left, dlp, drp);
869 instr = DIF_INSTR_TST(dnp->dn_left->dn_reg);
870 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
871 dt_regset_free(drp, dnp->dn_left->dn_reg);
872
873 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_false);
874 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
875
876 dt_cg_node(dnp->dn_right, dlp, drp);
877 instr = DIF_INSTR_TST(dnp->dn_right->dn_reg);
878 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
879 dnp->dn_reg = dnp->dn_right->dn_reg;
880
881 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_false);
882 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
883
884 dt_cg_setx(dlp, dnp->dn_reg, 1);
885
886 instr = DIF_INSTR_BRANCH(DIF_OP_BA, lbl_post);
887 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
888
889 instr = DIF_INSTR_MOV(DIF_REG_R0, dnp->dn_reg);
890 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_false, instr));
891
892 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_post, DIF_INSTR_NOP));
893 }
894
895 static void
dt_cg_logical_xor(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)896 dt_cg_logical_xor(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
897 {
898 uint_t lbl_next = dt_irlist_label(dlp);
899 uint_t lbl_tail = dt_irlist_label(dlp);
900
901 dif_instr_t instr;
902
903 dt_cg_node(dnp->dn_left, dlp, drp);
904 instr = DIF_INSTR_TST(dnp->dn_left->dn_reg);
905 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
906
907 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_next);
908 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
909 dt_cg_setx(dlp, dnp->dn_left->dn_reg, 1);
910
911 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_next, DIF_INSTR_NOP));
912 dt_cg_node(dnp->dn_right, dlp, drp);
913
914 instr = DIF_INSTR_TST(dnp->dn_right->dn_reg);
915 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
916
917 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_tail);
918 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
919 dt_cg_setx(dlp, dnp->dn_right->dn_reg, 1);
920
921 instr = DIF_INSTR_FMT(DIF_OP_XOR, dnp->dn_left->dn_reg,
922 dnp->dn_right->dn_reg, dnp->dn_left->dn_reg);
923
924 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_tail, instr));
925
926 dt_regset_free(drp, dnp->dn_right->dn_reg);
927 dnp->dn_reg = dnp->dn_left->dn_reg;
928 }
929
930 static void
dt_cg_logical_or(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)931 dt_cg_logical_or(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
932 {
933 uint_t lbl_true = dt_irlist_label(dlp);
934 uint_t lbl_false = dt_irlist_label(dlp);
935 uint_t lbl_post = dt_irlist_label(dlp);
936
937 dif_instr_t instr;
938
939 dt_cg_node(dnp->dn_left, dlp, drp);
940 instr = DIF_INSTR_TST(dnp->dn_left->dn_reg);
941 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
942 dt_regset_free(drp, dnp->dn_left->dn_reg);
943
944 instr = DIF_INSTR_BRANCH(DIF_OP_BNE, lbl_true);
945 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
946
947 dt_cg_node(dnp->dn_right, dlp, drp);
948 instr = DIF_INSTR_TST(dnp->dn_right->dn_reg);
949 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
950 dnp->dn_reg = dnp->dn_right->dn_reg;
951
952 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_false);
953 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
954
955 dt_cg_xsetx(dlp, NULL, lbl_true, dnp->dn_reg, 1);
956
957 instr = DIF_INSTR_BRANCH(DIF_OP_BA, lbl_post);
958 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
959
960 instr = DIF_INSTR_MOV(DIF_REG_R0, dnp->dn_reg);
961 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_false, instr));
962
963 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_post, DIF_INSTR_NOP));
964 }
965
966 static void
dt_cg_logical_neg(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)967 dt_cg_logical_neg(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
968 {
969 uint_t lbl_zero = dt_irlist_label(dlp);
970 uint_t lbl_post = dt_irlist_label(dlp);
971
972 dif_instr_t instr;
973
974 dt_cg_node(dnp->dn_child, dlp, drp);
975 dnp->dn_reg = dnp->dn_child->dn_reg;
976
977 instr = DIF_INSTR_TST(dnp->dn_reg);
978 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
979
980 instr = DIF_INSTR_BRANCH(DIF_OP_BE, lbl_zero);
981 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
982
983 instr = DIF_INSTR_MOV(DIF_REG_R0, dnp->dn_reg);
984 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
985
986 instr = DIF_INSTR_BRANCH(DIF_OP_BA, lbl_post);
987 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
988
989 dt_cg_xsetx(dlp, NULL, lbl_zero, dnp->dn_reg, 1);
990 dt_irlist_append(dlp, dt_cg_node_alloc(lbl_post, DIF_INSTR_NOP));
991 }
992
993 static void
dt_cg_asgn_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)994 dt_cg_asgn_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
995 {
996 dif_instr_t instr;
997 dt_ident_t *idp;
998
999 /*
1000 * If we are performing a structure assignment of a translated type,
1001 * we must instantiate all members and create a snapshot of the object
1002 * in scratch space. We allocs a chunk of memory, generate code for
1003 * each member, and then set dnp->dn_reg to the scratch object address.
1004 */
1005 if ((idp = dt_node_resolve(dnp->dn_right, DT_IDENT_XLSOU)) != NULL) {
1006 ctf_membinfo_t ctm;
1007 dt_xlator_t *dxp = idp->di_data;
1008 dt_node_t *mnp, dn, mn;
1009 int r1, r2;
1010
1011 /*
1012 * Create two fake dt_node_t's representing operator "." and a
1013 * right-hand identifier child node. These will be repeatedly
1014 * modified according to each instantiated member so that we
1015 * can pass them to dt_cg_store() and effect a member store.
1016 */
1017 bzero(&dn, sizeof (dt_node_t));
1018 dn.dn_kind = DT_NODE_OP2;
1019 dn.dn_op = DT_TOK_DOT;
1020 dn.dn_left = dnp;
1021 dn.dn_right = &mn;
1022
1023 bzero(&mn, sizeof (dt_node_t));
1024 mn.dn_kind = DT_NODE_IDENT;
1025 mn.dn_op = DT_TOK_IDENT;
1026
1027 /*
1028 * Allocate a register for our scratch data pointer. First we
1029 * set it to the size of our data structure, and then replace
1030 * it with the result of an allocs of the specified size.
1031 */
1032 r1 = dt_regset_alloc(drp);
1033 dt_cg_setx(dlp, r1,
1034 ctf_type_size(dxp->dx_dst_ctfp, dxp->dx_dst_base));
1035
1036 instr = DIF_INSTR_ALLOCS(r1, r1);
1037 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1038
1039 /*
1040 * When dt_cg_asgn_op() is called, we have already generated
1041 * code for dnp->dn_right, which is the translator input. We
1042 * now associate this register with the translator's input
1043 * identifier so it can be referenced during our member loop.
1044 */
1045 dxp->dx_ident->di_flags |= DT_IDFLG_CGREG;
1046 dxp->dx_ident->di_id = dnp->dn_right->dn_reg;
1047
1048 for (mnp = dxp->dx_members; mnp != NULL; mnp = mnp->dn_list) {
1049 /*
1050 * Generate code for the translator member expression,
1051 * and then cast the result to the member type.
1052 */
1053 dt_cg_node(mnp->dn_membexpr, dlp, drp);
1054 mnp->dn_reg = mnp->dn_membexpr->dn_reg;
1055 dt_cg_typecast(mnp->dn_membexpr, mnp, dlp, drp);
1056
1057 /*
1058 * Ask CTF for the offset of the member so we can store
1059 * to the appropriate offset. This call has already
1060 * been done once by the parser, so it should succeed.
1061 */
1062 if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_base,
1063 mnp->dn_membname, &ctm) == CTF_ERR) {
1064 yypcb->pcb_hdl->dt_ctferr =
1065 ctf_errno(dxp->dx_dst_ctfp);
1066 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
1067 }
1068
1069 /*
1070 * If the destination member is at offset 0, store the
1071 * result directly to r1 (the scratch buffer address).
1072 * Otherwise allocate another temporary for the offset
1073 * and add r1 to it before storing the result.
1074 */
1075 if (ctm.ctm_offset != 0) {
1076 r2 = dt_regset_alloc(drp);
1077
1078 /*
1079 * Add the member offset rounded down to the
1080 * nearest byte. If the offset was not aligned
1081 * on a byte boundary, this member is a bit-
1082 * field and dt_cg_store() will handle masking.
1083 */
1084 dt_cg_setx(dlp, r2, ctm.ctm_offset / NBBY);
1085 instr = DIF_INSTR_FMT(DIF_OP_ADD, r1, r2, r2);
1086 dt_irlist_append(dlp,
1087 dt_cg_node_alloc(DT_LBL_NONE, instr));
1088
1089 dt_node_type_propagate(mnp, &dn);
1090 dn.dn_right->dn_string = mnp->dn_membname;
1091 dn.dn_reg = r2;
1092
1093 dt_cg_store(mnp, dlp, drp, &dn);
1094 dt_regset_free(drp, r2);
1095
1096 } else {
1097 dt_node_type_propagate(mnp, &dn);
1098 dn.dn_right->dn_string = mnp->dn_membname;
1099 dn.dn_reg = r1;
1100
1101 dt_cg_store(mnp, dlp, drp, &dn);
1102 }
1103
1104 dt_regset_free(drp, mnp->dn_reg);
1105 }
1106
1107 dxp->dx_ident->di_flags &= ~DT_IDFLG_CGREG;
1108 dxp->dx_ident->di_id = 0;
1109
1110 if (dnp->dn_right->dn_reg != -1)
1111 dt_regset_free(drp, dnp->dn_right->dn_reg);
1112
1113 assert(dnp->dn_reg == dnp->dn_right->dn_reg);
1114 dnp->dn_reg = r1;
1115 }
1116
1117 /*
1118 * If we are storing to a variable, generate an stv instruction from
1119 * the variable specified by the identifier. If we are storing to a
1120 * memory address, generate code again for the left-hand side using
1121 * DT_NF_REF to get the address, and then generate a store to it.
1122 * In both paths, we assume dnp->dn_reg already has the new value.
1123 */
1124 if (dnp->dn_left->dn_kind == DT_NODE_VAR) {
1125 idp = dt_ident_resolve(dnp->dn_left->dn_ident);
1126
1127 if (idp->di_kind == DT_IDENT_ARRAY)
1128 dt_cg_arglist(idp, dnp->dn_left->dn_args, dlp, drp);
1129
1130 idp->di_flags |= DT_IDFLG_DIFW;
1131 instr = DIF_INSTR_STV(dt_cg_stvar(idp),
1132 idp->di_id, dnp->dn_reg);
1133 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1134 } else {
1135 uint_t rbit = dnp->dn_left->dn_flags & DT_NF_REF;
1136
1137 assert(dnp->dn_left->dn_flags & DT_NF_WRITABLE);
1138 assert(dnp->dn_left->dn_flags & DT_NF_LVALUE);
1139
1140 dnp->dn_left->dn_flags |= DT_NF_REF; /* force pass-by-ref */
1141
1142 dt_cg_node(dnp->dn_left, dlp, drp);
1143 dt_cg_store(dnp, dlp, drp, dnp->dn_left);
1144 dt_regset_free(drp, dnp->dn_left->dn_reg);
1145
1146 dnp->dn_left->dn_flags &= ~DT_NF_REF;
1147 dnp->dn_left->dn_flags |= rbit;
1148 }
1149 }
1150
1151 static void
dt_cg_assoc_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)1152 dt_cg_assoc_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
1153 {
1154 dif_instr_t instr;
1155 uint_t op;
1156
1157 assert(dnp->dn_kind == DT_NODE_VAR);
1158 assert(!(dnp->dn_ident->di_flags & DT_IDFLG_LOCAL));
1159 assert(dnp->dn_args != NULL);
1160
1161 dt_cg_arglist(dnp->dn_ident, dnp->dn_args, dlp, drp);
1162
1163 dnp->dn_reg = dt_regset_alloc(drp);
1164
1165 if (dnp->dn_ident->di_flags & DT_IDFLG_TLS)
1166 op = DIF_OP_LDTAA;
1167 else
1168 op = DIF_OP_LDGAA;
1169
1170 dnp->dn_ident->di_flags |= DT_IDFLG_DIFR;
1171 instr = DIF_INSTR_LDV(op, dnp->dn_ident->di_id, dnp->dn_reg);
1172 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1173
1174 /*
1175 * If the associative array is a pass-by-reference type, then we are
1176 * loading its value as a pointer to either load or store through it.
1177 * The array element in question may not have been faulted in yet, in
1178 * which case DIF_OP_LD*AA will return zero. We append an epilogue
1179 * of instructions similar to the following:
1180 *
1181 * ld?aa id, %r1 ! base ld?aa instruction above
1182 * tst %r1 ! start of epilogue
1183 * +--- bne label
1184 * | setx size, %r1
1185 * | allocs %r1, %r1
1186 * | st?aa id, %r1
1187 * | ld?aa id, %r1
1188 * v
1189 * label: < rest of code >
1190 *
1191 * The idea is that we allocs a zero-filled chunk of scratch space and
1192 * do a DIF_OP_ST*AA to fault in and initialize the array element, and
1193 * then reload it to get the faulted-in address of the new variable
1194 * storage. This isn't cheap, but pass-by-ref associative array values
1195 * are (thus far) uncommon and the allocs cost only occurs once. If
1196 * this path becomes important to DTrace users, we can improve things
1197 * by adding a new DIF opcode to fault in associative array elements.
1198 */
1199 if (dnp->dn_flags & DT_NF_REF) {
1200 uint_t stvop = op == DIF_OP_LDTAA ? DIF_OP_STTAA : DIF_OP_STGAA;
1201 uint_t label = dt_irlist_label(dlp);
1202
1203 instr = DIF_INSTR_TST(dnp->dn_reg);
1204 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1205
1206 instr = DIF_INSTR_BRANCH(DIF_OP_BNE, label);
1207 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1208
1209 dt_cg_setx(dlp, dnp->dn_reg, dt_node_type_size(dnp));
1210 instr = DIF_INSTR_ALLOCS(dnp->dn_reg, dnp->dn_reg);
1211 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1212
1213 dnp->dn_ident->di_flags |= DT_IDFLG_DIFW;
1214 instr = DIF_INSTR_STV(stvop, dnp->dn_ident->di_id, dnp->dn_reg);
1215 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1216
1217 instr = DIF_INSTR_LDV(op, dnp->dn_ident->di_id, dnp->dn_reg);
1218 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1219
1220 dt_irlist_append(dlp, dt_cg_node_alloc(label, DIF_INSTR_NOP));
1221 }
1222 }
1223
1224 static void
dt_cg_array_op(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)1225 dt_cg_array_op(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
1226 {
1227 dt_probe_t *prp = yypcb->pcb_probe;
1228 uintmax_t saved = dnp->dn_args->dn_value;
1229 dt_ident_t *idp = dnp->dn_ident;
1230
1231 dif_instr_t instr;
1232 uint_t op;
1233 size_t size;
1234 int reg, n;
1235
1236 assert(dnp->dn_kind == DT_NODE_VAR);
1237 assert(!(idp->di_flags & DT_IDFLG_LOCAL));
1238
1239 assert(dnp->dn_args->dn_kind == DT_NODE_INT);
1240 assert(dnp->dn_args->dn_list == NULL);
1241
1242 /*
1243 * If this is a reference in the args[] array, temporarily modify the
1244 * array index according to the static argument mapping (if any),
1245 * unless the argument reference is provided by a dynamic translator.
1246 * If we're using a dynamic translator for args[], then just set dn_reg
1247 * to an invalid reg and return: DIF_OP_XLARG will fetch the arg later.
1248 */
1249 if (idp->di_id == DIF_VAR_ARGS) {
1250 if ((idp->di_kind == DT_IDENT_XLPTR ||
1251 idp->di_kind == DT_IDENT_XLSOU) &&
1252 dt_xlator_dynamic(idp->di_data)) {
1253 dnp->dn_reg = -1;
1254 return;
1255 }
1256 dnp->dn_args->dn_value = prp->pr_mapping[saved];
1257 }
1258
1259 dt_cg_node(dnp->dn_args, dlp, drp);
1260 dnp->dn_args->dn_value = saved;
1261
1262 dnp->dn_reg = dnp->dn_args->dn_reg;
1263
1264 if (idp->di_flags & DT_IDFLG_TLS)
1265 op = DIF_OP_LDTA;
1266 else
1267 op = DIF_OP_LDGA;
1268
1269 idp->di_flags |= DT_IDFLG_DIFR;
1270
1271 instr = DIF_INSTR_LDA(op, idp->di_id,
1272 dnp->dn_args->dn_reg, dnp->dn_reg);
1273
1274 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1275
1276 /*
1277 * If this is a reference to the args[] array, we need to take the
1278 * additional step of explicitly eliminating any bits larger than the
1279 * type size: the DIF interpreter in the kernel will always give us
1280 * the raw (64-bit) argument value, and any bits larger than the type
1281 * size may be junk. As a practical matter, this arises only on 64-bit
1282 * architectures and only when the argument index is larger than the
1283 * number of arguments passed directly to DTrace: if a 8-, 16- or
1284 * 32-bit argument must be retrieved from the stack, it is possible
1285 * (and it some cases, likely) that the upper bits will be garbage.
1286 */
1287 if (idp->di_id != DIF_VAR_ARGS || !dt_node_is_scalar(dnp))
1288 return;
1289
1290 if ((size = dt_node_type_size(dnp)) == sizeof (uint64_t))
1291 return;
1292
1293 reg = dt_regset_alloc(drp);
1294 assert(size < sizeof (uint64_t));
1295 n = sizeof (uint64_t) * NBBY - size * NBBY;
1296
1297 dt_cg_setx(dlp, reg, n);
1298
1299 instr = DIF_INSTR_FMT(DIF_OP_SLL, dnp->dn_reg, reg, dnp->dn_reg);
1300 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1301
1302 instr = DIF_INSTR_FMT((dnp->dn_flags & DT_NF_SIGNED) ?
1303 DIF_OP_SRA : DIF_OP_SRL, dnp->dn_reg, reg, dnp->dn_reg);
1304
1305 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1306 dt_regset_free(drp, reg);
1307 }
1308
1309 /*
1310 * Generate code for an inlined variable reference. Inlines can be used to
1311 * define either scalar or associative array substitutions. For scalars, we
1312 * simply generate code for the parse tree saved in the identifier's din_root,
1313 * and then cast the resulting expression to the inline's declaration type.
1314 * For arrays, we take the input parameter subtrees from dnp->dn_args and
1315 * temporarily store them in the din_root of each din_argv[i] identifier,
1316 * which are themselves inlines and were set up for us by the parser. The
1317 * result is that any reference to the inlined parameter inside the top-level
1318 * din_root will turn into a recursive call to dt_cg_inline() for a scalar
1319 * inline whose din_root will refer to the subtree pointed to by the argument.
1320 */
1321 static void
dt_cg_inline(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)1322 dt_cg_inline(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
1323 {
1324 dt_ident_t *idp = dnp->dn_ident;
1325 dt_idnode_t *inp = idp->di_iarg;
1326
1327 dt_idnode_t *pinp;
1328 dt_node_t *pnp;
1329 int i;
1330
1331 assert(idp->di_flags & DT_IDFLG_INLINE);
1332 assert(idp->di_ops == &dt_idops_inline);
1333
1334 if (idp->di_kind == DT_IDENT_ARRAY) {
1335 for (i = 0, pnp = dnp->dn_args;
1336 pnp != NULL; pnp = pnp->dn_list, i++) {
1337 if (inp->din_argv[i] != NULL) {
1338 pinp = inp->din_argv[i]->di_iarg;
1339 pinp->din_root = pnp;
1340 }
1341 }
1342 }
1343
1344 dt_cg_node(inp->din_root, dlp, drp);
1345 dnp->dn_reg = inp->din_root->dn_reg;
1346 dt_cg_typecast(inp->din_root, dnp, dlp, drp);
1347
1348 if (idp->di_kind == DT_IDENT_ARRAY) {
1349 for (i = 0; i < inp->din_argc; i++) {
1350 pinp = inp->din_argv[i]->di_iarg;
1351 pinp->din_root = NULL;
1352 }
1353 }
1354 }
1355
1356 static void
dt_cg_func_typeref(dtrace_hdl_t * dtp,dt_node_t * dnp)1357 dt_cg_func_typeref(dtrace_hdl_t *dtp, dt_node_t *dnp)
1358 {
1359 dtrace_typeinfo_t dtt;
1360 dt_node_t *addr = dnp->dn_args;
1361 dt_node_t *nelm = addr->dn_list;
1362 dt_node_t *strp = nelm->dn_list;
1363 dt_node_t *typs = strp->dn_list;
1364 char buf[DT_TYPE_NAMELEN];
1365 char *p;
1366
1367 ctf_type_name(addr->dn_ctfp, addr->dn_type, buf, sizeof (buf));
1368
1369 /*
1370 * XXX Hack alert! XXX
1371 * The prototype has two dummy args that we munge to represent
1372 * the type string and the type size.
1373 *
1374 * Yes, I hear your grumble, but it works for now. We'll come
1375 * up with a more elegant implementation later. :-)
1376 */
1377 free(strp->dn_string);
1378
1379 if ((p = strchr(buf, '*')) != NULL)
1380 *p = '\0';
1381
1382 strp->dn_string = strdup(buf);
1383
1384 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_EVERY, buf, &dtt) < 0)
1385 return;
1386
1387 typs->dn_value = ctf_type_size(dtt.dtt_ctfp, dtt.dtt_type);
1388 }
1389
1390 typedef struct dt_xlmemb {
1391 dt_ident_t *dtxl_idp; /* translated ident */
1392 dt_irlist_t *dtxl_dlp; /* instruction list */
1393 dt_regset_t *dtxl_drp; /* register set */
1394 int dtxl_sreg; /* location of the translation input */
1395 int dtxl_dreg; /* location of our allocated buffer */
1396 } dt_xlmemb_t;
1397
1398 /*ARGSUSED*/
1399 static int
dt_cg_xlate_member(const char * name,ctf_id_t type,ulong_t off,void * arg)1400 dt_cg_xlate_member(const char *name, ctf_id_t type, ulong_t off, void *arg)
1401 {
1402 dt_xlmemb_t *dx = arg;
1403 dt_ident_t *idp = dx->dtxl_idp;
1404 dt_irlist_t *dlp = dx->dtxl_dlp;
1405 dt_regset_t *drp = dx->dtxl_drp;
1406
1407 dt_node_t *mnp;
1408 dt_xlator_t *dxp;
1409
1410 int reg, treg;
1411 uint32_t instr;
1412 size_t size;
1413
1414 /* Generate code for the translation. */
1415 dxp = idp->di_data;
1416 mnp = dt_xlator_member(dxp, name);
1417
1418 /* If there's no translator for the given member, skip it. */
1419 if (mnp == NULL)
1420 return (0);
1421
1422 dxp->dx_ident->di_flags |= DT_IDFLG_CGREG;
1423 dxp->dx_ident->di_id = dx->dtxl_sreg;
1424
1425 dt_cg_node(mnp->dn_membexpr, dlp, drp);
1426
1427 dxp->dx_ident->di_flags &= ~DT_IDFLG_CGREG;
1428 dxp->dx_ident->di_id = 0;
1429
1430 treg = mnp->dn_membexpr->dn_reg;
1431
1432 /* Compute the offset into our buffer and store the result there. */
1433 reg = dt_regset_alloc(drp);
1434
1435 dt_cg_setx(dlp, reg, off / NBBY);
1436 instr = DIF_INSTR_FMT(DIF_OP_ADD, dx->dtxl_dreg, reg, reg);
1437 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1438
1439 size = ctf_type_size(mnp->dn_membexpr->dn_ctfp,
1440 mnp->dn_membexpr->dn_type);
1441 if (dt_node_is_scalar(mnp->dn_membexpr)) {
1442 /*
1443 * Copying scalars is simple.
1444 */
1445 switch (size) {
1446 case 1:
1447 instr = DIF_INSTR_STORE(DIF_OP_STB, treg, reg);
1448 break;
1449 case 2:
1450 instr = DIF_INSTR_STORE(DIF_OP_STH, treg, reg);
1451 break;
1452 case 4:
1453 instr = DIF_INSTR_STORE(DIF_OP_STW, treg, reg);
1454 break;
1455 case 8:
1456 instr = DIF_INSTR_STORE(DIF_OP_STX, treg, reg);
1457 break;
1458 default:
1459 xyerror(D_UNKNOWN, "internal error -- unexpected "
1460 "size: %lu\n", (ulong_t)size);
1461 }
1462
1463 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1464
1465 } else if (dt_node_is_string(mnp->dn_membexpr)) {
1466 int szreg;
1467
1468 /*
1469 * Use the copys instruction for strings.
1470 */
1471 szreg = dt_regset_alloc(drp);
1472 dt_cg_setx(dlp, szreg, size);
1473 instr = DIF_INSTR_COPYS(treg, szreg, reg);
1474 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1475 dt_regset_free(drp, szreg);
1476 } else {
1477 int szreg;
1478
1479 /*
1480 * If it's anything else then we'll just bcopy it.
1481 */
1482 szreg = dt_regset_alloc(drp);
1483 dt_cg_setx(dlp, szreg, size);
1484 dt_irlist_append(dlp,
1485 dt_cg_node_alloc(DT_LBL_NONE, DIF_INSTR_FLUSHTS));
1486 instr = DIF_INSTR_PUSHTS(DIF_OP_PUSHTV, DIF_TYPE_CTF,
1487 DIF_REG_R0, treg);
1488 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1489 instr = DIF_INSTR_PUSHTS(DIF_OP_PUSHTV, DIF_TYPE_CTF,
1490 DIF_REG_R0, reg);
1491 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1492 instr = DIF_INSTR_PUSHTS(DIF_OP_PUSHTV, DIF_TYPE_CTF,
1493 DIF_REG_R0, szreg);
1494 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1495 instr = DIF_INSTR_CALL(DIF_SUBR_BCOPY, szreg);
1496 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1497 dt_regset_free(drp, szreg);
1498 }
1499
1500 dt_regset_free(drp, reg);
1501 dt_regset_free(drp, treg);
1502
1503 return (0);
1504 }
1505
1506 /*
1507 * If we're expanding a translated type, we create an appropriately sized
1508 * buffer with alloca() and then translate each member into it.
1509 */
1510 static int
dt_cg_xlate_expand(dt_node_t * dnp,dt_ident_t * idp,dt_irlist_t * dlp,dt_regset_t * drp)1511 dt_cg_xlate_expand(dt_node_t *dnp, dt_ident_t *idp, dt_irlist_t *dlp,
1512 dt_regset_t *drp)
1513 {
1514 dt_xlmemb_t dlm;
1515 uint32_t instr;
1516 int dreg;
1517 size_t size;
1518
1519 dreg = dt_regset_alloc(drp);
1520 size = ctf_type_size(dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type);
1521
1522 /* Call alloca() to create the buffer. */
1523 dt_cg_setx(dlp, dreg, size);
1524
1525 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, DIF_INSTR_FLUSHTS));
1526
1527 instr = DIF_INSTR_PUSHTS(DIF_OP_PUSHTV, DIF_TYPE_CTF, DIF_REG_R0, dreg);
1528 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1529
1530 instr = DIF_INSTR_CALL(DIF_SUBR_ALLOCA, dreg);
1531 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1532
1533 /* Generate the translation for each member. */
1534 dlm.dtxl_idp = idp;
1535 dlm.dtxl_dlp = dlp;
1536 dlm.dtxl_drp = drp;
1537 dlm.dtxl_sreg = dnp->dn_reg;
1538 dlm.dtxl_dreg = dreg;
1539 (void) ctf_member_iter(dnp->dn_ident->di_ctfp,
1540 dnp->dn_ident->di_type, dt_cg_xlate_member,
1541 &dlm);
1542
1543 return (dreg);
1544 }
1545
1546 static void
dt_cg_node(dt_node_t * dnp,dt_irlist_t * dlp,dt_regset_t * drp)1547 dt_cg_node(dt_node_t *dnp, dt_irlist_t *dlp, dt_regset_t *drp)
1548 {
1549 ctf_file_t *ctfp = dnp->dn_ctfp;
1550 ctf_file_t *octfp;
1551 ctf_membinfo_t m;
1552 ctf_id_t type;
1553
1554 dif_instr_t instr;
1555 dt_ident_t *idp;
1556 ssize_t stroff;
1557 uint_t op;
1558
1559 switch (dnp->dn_op) {
1560 case DT_TOK_COMMA:
1561 dt_cg_node(dnp->dn_left, dlp, drp);
1562 dt_regset_free(drp, dnp->dn_left->dn_reg);
1563 dt_cg_node(dnp->dn_right, dlp, drp);
1564 dnp->dn_reg = dnp->dn_right->dn_reg;
1565 break;
1566
1567 case DT_TOK_ASGN:
1568 dt_cg_node(dnp->dn_right, dlp, drp);
1569 dnp->dn_reg = dnp->dn_right->dn_reg;
1570 dt_cg_asgn_op(dnp, dlp, drp);
1571 break;
1572
1573 case DT_TOK_ADD_EQ:
1574 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_ADD);
1575 dt_cg_asgn_op(dnp, dlp, drp);
1576 break;
1577
1578 case DT_TOK_SUB_EQ:
1579 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_SUB);
1580 dt_cg_asgn_op(dnp, dlp, drp);
1581 break;
1582
1583 case DT_TOK_MUL_EQ:
1584 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_MUL);
1585 dt_cg_asgn_op(dnp, dlp, drp);
1586 break;
1587
1588 case DT_TOK_DIV_EQ:
1589 dt_cg_arithmetic_op(dnp, dlp, drp,
1590 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SDIV : DIF_OP_UDIV);
1591 dt_cg_asgn_op(dnp, dlp, drp);
1592 break;
1593
1594 case DT_TOK_MOD_EQ:
1595 dt_cg_arithmetic_op(dnp, dlp, drp,
1596 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SREM : DIF_OP_UREM);
1597 dt_cg_asgn_op(dnp, dlp, drp);
1598 break;
1599
1600 case DT_TOK_AND_EQ:
1601 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_AND);
1602 dt_cg_asgn_op(dnp, dlp, drp);
1603 break;
1604
1605 case DT_TOK_XOR_EQ:
1606 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_XOR);
1607 dt_cg_asgn_op(dnp, dlp, drp);
1608 break;
1609
1610 case DT_TOK_OR_EQ:
1611 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_OR);
1612 dt_cg_asgn_op(dnp, dlp, drp);
1613 break;
1614
1615 case DT_TOK_LSH_EQ:
1616 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_SLL);
1617 dt_cg_asgn_op(dnp, dlp, drp);
1618 break;
1619
1620 case DT_TOK_RSH_EQ:
1621 dt_cg_arithmetic_op(dnp, dlp, drp,
1622 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SRA : DIF_OP_SRL);
1623 dt_cg_asgn_op(dnp, dlp, drp);
1624 break;
1625
1626 case DT_TOK_QUESTION:
1627 dt_cg_ternary_op(dnp, dlp, drp);
1628 break;
1629
1630 case DT_TOK_LOR:
1631 dt_cg_logical_or(dnp, dlp, drp);
1632 break;
1633
1634 case DT_TOK_LXOR:
1635 dt_cg_logical_xor(dnp, dlp, drp);
1636 break;
1637
1638 case DT_TOK_LAND:
1639 dt_cg_logical_and(dnp, dlp, drp);
1640 break;
1641
1642 case DT_TOK_BOR:
1643 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_OR);
1644 break;
1645
1646 case DT_TOK_XOR:
1647 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_XOR);
1648 break;
1649
1650 case DT_TOK_BAND:
1651 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_AND);
1652 break;
1653
1654 case DT_TOK_EQU:
1655 dt_cg_compare_op(dnp, dlp, drp, DIF_OP_BE);
1656 break;
1657
1658 case DT_TOK_NEQ:
1659 dt_cg_compare_op(dnp, dlp, drp, DIF_OP_BNE);
1660 break;
1661
1662 case DT_TOK_LT:
1663 dt_cg_compare_op(dnp, dlp, drp,
1664 dt_cg_compare_signed(dnp) ? DIF_OP_BL : DIF_OP_BLU);
1665 break;
1666
1667 case DT_TOK_LE:
1668 dt_cg_compare_op(dnp, dlp, drp,
1669 dt_cg_compare_signed(dnp) ? DIF_OP_BLE : DIF_OP_BLEU);
1670 break;
1671
1672 case DT_TOK_GT:
1673 dt_cg_compare_op(dnp, dlp, drp,
1674 dt_cg_compare_signed(dnp) ? DIF_OP_BG : DIF_OP_BGU);
1675 break;
1676
1677 case DT_TOK_GE:
1678 dt_cg_compare_op(dnp, dlp, drp,
1679 dt_cg_compare_signed(dnp) ? DIF_OP_BGE : DIF_OP_BGEU);
1680 break;
1681
1682 case DT_TOK_LSH:
1683 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_SLL);
1684 break;
1685
1686 case DT_TOK_RSH:
1687 dt_cg_arithmetic_op(dnp, dlp, drp,
1688 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SRA : DIF_OP_SRL);
1689 break;
1690
1691 case DT_TOK_ADD:
1692 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_ADD);
1693 break;
1694
1695 case DT_TOK_SUB:
1696 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_SUB);
1697 break;
1698
1699 case DT_TOK_MUL:
1700 dt_cg_arithmetic_op(dnp, dlp, drp, DIF_OP_MUL);
1701 break;
1702
1703 case DT_TOK_DIV:
1704 dt_cg_arithmetic_op(dnp, dlp, drp,
1705 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SDIV : DIF_OP_UDIV);
1706 break;
1707
1708 case DT_TOK_MOD:
1709 dt_cg_arithmetic_op(dnp, dlp, drp,
1710 (dnp->dn_flags & DT_NF_SIGNED) ? DIF_OP_SREM : DIF_OP_UREM);
1711 break;
1712
1713 case DT_TOK_LNEG:
1714 dt_cg_logical_neg(dnp, dlp, drp);
1715 break;
1716
1717 case DT_TOK_BNEG:
1718 dt_cg_node(dnp->dn_child, dlp, drp);
1719 dnp->dn_reg = dnp->dn_child->dn_reg;
1720 instr = DIF_INSTR_NOT(dnp->dn_reg, dnp->dn_reg);
1721 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1722 break;
1723
1724 case DT_TOK_PREINC:
1725 dt_cg_prearith_op(dnp, dlp, drp, DIF_OP_ADD);
1726 break;
1727
1728 case DT_TOK_POSTINC:
1729 dt_cg_postarith_op(dnp, dlp, drp, DIF_OP_ADD);
1730 break;
1731
1732 case DT_TOK_PREDEC:
1733 dt_cg_prearith_op(dnp, dlp, drp, DIF_OP_SUB);
1734 break;
1735
1736 case DT_TOK_POSTDEC:
1737 dt_cg_postarith_op(dnp, dlp, drp, DIF_OP_SUB);
1738 break;
1739
1740 case DT_TOK_IPOS:
1741 dt_cg_node(dnp->dn_child, dlp, drp);
1742 dnp->dn_reg = dnp->dn_child->dn_reg;
1743 break;
1744
1745 case DT_TOK_INEG:
1746 dt_cg_node(dnp->dn_child, dlp, drp);
1747 dnp->dn_reg = dnp->dn_child->dn_reg;
1748
1749 instr = DIF_INSTR_FMT(DIF_OP_SUB, DIF_REG_R0,
1750 dnp->dn_reg, dnp->dn_reg);
1751
1752 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1753 break;
1754
1755 case DT_TOK_DEREF:
1756 dt_cg_node(dnp->dn_child, dlp, drp);
1757 dnp->dn_reg = dnp->dn_child->dn_reg;
1758
1759 if (dt_node_is_dynamic(dnp->dn_child)) {
1760 int reg;
1761 idp = dt_node_resolve(dnp->dn_child, DT_IDENT_XLPTR);
1762 assert(idp != NULL);
1763 reg = dt_cg_xlate_expand(dnp, idp, dlp, drp);
1764
1765 dt_regset_free(drp, dnp->dn_child->dn_reg);
1766 dnp->dn_reg = reg;
1767
1768 } else if (!(dnp->dn_flags & DT_NF_REF)) {
1769 uint_t ubit = dnp->dn_flags & DT_NF_USERLAND;
1770
1771 /*
1772 * Save and restore DT_NF_USERLAND across dt_cg_load():
1773 * we need the sign bit from dnp and the user bit from
1774 * dnp->dn_child in order to get the proper opcode.
1775 */
1776 dnp->dn_flags |=
1777 (dnp->dn_child->dn_flags & DT_NF_USERLAND);
1778
1779 instr = DIF_INSTR_LOAD(dt_cg_load(dnp, ctfp,
1780 dnp->dn_type), dnp->dn_reg, dnp->dn_reg);
1781
1782 dnp->dn_flags &= ~DT_NF_USERLAND;
1783 dnp->dn_flags |= ubit;
1784
1785 dt_irlist_append(dlp,
1786 dt_cg_node_alloc(DT_LBL_NONE, instr));
1787 }
1788 break;
1789
1790 case DT_TOK_ADDROF: {
1791 uint_t rbit = dnp->dn_child->dn_flags & DT_NF_REF;
1792
1793 dnp->dn_child->dn_flags |= DT_NF_REF; /* force pass-by-ref */
1794 dt_cg_node(dnp->dn_child, dlp, drp);
1795 dnp->dn_reg = dnp->dn_child->dn_reg;
1796
1797 dnp->dn_child->dn_flags &= ~DT_NF_REF;
1798 dnp->dn_child->dn_flags |= rbit;
1799 break;
1800 }
1801
1802 case DT_TOK_SIZEOF: {
1803 size_t size = dt_node_sizeof(dnp->dn_child);
1804 dnp->dn_reg = dt_regset_alloc(drp);
1805 assert(size != 0);
1806 dt_cg_setx(dlp, dnp->dn_reg, size);
1807 break;
1808 }
1809
1810 case DT_TOK_STRINGOF:
1811 dt_cg_node(dnp->dn_child, dlp, drp);
1812 dnp->dn_reg = dnp->dn_child->dn_reg;
1813 break;
1814
1815 case DT_TOK_XLATE:
1816 /*
1817 * An xlate operator appears in either an XLATOR, indicating a
1818 * reference to a dynamic translator, or an OP2, indicating
1819 * use of the xlate operator in the user's program. For the
1820 * dynamic case, generate an xlate opcode with a reference to
1821 * the corresponding member, pre-computed for us in dn_members.
1822 */
1823 if (dnp->dn_kind == DT_NODE_XLATOR) {
1824 dt_xlator_t *dxp = dnp->dn_xlator;
1825
1826 assert(dxp->dx_ident->di_flags & DT_IDFLG_CGREG);
1827 assert(dxp->dx_ident->di_id != 0);
1828
1829 dnp->dn_reg = dt_regset_alloc(drp);
1830
1831 if (dxp->dx_arg == -1) {
1832 instr = DIF_INSTR_MOV(
1833 dxp->dx_ident->di_id, dnp->dn_reg);
1834 dt_irlist_append(dlp,
1835 dt_cg_node_alloc(DT_LBL_NONE, instr));
1836 op = DIF_OP_XLATE;
1837 } else
1838 op = DIF_OP_XLARG;
1839
1840 instr = DIF_INSTR_XLATE(op, 0, dnp->dn_reg);
1841 dt_irlist_append(dlp,
1842 dt_cg_node_alloc(DT_LBL_NONE, instr));
1843
1844 dlp->dl_last->di_extern = dnp->dn_xmember;
1845 break;
1846 }
1847
1848 assert(dnp->dn_kind == DT_NODE_OP2);
1849 dt_cg_node(dnp->dn_right, dlp, drp);
1850 dnp->dn_reg = dnp->dn_right->dn_reg;
1851 break;
1852
1853 case DT_TOK_LPAR:
1854 dt_cg_node(dnp->dn_right, dlp, drp);
1855 dnp->dn_reg = dnp->dn_right->dn_reg;
1856 dt_cg_typecast(dnp->dn_right, dnp, dlp, drp);
1857 break;
1858
1859 case DT_TOK_PTR:
1860 case DT_TOK_DOT:
1861 assert(dnp->dn_right->dn_kind == DT_NODE_IDENT);
1862 dt_cg_node(dnp->dn_left, dlp, drp);
1863
1864 /*
1865 * If the left-hand side of PTR or DOT is a dynamic variable,
1866 * we expect it to be the output of a D translator. In this
1867 * case, we look up the parse tree corresponding to the member
1868 * that is being accessed and run the code generator over it.
1869 * We then cast the result as if by the assignment operator.
1870 */
1871 if ((idp = dt_node_resolve(
1872 dnp->dn_left, DT_IDENT_XLSOU)) != NULL ||
1873 (idp = dt_node_resolve(
1874 dnp->dn_left, DT_IDENT_XLPTR)) != NULL) {
1875
1876 dt_xlator_t *dxp;
1877 dt_node_t *mnp;
1878
1879 dxp = idp->di_data;
1880 mnp = dt_xlator_member(dxp, dnp->dn_right->dn_string);
1881 assert(mnp != NULL);
1882
1883 dxp->dx_ident->di_flags |= DT_IDFLG_CGREG;
1884 dxp->dx_ident->di_id = dnp->dn_left->dn_reg;
1885
1886 dt_cg_node(mnp->dn_membexpr, dlp, drp);
1887 dnp->dn_reg = mnp->dn_membexpr->dn_reg;
1888 dt_cg_typecast(mnp->dn_membexpr, dnp, dlp, drp);
1889
1890 dxp->dx_ident->di_flags &= ~DT_IDFLG_CGREG;
1891 dxp->dx_ident->di_id = 0;
1892
1893 if (dnp->dn_left->dn_reg != -1)
1894 dt_regset_free(drp, dnp->dn_left->dn_reg);
1895 break;
1896 }
1897
1898 ctfp = dnp->dn_left->dn_ctfp;
1899 type = ctf_type_resolve(ctfp, dnp->dn_left->dn_type);
1900
1901 if (dnp->dn_op == DT_TOK_PTR) {
1902 type = ctf_type_reference(ctfp, type);
1903 type = ctf_type_resolve(ctfp, type);
1904 }
1905
1906 if ((ctfp = dt_cg_membinfo(octfp = ctfp, type,
1907 dnp->dn_right->dn_string, &m)) == NULL) {
1908 yypcb->pcb_hdl->dt_ctferr = ctf_errno(octfp);
1909 longjmp(yypcb->pcb_jmpbuf, EDT_CTF);
1910 }
1911
1912 if (m.ctm_offset != 0) {
1913 int reg;
1914
1915 reg = dt_regset_alloc(drp);
1916
1917 /*
1918 * If the offset is not aligned on a byte boundary, it
1919 * is a bit-field member and we will extract the value
1920 * bits below after we generate the appropriate load.
1921 */
1922 dt_cg_setx(dlp, reg, m.ctm_offset / NBBY);
1923
1924 instr = DIF_INSTR_FMT(DIF_OP_ADD,
1925 dnp->dn_left->dn_reg, reg, dnp->dn_left->dn_reg);
1926
1927 dt_irlist_append(dlp,
1928 dt_cg_node_alloc(DT_LBL_NONE, instr));
1929 dt_regset_free(drp, reg);
1930 }
1931
1932 if (!(dnp->dn_flags & DT_NF_REF)) {
1933 uint_t ubit = dnp->dn_flags & DT_NF_USERLAND;
1934
1935 /*
1936 * Save and restore DT_NF_USERLAND across dt_cg_load():
1937 * we need the sign bit from dnp and the user bit from
1938 * dnp->dn_left in order to get the proper opcode.
1939 */
1940 dnp->dn_flags |=
1941 (dnp->dn_left->dn_flags & DT_NF_USERLAND);
1942
1943 instr = DIF_INSTR_LOAD(dt_cg_load(dnp,
1944 ctfp, m.ctm_type), dnp->dn_left->dn_reg,
1945 dnp->dn_left->dn_reg);
1946
1947 dnp->dn_flags &= ~DT_NF_USERLAND;
1948 dnp->dn_flags |= ubit;
1949
1950 dt_irlist_append(dlp,
1951 dt_cg_node_alloc(DT_LBL_NONE, instr));
1952
1953 if (dnp->dn_flags & DT_NF_BITFIELD)
1954 dt_cg_field_get(dnp, dlp, drp, ctfp, &m);
1955 }
1956
1957 dnp->dn_reg = dnp->dn_left->dn_reg;
1958 break;
1959
1960 case DT_TOK_STRING:
1961 dnp->dn_reg = dt_regset_alloc(drp);
1962
1963 assert(dnp->dn_kind == DT_NODE_STRING);
1964 stroff = dt_strtab_insert(yypcb->pcb_strtab, dnp->dn_string);
1965
1966 if (stroff == -1L)
1967 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
1968 if (stroff > DIF_STROFF_MAX)
1969 longjmp(yypcb->pcb_jmpbuf, EDT_STR2BIG);
1970
1971 instr = DIF_INSTR_SETS((ulong_t)stroff, dnp->dn_reg);
1972 dt_irlist_append(dlp, dt_cg_node_alloc(DT_LBL_NONE, instr));
1973 break;
1974
1975 case DT_TOK_IDENT:
1976 /*
1977 * If the specified identifier is a variable on which we have
1978 * set the code generator register flag, then this variable
1979 * has already had code generated for it and saved in di_id.
1980 * Allocate a new register and copy the existing value to it.
1981 */
1982 if (dnp->dn_kind == DT_NODE_VAR &&
1983 (dnp->dn_ident->di_flags & DT_IDFLG_CGREG)) {
1984 dnp->dn_reg = dt_regset_alloc(drp);
1985 instr = DIF_INSTR_MOV(dnp->dn_ident->di_id,
1986 dnp->dn_reg);
1987 dt_irlist_append(dlp,
1988 dt_cg_node_alloc(DT_LBL_NONE, instr));
1989 break;
1990 }
1991
1992 /*
1993 * Identifiers can represent function calls, variable refs, or
1994 * symbols. First we check for inlined variables, and handle
1995 * them by generating code for the inline parse tree.
1996 */
1997 if (dnp->dn_kind == DT_NODE_VAR &&
1998 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
1999 dt_cg_inline(dnp, dlp, drp);
2000 break;
2001 }
2002
2003 switch (dnp->dn_kind) {
2004 case DT_NODE_FUNC: {
2005 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2006
2007 if ((idp = dnp->dn_ident)->di_kind != DT_IDENT_FUNC) {
2008 dnerror(dnp, D_CG_EXPR, "%s %s( ) may not be "
2009 "called from a D expression (D program "
2010 "context required)\n",
2011 dt_idkind_name(idp->di_kind), idp->di_name);
2012 }
2013
2014 switch (idp->di_id) {
2015 case DIF_SUBR_TYPEREF:
2016 dt_cg_func_typeref(dtp, dnp);
2017 break;
2018
2019 default:
2020 break;
2021 }
2022
2023 dt_cg_arglist(dnp->dn_ident, dnp->dn_args, dlp, drp);
2024
2025 dnp->dn_reg = dt_regset_alloc(drp);
2026 instr = DIF_INSTR_CALL(dnp->dn_ident->di_id,
2027 dnp->dn_reg);
2028
2029 dt_irlist_append(dlp,
2030 dt_cg_node_alloc(DT_LBL_NONE, instr));
2031
2032 break;
2033 }
2034
2035 case DT_NODE_VAR:
2036 if (dnp->dn_ident->di_kind == DT_IDENT_XLSOU ||
2037 dnp->dn_ident->di_kind == DT_IDENT_XLPTR) {
2038 /*
2039 * This can only happen if we have translated
2040 * args[]. See dt_idcook_args() for details.
2041 */
2042 assert(dnp->dn_ident->di_id == DIF_VAR_ARGS);
2043 dt_cg_array_op(dnp, dlp, drp);
2044 break;
2045 }
2046
2047 if (dnp->dn_ident->di_kind == DT_IDENT_ARRAY) {
2048 if (dnp->dn_ident->di_id > DIF_VAR_ARRAY_MAX)
2049 dt_cg_assoc_op(dnp, dlp, drp);
2050 else
2051 dt_cg_array_op(dnp, dlp, drp);
2052 break;
2053 }
2054
2055 dnp->dn_reg = dt_regset_alloc(drp);
2056
2057 if (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL)
2058 op = DIF_OP_LDLS;
2059 else if (dnp->dn_ident->di_flags & DT_IDFLG_TLS)
2060 op = DIF_OP_LDTS;
2061 else
2062 op = DIF_OP_LDGS;
2063
2064 dnp->dn_ident->di_flags |= DT_IDFLG_DIFR;
2065
2066 instr = DIF_INSTR_LDV(op,
2067 dnp->dn_ident->di_id, dnp->dn_reg);
2068
2069 dt_irlist_append(dlp,
2070 dt_cg_node_alloc(DT_LBL_NONE, instr));
2071 break;
2072
2073 case DT_NODE_SYM: {
2074 dtrace_hdl_t *dtp = yypcb->pcb_hdl;
2075 dtrace_syminfo_t *sip = dnp->dn_ident->di_data;
2076 GElf_Sym sym;
2077
2078 if (dtrace_lookup_by_name(dtp,
2079 sip->dts_object, sip->dts_name, &sym, NULL) == -1) {
2080 xyerror(D_UNKNOWN, "cg failed for symbol %s`%s:"
2081 " %s\n", sip->dts_object, sip->dts_name,
2082 dtrace_errmsg(dtp, dtrace_errno(dtp)));
2083 }
2084
2085 dnp->dn_reg = dt_regset_alloc(drp);
2086 dt_cg_xsetx(dlp, dnp->dn_ident,
2087 DT_LBL_NONE, dnp->dn_reg, sym.st_value);
2088
2089 if (!(dnp->dn_flags & DT_NF_REF)) {
2090 instr = DIF_INSTR_LOAD(dt_cg_load(dnp, ctfp,
2091 dnp->dn_type), dnp->dn_reg, dnp->dn_reg);
2092 dt_irlist_append(dlp,
2093 dt_cg_node_alloc(DT_LBL_NONE, instr));
2094 }
2095 break;
2096 }
2097
2098 default:
2099 xyerror(D_UNKNOWN, "internal error -- node type %u is "
2100 "not valid for an identifier\n", dnp->dn_kind);
2101 }
2102 break;
2103
2104 case DT_TOK_INT:
2105 dnp->dn_reg = dt_regset_alloc(drp);
2106 dt_cg_setx(dlp, dnp->dn_reg, dnp->dn_value);
2107 break;
2108
2109 default:
2110 xyerror(D_UNKNOWN, "internal error -- token type %u is not a "
2111 "valid D compilation token\n", dnp->dn_op);
2112 }
2113 }
2114
2115 void
dt_cg(dt_pcb_t * pcb,dt_node_t * dnp)2116 dt_cg(dt_pcb_t *pcb, dt_node_t *dnp)
2117 {
2118 dif_instr_t instr;
2119 dt_xlator_t *dxp;
2120 dt_ident_t *idp;
2121
2122 if (pcb->pcb_regs == NULL && (pcb->pcb_regs =
2123 dt_regset_create(pcb->pcb_hdl->dt_conf.dtc_difintregs)) == NULL)
2124 longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
2125
2126 dt_regset_reset(pcb->pcb_regs);
2127 (void) dt_regset_alloc(pcb->pcb_regs); /* allocate %r0 */
2128
2129 if (pcb->pcb_inttab != NULL)
2130 dt_inttab_destroy(pcb->pcb_inttab);
2131
2132 if ((pcb->pcb_inttab = dt_inttab_create(yypcb->pcb_hdl)) == NULL)
2133 longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
2134
2135 if (pcb->pcb_strtab != NULL)
2136 dt_strtab_destroy(pcb->pcb_strtab);
2137
2138 if ((pcb->pcb_strtab = dt_strtab_create(BUFSIZ)) == NULL)
2139 longjmp(pcb->pcb_jmpbuf, EDT_NOMEM);
2140
2141 dt_irlist_destroy(&pcb->pcb_ir);
2142 dt_irlist_create(&pcb->pcb_ir);
2143
2144 assert(pcb->pcb_dret == NULL);
2145 pcb->pcb_dret = dnp;
2146
2147 if (dt_node_resolve(dnp, DT_IDENT_XLPTR) != NULL) {
2148 dnerror(dnp, D_CG_DYN, "expression cannot evaluate to result "
2149 "of a translated pointer\n");
2150 }
2151
2152 /*
2153 * If we're generating code for a translator body, assign the input
2154 * parameter to the first available register (i.e. caller passes %r1).
2155 */
2156 if (dnp->dn_kind == DT_NODE_MEMBER) {
2157 dxp = dnp->dn_membxlator;
2158 dnp = dnp->dn_membexpr;
2159
2160 dxp->dx_ident->di_flags |= DT_IDFLG_CGREG;
2161 dxp->dx_ident->di_id = dt_regset_alloc(pcb->pcb_regs);
2162 }
2163
2164 dt_cg_node(dnp, &pcb->pcb_ir, pcb->pcb_regs);
2165
2166 if ((idp = dt_node_resolve(dnp, DT_IDENT_XLSOU)) != NULL) {
2167 int reg = dt_cg_xlate_expand(dnp, idp,
2168 &pcb->pcb_ir, pcb->pcb_regs);
2169 dt_regset_free(pcb->pcb_regs, dnp->dn_reg);
2170 dnp->dn_reg = reg;
2171 }
2172
2173 instr = DIF_INSTR_RET(dnp->dn_reg);
2174 dt_regset_free(pcb->pcb_regs, dnp->dn_reg);
2175 dt_irlist_append(&pcb->pcb_ir, dt_cg_node_alloc(DT_LBL_NONE, instr));
2176
2177 if (dnp->dn_kind == DT_NODE_MEMBER) {
2178 dt_regset_free(pcb->pcb_regs, dxp->dx_ident->di_id);
2179 dxp->dx_ident->di_id = 0;
2180 dxp->dx_ident->di_flags &= ~DT_IDFLG_CGREG;
2181 }
2182
2183 dt_regset_free(pcb->pcb_regs, 0);
2184 dt_regset_assert_free(pcb->pcb_regs);
2185 }
2186