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 47static void dt_cg_node(dt_node_t *, dt_irlist_t *, dt_regset_t *); 48 49static dt_irnode_t * 50dt_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 */ 70static ctf_file_t * 71dt_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 92static void 93dt_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 111static void 112dt_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 */ 122static size_t 123clp2(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 */ 144static uint_t 145dt_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 187static void 188dt_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 */ 239static void 240dt_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 */ 323static int 324dt_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 404static void 405dt_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 */ 466static void 467dt_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 */ 540static void 541dt_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 590static void 591dt_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 627static uint_t 628dt_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 639static void 640dt_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 695static void 696dt_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 */ 759static int 760dt_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 776static void 777dt_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 */ 821static void 822dt_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 860static void 861dt_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 895static void 896dt_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 930static void 931dt_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 966static void 967dt_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 993static void 994dt_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 1151static void 1152dt_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 1224static void 1225dt_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 */ 1321static void 1322dt_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 1356static void 1357dt_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 1390typedef 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*/ 1399static int 1400dt_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 */ 1510static int 1511dt_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 1546static void 1547dt_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 2115void 2116dt_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