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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved. 24 * Copyright (c) 2011, Joyent Inc. All rights reserved. 25 * Copyright (c) 2012 by Delphix. All rights reserved. 26 */ 27 28 /* 29 * DTrace D Language Parser 30 * 31 * The D Parser is a lex/yacc parser consisting of the lexer dt_lex.l, the 32 * parsing grammar dt_grammar.y, and this file, dt_parser.c, which handles 33 * the construction of the parse tree nodes and their syntactic validation. 34 * The parse tree is constructed of dt_node_t structures (see <dt_parser.h>) 35 * that are built in two passes: (1) the "create" pass, where the parse tree 36 * nodes are allocated by calls from the grammar to dt_node_*() subroutines, 37 * and (2) the "cook" pass, where nodes are coalesced, assigned D types, and 38 * validated according to the syntactic rules of the language. 39 * 40 * All node allocations are performed using dt_node_alloc(). All node frees 41 * during the parsing phase are performed by dt_node_free(), which frees node- 42 * internal state but does not actually free the nodes. All final node frees 43 * are done as part of the end of dt_compile() or as part of destroying 44 * persistent identifiers or translators which have embedded nodes. 45 * 46 * The dt_node_* routines that implement pass (1) may allocate new nodes. The 47 * dt_cook_* routines that implement pass (2) may *not* allocate new nodes. 48 * They may free existing nodes using dt_node_free(), but they may not actually 49 * deallocate any dt_node_t's. Currently dt_cook_op2() is an exception to this 50 * rule: see the comments therein for how this issue is resolved. 51 * 52 * The dt_cook_* routines are responsible for (at minimum) setting the final 53 * node type (dn_ctfp/dn_type) and attributes (dn_attr). If dn_ctfp/dn_type 54 * are set manually (i.e. not by one of the type assignment functions), then 55 * the DT_NF_COOKED flag must be set manually on the node. 56 * 57 * The cooking pass can be applied to the same parse tree more than once (used 58 * in the case of a comma-separated list of probe descriptions). As such, the 59 * cook routines must not perform any parse tree transformations which would 60 * be invalid if the tree were subsequently cooked using a different context. 61 * 62 * The dn_ctfp and dn_type fields form the type of the node. This tuple can 63 * take on the following set of values, which form our type invariants: 64 * 65 * 1. dn_ctfp = NULL, dn_type = CTF_ERR 66 * 67 * In this state, the node has unknown type and is not yet cooked. The 68 * DT_NF_COOKED flag is not yet set on the node. 69 * 70 * 2. dn_ctfp = DT_DYN_CTFP(dtp), dn_type = DT_DYN_TYPE(dtp) 71 * 72 * In this state, the node is a dynamic D type. This means that generic 73 * operations are not valid on this node and only code that knows how to 74 * examine the inner details of the node can operate on it. A <DYN> node 75 * must have dn_ident set to point to an identifier describing the object 76 * and its type. The DT_NF_REF flag is set for all nodes of type <DYN>. 77 * At present, the D compiler uses the <DYN> type for: 78 * 79 * - associative arrays that do not yet have a value type defined 80 * - translated data (i.e. the result of the xlate operator) 81 * - aggregations 82 * 83 * 3. dn_ctfp = DT_STR_CTFP(dtp), dn_type = DT_STR_TYPE(dtp) 84 * 85 * In this state, the node is of type D string. The string type is really 86 * a char[0] typedef, but requires special handling throughout the compiler. 87 * 88 * 4. dn_ctfp != NULL, dn_type = any other type ID 89 * 90 * In this state, the node is of some known D/CTF type. The normal libctf 91 * APIs can be used to learn more about the type name or structure. When 92 * the type is assigned, the DT_NF_SIGNED, DT_NF_REF, and DT_NF_BITFIELD 93 * flags cache the corresponding attributes of the underlying CTF type. 94 */ 95 96 #include <sys/param.h> 97 #include <sys/sysmacros.h> 98 #include <limits.h> 99 #include <setjmp.h> 100 #include <strings.h> 101 #include <assert.h> 102 #include <alloca.h> 103 #include <stdlib.h> 104 #include <stdarg.h> 105 #include <stdio.h> 106 #include <errno.h> 107 #include <ctype.h> 108 109 #include <dt_impl.h> 110 #include <dt_grammar.h> 111 #include <dt_module.h> 112 #include <dt_provider.h> 113 #include <dt_string.h> 114 #include <dt_as.h> 115 116 dt_pcb_t *yypcb; /* current control block for parser */ 117 dt_node_t *yypragma; /* lex token list for control lines */ 118 char yyintprefix; /* int token macro prefix (+/-) */ 119 char yyintsuffix[4]; /* int token suffix string [uU][lL] */ 120 int yyintdecimal; /* int token format flag (1=decimal, 0=octal/hex) */ 121 122 static const char * 123 opstr(int op) 124 { 125 switch (op) { 126 case DT_TOK_COMMA: return (","); 127 case DT_TOK_ELLIPSIS: return ("..."); 128 case DT_TOK_ASGN: return ("="); 129 case DT_TOK_ADD_EQ: return ("+="); 130 case DT_TOK_SUB_EQ: return ("-="); 131 case DT_TOK_MUL_EQ: return ("*="); 132 case DT_TOK_DIV_EQ: return ("/="); 133 case DT_TOK_MOD_EQ: return ("%="); 134 case DT_TOK_AND_EQ: return ("&="); 135 case DT_TOK_XOR_EQ: return ("^="); 136 case DT_TOK_OR_EQ: return ("|="); 137 case DT_TOK_LSH_EQ: return ("<<="); 138 case DT_TOK_RSH_EQ: return (">>="); 139 case DT_TOK_QUESTION: return ("?"); 140 case DT_TOK_COLON: return (":"); 141 case DT_TOK_LOR: return ("||"); 142 case DT_TOK_LXOR: return ("^^"); 143 case DT_TOK_LAND: return ("&&"); 144 case DT_TOK_BOR: return ("|"); 145 case DT_TOK_XOR: return ("^"); 146 case DT_TOK_BAND: return ("&"); 147 case DT_TOK_EQU: return ("=="); 148 case DT_TOK_NEQ: return ("!="); 149 case DT_TOK_LT: return ("<"); 150 case DT_TOK_LE: return ("<="); 151 case DT_TOK_GT: return (">"); 152 case DT_TOK_GE: return (">="); 153 case DT_TOK_LSH: return ("<<"); 154 case DT_TOK_RSH: return (">>"); 155 case DT_TOK_ADD: return ("+"); 156 case DT_TOK_SUB: return ("-"); 157 case DT_TOK_MUL: return ("*"); 158 case DT_TOK_DIV: return ("/"); 159 case DT_TOK_MOD: return ("%"); 160 case DT_TOK_LNEG: return ("!"); 161 case DT_TOK_BNEG: return ("~"); 162 case DT_TOK_ADDADD: return ("++"); 163 case DT_TOK_PREINC: return ("++"); 164 case DT_TOK_POSTINC: return ("++"); 165 case DT_TOK_SUBSUB: return ("--"); 166 case DT_TOK_PREDEC: return ("--"); 167 case DT_TOK_POSTDEC: return ("--"); 168 case DT_TOK_IPOS: return ("+"); 169 case DT_TOK_INEG: return ("-"); 170 case DT_TOK_DEREF: return ("*"); 171 case DT_TOK_ADDROF: return ("&"); 172 case DT_TOK_OFFSETOF: return ("offsetof"); 173 case DT_TOK_SIZEOF: return ("sizeof"); 174 case DT_TOK_STRINGOF: return ("stringof"); 175 case DT_TOK_XLATE: return ("xlate"); 176 case DT_TOK_LPAR: return ("("); 177 case DT_TOK_RPAR: return (")"); 178 case DT_TOK_LBRAC: return ("["); 179 case DT_TOK_RBRAC: return ("]"); 180 case DT_TOK_PTR: return ("->"); 181 case DT_TOK_DOT: return ("."); 182 case DT_TOK_STRING: return ("<string>"); 183 case DT_TOK_IDENT: return ("<ident>"); 184 case DT_TOK_TNAME: return ("<type>"); 185 case DT_TOK_INT: return ("<int>"); 186 default: return ("<?>"); 187 } 188 } 189 190 int 191 dt_type_lookup(const char *s, dtrace_typeinfo_t *tip) 192 { 193 static const char delimiters[] = " \t\n\r\v\f*`"; 194 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 195 const char *p, *q, *end, *obj; 196 197 for (p = s, end = s + strlen(s); *p != '\0'; p = q) { 198 while (isspace(*p)) 199 p++; /* skip leading whitespace prior to token */ 200 201 if (p == end || (q = strpbrk(p + 1, delimiters)) == NULL) 202 break; /* empty string or single token remaining */ 203 204 if (*q == '`') { 205 char *object = alloca((size_t)(q - p) + 1); 206 char *type = alloca((size_t)(end - s) + 1); 207 208 /* 209 * Copy from the start of the token (p) to the location 210 * backquote (q) to extract the nul-terminated object. 211 */ 212 bcopy(p, object, (size_t)(q - p)); 213 object[(size_t)(q - p)] = '\0'; 214 215 /* 216 * Copy the original string up to the start of this 217 * token (p) into type, and then concatenate everything 218 * after q. This is the type name without the object. 219 */ 220 bcopy(s, type, (size_t)(p - s)); 221 bcopy(q + 1, type + (size_t)(p - s), strlen(q + 1) + 1); 222 223 if (strchr(q + 1, '`') != NULL) 224 return (dt_set_errno(dtp, EDT_BADSCOPE)); 225 226 return (dtrace_lookup_by_type(dtp, object, type, tip)); 227 } 228 } 229 230 if (yypcb->pcb_idepth != 0) 231 obj = DTRACE_OBJ_CDEFS; 232 else 233 obj = DTRACE_OBJ_EVERY; 234 235 return (dtrace_lookup_by_type(dtp, obj, s, tip)); 236 } 237 238 /* 239 * When we parse type expressions or parse an expression with unary "&", we 240 * need to find a type that is a pointer to a previously known type. 241 * Unfortunately CTF is limited to a per-container view, so ctf_type_pointer() 242 * alone does not suffice for our needs. We provide a more intelligent wrapper 243 * for the compiler that attempts to compute a pointer to either the given type 244 * or its base (that is, we try both "foo_t *" and "struct foo *"), and also 245 * to potentially construct the required type on-the-fly. 246 */ 247 int 248 dt_type_pointer(dtrace_typeinfo_t *tip) 249 { 250 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 251 ctf_file_t *ctfp = tip->dtt_ctfp; 252 ctf_id_t type = tip->dtt_type; 253 ctf_id_t base = ctf_type_resolve(ctfp, type); 254 255 dt_module_t *dmp; 256 ctf_id_t ptr; 257 258 if ((ptr = ctf_type_pointer(ctfp, type)) != CTF_ERR || 259 (ptr = ctf_type_pointer(ctfp, base)) != CTF_ERR) { 260 tip->dtt_type = ptr; 261 return (0); 262 } 263 264 if (yypcb->pcb_idepth != 0) 265 dmp = dtp->dt_cdefs; 266 else 267 dmp = dtp->dt_ddefs; 268 269 if (ctfp != dmp->dm_ctfp && ctfp != ctf_parent_file(dmp->dm_ctfp) && 270 (type = ctf_add_type(dmp->dm_ctfp, ctfp, type)) == CTF_ERR) { 271 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp); 272 return (dt_set_errno(dtp, EDT_CTF)); 273 } 274 275 ptr = ctf_add_pointer(dmp->dm_ctfp, CTF_ADD_ROOT, type); 276 277 if (ptr == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) { 278 dtp->dt_ctferr = ctf_errno(dmp->dm_ctfp); 279 return (dt_set_errno(dtp, EDT_CTF)); 280 } 281 282 tip->dtt_object = dmp->dm_name; 283 tip->dtt_ctfp = dmp->dm_ctfp; 284 tip->dtt_type = ptr; 285 286 return (0); 287 } 288 289 const char * 290 dt_type_name(ctf_file_t *ctfp, ctf_id_t type, char *buf, size_t len) 291 { 292 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 293 294 if (ctfp == DT_FPTR_CTFP(dtp) && type == DT_FPTR_TYPE(dtp)) 295 (void) snprintf(buf, len, "function pointer"); 296 else if (ctfp == DT_FUNC_CTFP(dtp) && type == DT_FUNC_TYPE(dtp)) 297 (void) snprintf(buf, len, "function"); 298 else if (ctfp == DT_DYN_CTFP(dtp) && type == DT_DYN_TYPE(dtp)) 299 (void) snprintf(buf, len, "dynamic variable"); 300 else if (ctfp == NULL) 301 (void) snprintf(buf, len, "<none>"); 302 else if (ctf_type_name(ctfp, type, buf, len) == NULL) 303 (void) snprintf(buf, len, "unknown"); 304 305 return (buf); 306 } 307 308 /* 309 * Perform the "usual arithmetic conversions" to determine which of the two 310 * input operand types should be promoted and used as a result type. The 311 * rules for this are described in ISOC[6.3.1.8] and K&R[A6.5]. 312 */ 313 static void 314 dt_type_promote(dt_node_t *lp, dt_node_t *rp, ctf_file_t **ofp, ctf_id_t *otype) 315 { 316 ctf_file_t *lfp = lp->dn_ctfp; 317 ctf_id_t ltype = lp->dn_type; 318 319 ctf_file_t *rfp = rp->dn_ctfp; 320 ctf_id_t rtype = rp->dn_type; 321 322 ctf_id_t lbase = ctf_type_resolve(lfp, ltype); 323 uint_t lkind = ctf_type_kind(lfp, lbase); 324 325 ctf_id_t rbase = ctf_type_resolve(rfp, rtype); 326 uint_t rkind = ctf_type_kind(rfp, rbase); 327 328 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 329 ctf_encoding_t le, re; 330 uint_t lrank, rrank; 331 332 assert(lkind == CTF_K_INTEGER || lkind == CTF_K_ENUM); 333 assert(rkind == CTF_K_INTEGER || rkind == CTF_K_ENUM); 334 335 if (lkind == CTF_K_ENUM) { 336 lfp = DT_INT_CTFP(dtp); 337 ltype = lbase = DT_INT_TYPE(dtp); 338 } 339 340 if (rkind == CTF_K_ENUM) { 341 rfp = DT_INT_CTFP(dtp); 342 rtype = rbase = DT_INT_TYPE(dtp); 343 } 344 345 if (ctf_type_encoding(lfp, lbase, &le) == CTF_ERR) { 346 yypcb->pcb_hdl->dt_ctferr = ctf_errno(lfp); 347 longjmp(yypcb->pcb_jmpbuf, EDT_CTF); 348 } 349 350 if (ctf_type_encoding(rfp, rbase, &re) == CTF_ERR) { 351 yypcb->pcb_hdl->dt_ctferr = ctf_errno(rfp); 352 longjmp(yypcb->pcb_jmpbuf, EDT_CTF); 353 } 354 355 /* 356 * Compute an integer rank based on the size and unsigned status. 357 * If rank is identical, pick the "larger" of the equivalent types 358 * which we define as having a larger base ctf_id_t. If rank is 359 * different, pick the type with the greater rank. 360 */ 361 lrank = le.cte_bits + ((le.cte_format & CTF_INT_SIGNED) == 0); 362 rrank = re.cte_bits + ((re.cte_format & CTF_INT_SIGNED) == 0); 363 364 if (lrank == rrank) { 365 if (lbase - rbase < 0) 366 goto return_rtype; 367 else 368 goto return_ltype; 369 } else if (lrank > rrank) { 370 goto return_ltype; 371 } else 372 goto return_rtype; 373 374 return_ltype: 375 *ofp = lfp; 376 *otype = ltype; 377 return; 378 379 return_rtype: 380 *ofp = rfp; 381 *otype = rtype; 382 } 383 384 void 385 dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp) 386 { 387 dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type); 388 dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type); 389 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 390 } 391 392 const char * 393 dt_node_name(const dt_node_t *dnp, char *buf, size_t len) 394 { 395 char n1[DT_TYPE_NAMELEN]; 396 char n2[DT_TYPE_NAMELEN]; 397 398 const char *prefix = "", *suffix = ""; 399 const dtrace_syminfo_t *dts; 400 char *s; 401 402 switch (dnp->dn_kind) { 403 case DT_NODE_INT: 404 (void) snprintf(buf, len, "integer constant 0x%llx", 405 (u_longlong_t)dnp->dn_value); 406 break; 407 case DT_NODE_STRING: 408 s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string)); 409 (void) snprintf(buf, len, "string constant \"%s\"", 410 s != NULL ? s : dnp->dn_string); 411 free(s); 412 break; 413 case DT_NODE_IDENT: 414 (void) snprintf(buf, len, "identifier %s", dnp->dn_string); 415 break; 416 case DT_NODE_VAR: 417 case DT_NODE_FUNC: 418 case DT_NODE_AGG: 419 case DT_NODE_INLINE: 420 switch (dnp->dn_ident->di_kind) { 421 case DT_IDENT_FUNC: 422 case DT_IDENT_AGGFUNC: 423 case DT_IDENT_ACTFUNC: 424 suffix = "( )"; 425 break; 426 case DT_IDENT_AGG: 427 prefix = "@"; 428 break; 429 } 430 (void) snprintf(buf, len, "%s %s%s%s", 431 dt_idkind_name(dnp->dn_ident->di_kind), 432 prefix, dnp->dn_ident->di_name, suffix); 433 break; 434 case DT_NODE_SYM: 435 dts = dnp->dn_ident->di_data; 436 (void) snprintf(buf, len, "symbol %s`%s", 437 dts->dts_object, dts->dts_name); 438 break; 439 case DT_NODE_TYPE: 440 (void) snprintf(buf, len, "type %s", 441 dt_node_type_name(dnp, n1, sizeof (n1))); 442 break; 443 case DT_NODE_OP1: 444 case DT_NODE_OP2: 445 case DT_NODE_OP3: 446 (void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op)); 447 break; 448 case DT_NODE_DEXPR: 449 case DT_NODE_DFUNC: 450 if (dnp->dn_expr) 451 return (dt_node_name(dnp->dn_expr, buf, len)); 452 (void) snprintf(buf, len, "%s", "statement"); 453 break; 454 case DT_NODE_PDESC: 455 if (dnp->dn_desc->dtpd_id == 0) { 456 (void) snprintf(buf, len, 457 "probe description %s:%s:%s:%s", 458 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod, 459 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name); 460 } else { 461 (void) snprintf(buf, len, "probe description %u", 462 dnp->dn_desc->dtpd_id); 463 } 464 break; 465 case DT_NODE_CLAUSE: 466 (void) snprintf(buf, len, "%s", "clause"); 467 break; 468 case DT_NODE_MEMBER: 469 (void) snprintf(buf, len, "member %s", dnp->dn_membname); 470 break; 471 case DT_NODE_XLATOR: 472 (void) snprintf(buf, len, "translator <%s> (%s)", 473 dt_type_name(dnp->dn_xlator->dx_dst_ctfp, 474 dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)), 475 dt_type_name(dnp->dn_xlator->dx_src_ctfp, 476 dnp->dn_xlator->dx_src_type, n2, sizeof (n2))); 477 break; 478 case DT_NODE_PROG: 479 (void) snprintf(buf, len, "%s", "program"); 480 break; 481 default: 482 (void) snprintf(buf, len, "node <%u>", dnp->dn_kind); 483 break; 484 } 485 486 return (buf); 487 } 488 489 /* 490 * dt_node_xalloc() can be used to create new parse nodes from any libdtrace 491 * caller. The caller is responsible for assigning dn_link appropriately. 492 */ 493 dt_node_t * 494 dt_node_xalloc(dtrace_hdl_t *dtp, int kind) 495 { 496 dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t)); 497 498 if (dnp == NULL) 499 return (NULL); 500 501 dnp->dn_ctfp = NULL; 502 dnp->dn_type = CTF_ERR; 503 dnp->dn_kind = (uchar_t)kind; 504 dnp->dn_flags = 0; 505 dnp->dn_op = 0; 506 dnp->dn_line = -1; 507 dnp->dn_reg = -1; 508 dnp->dn_attr = _dtrace_defattr; 509 dnp->dn_list = NULL; 510 dnp->dn_link = NULL; 511 bzero(&dnp->dn_u, sizeof (dnp->dn_u)); 512 513 return (dnp); 514 } 515 516 /* 517 * dt_node_alloc() is used to create new parse nodes from the parser. It 518 * assigns the node location based on the current lexer line number and places 519 * the new node on the default allocation list. If allocation fails, we 520 * automatically longjmp the caller back to the enclosing compilation call. 521 */ 522 static dt_node_t * 523 dt_node_alloc(int kind) 524 { 525 dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind); 526 527 if (dnp == NULL) 528 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 529 530 dnp->dn_line = yylineno; 531 dnp->dn_link = yypcb->pcb_list; 532 yypcb->pcb_list = dnp; 533 534 return (dnp); 535 } 536 537 void 538 dt_node_free(dt_node_t *dnp) 539 { 540 uchar_t kind = dnp->dn_kind; 541 542 dnp->dn_kind = DT_NODE_FREE; 543 544 switch (kind) { 545 case DT_NODE_STRING: 546 case DT_NODE_IDENT: 547 case DT_NODE_TYPE: 548 free(dnp->dn_string); 549 dnp->dn_string = NULL; 550 break; 551 552 case DT_NODE_VAR: 553 case DT_NODE_FUNC: 554 case DT_NODE_PROBE: 555 if (dnp->dn_ident != NULL) { 556 if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN) 557 dt_ident_destroy(dnp->dn_ident); 558 dnp->dn_ident = NULL; 559 } 560 dt_node_list_free(&dnp->dn_args); 561 break; 562 563 case DT_NODE_OP1: 564 if (dnp->dn_child != NULL) { 565 dt_node_free(dnp->dn_child); 566 dnp->dn_child = NULL; 567 } 568 break; 569 570 case DT_NODE_OP3: 571 if (dnp->dn_expr != NULL) { 572 dt_node_free(dnp->dn_expr); 573 dnp->dn_expr = NULL; 574 } 575 /*FALLTHRU*/ 576 case DT_NODE_OP2: 577 if (dnp->dn_left != NULL) { 578 dt_node_free(dnp->dn_left); 579 dnp->dn_left = NULL; 580 } 581 if (dnp->dn_right != NULL) { 582 dt_node_free(dnp->dn_right); 583 dnp->dn_right = NULL; 584 } 585 break; 586 587 case DT_NODE_DEXPR: 588 case DT_NODE_DFUNC: 589 if (dnp->dn_expr != NULL) { 590 dt_node_free(dnp->dn_expr); 591 dnp->dn_expr = NULL; 592 } 593 break; 594 595 case DT_NODE_AGG: 596 if (dnp->dn_aggfun != NULL) { 597 dt_node_free(dnp->dn_aggfun); 598 dnp->dn_aggfun = NULL; 599 } 600 dt_node_list_free(&dnp->dn_aggtup); 601 break; 602 603 case DT_NODE_PDESC: 604 free(dnp->dn_spec); 605 dnp->dn_spec = NULL; 606 free(dnp->dn_desc); 607 dnp->dn_desc = NULL; 608 break; 609 610 case DT_NODE_CLAUSE: 611 if (dnp->dn_pred != NULL) 612 dt_node_free(dnp->dn_pred); 613 if (dnp->dn_locals != NULL) 614 dt_idhash_destroy(dnp->dn_locals); 615 dt_node_list_free(&dnp->dn_pdescs); 616 dt_node_list_free(&dnp->dn_acts); 617 break; 618 619 case DT_NODE_MEMBER: 620 free(dnp->dn_membname); 621 dnp->dn_membname = NULL; 622 if (dnp->dn_membexpr != NULL) { 623 dt_node_free(dnp->dn_membexpr); 624 dnp->dn_membexpr = NULL; 625 } 626 break; 627 628 case DT_NODE_PROVIDER: 629 dt_node_list_free(&dnp->dn_probes); 630 free(dnp->dn_provname); 631 dnp->dn_provname = NULL; 632 break; 633 634 case DT_NODE_PROG: 635 dt_node_list_free(&dnp->dn_list); 636 break; 637 } 638 } 639 640 void 641 dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr) 642 { 643 if ((yypcb->pcb_cflags & DTRACE_C_EATTR) && 644 (dt_attr_cmp(attr, yypcb->pcb_amin) < 0)) { 645 char a[DTRACE_ATTR2STR_MAX]; 646 char s[BUFSIZ]; 647 648 dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than " 649 "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)), 650 dtrace_attr2str(attr, a, sizeof (a))); 651 } 652 653 dnp->dn_attr = attr; 654 } 655 656 void 657 dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type) 658 { 659 ctf_id_t base = ctf_type_resolve(fp, type); 660 uint_t kind = ctf_type_kind(fp, base); 661 ctf_encoding_t e; 662 663 dnp->dn_flags &= 664 ~(DT_NF_SIGNED | DT_NF_REF | DT_NF_BITFIELD | DT_NF_USERLAND); 665 666 if (kind == CTF_K_INTEGER && ctf_type_encoding(fp, base, &e) == 0) { 667 size_t size = e.cte_bits / NBBY; 668 669 if (size > 8 || (e.cte_bits % NBBY) != 0 || (size & (size - 1))) 670 dnp->dn_flags |= DT_NF_BITFIELD; 671 672 if (e.cte_format & CTF_INT_SIGNED) 673 dnp->dn_flags |= DT_NF_SIGNED; 674 } 675 676 if (kind == CTF_K_FLOAT && ctf_type_encoding(fp, base, &e) == 0) { 677 if (e.cte_bits / NBBY > sizeof (uint64_t)) 678 dnp->dn_flags |= DT_NF_REF; 679 } 680 681 if (kind == CTF_K_STRUCT || kind == CTF_K_UNION || 682 kind == CTF_K_FORWARD || 683 kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) 684 dnp->dn_flags |= DT_NF_REF; 685 else if (yypcb != NULL && fp == DT_DYN_CTFP(yypcb->pcb_hdl) && 686 type == DT_DYN_TYPE(yypcb->pcb_hdl)) 687 dnp->dn_flags |= DT_NF_REF; 688 689 dnp->dn_flags |= DT_NF_COOKED; 690 dnp->dn_ctfp = fp; 691 dnp->dn_type = type; 692 } 693 694 void 695 dt_node_type_propagate(const dt_node_t *src, dt_node_t *dst) 696 { 697 assert(src->dn_flags & DT_NF_COOKED); 698 dst->dn_flags = src->dn_flags & ~DT_NF_LVALUE; 699 dst->dn_ctfp = src->dn_ctfp; 700 dst->dn_type = src->dn_type; 701 } 702 703 const char * 704 dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len) 705 { 706 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) { 707 (void) snprintf(buf, len, "%s", 708 dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind)); 709 return (buf); 710 } 711 712 if (dnp->dn_flags & DT_NF_USERLAND) { 713 size_t n = snprintf(buf, len, "userland "); 714 len = len > n ? len - n : 0; 715 (void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len); 716 return (buf); 717 } 718 719 return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len)); 720 } 721 722 size_t 723 dt_node_type_size(const dt_node_t *dnp) 724 { 725 ctf_id_t base; 726 727 if (dnp->dn_kind == DT_NODE_STRING) 728 return (strlen(dnp->dn_string) + 1); 729 730 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) 731 return (dt_ident_size(dnp->dn_ident)); 732 733 base = ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type); 734 735 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_FORWARD) 736 return (0); 737 738 return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type)); 739 } 740 741 /* 742 * Determine if the specified parse tree node references an identifier of the 743 * specified kind, and if so return a pointer to it; otherwise return NULL. 744 * This function resolves the identifier itself, following through any inlines. 745 */ 746 dt_ident_t * 747 dt_node_resolve(const dt_node_t *dnp, uint_t idkind) 748 { 749 dt_ident_t *idp; 750 751 switch (dnp->dn_kind) { 752 case DT_NODE_VAR: 753 case DT_NODE_SYM: 754 case DT_NODE_FUNC: 755 case DT_NODE_AGG: 756 case DT_NODE_INLINE: 757 case DT_NODE_PROBE: 758 idp = dt_ident_resolve(dnp->dn_ident); 759 return (idp->di_kind == idkind ? idp : NULL); 760 } 761 762 if (dt_node_is_dynamic(dnp)) { 763 idp = dt_ident_resolve(dnp->dn_ident); 764 return (idp->di_kind == idkind ? idp : NULL); 765 } 766 767 return (NULL); 768 } 769 770 size_t 771 dt_node_sizeof(const dt_node_t *dnp) 772 { 773 dtrace_syminfo_t *sip; 774 GElf_Sym sym; 775 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 776 777 /* 778 * The size of the node as used for the sizeof() operator depends on 779 * the kind of the node. If the node is a SYM, the size is obtained 780 * from the symbol table; if it is not a SYM, the size is determined 781 * from the node's type. This is slightly different from C's sizeof() 782 * operator in that (for example) when applied to a function, sizeof() 783 * will evaluate to the length of the function rather than the size of 784 * the function type. 785 */ 786 if (dnp->dn_kind != DT_NODE_SYM) 787 return (dt_node_type_size(dnp)); 788 789 sip = dnp->dn_ident->di_data; 790 791 if (dtrace_lookup_by_name(dtp, sip->dts_object, 792 sip->dts_name, &sym, NULL) == -1) 793 return (0); 794 795 return (sym.st_size); 796 } 797 798 int 799 dt_node_is_integer(const dt_node_t *dnp) 800 { 801 ctf_file_t *fp = dnp->dn_ctfp; 802 ctf_encoding_t e; 803 ctf_id_t type; 804 uint_t kind; 805 806 assert(dnp->dn_flags & DT_NF_COOKED); 807 808 type = ctf_type_resolve(fp, dnp->dn_type); 809 kind = ctf_type_kind(fp, type); 810 811 if (kind == CTF_K_INTEGER && 812 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)) 813 return (0); /* void integer */ 814 815 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM); 816 } 817 818 int 819 dt_node_is_float(const dt_node_t *dnp) 820 { 821 ctf_file_t *fp = dnp->dn_ctfp; 822 ctf_encoding_t e; 823 ctf_id_t type; 824 uint_t kind; 825 826 assert(dnp->dn_flags & DT_NF_COOKED); 827 828 type = ctf_type_resolve(fp, dnp->dn_type); 829 kind = ctf_type_kind(fp, type); 830 831 return (kind == CTF_K_FLOAT && 832 ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && ( 833 e.cte_format == CTF_FP_SINGLE || e.cte_format == CTF_FP_DOUBLE || 834 e.cte_format == CTF_FP_LDOUBLE)); 835 } 836 837 int 838 dt_node_is_scalar(const dt_node_t *dnp) 839 { 840 ctf_file_t *fp = dnp->dn_ctfp; 841 ctf_encoding_t e; 842 ctf_id_t type; 843 uint_t kind; 844 845 assert(dnp->dn_flags & DT_NF_COOKED); 846 847 type = ctf_type_resolve(fp, dnp->dn_type); 848 kind = ctf_type_kind(fp, type); 849 850 if (kind == CTF_K_INTEGER && 851 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)) 852 return (0); /* void cannot be used as a scalar */ 853 854 return (kind == CTF_K_INTEGER || kind == CTF_K_ENUM || 855 kind == CTF_K_POINTER); 856 } 857 858 int 859 dt_node_is_arith(const dt_node_t *dnp) 860 { 861 ctf_file_t *fp = dnp->dn_ctfp; 862 ctf_encoding_t e; 863 ctf_id_t type; 864 uint_t kind; 865 866 assert(dnp->dn_flags & DT_NF_COOKED); 867 868 type = ctf_type_resolve(fp, dnp->dn_type); 869 kind = ctf_type_kind(fp, type); 870 871 if (kind == CTF_K_INTEGER) 872 return (ctf_type_encoding(fp, type, &e) == 0 && !IS_VOID(e)); 873 else 874 return (kind == CTF_K_ENUM); 875 } 876 877 int 878 dt_node_is_vfptr(const dt_node_t *dnp) 879 { 880 ctf_file_t *fp = dnp->dn_ctfp; 881 ctf_encoding_t e; 882 ctf_id_t type; 883 uint_t kind; 884 885 assert(dnp->dn_flags & DT_NF_COOKED); 886 887 type = ctf_type_resolve(fp, dnp->dn_type); 888 if (ctf_type_kind(fp, type) != CTF_K_POINTER) 889 return (0); /* type is not a pointer */ 890 891 type = ctf_type_resolve(fp, ctf_type_reference(fp, type)); 892 kind = ctf_type_kind(fp, type); 893 894 return (kind == CTF_K_FUNCTION || (kind == CTF_K_INTEGER && 895 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e))); 896 } 897 898 int 899 dt_node_is_dynamic(const dt_node_t *dnp) 900 { 901 if (dnp->dn_kind == DT_NODE_VAR && 902 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) { 903 const dt_idnode_t *inp = dnp->dn_ident->di_iarg; 904 return (inp->din_root ? dt_node_is_dynamic(inp->din_root) : 0); 905 } 906 907 return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) && 908 dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl)); 909 } 910 911 int 912 dt_node_is_string(const dt_node_t *dnp) 913 { 914 return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) && 915 dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl)); 916 } 917 918 int 919 dt_node_is_stack(const dt_node_t *dnp) 920 { 921 return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) && 922 dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl)); 923 } 924 925 int 926 dt_node_is_symaddr(const dt_node_t *dnp) 927 { 928 return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) && 929 dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl)); 930 } 931 932 int 933 dt_node_is_usymaddr(const dt_node_t *dnp) 934 { 935 return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) && 936 dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl)); 937 } 938 939 int 940 dt_node_is_strcompat(const dt_node_t *dnp) 941 { 942 ctf_file_t *fp = dnp->dn_ctfp; 943 ctf_encoding_t e; 944 ctf_arinfo_t r; 945 ctf_id_t base; 946 uint_t kind; 947 948 assert(dnp->dn_flags & DT_NF_COOKED); 949 950 base = ctf_type_resolve(fp, dnp->dn_type); 951 kind = ctf_type_kind(fp, base); 952 953 if (kind == CTF_K_POINTER && 954 (base = ctf_type_reference(fp, base)) != CTF_ERR && 955 (base = ctf_type_resolve(fp, base)) != CTF_ERR && 956 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e)) 957 return (1); /* promote char pointer to string */ 958 959 if (kind == CTF_K_ARRAY && ctf_array_info(fp, base, &r) == 0 && 960 (base = ctf_type_resolve(fp, r.ctr_contents)) != CTF_ERR && 961 ctf_type_encoding(fp, base, &e) == 0 && IS_CHAR(e)) 962 return (1); /* promote char array to string */ 963 964 return (0); 965 } 966 967 int 968 dt_node_is_pointer(const dt_node_t *dnp) 969 { 970 ctf_file_t *fp = dnp->dn_ctfp; 971 uint_t kind; 972 973 assert(dnp->dn_flags & DT_NF_COOKED); 974 975 if (dt_node_is_string(dnp)) 976 return (0); /* string are pass-by-ref but act like structs */ 977 978 kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type)); 979 return (kind == CTF_K_POINTER || kind == CTF_K_ARRAY); 980 } 981 982 int 983 dt_node_is_void(const dt_node_t *dnp) 984 { 985 ctf_file_t *fp = dnp->dn_ctfp; 986 ctf_encoding_t e; 987 ctf_id_t type; 988 989 if (dt_node_is_dynamic(dnp)) 990 return (0); /* <DYN> is an alias for void but not the same */ 991 992 if (dt_node_is_stack(dnp)) 993 return (0); 994 995 if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp)) 996 return (0); 997 998 type = ctf_type_resolve(fp, dnp->dn_type); 999 1000 return (ctf_type_kind(fp, type) == CTF_K_INTEGER && 1001 ctf_type_encoding(fp, type, &e) == 0 && IS_VOID(e)); 1002 } 1003 1004 int 1005 dt_node_is_ptrcompat(const dt_node_t *lp, const dt_node_t *rp, 1006 ctf_file_t **fpp, ctf_id_t *tp) 1007 { 1008 ctf_file_t *lfp = lp->dn_ctfp; 1009 ctf_file_t *rfp = rp->dn_ctfp; 1010 1011 ctf_id_t lbase = CTF_ERR, rbase = CTF_ERR; 1012 ctf_id_t lref = CTF_ERR, rref = CTF_ERR; 1013 1014 int lp_is_void, rp_is_void, lp_is_int, rp_is_int, compat; 1015 uint_t lkind, rkind; 1016 ctf_encoding_t e; 1017 ctf_arinfo_t r; 1018 1019 assert(lp->dn_flags & DT_NF_COOKED); 1020 assert(rp->dn_flags & DT_NF_COOKED); 1021 1022 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) 1023 return (0); /* fail if either node is a dynamic variable */ 1024 1025 lp_is_int = dt_node_is_integer(lp); 1026 rp_is_int = dt_node_is_integer(rp); 1027 1028 if (lp_is_int && rp_is_int) 1029 return (0); /* fail if both nodes are integers */ 1030 1031 if (lp_is_int && (lp->dn_kind != DT_NODE_INT || lp->dn_value != 0)) 1032 return (0); /* fail if lp is an integer that isn't 0 constant */ 1033 1034 if (rp_is_int && (rp->dn_kind != DT_NODE_INT || rp->dn_value != 0)) 1035 return (0); /* fail if rp is an integer that isn't 0 constant */ 1036 1037 if ((lp_is_int == 0 && rp_is_int == 0) && ( 1038 (lp->dn_flags & DT_NF_USERLAND) ^ (rp->dn_flags & DT_NF_USERLAND))) 1039 return (0); /* fail if only one pointer is a userland address */ 1040 1041 /* 1042 * Resolve the left-hand and right-hand types to their base type, and 1043 * then resolve the referenced type as well (assuming the base type 1044 * is CTF_K_POINTER or CTF_K_ARRAY). Otherwise [lr]ref = CTF_ERR. 1045 */ 1046 if (!lp_is_int) { 1047 lbase = ctf_type_resolve(lfp, lp->dn_type); 1048 lkind = ctf_type_kind(lfp, lbase); 1049 1050 if (lkind == CTF_K_POINTER) { 1051 lref = ctf_type_resolve(lfp, 1052 ctf_type_reference(lfp, lbase)); 1053 } else if (lkind == CTF_K_ARRAY && 1054 ctf_array_info(lfp, lbase, &r) == 0) { 1055 lref = ctf_type_resolve(lfp, r.ctr_contents); 1056 } 1057 } 1058 1059 if (!rp_is_int) { 1060 rbase = ctf_type_resolve(rfp, rp->dn_type); 1061 rkind = ctf_type_kind(rfp, rbase); 1062 1063 if (rkind == CTF_K_POINTER) { 1064 rref = ctf_type_resolve(rfp, 1065 ctf_type_reference(rfp, rbase)); 1066 } else if (rkind == CTF_K_ARRAY && 1067 ctf_array_info(rfp, rbase, &r) == 0) { 1068 rref = ctf_type_resolve(rfp, r.ctr_contents); 1069 } 1070 } 1071 1072 /* 1073 * We know that one or the other type may still be a zero-valued 1074 * integer constant. To simplify the code below, set the integer 1075 * type variables equal to the non-integer types and proceed. 1076 */ 1077 if (lp_is_int) { 1078 lbase = rbase; 1079 lkind = rkind; 1080 lref = rref; 1081 lfp = rfp; 1082 } else if (rp_is_int) { 1083 rbase = lbase; 1084 rkind = lkind; 1085 rref = lref; 1086 rfp = lfp; 1087 } 1088 1089 lp_is_void = ctf_type_encoding(lfp, lref, &e) == 0 && IS_VOID(e); 1090 rp_is_void = ctf_type_encoding(rfp, rref, &e) == 0 && IS_VOID(e); 1091 1092 /* 1093 * The types are compatible if both are pointers to the same type, or 1094 * if either pointer is a void pointer. If they are compatible, set 1095 * tp to point to the more specific pointer type and return it. 1096 */ 1097 compat = (lkind == CTF_K_POINTER || lkind == CTF_K_ARRAY) && 1098 (rkind == CTF_K_POINTER || rkind == CTF_K_ARRAY) && 1099 (lp_is_void || rp_is_void || ctf_type_compat(lfp, lref, rfp, rref)); 1100 1101 if (compat) { 1102 if (fpp != NULL) 1103 *fpp = rp_is_void ? lfp : rfp; 1104 if (tp != NULL) 1105 *tp = rp_is_void ? lbase : rbase; 1106 } 1107 1108 return (compat); 1109 } 1110 1111 /* 1112 * The rules for checking argument types against parameter types are described 1113 * in the ANSI-C spec (see K&R[A7.3.2] and K&R[A7.17]). We use the same rule 1114 * set to determine whether associative array arguments match the prototype. 1115 */ 1116 int 1117 dt_node_is_argcompat(const dt_node_t *lp, const dt_node_t *rp) 1118 { 1119 ctf_file_t *lfp = lp->dn_ctfp; 1120 ctf_file_t *rfp = rp->dn_ctfp; 1121 1122 assert(lp->dn_flags & DT_NF_COOKED); 1123 assert(rp->dn_flags & DT_NF_COOKED); 1124 1125 if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) 1126 return (1); /* integer types are compatible */ 1127 1128 if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp)) 1129 return (1); /* string types are compatible */ 1130 1131 if (dt_node_is_stack(lp) && dt_node_is_stack(rp)) 1132 return (1); /* stack types are compatible */ 1133 1134 if (dt_node_is_symaddr(lp) && dt_node_is_symaddr(rp)) 1135 return (1); /* symaddr types are compatible */ 1136 1137 if (dt_node_is_usymaddr(lp) && dt_node_is_usymaddr(rp)) 1138 return (1); /* usymaddr types are compatible */ 1139 1140 switch (ctf_type_kind(lfp, ctf_type_resolve(lfp, lp->dn_type))) { 1141 case CTF_K_FUNCTION: 1142 case CTF_K_STRUCT: 1143 case CTF_K_UNION: 1144 return (ctf_type_compat(lfp, lp->dn_type, rfp, rp->dn_type)); 1145 default: 1146 return (dt_node_is_ptrcompat(lp, rp, NULL, NULL)); 1147 } 1148 } 1149 1150 /* 1151 * We provide dt_node_is_posconst() as a convenience routine for callers who 1152 * wish to verify that an argument is a positive non-zero integer constant. 1153 */ 1154 int 1155 dt_node_is_posconst(const dt_node_t *dnp) 1156 { 1157 return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && ( 1158 (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0)); 1159 } 1160 1161 int 1162 dt_node_is_actfunc(const dt_node_t *dnp) 1163 { 1164 return (dnp->dn_kind == DT_NODE_FUNC && 1165 dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC); 1166 } 1167 1168 /* 1169 * The original rules for integer constant typing are described in K&R[A2.5.1]. 1170 * However, since we support long long, we instead use the rules from ISO C99 1171 * clause 6.4.4.1 since that is where long longs are formally described. The 1172 * rules require us to know whether the constant was specified in decimal or 1173 * in octal or hex, which we do by looking at our lexer's 'yyintdecimal' flag. 1174 * The type of an integer constant is the first of the corresponding list in 1175 * which its value can be represented: 1176 * 1177 * unsuffixed decimal: int, long, long long 1178 * unsuffixed oct/hex: int, unsigned int, long, unsigned long, 1179 * long long, unsigned long long 1180 * suffix [uU]: unsigned int, unsigned long, unsigned long long 1181 * suffix [lL] decimal: long, long long 1182 * suffix [lL] oct/hex: long, unsigned long, long long, unsigned long long 1183 * suffix [uU][Ll]: unsigned long, unsigned long long 1184 * suffix ll/LL decimal: long long 1185 * suffix ll/LL oct/hex: long long, unsigned long long 1186 * suffix [uU][ll/LL]: unsigned long long 1187 * 1188 * Given that our lexer has already validated the suffixes by regexp matching, 1189 * there is an obvious way to concisely encode these rules: construct an array 1190 * of the types in the order int, unsigned int, long, unsigned long, long long, 1191 * unsigned long long. Compute an integer array starting index based on the 1192 * suffix (e.g. none = 0, u = 1, ull = 5), and compute an increment based on 1193 * the specifier (dec/oct/hex) and suffix (u). Then iterate from the starting 1194 * index to the end, advancing using the increment, and searching until we 1195 * find a limit that matches or we run out of choices (overflow). To make it 1196 * even faster, we precompute the table of type information in dtrace_open(). 1197 */ 1198 dt_node_t * 1199 dt_node_int(uintmax_t value) 1200 { 1201 dt_node_t *dnp = dt_node_alloc(DT_NODE_INT); 1202 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1203 1204 int n = (yyintdecimal | (yyintsuffix[0] == 'u')) + 1; 1205 int i = 0; 1206 1207 const char *p; 1208 char c; 1209 1210 dnp->dn_op = DT_TOK_INT; 1211 dnp->dn_value = value; 1212 1213 for (p = yyintsuffix; (c = *p) != '\0'; p++) { 1214 if (c == 'U' || c == 'u') 1215 i += 1; 1216 else if (c == 'L' || c == 'l') 1217 i += 2; 1218 } 1219 1220 for (; i < sizeof (dtp->dt_ints) / sizeof (dtp->dt_ints[0]); i += n) { 1221 if (value <= dtp->dt_ints[i].did_limit) { 1222 dt_node_type_assign(dnp, 1223 dtp->dt_ints[i].did_ctfp, 1224 dtp->dt_ints[i].did_type); 1225 1226 /* 1227 * If a prefix character is present in macro text, add 1228 * in the corresponding operator node (see dt_lex.l). 1229 */ 1230 switch (yyintprefix) { 1231 case '+': 1232 return (dt_node_op1(DT_TOK_IPOS, dnp)); 1233 case '-': 1234 return (dt_node_op1(DT_TOK_INEG, dnp)); 1235 default: 1236 return (dnp); 1237 } 1238 } 1239 } 1240 1241 xyerror(D_INT_OFLOW, "integer constant 0x%llx cannot be represented " 1242 "in any built-in integral type\n", (u_longlong_t)value); 1243 /*NOTREACHED*/ 1244 return (NULL); /* keep gcc happy */ 1245 } 1246 1247 dt_node_t * 1248 dt_node_string(char *string) 1249 { 1250 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1251 dt_node_t *dnp; 1252 1253 if (string == NULL) 1254 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1255 1256 dnp = dt_node_alloc(DT_NODE_STRING); 1257 dnp->dn_op = DT_TOK_STRING; 1258 dnp->dn_string = string; 1259 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp)); 1260 1261 return (dnp); 1262 } 1263 1264 dt_node_t * 1265 dt_node_ident(char *name) 1266 { 1267 dt_ident_t *idp; 1268 dt_node_t *dnp; 1269 1270 if (name == NULL) 1271 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1272 1273 /* 1274 * If the identifier is an inlined integer constant, then create an INT 1275 * node that is a clone of the inline parse tree node and return that 1276 * immediately, allowing this inline to be used in parsing contexts 1277 * that require constant expressions (e.g. scalar array sizes). 1278 */ 1279 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL && 1280 (idp->di_flags & DT_IDFLG_INLINE)) { 1281 dt_idnode_t *inp = idp->di_iarg; 1282 1283 if (inp->din_root != NULL && 1284 inp->din_root->dn_kind == DT_NODE_INT) { 1285 free(name); 1286 1287 dnp = dt_node_alloc(DT_NODE_INT); 1288 dnp->dn_op = DT_TOK_INT; 1289 dnp->dn_value = inp->din_root->dn_value; 1290 dt_node_type_propagate(inp->din_root, dnp); 1291 1292 return (dnp); 1293 } 1294 } 1295 1296 dnp = dt_node_alloc(DT_NODE_IDENT); 1297 dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT; 1298 dnp->dn_string = name; 1299 1300 return (dnp); 1301 } 1302 1303 /* 1304 * Create an empty node of type corresponding to the given declaration. 1305 * Explicit references to user types (C or D) are assigned the default 1306 * stability; references to other types are _dtrace_typattr (Private). 1307 */ 1308 dt_node_t * 1309 dt_node_type(dt_decl_t *ddp) 1310 { 1311 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1312 dtrace_typeinfo_t dtt; 1313 dt_node_t *dnp; 1314 char *name = NULL; 1315 int err; 1316 1317 /* 1318 * If 'ddp' is NULL, we get a decl by popping the decl stack. This 1319 * form of dt_node_type() is used by parameter rules in dt_grammar.y. 1320 */ 1321 if (ddp == NULL) 1322 ddp = dt_decl_pop_param(&name); 1323 1324 err = dt_decl_type(ddp, &dtt); 1325 dt_decl_free(ddp); 1326 1327 if (err != 0) { 1328 free(name); 1329 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 1330 } 1331 1332 dnp = dt_node_alloc(DT_NODE_TYPE); 1333 dnp->dn_op = DT_TOK_IDENT; 1334 dnp->dn_string = name; 1335 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 1336 1337 if (dtt.dtt_ctfp == dtp->dt_cdefs->dm_ctfp || 1338 dtt.dtt_ctfp == dtp->dt_ddefs->dm_ctfp) 1339 dt_node_attr_assign(dnp, _dtrace_defattr); 1340 else 1341 dt_node_attr_assign(dnp, _dtrace_typattr); 1342 1343 return (dnp); 1344 } 1345 1346 /* 1347 * Create a type node corresponding to a varargs (...) parameter by just 1348 * assigning it type CTF_ERR. The decl processing code will handle this. 1349 */ 1350 dt_node_t * 1351 dt_node_vatype(void) 1352 { 1353 dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE); 1354 1355 dnp->dn_op = DT_TOK_IDENT; 1356 dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp; 1357 dnp->dn_type = CTF_ERR; 1358 dnp->dn_attr = _dtrace_defattr; 1359 1360 return (dnp); 1361 } 1362 1363 /* 1364 * Instantiate a decl using the contents of the current declaration stack. As 1365 * we do not currently permit decls to be initialized, this function currently 1366 * returns NULL and no parse node is created. When this function is called, 1367 * the topmost scope's ds_ident pointer will be set to NULL (indicating no 1368 * init_declarator rule was matched) or will point to the identifier to use. 1369 */ 1370 dt_node_t * 1371 dt_node_decl(void) 1372 { 1373 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1374 dt_scope_t *dsp = &yypcb->pcb_dstack; 1375 dt_dclass_t class = dsp->ds_class; 1376 dt_decl_t *ddp = dt_decl_top(); 1377 1378 dt_module_t *dmp; 1379 dtrace_typeinfo_t dtt; 1380 ctf_id_t type; 1381 1382 char n1[DT_TYPE_NAMELEN]; 1383 char n2[DT_TYPE_NAMELEN]; 1384 1385 if (dt_decl_type(ddp, &dtt) != 0) 1386 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 1387 1388 /* 1389 * If we have no declaration identifier, then this is either a spurious 1390 * declaration of an intrinsic type (e.g. "extern int;") or declaration 1391 * or redeclaration of a struct, union, or enum type or tag. 1392 */ 1393 if (dsp->ds_ident == NULL) { 1394 if (ddp->dd_kind != CTF_K_STRUCT && 1395 ddp->dd_kind != CTF_K_UNION && ddp->dd_kind != CTF_K_ENUM) 1396 xyerror(D_DECL_USELESS, "useless declaration\n"); 1397 1398 dt_dprintf("type %s added as id %ld\n", dt_type_name( 1399 ddp->dd_ctfp, ddp->dd_type, n1, sizeof (n1)), ddp->dd_type); 1400 1401 return (NULL); 1402 } 1403 1404 if (strchr(dsp->ds_ident, '`') != NULL) { 1405 xyerror(D_DECL_SCOPE, "D scoping operator may not be used in " 1406 "a declaration name (%s)\n", dsp->ds_ident); 1407 } 1408 1409 /* 1410 * If we are nested inside of a C include file, add the declaration to 1411 * the C definition module; otherwise use the D definition module. 1412 */ 1413 if (yypcb->pcb_idepth != 0) 1414 dmp = dtp->dt_cdefs; 1415 else 1416 dmp = dtp->dt_ddefs; 1417 1418 /* 1419 * If we see a global or static declaration of a function prototype, 1420 * treat this as equivalent to a D extern declaration. 1421 */ 1422 if (ctf_type_kind(dtt.dtt_ctfp, dtt.dtt_type) == CTF_K_FUNCTION && 1423 (class == DT_DC_DEFAULT || class == DT_DC_STATIC)) 1424 class = DT_DC_EXTERN; 1425 1426 switch (class) { 1427 case DT_DC_AUTO: 1428 case DT_DC_REGISTER: 1429 case DT_DC_STATIC: 1430 xyerror(D_DECL_BADCLASS, "specified storage class not " 1431 "appropriate in D\n"); 1432 /*NOTREACHED*/ 1433 1434 case DT_DC_EXTERN: { 1435 dtrace_typeinfo_t ott; 1436 dtrace_syminfo_t dts; 1437 GElf_Sym sym; 1438 1439 int exists = dtrace_lookup_by_name(dtp, 1440 dmp->dm_name, dsp->ds_ident, &sym, &dts) == 0; 1441 1442 if (exists && (dtrace_symbol_type(dtp, &sym, &dts, &ott) != 0 || 1443 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type, 1444 ott.dtt_ctfp, ott.dtt_type) != 0)) { 1445 xyerror(D_DECL_IDRED, "identifier redeclared: %s`%s\n" 1446 "\t current: %s\n\tprevious: %s\n", 1447 dmp->dm_name, dsp->ds_ident, 1448 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 1449 n1, sizeof (n1)), 1450 dt_type_name(ott.dtt_ctfp, ott.dtt_type, 1451 n2, sizeof (n2))); 1452 } else if (!exists && dt_module_extern(dtp, dmp, 1453 dsp->ds_ident, &dtt) == NULL) { 1454 xyerror(D_UNKNOWN, 1455 "failed to extern %s: %s\n", dsp->ds_ident, 1456 dtrace_errmsg(dtp, dtrace_errno(dtp))); 1457 } else { 1458 dt_dprintf("extern %s`%s type=<%s>\n", 1459 dmp->dm_name, dsp->ds_ident, 1460 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 1461 n1, sizeof (n1))); 1462 } 1463 break; 1464 } 1465 1466 case DT_DC_TYPEDEF: 1467 if (dt_idstack_lookup(&yypcb->pcb_globals, dsp->ds_ident)) { 1468 xyerror(D_DECL_IDRED, "global variable identifier " 1469 "redeclared: %s\n", dsp->ds_ident); 1470 } 1471 1472 if (ctf_lookup_by_name(dmp->dm_ctfp, 1473 dsp->ds_ident) != CTF_ERR) { 1474 xyerror(D_DECL_IDRED, 1475 "typedef redeclared: %s\n", dsp->ds_ident); 1476 } 1477 1478 /* 1479 * If the source type for the typedef is not defined in the 1480 * target container or its parent, copy the type to the target 1481 * container and reset dtt_ctfp and dtt_type to the copy. 1482 */ 1483 if (dtt.dtt_ctfp != dmp->dm_ctfp && 1484 dtt.dtt_ctfp != ctf_parent_file(dmp->dm_ctfp)) { 1485 1486 dtt.dtt_type = ctf_add_type(dmp->dm_ctfp, 1487 dtt.dtt_ctfp, dtt.dtt_type); 1488 dtt.dtt_ctfp = dmp->dm_ctfp; 1489 1490 if (dtt.dtt_type == CTF_ERR || 1491 ctf_update(dtt.dtt_ctfp) == CTF_ERR) { 1492 xyerror(D_UNKNOWN, "failed to copy typedef %s " 1493 "source type: %s\n", dsp->ds_ident, 1494 ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 1495 } 1496 } 1497 1498 type = ctf_add_typedef(dmp->dm_ctfp, 1499 CTF_ADD_ROOT, dsp->ds_ident, dtt.dtt_type); 1500 1501 if (type == CTF_ERR || ctf_update(dmp->dm_ctfp) == CTF_ERR) { 1502 xyerror(D_UNKNOWN, "failed to typedef %s: %s\n", 1503 dsp->ds_ident, ctf_errmsg(ctf_errno(dmp->dm_ctfp))); 1504 } 1505 1506 dt_dprintf("typedef %s added as id %ld\n", dsp->ds_ident, type); 1507 break; 1508 1509 default: { 1510 ctf_encoding_t cte; 1511 dt_idhash_t *dhp; 1512 dt_ident_t *idp; 1513 dt_node_t idn; 1514 int assc, idkind; 1515 uint_t id, kind; 1516 ushort_t idflags; 1517 1518 switch (class) { 1519 case DT_DC_THIS: 1520 dhp = yypcb->pcb_locals; 1521 idflags = DT_IDFLG_LOCAL; 1522 idp = dt_idhash_lookup(dhp, dsp->ds_ident); 1523 break; 1524 case DT_DC_SELF: 1525 dhp = dtp->dt_tls; 1526 idflags = DT_IDFLG_TLS; 1527 idp = dt_idhash_lookup(dhp, dsp->ds_ident); 1528 break; 1529 default: 1530 dhp = dtp->dt_globals; 1531 idflags = 0; 1532 idp = dt_idstack_lookup( 1533 &yypcb->pcb_globals, dsp->ds_ident); 1534 break; 1535 } 1536 1537 if (ddp->dd_kind == CTF_K_ARRAY && ddp->dd_node == NULL) { 1538 xyerror(D_DECL_ARRNULL, 1539 "array declaration requires array dimension or " 1540 "tuple signature: %s\n", dsp->ds_ident); 1541 } 1542 1543 if (idp != NULL && idp->di_gen == 0) { 1544 xyerror(D_DECL_IDRED, "built-in identifier " 1545 "redeclared: %s\n", idp->di_name); 1546 } 1547 1548 if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_CDEFS, 1549 dsp->ds_ident, NULL) == 0 || 1550 dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, 1551 dsp->ds_ident, NULL) == 0) { 1552 xyerror(D_DECL_IDRED, "typedef identifier " 1553 "redeclared: %s\n", dsp->ds_ident); 1554 } 1555 1556 /* 1557 * Cache some attributes of the decl to make the rest of this 1558 * code simpler: if the decl is an array which is subscripted 1559 * by a type rather than an integer, then it's an associative 1560 * array (assc). We then expect to match either DT_IDENT_ARRAY 1561 * for associative arrays or DT_IDENT_SCALAR for anything else. 1562 */ 1563 assc = ddp->dd_kind == CTF_K_ARRAY && 1564 ddp->dd_node->dn_kind == DT_NODE_TYPE; 1565 1566 idkind = assc ? DT_IDENT_ARRAY : DT_IDENT_SCALAR; 1567 1568 /* 1569 * Create a fake dt_node_t on the stack so we can determine the 1570 * type of any matching identifier by assigning to this node. 1571 * If the pre-existing ident has its di_type set, propagate 1572 * the type by hand so as not to trigger a prototype check for 1573 * arrays (yet); otherwise we use dt_ident_cook() on the ident 1574 * to ensure it is fully initialized before looking at it. 1575 */ 1576 bzero(&idn, sizeof (dt_node_t)); 1577 1578 if (idp != NULL && idp->di_type != CTF_ERR) 1579 dt_node_type_assign(&idn, idp->di_ctfp, idp->di_type); 1580 else if (idp != NULL) 1581 (void) dt_ident_cook(&idn, idp, NULL); 1582 1583 if (assc) { 1584 if (class == DT_DC_THIS) { 1585 xyerror(D_DECL_LOCASSC, "associative arrays " 1586 "may not be declared as local variables:" 1587 " %s\n", dsp->ds_ident); 1588 } 1589 1590 if (dt_decl_type(ddp->dd_next, &dtt) != 0) 1591 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 1592 } 1593 1594 if (idp != NULL && (idp->di_kind != idkind || 1595 ctf_type_cmp(dtt.dtt_ctfp, dtt.dtt_type, 1596 idn.dn_ctfp, idn.dn_type) != 0)) { 1597 xyerror(D_DECL_IDRED, "identifier redeclared: %s\n" 1598 "\t current: %s %s\n\tprevious: %s %s\n", 1599 dsp->ds_ident, dt_idkind_name(idkind), 1600 dt_type_name(dtt.dtt_ctfp, 1601 dtt.dtt_type, n1, sizeof (n1)), 1602 dt_idkind_name(idp->di_kind), 1603 dt_node_type_name(&idn, n2, sizeof (n2))); 1604 1605 } else if (idp != NULL && assc) { 1606 const dt_idsig_t *isp = idp->di_data; 1607 dt_node_t *dnp = ddp->dd_node; 1608 int argc = 0; 1609 1610 for (; dnp != NULL; dnp = dnp->dn_list, argc++) { 1611 const dt_node_t *pnp = &isp->dis_args[argc]; 1612 1613 if (argc >= isp->dis_argc) 1614 continue; /* tuple length mismatch */ 1615 1616 if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type, 1617 pnp->dn_ctfp, pnp->dn_type) == 0) 1618 continue; 1619 1620 xyerror(D_DECL_IDRED, 1621 "identifier redeclared: %s\n" 1622 "\t current: %s, key #%d of type %s\n" 1623 "\tprevious: %s, key #%d of type %s\n", 1624 dsp->ds_ident, 1625 dt_idkind_name(idkind), argc + 1, 1626 dt_node_type_name(dnp, n1, sizeof (n1)), 1627 dt_idkind_name(idp->di_kind), argc + 1, 1628 dt_node_type_name(pnp, n2, sizeof (n2))); 1629 } 1630 1631 if (isp->dis_argc != argc) { 1632 xyerror(D_DECL_IDRED, 1633 "identifier redeclared: %s\n" 1634 "\t current: %s of %s, tuple length %d\n" 1635 "\tprevious: %s of %s, tuple length %d\n", 1636 dsp->ds_ident, dt_idkind_name(idkind), 1637 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 1638 n1, sizeof (n1)), argc, 1639 dt_idkind_name(idp->di_kind), 1640 dt_node_type_name(&idn, n2, sizeof (n2)), 1641 isp->dis_argc); 1642 } 1643 1644 } else if (idp == NULL) { 1645 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type); 1646 kind = ctf_type_kind(dtt.dtt_ctfp, type); 1647 1648 switch (kind) { 1649 case CTF_K_INTEGER: 1650 if (ctf_type_encoding(dtt.dtt_ctfp, type, 1651 &cte) == 0 && IS_VOID(cte)) { 1652 xyerror(D_DECL_VOIDOBJ, "cannot have " 1653 "void object: %s\n", dsp->ds_ident); 1654 } 1655 break; 1656 case CTF_K_STRUCT: 1657 case CTF_K_UNION: 1658 if (ctf_type_size(dtt.dtt_ctfp, type) != 0) 1659 break; /* proceed to declaring */ 1660 /*FALLTHRU*/ 1661 case CTF_K_FORWARD: 1662 xyerror(D_DECL_INCOMPLETE, 1663 "incomplete struct/union/enum %s: %s\n", 1664 dt_type_name(dtt.dtt_ctfp, dtt.dtt_type, 1665 n1, sizeof (n1)), dsp->ds_ident); 1666 /*NOTREACHED*/ 1667 } 1668 1669 if (dt_idhash_nextid(dhp, &id) == -1) { 1670 xyerror(D_ID_OFLOW, "cannot create %s: limit " 1671 "on number of %s variables exceeded\n", 1672 dsp->ds_ident, dt_idhash_name(dhp)); 1673 } 1674 1675 dt_dprintf("declare %s %s variable %s, id=%u\n", 1676 dt_idhash_name(dhp), dt_idkind_name(idkind), 1677 dsp->ds_ident, id); 1678 1679 idp = dt_idhash_insert(dhp, dsp->ds_ident, idkind, 1680 idflags | DT_IDFLG_WRITE | DT_IDFLG_DECL, id, 1681 _dtrace_defattr, 0, assc ? &dt_idops_assc : 1682 &dt_idops_thaw, NULL, dtp->dt_gen); 1683 1684 if (idp == NULL) 1685 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 1686 1687 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type); 1688 1689 /* 1690 * If we are declaring an associative array, use our 1691 * fake parse node to cook the new assoc identifier. 1692 * This will force the ident code to instantiate the 1693 * array type signature corresponding to the list of 1694 * types pointed to by ddp->dd_node. We also reset 1695 * the identifier's attributes based upon the result. 1696 */ 1697 if (assc) { 1698 idp->di_attr = 1699 dt_ident_cook(&idn, idp, &ddp->dd_node); 1700 } 1701 } 1702 } 1703 1704 } /* end of switch */ 1705 1706 free(dsp->ds_ident); 1707 dsp->ds_ident = NULL; 1708 1709 return (NULL); 1710 } 1711 1712 dt_node_t * 1713 dt_node_func(dt_node_t *dnp, dt_node_t *args) 1714 { 1715 dt_ident_t *idp; 1716 1717 if (dnp->dn_kind != DT_NODE_IDENT) { 1718 xyerror(D_FUNC_IDENT, 1719 "function designator is not of function type\n"); 1720 } 1721 1722 idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string); 1723 1724 if (idp == NULL) { 1725 xyerror(D_FUNC_UNDEF, 1726 "undefined function name: %s\n", dnp->dn_string); 1727 } 1728 1729 if (idp->di_kind != DT_IDENT_FUNC && 1730 idp->di_kind != DT_IDENT_AGGFUNC && 1731 idp->di_kind != DT_IDENT_ACTFUNC) { 1732 xyerror(D_FUNC_IDKIND, "%s '%s' may not be referenced as a " 1733 "function\n", dt_idkind_name(idp->di_kind), idp->di_name); 1734 } 1735 1736 free(dnp->dn_string); 1737 dnp->dn_string = NULL; 1738 1739 dnp->dn_kind = DT_NODE_FUNC; 1740 dnp->dn_flags &= ~DT_NF_COOKED; 1741 dnp->dn_ident = idp; 1742 dnp->dn_args = args; 1743 dnp->dn_list = NULL; 1744 1745 return (dnp); 1746 } 1747 1748 /* 1749 * The offsetof() function is special because it takes a type name as an 1750 * argument. It does not actually construct its own node; after looking up the 1751 * structure or union offset, we just return an integer node with the offset. 1752 */ 1753 dt_node_t * 1754 dt_node_offsetof(dt_decl_t *ddp, char *s) 1755 { 1756 dtrace_typeinfo_t dtt; 1757 dt_node_t dn; 1758 char *name; 1759 int err; 1760 1761 ctf_membinfo_t ctm; 1762 ctf_id_t type; 1763 uint_t kind; 1764 1765 name = strdupa(s); 1766 free(s); 1767 1768 err = dt_decl_type(ddp, &dtt); 1769 dt_decl_free(ddp); 1770 1771 if (err != 0) 1772 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 1773 1774 type = ctf_type_resolve(dtt.dtt_ctfp, dtt.dtt_type); 1775 kind = ctf_type_kind(dtt.dtt_ctfp, type); 1776 1777 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 1778 xyerror(D_OFFSETOF_TYPE, 1779 "offsetof operand must be a struct or union type\n"); 1780 } 1781 1782 if (ctf_member_info(dtt.dtt_ctfp, type, name, &ctm) == CTF_ERR) { 1783 xyerror(D_UNKNOWN, "failed to determine offset of %s: %s\n", 1784 name, ctf_errmsg(ctf_errno(dtt.dtt_ctfp))); 1785 } 1786 1787 bzero(&dn, sizeof (dn)); 1788 dt_node_type_assign(&dn, dtt.dtt_ctfp, ctm.ctm_type); 1789 1790 if (dn.dn_flags & DT_NF_BITFIELD) { 1791 xyerror(D_OFFSETOF_BITFIELD, 1792 "cannot take offset of a bit-field: %s\n", name); 1793 } 1794 1795 return (dt_node_int(ctm.ctm_offset / NBBY)); 1796 } 1797 1798 dt_node_t * 1799 dt_node_op1(int op, dt_node_t *cp) 1800 { 1801 dt_node_t *dnp; 1802 1803 if (cp->dn_kind == DT_NODE_INT) { 1804 switch (op) { 1805 case DT_TOK_INEG: 1806 /* 1807 * If we're negating an unsigned integer, zero out any 1808 * extra top bits to truncate the value to the size of 1809 * the effective type determined by dt_node_int(). 1810 */ 1811 cp->dn_value = -cp->dn_value; 1812 if (!(cp->dn_flags & DT_NF_SIGNED)) { 1813 cp->dn_value &= ~0ULL >> 1814 (64 - dt_node_type_size(cp) * NBBY); 1815 } 1816 /*FALLTHRU*/ 1817 case DT_TOK_IPOS: 1818 return (cp); 1819 case DT_TOK_BNEG: 1820 cp->dn_value = ~cp->dn_value; 1821 return (cp); 1822 case DT_TOK_LNEG: 1823 cp->dn_value = !cp->dn_value; 1824 return (cp); 1825 } 1826 } 1827 1828 /* 1829 * If sizeof is applied to a type_name or string constant, we can 1830 * transform 'cp' into an integer constant in the node construction 1831 * pass so that it can then be used for arithmetic in this pass. 1832 */ 1833 if (op == DT_TOK_SIZEOF && 1834 (cp->dn_kind == DT_NODE_STRING || cp->dn_kind == DT_NODE_TYPE)) { 1835 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1836 size_t size = dt_node_type_size(cp); 1837 1838 if (size == 0) { 1839 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an " 1840 "operand of unknown size\n"); 1841 } 1842 1843 dt_node_type_assign(cp, dtp->dt_ddefs->dm_ctfp, 1844 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t")); 1845 1846 cp->dn_kind = DT_NODE_INT; 1847 cp->dn_op = DT_TOK_INT; 1848 cp->dn_value = size; 1849 1850 return (cp); 1851 } 1852 1853 dnp = dt_node_alloc(DT_NODE_OP1); 1854 assert(op <= USHRT_MAX); 1855 dnp->dn_op = (ushort_t)op; 1856 dnp->dn_child = cp; 1857 1858 return (dnp); 1859 } 1860 1861 /* 1862 * If an integer constant is being cast to another integer type, we can 1863 * perform the cast as part of integer constant folding in this pass. We must 1864 * take action when the integer is being cast to a smaller type or if it is 1865 * changing signed-ness. If so, we first shift rp's bits bits high (losing 1866 * excess bits if narrowing) and then shift them down with either a logical 1867 * shift (unsigned) or arithmetic shift (signed). 1868 */ 1869 static void 1870 dt_cast(dt_node_t *lp, dt_node_t *rp) 1871 { 1872 size_t srcsize = dt_node_type_size(rp); 1873 size_t dstsize = dt_node_type_size(lp); 1874 1875 if (dstsize < srcsize) { 1876 int n = (sizeof (uint64_t) - dstsize) * NBBY; 1877 rp->dn_value <<= n; 1878 rp->dn_value >>= n; 1879 } else if (dstsize > srcsize) { 1880 int n = (sizeof (uint64_t) - srcsize) * NBBY; 1881 int s = (dstsize - srcsize) * NBBY; 1882 1883 rp->dn_value <<= n; 1884 if (rp->dn_flags & DT_NF_SIGNED) { 1885 rp->dn_value = (intmax_t)rp->dn_value >> s; 1886 rp->dn_value >>= n - s; 1887 } else { 1888 rp->dn_value >>= n; 1889 } 1890 } 1891 } 1892 1893 dt_node_t * 1894 dt_node_op2(int op, dt_node_t *lp, dt_node_t *rp) 1895 { 1896 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 1897 dt_node_t *dnp; 1898 1899 /* 1900 * First we check for operations that are illegal -- namely those that 1901 * might result in integer division by zero, and abort if one is found. 1902 */ 1903 if (rp->dn_kind == DT_NODE_INT && rp->dn_value == 0 && 1904 (op == DT_TOK_MOD || op == DT_TOK_DIV || 1905 op == DT_TOK_MOD_EQ || op == DT_TOK_DIV_EQ)) 1906 xyerror(D_DIV_ZERO, "expression contains division by zero\n"); 1907 1908 /* 1909 * If both children are immediate values, we can just perform inline 1910 * calculation and return a new immediate node with the result. 1911 */ 1912 if (lp->dn_kind == DT_NODE_INT && rp->dn_kind == DT_NODE_INT) { 1913 uintmax_t l = lp->dn_value; 1914 uintmax_t r = rp->dn_value; 1915 1916 dnp = dt_node_int(0); /* allocate new integer node for result */ 1917 1918 switch (op) { 1919 case DT_TOK_LOR: 1920 dnp->dn_value = l || r; 1921 dt_node_type_assign(dnp, 1922 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1923 break; 1924 case DT_TOK_LXOR: 1925 dnp->dn_value = (l != 0) ^ (r != 0); 1926 dt_node_type_assign(dnp, 1927 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1928 break; 1929 case DT_TOK_LAND: 1930 dnp->dn_value = l && r; 1931 dt_node_type_assign(dnp, 1932 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1933 break; 1934 case DT_TOK_BOR: 1935 dnp->dn_value = l | r; 1936 dt_node_promote(lp, rp, dnp); 1937 break; 1938 case DT_TOK_XOR: 1939 dnp->dn_value = l ^ r; 1940 dt_node_promote(lp, rp, dnp); 1941 break; 1942 case DT_TOK_BAND: 1943 dnp->dn_value = l & r; 1944 dt_node_promote(lp, rp, dnp); 1945 break; 1946 case DT_TOK_EQU: 1947 dnp->dn_value = l == r; 1948 dt_node_type_assign(dnp, 1949 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1950 break; 1951 case DT_TOK_NEQ: 1952 dnp->dn_value = l != r; 1953 dt_node_type_assign(dnp, 1954 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1955 break; 1956 case DT_TOK_LT: 1957 dt_node_promote(lp, rp, dnp); 1958 if (dnp->dn_flags & DT_NF_SIGNED) 1959 dnp->dn_value = (intmax_t)l < (intmax_t)r; 1960 else 1961 dnp->dn_value = l < r; 1962 dt_node_type_assign(dnp, 1963 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1964 break; 1965 case DT_TOK_LE: 1966 dt_node_promote(lp, rp, dnp); 1967 if (dnp->dn_flags & DT_NF_SIGNED) 1968 dnp->dn_value = (intmax_t)l <= (intmax_t)r; 1969 else 1970 dnp->dn_value = l <= r; 1971 dt_node_type_assign(dnp, 1972 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1973 break; 1974 case DT_TOK_GT: 1975 dt_node_promote(lp, rp, dnp); 1976 if (dnp->dn_flags & DT_NF_SIGNED) 1977 dnp->dn_value = (intmax_t)l > (intmax_t)r; 1978 else 1979 dnp->dn_value = l > r; 1980 dt_node_type_assign(dnp, 1981 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1982 break; 1983 case DT_TOK_GE: 1984 dt_node_promote(lp, rp, dnp); 1985 if (dnp->dn_flags & DT_NF_SIGNED) 1986 dnp->dn_value = (intmax_t)l >= (intmax_t)r; 1987 else 1988 dnp->dn_value = l >= r; 1989 dt_node_type_assign(dnp, 1990 DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 1991 break; 1992 case DT_TOK_LSH: 1993 dnp->dn_value = l << r; 1994 dt_node_type_propagate(lp, dnp); 1995 dt_node_attr_assign(rp, 1996 dt_attr_min(lp->dn_attr, rp->dn_attr)); 1997 break; 1998 case DT_TOK_RSH: 1999 dnp->dn_value = l >> r; 2000 dt_node_type_propagate(lp, dnp); 2001 dt_node_attr_assign(rp, 2002 dt_attr_min(lp->dn_attr, rp->dn_attr)); 2003 break; 2004 case DT_TOK_ADD: 2005 dnp->dn_value = l + r; 2006 dt_node_promote(lp, rp, dnp); 2007 break; 2008 case DT_TOK_SUB: 2009 dnp->dn_value = l - r; 2010 dt_node_promote(lp, rp, dnp); 2011 break; 2012 case DT_TOK_MUL: 2013 dnp->dn_value = l * r; 2014 dt_node_promote(lp, rp, dnp); 2015 break; 2016 case DT_TOK_DIV: 2017 dt_node_promote(lp, rp, dnp); 2018 if (dnp->dn_flags & DT_NF_SIGNED) 2019 dnp->dn_value = (intmax_t)l / (intmax_t)r; 2020 else 2021 dnp->dn_value = l / r; 2022 break; 2023 case DT_TOK_MOD: 2024 dt_node_promote(lp, rp, dnp); 2025 if (dnp->dn_flags & DT_NF_SIGNED) 2026 dnp->dn_value = (intmax_t)l % (intmax_t)r; 2027 else 2028 dnp->dn_value = l % r; 2029 break; 2030 default: 2031 dt_node_free(dnp); 2032 dnp = NULL; 2033 } 2034 2035 if (dnp != NULL) { 2036 dt_node_free(lp); 2037 dt_node_free(rp); 2038 return (dnp); 2039 } 2040 } 2041 2042 if (op == DT_TOK_LPAR && rp->dn_kind == DT_NODE_INT && 2043 dt_node_is_integer(lp)) { 2044 dt_cast(lp, rp); 2045 dt_node_type_propagate(lp, rp); 2046 dt_node_attr_assign(rp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 2047 dt_node_free(lp); 2048 2049 return (rp); 2050 } 2051 2052 /* 2053 * If no immediate optimizations are available, create an new OP2 node 2054 * and glue the left and right children into place and return. 2055 */ 2056 dnp = dt_node_alloc(DT_NODE_OP2); 2057 assert(op <= USHRT_MAX); 2058 dnp->dn_op = (ushort_t)op; 2059 dnp->dn_left = lp; 2060 dnp->dn_right = rp; 2061 2062 return (dnp); 2063 } 2064 2065 dt_node_t * 2066 dt_node_op3(dt_node_t *expr, dt_node_t *lp, dt_node_t *rp) 2067 { 2068 dt_node_t *dnp; 2069 2070 if (expr->dn_kind == DT_NODE_INT) 2071 return (expr->dn_value != 0 ? lp : rp); 2072 2073 dnp = dt_node_alloc(DT_NODE_OP3); 2074 dnp->dn_op = DT_TOK_QUESTION; 2075 dnp->dn_expr = expr; 2076 dnp->dn_left = lp; 2077 dnp->dn_right = rp; 2078 2079 return (dnp); 2080 } 2081 2082 dt_node_t * 2083 dt_node_statement(dt_node_t *expr) 2084 { 2085 dt_node_t *dnp; 2086 2087 if (expr->dn_kind == DT_NODE_AGG) 2088 return (expr); 2089 2090 if (expr->dn_kind == DT_NODE_FUNC && 2091 expr->dn_ident->di_kind == DT_IDENT_ACTFUNC) 2092 dnp = dt_node_alloc(DT_NODE_DFUNC); 2093 else 2094 dnp = dt_node_alloc(DT_NODE_DEXPR); 2095 2096 dnp->dn_expr = expr; 2097 return (dnp); 2098 } 2099 2100 dt_node_t * 2101 dt_node_pdesc_by_name(char *spec) 2102 { 2103 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2104 dt_node_t *dnp; 2105 2106 if (spec == NULL) 2107 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2108 2109 dnp = dt_node_alloc(DT_NODE_PDESC); 2110 dnp->dn_spec = spec; 2111 dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t)); 2112 2113 if (dnp->dn_desc == NULL) 2114 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2115 2116 if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec, 2117 yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) { 2118 xyerror(D_PDESC_INVAL, "invalid probe description \"%s\": %s\n", 2119 dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp))); 2120 } 2121 2122 free(dnp->dn_spec); 2123 dnp->dn_spec = NULL; 2124 2125 return (dnp); 2126 } 2127 2128 dt_node_t * 2129 dt_node_pdesc_by_id(uintmax_t id) 2130 { 2131 static const char *const names[] = { 2132 "providers", "modules", "functions" 2133 }; 2134 2135 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2136 dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC); 2137 2138 if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL) 2139 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2140 2141 if (id > UINT_MAX) { 2142 xyerror(D_PDESC_INVAL, "identifier %llu exceeds maximum " 2143 "probe id\n", (u_longlong_t)id); 2144 } 2145 2146 if (yypcb->pcb_pspec != DTRACE_PROBESPEC_NAME) { 2147 xyerror(D_PDESC_INVAL, "probe identifier %llu not permitted " 2148 "when specifying %s\n", (u_longlong_t)id, 2149 names[yypcb->pcb_pspec]); 2150 } 2151 2152 if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) { 2153 xyerror(D_PDESC_INVAL, "invalid probe identifier %llu: %s\n", 2154 (u_longlong_t)id, dtrace_errmsg(dtp, dtrace_errno(dtp))); 2155 } 2156 2157 return (dnp); 2158 } 2159 2160 dt_node_t * 2161 dt_node_clause(dt_node_t *pdescs, dt_node_t *pred, dt_node_t *acts) 2162 { 2163 dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE); 2164 2165 dnp->dn_pdescs = pdescs; 2166 dnp->dn_pred = pred; 2167 dnp->dn_acts = acts; 2168 2169 yybegin(YYS_CLAUSE); 2170 return (dnp); 2171 } 2172 2173 dt_node_t * 2174 dt_node_inline(dt_node_t *expr) 2175 { 2176 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2177 dt_scope_t *dsp = &yypcb->pcb_dstack; 2178 dt_decl_t *ddp = dt_decl_top(); 2179 2180 char n[DT_TYPE_NAMELEN]; 2181 dtrace_typeinfo_t dtt; 2182 2183 dt_ident_t *idp, *rdp; 2184 dt_idnode_t *inp; 2185 dt_node_t *dnp; 2186 2187 if (dt_decl_type(ddp, &dtt) != 0) 2188 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 2189 2190 if (dsp->ds_class != DT_DC_DEFAULT) { 2191 xyerror(D_DECL_BADCLASS, "specified storage class not " 2192 "appropriate for inline declaration\n"); 2193 } 2194 2195 if (dsp->ds_ident == NULL) 2196 xyerror(D_DECL_USELESS, "inline declaration requires a name\n"); 2197 2198 if ((idp = dt_idstack_lookup( 2199 &yypcb->pcb_globals, dsp->ds_ident)) != NULL) { 2200 xyerror(D_DECL_IDRED, "identifier redefined: %s\n\t current: " 2201 "inline definition\n\tprevious: %s %s\n", 2202 idp->di_name, dt_idkind_name(idp->di_kind), 2203 (idp->di_flags & DT_IDFLG_INLINE) ? "inline" : ""); 2204 } 2205 2206 /* 2207 * If we are declaring an inlined array, verify that we have a tuple 2208 * signature, and then recompute 'dtt' as the array's value type. 2209 */ 2210 if (ddp->dd_kind == CTF_K_ARRAY) { 2211 if (ddp->dd_node == NULL) { 2212 xyerror(D_DECL_ARRNULL, "inline declaration requires " 2213 "array tuple signature: %s\n", dsp->ds_ident); 2214 } 2215 2216 if (ddp->dd_node->dn_kind != DT_NODE_TYPE) { 2217 xyerror(D_DECL_ARRNULL, "inline declaration cannot be " 2218 "of scalar array type: %s\n", dsp->ds_ident); 2219 } 2220 2221 if (dt_decl_type(ddp->dd_next, &dtt) != 0) 2222 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 2223 } 2224 2225 /* 2226 * If the inline identifier is not defined, then create it with the 2227 * orphan flag set. We do not insert the identifier into dt_globals 2228 * until we have successfully cooked the right-hand expression, below. 2229 */ 2230 dnp = dt_node_alloc(DT_NODE_INLINE); 2231 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 2232 dt_node_attr_assign(dnp, _dtrace_defattr); 2233 2234 if (dt_node_is_void(dnp)) { 2235 xyerror(D_DECL_VOIDOBJ, 2236 "cannot declare void inline: %s\n", dsp->ds_ident); 2237 } 2238 2239 if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve( 2240 dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) { 2241 xyerror(D_DECL_INCOMPLETE, 2242 "incomplete struct/union/enum %s: %s\n", 2243 dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident); 2244 } 2245 2246 if ((inp = malloc(sizeof (dt_idnode_t))) == NULL) 2247 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2248 2249 bzero(inp, sizeof (dt_idnode_t)); 2250 2251 idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident, 2252 ddp->dd_kind == CTF_K_ARRAY ? DT_IDENT_ARRAY : DT_IDENT_SCALAR, 2253 DT_IDFLG_INLINE | DT_IDFLG_REF | DT_IDFLG_DECL | DT_IDFLG_ORPHAN, 0, 2254 _dtrace_defattr, 0, &dt_idops_inline, inp, dtp->dt_gen); 2255 2256 if (idp == NULL) { 2257 free(inp); 2258 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2259 } 2260 2261 /* 2262 * If we're inlining an associative array, create a private identifier 2263 * hash containing the named parameters and store it in inp->din_hash. 2264 * We then push this hash on to the top of the pcb_globals stack. 2265 */ 2266 if (ddp->dd_kind == CTF_K_ARRAY) { 2267 dt_idnode_t *pinp; 2268 dt_ident_t *pidp; 2269 dt_node_t *pnp; 2270 uint_t i = 0; 2271 2272 for (pnp = ddp->dd_node; pnp != NULL; pnp = pnp->dn_list) 2273 i++; /* count up parameters for din_argv[] */ 2274 2275 inp->din_hash = dt_idhash_create("inline args", NULL, 0, 0); 2276 inp->din_argv = calloc(i, sizeof (dt_ident_t *)); 2277 2278 if (inp->din_hash == NULL || inp->din_argv == NULL) 2279 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2280 2281 /* 2282 * Create an identifier for each parameter as a scalar inline, 2283 * and store it in din_hash and in position in din_argv[]. The 2284 * parameter identifiers also use dt_idops_inline, but we leave 2285 * the dt_idnode_t argument 'pinp' zeroed. This will be filled 2286 * in by the code generation pass with references to the args. 2287 */ 2288 for (i = 0, pnp = ddp->dd_node; 2289 pnp != NULL; pnp = pnp->dn_list, i++) { 2290 2291 if (pnp->dn_string == NULL) 2292 continue; /* ignore anonymous parameters */ 2293 2294 if ((pinp = malloc(sizeof (dt_idnode_t))) == NULL) 2295 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2296 2297 pidp = dt_idhash_insert(inp->din_hash, pnp->dn_string, 2298 DT_IDENT_SCALAR, DT_IDFLG_DECL | DT_IDFLG_INLINE, 0, 2299 _dtrace_defattr, 0, &dt_idops_inline, 2300 pinp, dtp->dt_gen); 2301 2302 if (pidp == NULL) { 2303 free(pinp); 2304 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2305 } 2306 2307 inp->din_argv[i] = pidp; 2308 bzero(pinp, sizeof (dt_idnode_t)); 2309 dt_ident_type_assign(pidp, pnp->dn_ctfp, pnp->dn_type); 2310 } 2311 2312 dt_idstack_push(&yypcb->pcb_globals, inp->din_hash); 2313 } 2314 2315 /* 2316 * Unlike most constructors, we need to explicitly cook the right-hand 2317 * side of the inline definition immediately to prevent recursion. If 2318 * the right-hand side uses the inline itself, the cook will fail. 2319 */ 2320 expr = dt_node_cook(expr, DT_IDFLG_REF); 2321 2322 if (ddp->dd_kind == CTF_K_ARRAY) 2323 dt_idstack_pop(&yypcb->pcb_globals, inp->din_hash); 2324 2325 /* 2326 * Set the type, attributes, and flags for the inline. If the right- 2327 * hand expression has an identifier, propagate its flags. Then cook 2328 * the identifier to fully initialize it: if we're declaring an inline 2329 * associative array this will construct a type signature from 'ddp'. 2330 */ 2331 if (dt_node_is_dynamic(expr)) 2332 rdp = dt_ident_resolve(expr->dn_ident); 2333 else if (expr->dn_kind == DT_NODE_VAR || expr->dn_kind == DT_NODE_SYM) 2334 rdp = expr->dn_ident; 2335 else 2336 rdp = NULL; 2337 2338 if (rdp != NULL) { 2339 idp->di_flags |= (rdp->di_flags & 2340 (DT_IDFLG_WRITE | DT_IDFLG_USER | DT_IDFLG_PRIM)); 2341 } 2342 2343 idp->di_attr = dt_attr_min(_dtrace_defattr, expr->dn_attr); 2344 dt_ident_type_assign(idp, dtt.dtt_ctfp, dtt.dtt_type); 2345 (void) dt_ident_cook(dnp, idp, &ddp->dd_node); 2346 2347 /* 2348 * Store the parse tree nodes for 'expr' inside of idp->di_data ('inp') 2349 * so that they will be preserved with this identifier. Then pop the 2350 * inline declaration from the declaration stack and restore the lexer. 2351 */ 2352 inp->din_list = yypcb->pcb_list; 2353 inp->din_root = expr; 2354 2355 dt_decl_free(dt_decl_pop()); 2356 yybegin(YYS_CLAUSE); 2357 2358 /* 2359 * Finally, insert the inline identifier into dt_globals to make it 2360 * visible, and then cook 'dnp' to check its type against 'expr'. 2361 */ 2362 dt_idhash_xinsert(dtp->dt_globals, idp); 2363 return (dt_node_cook(dnp, DT_IDFLG_REF)); 2364 } 2365 2366 dt_node_t * 2367 dt_node_member(dt_decl_t *ddp, char *name, dt_node_t *expr) 2368 { 2369 dtrace_typeinfo_t dtt; 2370 dt_node_t *dnp; 2371 int err; 2372 2373 if (ddp != NULL) { 2374 err = dt_decl_type(ddp, &dtt); 2375 dt_decl_free(ddp); 2376 2377 if (err != 0) 2378 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 2379 } 2380 2381 dnp = dt_node_alloc(DT_NODE_MEMBER); 2382 dnp->dn_membname = name; 2383 dnp->dn_membexpr = expr; 2384 2385 if (ddp != NULL) 2386 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 2387 2388 return (dnp); 2389 } 2390 2391 dt_node_t * 2392 dt_node_xlator(dt_decl_t *ddp, dt_decl_t *sdp, char *name, dt_node_t *members) 2393 { 2394 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2395 dtrace_typeinfo_t src, dst; 2396 dt_node_t sn, dn; 2397 dt_xlator_t *dxp; 2398 dt_node_t *dnp; 2399 int edst, esrc; 2400 uint_t kind; 2401 2402 char n1[DT_TYPE_NAMELEN]; 2403 char n2[DT_TYPE_NAMELEN]; 2404 2405 edst = dt_decl_type(ddp, &dst); 2406 dt_decl_free(ddp); 2407 2408 esrc = dt_decl_type(sdp, &src); 2409 dt_decl_free(sdp); 2410 2411 if (edst != 0 || esrc != 0) { 2412 free(name); 2413 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 2414 } 2415 2416 bzero(&sn, sizeof (sn)); 2417 dt_node_type_assign(&sn, src.dtt_ctfp, src.dtt_type); 2418 2419 bzero(&dn, sizeof (dn)); 2420 dt_node_type_assign(&dn, dst.dtt_ctfp, dst.dtt_type); 2421 2422 if (dt_xlator_lookup(dtp, &sn, &dn, DT_XLATE_EXACT) != NULL) { 2423 xyerror(D_XLATE_REDECL, 2424 "translator from %s to %s has already been declared\n", 2425 dt_node_type_name(&sn, n1, sizeof (n1)), 2426 dt_node_type_name(&dn, n2, sizeof (n2))); 2427 } 2428 2429 kind = ctf_type_kind(dst.dtt_ctfp, 2430 ctf_type_resolve(dst.dtt_ctfp, dst.dtt_type)); 2431 2432 if (kind == CTF_K_FORWARD) { 2433 xyerror(D_XLATE_SOU, "incomplete struct/union/enum %s\n", 2434 dt_type_name(dst.dtt_ctfp, dst.dtt_type, n1, sizeof (n1))); 2435 } 2436 2437 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 2438 xyerror(D_XLATE_SOU, 2439 "translator output type must be a struct or union\n"); 2440 } 2441 2442 dxp = dt_xlator_create(dtp, &src, &dst, name, members, yypcb->pcb_list); 2443 yybegin(YYS_CLAUSE); 2444 free(name); 2445 2446 if (dxp == NULL) 2447 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2448 2449 dnp = dt_node_alloc(DT_NODE_XLATOR); 2450 dnp->dn_xlator = dxp; 2451 dnp->dn_members = members; 2452 2453 return (dt_node_cook(dnp, DT_IDFLG_REF)); 2454 } 2455 2456 dt_node_t * 2457 dt_node_probe(char *s, int protoc, dt_node_t *nargs, dt_node_t *xargs) 2458 { 2459 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2460 int nargc, xargc; 2461 dt_node_t *dnp; 2462 2463 size_t len = strlen(s) + 3; /* +3 for :: and \0 */ 2464 char *name = alloca(len); 2465 2466 (void) snprintf(name, len, "::%s", s); 2467 (void) strhyphenate(name); 2468 free(s); 2469 2470 if (strchr(name, '`') != NULL) { 2471 xyerror(D_PROV_BADNAME, "probe name may not " 2472 "contain scoping operator: %s\n", name); 2473 } 2474 2475 if (strlen(name) - 2 >= DTRACE_NAMELEN) { 2476 xyerror(D_PROV_BADNAME, "probe name may not exceed %d " 2477 "characters: %s\n", DTRACE_NAMELEN - 1, name); 2478 } 2479 2480 dnp = dt_node_alloc(DT_NODE_PROBE); 2481 2482 dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE, 2483 DT_IDFLG_ORPHAN, DTRACE_IDNONE, _dtrace_defattr, 0, 2484 &dt_idops_probe, NULL, dtp->dt_gen); 2485 2486 nargc = dt_decl_prototype(nargs, nargs, 2487 "probe input", DT_DP_VOID | DT_DP_ANON); 2488 2489 xargc = dt_decl_prototype(xargs, nargs, 2490 "probe output", DT_DP_VOID); 2491 2492 if (nargc > UINT8_MAX) { 2493 xyerror(D_PROV_PRARGLEN, "probe %s input prototype exceeds %u " 2494 "parameters: %d params used\n", name, UINT8_MAX, nargc); 2495 } 2496 2497 if (xargc > UINT8_MAX) { 2498 xyerror(D_PROV_PRARGLEN, "probe %s output prototype exceeds %u " 2499 "parameters: %d params used\n", name, UINT8_MAX, xargc); 2500 } 2501 2502 if (dnp->dn_ident == NULL || dt_probe_create(dtp, 2503 dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL) 2504 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2505 2506 return (dnp); 2507 } 2508 2509 dt_node_t * 2510 dt_node_provider(char *name, dt_node_t *probes) 2511 { 2512 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2513 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER); 2514 dt_node_t *lnp; 2515 size_t len; 2516 2517 dnp->dn_provname = name; 2518 dnp->dn_probes = probes; 2519 2520 if (strchr(name, '`') != NULL) { 2521 dnerror(dnp, D_PROV_BADNAME, "provider name may not " 2522 "contain scoping operator: %s\n", name); 2523 } 2524 2525 if ((len = strlen(name)) >= DTRACE_PROVNAMELEN) { 2526 dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d " 2527 "characters: %s\n", DTRACE_PROVNAMELEN - 1, name); 2528 } 2529 2530 if (isdigit(name[len - 1])) { 2531 dnerror(dnp, D_PROV_BADNAME, "provider name may not " 2532 "end with a digit: %s\n", name); 2533 } 2534 2535 /* 2536 * Check to see if the provider is already defined or visible through 2537 * dtrace(7D). If so, set dn_provred to treat it as a re-declaration. 2538 * If not, create a new provider and set its interface-only flag. This 2539 * flag may be cleared later by calls made to dt_probe_declare(). 2540 */ 2541 if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL) 2542 dnp->dn_provred = B_TRUE; 2543 else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL) 2544 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2545 else 2546 dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF; 2547 2548 /* 2549 * Store all parse nodes created since we consumed the DT_KEY_PROVIDER 2550 * token with the provider and then restore our lexing state to CLAUSE. 2551 * Note that if dnp->dn_provred is true, we may end up storing dups of 2552 * a provider's interface and implementation: we eat this space because 2553 * the implementation will likely need to redeclare probe members, and 2554 * therefore may result in those member nodes becoming persistent. 2555 */ 2556 for (lnp = yypcb->pcb_list; lnp->dn_link != NULL; lnp = lnp->dn_link) 2557 continue; /* skip to end of allocation list */ 2558 2559 lnp->dn_link = dnp->dn_provider->pv_nodes; 2560 dnp->dn_provider->pv_nodes = yypcb->pcb_list; 2561 2562 yybegin(YYS_CLAUSE); 2563 return (dnp); 2564 } 2565 2566 dt_node_t * 2567 dt_node_program(dt_node_t *lnp) 2568 { 2569 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG); 2570 dnp->dn_list = lnp; 2571 return (dnp); 2572 } 2573 2574 /* 2575 * This function provides the underlying implementation of cooking an 2576 * identifier given its node, a hash of dynamic identifiers, an identifier 2577 * kind, and a boolean flag indicating whether we are allowed to instantiate 2578 * a new identifier if the string is not found. This function is either 2579 * called from dt_cook_ident(), below, or directly by the various cooking 2580 * routines that are allowed to instantiate identifiers (e.g. op2 TOK_ASGN). 2581 */ 2582 static void 2583 dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create) 2584 { 2585 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2586 const char *sname = dt_idhash_name(dhp); 2587 int uref = 0; 2588 2589 dtrace_attribute_t attr = _dtrace_defattr; 2590 dt_ident_t *idp; 2591 dtrace_syminfo_t dts; 2592 GElf_Sym sym; 2593 2594 const char *scope, *mark; 2595 uchar_t dnkind; 2596 char *name; 2597 2598 /* 2599 * Look for scoping marks in the identifier. If one is found, set our 2600 * scope to either DTRACE_OBJ_KMODS or UMODS or to the first part of 2601 * the string that specifies the scope using an explicit module name. 2602 * If two marks in a row are found, set 'uref' (user symbol reference). 2603 * Otherwise we set scope to DTRACE_OBJ_EXEC, indicating that normal 2604 * scope is desired and we should search the specified idhash. 2605 */ 2606 if ((name = strrchr(dnp->dn_string, '`')) != NULL) { 2607 if (name > dnp->dn_string && name[-1] == '`') { 2608 uref++; 2609 name[-1] = '\0'; 2610 } 2611 2612 if (name == dnp->dn_string + uref) 2613 scope = uref ? DTRACE_OBJ_UMODS : DTRACE_OBJ_KMODS; 2614 else 2615 scope = dnp->dn_string; 2616 2617 *name++ = '\0'; /* leave name pointing after scoping mark */ 2618 dnkind = DT_NODE_VAR; 2619 2620 } else if (idkind == DT_IDENT_AGG) { 2621 scope = DTRACE_OBJ_EXEC; 2622 name = dnp->dn_string + 1; 2623 dnkind = DT_NODE_AGG; 2624 } else { 2625 scope = DTRACE_OBJ_EXEC; 2626 name = dnp->dn_string; 2627 dnkind = DT_NODE_VAR; 2628 } 2629 2630 /* 2631 * If create is set to false, and we fail our idhash lookup, preset 2632 * the errno code to EDT_NOVAR for our final error message below. 2633 * If we end up calling dtrace_lookup_by_name(), it will reset the 2634 * errno appropriately and that error will be reported instead. 2635 */ 2636 (void) dt_set_errno(dtp, EDT_NOVAR); 2637 mark = uref ? "``" : "`"; 2638 2639 if (scope == DTRACE_OBJ_EXEC && ( 2640 (dhp != dtp->dt_globals && 2641 (idp = dt_idhash_lookup(dhp, name)) != NULL) || 2642 (dhp == dtp->dt_globals && 2643 (idp = dt_idstack_lookup(&yypcb->pcb_globals, name)) != NULL))) { 2644 /* 2645 * Check that we are referencing the ident in the manner that 2646 * matches its type if this is a global lookup. In the TLS or 2647 * local case, we don't know how the ident will be used until 2648 * the time operator -> is seen; more parsing is needed. 2649 */ 2650 if (idp->di_kind != idkind && dhp == dtp->dt_globals) { 2651 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced " 2652 "as %s\n", dt_idkind_name(idp->di_kind), 2653 idp->di_name, dt_idkind_name(idkind)); 2654 } 2655 2656 /* 2657 * Arrays and aggregations are not cooked individually. They 2658 * have dynamic types and must be referenced using operator []. 2659 * This is handled explicitly by the code for DT_TOK_LBRAC. 2660 */ 2661 if (idp->di_kind != DT_IDENT_ARRAY && 2662 idp->di_kind != DT_IDENT_AGG) 2663 attr = dt_ident_cook(dnp, idp, NULL); 2664 else { 2665 dt_node_type_assign(dnp, 2666 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 2667 attr = idp->di_attr; 2668 } 2669 2670 free(dnp->dn_string); 2671 dnp->dn_string = NULL; 2672 dnp->dn_kind = dnkind; 2673 dnp->dn_ident = idp; 2674 dnp->dn_flags |= DT_NF_LVALUE; 2675 2676 if (idp->di_flags & DT_IDFLG_WRITE) 2677 dnp->dn_flags |= DT_NF_WRITABLE; 2678 2679 dt_node_attr_assign(dnp, attr); 2680 2681 } else if (dhp == dtp->dt_globals && scope != DTRACE_OBJ_EXEC && 2682 dtrace_lookup_by_name(dtp, scope, name, &sym, &dts) == 0) { 2683 2684 dt_module_t *mp = dt_module_lookup_by_name(dtp, dts.dts_object); 2685 int umod = (mp->dm_flags & DT_DM_KERNEL) == 0; 2686 static const char *const kunames[] = { "kernel", "user" }; 2687 2688 dtrace_typeinfo_t dtt; 2689 dtrace_syminfo_t *sip; 2690 2691 if (uref ^ umod) { 2692 xyerror(D_SYM_BADREF, "%s module '%s' symbol '%s' may " 2693 "not be referenced as a %s symbol\n", kunames[umod], 2694 dts.dts_object, dts.dts_name, kunames[uref]); 2695 } 2696 2697 if (dtrace_symbol_type(dtp, &sym, &dts, &dtt) != 0) { 2698 /* 2699 * For now, we special-case EDT_DATAMODEL to clarify 2700 * that mixed data models are not currently supported. 2701 */ 2702 if (dtp->dt_errno == EDT_DATAMODEL) { 2703 xyerror(D_SYM_MODEL, "cannot use %s symbol " 2704 "%s%s%s in a %s D program\n", 2705 dt_module_modelname(mp), 2706 dts.dts_object, mark, dts.dts_name, 2707 dt_module_modelname(dtp->dt_ddefs)); 2708 } 2709 2710 xyerror(D_SYM_NOTYPES, 2711 "no symbolic type information is available for " 2712 "%s%s%s: %s\n", dts.dts_object, mark, dts.dts_name, 2713 dtrace_errmsg(dtp, dtrace_errno(dtp))); 2714 } 2715 2716 idp = dt_ident_create(name, DT_IDENT_SYMBOL, 0, 0, 2717 _dtrace_symattr, 0, &dt_idops_thaw, NULL, dtp->dt_gen); 2718 2719 if (idp == NULL) 2720 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2721 2722 if (mp->dm_flags & DT_DM_PRIMARY) 2723 idp->di_flags |= DT_IDFLG_PRIM; 2724 2725 idp->di_next = dtp->dt_externs; 2726 dtp->dt_externs = idp; 2727 2728 if ((sip = malloc(sizeof (dtrace_syminfo_t))) == NULL) 2729 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2730 2731 bcopy(&dts, sip, sizeof (dtrace_syminfo_t)); 2732 idp->di_data = sip; 2733 idp->di_ctfp = dtt.dtt_ctfp; 2734 idp->di_type = dtt.dtt_type; 2735 2736 free(dnp->dn_string); 2737 dnp->dn_string = NULL; 2738 dnp->dn_kind = DT_NODE_SYM; 2739 dnp->dn_ident = idp; 2740 dnp->dn_flags |= DT_NF_LVALUE; 2741 2742 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 2743 dt_node_attr_assign(dnp, _dtrace_symattr); 2744 2745 if (uref) { 2746 idp->di_flags |= DT_IDFLG_USER; 2747 dnp->dn_flags |= DT_NF_USERLAND; 2748 } 2749 2750 } else if (scope == DTRACE_OBJ_EXEC && create == B_TRUE) { 2751 uint_t flags = DT_IDFLG_WRITE; 2752 uint_t id; 2753 2754 if (dt_idhash_nextid(dhp, &id) == -1) { 2755 xyerror(D_ID_OFLOW, "cannot create %s: limit on number " 2756 "of %s variables exceeded\n", name, sname); 2757 } 2758 2759 if (dhp == yypcb->pcb_locals) 2760 flags |= DT_IDFLG_LOCAL; 2761 else if (dhp == dtp->dt_tls) 2762 flags |= DT_IDFLG_TLS; 2763 2764 dt_dprintf("create %s %s variable %s, id=%u\n", 2765 sname, dt_idkind_name(idkind), name, id); 2766 2767 if (idkind == DT_IDENT_ARRAY || idkind == DT_IDENT_AGG) { 2768 idp = dt_idhash_insert(dhp, name, 2769 idkind, flags, id, _dtrace_defattr, 0, 2770 &dt_idops_assc, NULL, dtp->dt_gen); 2771 } else { 2772 idp = dt_idhash_insert(dhp, name, 2773 idkind, flags, id, _dtrace_defattr, 0, 2774 &dt_idops_thaw, NULL, dtp->dt_gen); 2775 } 2776 2777 if (idp == NULL) 2778 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 2779 2780 /* 2781 * Arrays and aggregations are not cooked individually. They 2782 * have dynamic types and must be referenced using operator []. 2783 * This is handled explicitly by the code for DT_TOK_LBRAC. 2784 */ 2785 if (idp->di_kind != DT_IDENT_ARRAY && 2786 idp->di_kind != DT_IDENT_AGG) 2787 attr = dt_ident_cook(dnp, idp, NULL); 2788 else { 2789 dt_node_type_assign(dnp, 2790 DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 2791 attr = idp->di_attr; 2792 } 2793 2794 free(dnp->dn_string); 2795 dnp->dn_string = NULL; 2796 dnp->dn_kind = dnkind; 2797 dnp->dn_ident = idp; 2798 dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE; 2799 2800 dt_node_attr_assign(dnp, attr); 2801 2802 } else if (scope != DTRACE_OBJ_EXEC) { 2803 xyerror(D_IDENT_UNDEF, "failed to resolve %s%s%s: %s\n", 2804 dnp->dn_string, mark, name, 2805 dtrace_errmsg(dtp, dtrace_errno(dtp))); 2806 } else { 2807 xyerror(D_IDENT_UNDEF, "failed to resolve %s: %s\n", 2808 dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp))); 2809 } 2810 } 2811 2812 static dt_node_t * 2813 dt_cook_ident(dt_node_t *dnp, uint_t idflags) 2814 { 2815 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2816 2817 if (dnp->dn_op == DT_TOK_AGG) 2818 dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE); 2819 else 2820 dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE); 2821 2822 return (dt_node_cook(dnp, idflags)); 2823 } 2824 2825 /* 2826 * Since operators [ and -> can instantiate new variables before we know 2827 * whether the reference is for a read or a write, we need to check read 2828 * references to determine if the identifier is currently dt_ident_unref(). 2829 * If so, we report that this first access was to an undefined variable. 2830 */ 2831 static dt_node_t * 2832 dt_cook_var(dt_node_t *dnp, uint_t idflags) 2833 { 2834 dt_ident_t *idp = dnp->dn_ident; 2835 2836 if ((idflags & DT_IDFLG_REF) && dt_ident_unref(idp)) { 2837 dnerror(dnp, D_VAR_UNDEF, 2838 "%s%s has not yet been declared or assigned\n", 2839 (idp->di_flags & DT_IDFLG_LOCAL) ? "this->" : 2840 (idp->di_flags & DT_IDFLG_TLS) ? "self->" : "", 2841 idp->di_name); 2842 } 2843 2844 dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args)); 2845 return (dnp); 2846 } 2847 2848 /*ARGSUSED*/ 2849 static dt_node_t * 2850 dt_cook_func(dt_node_t *dnp, uint_t idflags) 2851 { 2852 dt_node_attr_assign(dnp, 2853 dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args)); 2854 2855 return (dnp); 2856 } 2857 2858 static dt_node_t * 2859 dt_cook_op1(dt_node_t *dnp, uint_t idflags) 2860 { 2861 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 2862 dt_node_t *cp = dnp->dn_child; 2863 2864 char n[DT_TYPE_NAMELEN]; 2865 dtrace_typeinfo_t dtt; 2866 dt_ident_t *idp; 2867 2868 ctf_encoding_t e; 2869 ctf_arinfo_t r; 2870 ctf_id_t type, base; 2871 uint_t kind; 2872 2873 if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC || 2874 dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC) 2875 idflags = DT_IDFLG_REF | DT_IDFLG_MOD; 2876 else 2877 idflags = DT_IDFLG_REF; 2878 2879 /* 2880 * We allow the unary ++ and -- operators to instantiate new scalar 2881 * variables if applied to an identifier; otherwise just cook as usual. 2882 */ 2883 if (cp->dn_kind == DT_NODE_IDENT && (idflags & DT_IDFLG_MOD)) 2884 dt_xcook_ident(cp, dtp->dt_globals, DT_IDENT_SCALAR, B_TRUE); 2885 2886 cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */ 2887 2888 if (cp->dn_kind == DT_NODE_VAR && dt_ident_unref(cp->dn_ident)) { 2889 if (dt_type_lookup("int64_t", &dtt) != 0) 2890 xyerror(D_TYPE_ERR, "failed to lookup int64_t\n"); 2891 2892 dt_ident_type_assign(cp->dn_ident, dtt.dtt_ctfp, dtt.dtt_type); 2893 dt_node_type_assign(cp, dtt.dtt_ctfp, dtt.dtt_type); 2894 } 2895 2896 if (cp->dn_kind == DT_NODE_VAR) 2897 cp->dn_ident->di_flags |= idflags; 2898 2899 switch (dnp->dn_op) { 2900 case DT_TOK_DEREF: 2901 /* 2902 * If the deref operator is applied to a translated pointer, 2903 * we set our output type to the output of the translation. 2904 */ 2905 if ((idp = dt_node_resolve(cp, DT_IDENT_XLPTR)) != NULL) { 2906 dt_xlator_t *dxp = idp->di_data; 2907 2908 dnp->dn_ident = &dxp->dx_souid; 2909 dt_node_type_assign(dnp, 2910 dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type); 2911 break; 2912 } 2913 2914 type = ctf_type_resolve(cp->dn_ctfp, cp->dn_type); 2915 kind = ctf_type_kind(cp->dn_ctfp, type); 2916 2917 if (kind == CTF_K_ARRAY) { 2918 if (ctf_array_info(cp->dn_ctfp, type, &r) != 0) { 2919 dtp->dt_ctferr = ctf_errno(cp->dn_ctfp); 2920 longjmp(yypcb->pcb_jmpbuf, EDT_CTF); 2921 } else 2922 type = r.ctr_contents; 2923 } else if (kind == CTF_K_POINTER) { 2924 type = ctf_type_reference(cp->dn_ctfp, type); 2925 } else { 2926 xyerror(D_DEREF_NONPTR, 2927 "cannot dereference non-pointer type\n"); 2928 } 2929 2930 dt_node_type_assign(dnp, cp->dn_ctfp, type); 2931 base = ctf_type_resolve(cp->dn_ctfp, type); 2932 kind = ctf_type_kind(cp->dn_ctfp, base); 2933 2934 if (kind == CTF_K_INTEGER && ctf_type_encoding(cp->dn_ctfp, 2935 base, &e) == 0 && IS_VOID(e)) { 2936 xyerror(D_DEREF_VOID, 2937 "cannot dereference pointer to void\n"); 2938 } 2939 2940 if (kind == CTF_K_FUNCTION) { 2941 xyerror(D_DEREF_FUNC, 2942 "cannot dereference pointer to function\n"); 2943 } 2944 2945 if (kind != CTF_K_ARRAY || dt_node_is_string(dnp)) 2946 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */ 2947 2948 /* 2949 * If we propagated the l-value bit and the child operand was 2950 * a writable D variable or a binary operation of the form 2951 * a + b where a is writable, then propagate the writable bit. 2952 * This is necessary to permit assignments to scalar arrays, 2953 * which are converted to expressions of the form *(a + i). 2954 */ 2955 if ((cp->dn_flags & DT_NF_WRITABLE) || 2956 (cp->dn_kind == DT_NODE_OP2 && cp->dn_op == DT_TOK_ADD && 2957 (cp->dn_left->dn_flags & DT_NF_WRITABLE))) 2958 dnp->dn_flags |= DT_NF_WRITABLE; 2959 2960 if ((cp->dn_flags & DT_NF_USERLAND) && 2961 (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF))) 2962 dnp->dn_flags |= DT_NF_USERLAND; 2963 break; 2964 2965 case DT_TOK_IPOS: 2966 case DT_TOK_INEG: 2967 if (!dt_node_is_arith(cp)) { 2968 xyerror(D_OP_ARITH, "operator %s requires an operand " 2969 "of arithmetic type\n", opstr(dnp->dn_op)); 2970 } 2971 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */ 2972 break; 2973 2974 case DT_TOK_BNEG: 2975 if (!dt_node_is_integer(cp)) { 2976 xyerror(D_OP_INT, "operator %s requires an operand of " 2977 "integral type\n", opstr(dnp->dn_op)); 2978 } 2979 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */ 2980 break; 2981 2982 case DT_TOK_LNEG: 2983 if (!dt_node_is_scalar(cp)) { 2984 xyerror(D_OP_SCALAR, "operator %s requires an operand " 2985 "of scalar type\n", opstr(dnp->dn_op)); 2986 } 2987 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 2988 break; 2989 2990 case DT_TOK_ADDROF: 2991 if (cp->dn_kind == DT_NODE_VAR || cp->dn_kind == DT_NODE_AGG) { 2992 xyerror(D_ADDROF_VAR, 2993 "cannot take address of dynamic variable\n"); 2994 } 2995 2996 if (dt_node_is_dynamic(cp)) { 2997 xyerror(D_ADDROF_VAR, 2998 "cannot take address of dynamic object\n"); 2999 } 3000 3001 if (!(cp->dn_flags & DT_NF_LVALUE)) { 3002 xyerror(D_ADDROF_LVAL, /* see K&R[A7.4.2] */ 3003 "unacceptable operand for unary & operator\n"); 3004 } 3005 3006 if (cp->dn_flags & DT_NF_BITFIELD) { 3007 xyerror(D_ADDROF_BITFIELD, 3008 "cannot take address of bit-field\n"); 3009 } 3010 3011 dtt.dtt_object = NULL; 3012 dtt.dtt_ctfp = cp->dn_ctfp; 3013 dtt.dtt_type = cp->dn_type; 3014 3015 if (dt_type_pointer(&dtt) == -1) { 3016 xyerror(D_TYPE_ERR, "cannot find type for \"&\": %s*\n", 3017 dt_node_type_name(cp, n, sizeof (n))); 3018 } 3019 3020 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type); 3021 3022 if (cp->dn_flags & DT_NF_USERLAND) 3023 dnp->dn_flags |= DT_NF_USERLAND; 3024 break; 3025 3026 case DT_TOK_SIZEOF: 3027 if (cp->dn_flags & DT_NF_BITFIELD) { 3028 xyerror(D_SIZEOF_BITFIELD, 3029 "cannot apply sizeof to a bit-field\n"); 3030 } 3031 3032 if (dt_node_sizeof(cp) == 0) { 3033 xyerror(D_SIZEOF_TYPE, "cannot apply sizeof to an " 3034 "operand of unknown size\n"); 3035 } 3036 3037 dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp, 3038 ctf_lookup_by_name(dtp->dt_ddefs->dm_ctfp, "size_t")); 3039 break; 3040 3041 case DT_TOK_STRINGOF: 3042 if (!dt_node_is_scalar(cp) && !dt_node_is_pointer(cp) && 3043 !dt_node_is_strcompat(cp)) { 3044 xyerror(D_STRINGOF_TYPE, 3045 "cannot apply stringof to a value of type %s\n", 3046 dt_node_type_name(cp, n, sizeof (n))); 3047 } 3048 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp)); 3049 break; 3050 3051 case DT_TOK_PREINC: 3052 case DT_TOK_POSTINC: 3053 case DT_TOK_PREDEC: 3054 case DT_TOK_POSTDEC: 3055 if (dt_node_is_scalar(cp) == 0) { 3056 xyerror(D_OP_SCALAR, "operator %s requires operand of " 3057 "scalar type\n", opstr(dnp->dn_op)); 3058 } 3059 3060 if (dt_node_is_vfptr(cp)) { 3061 xyerror(D_OP_VFPTR, "operator %s requires an operand " 3062 "of known size\n", opstr(dnp->dn_op)); 3063 } 3064 3065 if (!(cp->dn_flags & DT_NF_LVALUE)) { 3066 xyerror(D_OP_LVAL, "operator %s requires modifiable " 3067 "lvalue as an operand\n", opstr(dnp->dn_op)); 3068 } 3069 3070 if (!(cp->dn_flags & DT_NF_WRITABLE)) { 3071 xyerror(D_OP_WRITE, "operator %s can only be applied " 3072 "to a writable variable\n", opstr(dnp->dn_op)); 3073 } 3074 3075 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */ 3076 break; 3077 3078 default: 3079 xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op)); 3080 } 3081 3082 dt_node_attr_assign(dnp, cp->dn_attr); 3083 return (dnp); 3084 } 3085 3086 static void 3087 dt_assign_common(dt_node_t *dnp) 3088 { 3089 dt_node_t *lp = dnp->dn_left; 3090 dt_node_t *rp = dnp->dn_right; 3091 int op = dnp->dn_op; 3092 3093 if (rp->dn_kind == DT_NODE_INT) 3094 dt_cast(lp, rp); 3095 3096 if (!(lp->dn_flags & DT_NF_LVALUE)) { 3097 xyerror(D_OP_LVAL, "operator %s requires modifiable " 3098 "lvalue as an operand\n", opstr(op)); 3099 /* see K&R[A7.17] */ 3100 } 3101 3102 if (!(lp->dn_flags & DT_NF_WRITABLE)) { 3103 xyerror(D_OP_WRITE, "operator %s can only be applied " 3104 "to a writable variable\n", opstr(op)); 3105 } 3106 3107 dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */ 3108 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3109 } 3110 3111 static dt_node_t * 3112 dt_cook_op2(dt_node_t *dnp, uint_t idflags) 3113 { 3114 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 3115 dt_node_t *lp = dnp->dn_left; 3116 dt_node_t *rp = dnp->dn_right; 3117 int op = dnp->dn_op; 3118 3119 ctf_membinfo_t m; 3120 ctf_file_t *ctfp; 3121 ctf_id_t type; 3122 int kind, val, uref; 3123 dt_ident_t *idp; 3124 3125 char n1[DT_TYPE_NAMELEN]; 3126 char n2[DT_TYPE_NAMELEN]; 3127 3128 /* 3129 * The expression E1[E2] is identical by definition to *((E1)+(E2)) so 3130 * we convert "[" to "+" and glue on "*" at the end (see K&R[A7.3.1]) 3131 * unless the left-hand side is an untyped D scalar, associative array, 3132 * or aggregation. In these cases, we proceed to case DT_TOK_LBRAC and 3133 * handle associative array and aggregation references there. 3134 */ 3135 if (op == DT_TOK_LBRAC) { 3136 if (lp->dn_kind == DT_NODE_IDENT) { 3137 dt_idhash_t *dhp; 3138 uint_t idkind; 3139 3140 if (lp->dn_op == DT_TOK_AGG) { 3141 dhp = dtp->dt_aggs; 3142 idp = dt_idhash_lookup(dhp, lp->dn_string + 1); 3143 idkind = DT_IDENT_AGG; 3144 } else { 3145 dhp = dtp->dt_globals; 3146 idp = dt_idstack_lookup( 3147 &yypcb->pcb_globals, lp->dn_string); 3148 idkind = DT_IDENT_ARRAY; 3149 } 3150 3151 if (idp == NULL || dt_ident_unref(idp)) 3152 dt_xcook_ident(lp, dhp, idkind, B_TRUE); 3153 else 3154 dt_xcook_ident(lp, dhp, idp->di_kind, B_FALSE); 3155 } else 3156 lp = dnp->dn_left = dt_node_cook(lp, 0); 3157 3158 /* 3159 * Switch op to '+' for *(E1 + E2) array mode in these cases: 3160 * (a) lp is a DT_IDENT_ARRAY variable that has already been 3161 * referenced using [] notation (dn_args != NULL). 3162 * (b) lp is a non-ARRAY variable that has already been given 3163 * a type by assignment or declaration (!dt_ident_unref()) 3164 * (c) lp is neither a variable nor an aggregation 3165 */ 3166 if (lp->dn_kind == DT_NODE_VAR) { 3167 if (lp->dn_ident->di_kind == DT_IDENT_ARRAY) { 3168 if (lp->dn_args != NULL) 3169 op = DT_TOK_ADD; 3170 } else if (!dt_ident_unref(lp->dn_ident)) 3171 op = DT_TOK_ADD; 3172 } else if (lp->dn_kind != DT_NODE_AGG) 3173 op = DT_TOK_ADD; 3174 } 3175 3176 switch (op) { 3177 case DT_TOK_BAND: 3178 case DT_TOK_XOR: 3179 case DT_TOK_BOR: 3180 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3181 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3182 3183 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 3184 xyerror(D_OP_INT, "operator %s requires operands of " 3185 "integral type\n", opstr(op)); 3186 } 3187 3188 dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */ 3189 break; 3190 3191 case DT_TOK_LSH: 3192 case DT_TOK_RSH: 3193 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3194 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3195 3196 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 3197 xyerror(D_OP_INT, "operator %s requires operands of " 3198 "integral type\n", opstr(op)); 3199 } 3200 3201 dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */ 3202 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3203 break; 3204 3205 case DT_TOK_MOD: 3206 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3207 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3208 3209 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 3210 xyerror(D_OP_INT, "operator %s requires operands of " 3211 "integral type\n", opstr(op)); 3212 } 3213 3214 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */ 3215 break; 3216 3217 case DT_TOK_MUL: 3218 case DT_TOK_DIV: 3219 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3220 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3221 3222 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) { 3223 xyerror(D_OP_ARITH, "operator %s requires operands of " 3224 "arithmetic type\n", opstr(op)); 3225 } 3226 3227 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */ 3228 break; 3229 3230 case DT_TOK_LAND: 3231 case DT_TOK_LXOR: 3232 case DT_TOK_LOR: 3233 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3234 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3235 3236 if (!dt_node_is_scalar(lp) || !dt_node_is_scalar(rp)) { 3237 xyerror(D_OP_SCALAR, "operator %s requires operands " 3238 "of scalar type\n", opstr(op)); 3239 } 3240 3241 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 3242 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3243 break; 3244 3245 case DT_TOK_LT: 3246 case DT_TOK_LE: 3247 case DT_TOK_GT: 3248 case DT_TOK_GE: 3249 case DT_TOK_EQU: 3250 case DT_TOK_NEQ: 3251 /* 3252 * The D comparison operators provide the ability to transform 3253 * a right-hand identifier into a corresponding enum tag value 3254 * if the left-hand side is an enum type. To do this, we cook 3255 * the left-hand side, and then see if the right-hand side is 3256 * an unscoped identifier defined in the enum. If so, we 3257 * convert into an integer constant node with the tag's value. 3258 */ 3259 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3260 3261 kind = ctf_type_kind(lp->dn_ctfp, 3262 ctf_type_resolve(lp->dn_ctfp, lp->dn_type)); 3263 3264 if (kind == CTF_K_ENUM && rp->dn_kind == DT_NODE_IDENT && 3265 strchr(rp->dn_string, '`') == NULL && ctf_enum_value( 3266 lp->dn_ctfp, lp->dn_type, rp->dn_string, &val) == 0) { 3267 3268 if ((idp = dt_idstack_lookup(&yypcb->pcb_globals, 3269 rp->dn_string)) != NULL) { 3270 xyerror(D_IDENT_AMBIG, 3271 "ambiguous use of operator %s: %s is " 3272 "both a %s enum tag and a global %s\n", 3273 opstr(op), rp->dn_string, 3274 dt_node_type_name(lp, n1, sizeof (n1)), 3275 dt_idkind_name(idp->di_kind)); 3276 } 3277 3278 free(rp->dn_string); 3279 rp->dn_string = NULL; 3280 rp->dn_kind = DT_NODE_INT; 3281 rp->dn_flags |= DT_NF_COOKED; 3282 rp->dn_op = DT_TOK_INT; 3283 rp->dn_value = (intmax_t)val; 3284 3285 dt_node_type_assign(rp, lp->dn_ctfp, lp->dn_type); 3286 dt_node_attr_assign(rp, _dtrace_symattr); 3287 } 3288 3289 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3290 3291 /* 3292 * The rules for type checking for the relational operators are 3293 * described in the ANSI-C spec (see K&R[A7.9-10]). We perform 3294 * the various tests in order from least to most expensive. We 3295 * also allow derived strings to be compared as a first-class 3296 * type (resulting in a strcmp(3C)-style comparison), and we 3297 * slightly relax the A7.9 rules to permit void pointer 3298 * comparisons as in A7.10. Our users won't be confused by 3299 * this since they understand pointers are just numbers, and 3300 * relaxing this constraint simplifies the implementation. 3301 */ 3302 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 3303 rp->dn_ctfp, rp->dn_type)) 3304 /*EMPTY*/; 3305 else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) 3306 /*EMPTY*/; 3307 else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) && 3308 (dt_node_is_string(lp) || dt_node_is_string(rp))) 3309 /*EMPTY*/; 3310 else if (dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) { 3311 xyerror(D_OP_INCOMPAT, "operands have " 3312 "incompatible types: \"%s\" %s \"%s\"\n", 3313 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 3314 dt_node_type_name(rp, n2, sizeof (n2))); 3315 } 3316 3317 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp)); 3318 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3319 break; 3320 3321 case DT_TOK_ADD: 3322 case DT_TOK_SUB: { 3323 /* 3324 * The rules for type checking for the additive operators are 3325 * described in the ANSI-C spec (see K&R[A7.7]). Pointers and 3326 * integers may be manipulated according to specific rules. In 3327 * these cases D permits strings to be treated as pointers. 3328 */ 3329 int lp_is_ptr, lp_is_int, rp_is_ptr, rp_is_int; 3330 3331 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3332 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3333 3334 lp_is_ptr = dt_node_is_string(lp) || 3335 (dt_node_is_pointer(lp) && !dt_node_is_vfptr(lp)); 3336 lp_is_int = dt_node_is_integer(lp); 3337 3338 rp_is_ptr = dt_node_is_string(rp) || 3339 (dt_node_is_pointer(rp) && !dt_node_is_vfptr(rp)); 3340 rp_is_int = dt_node_is_integer(rp); 3341 3342 if (lp_is_int && rp_is_int) { 3343 dt_type_promote(lp, rp, &ctfp, &type); 3344 uref = 0; 3345 } else if (lp_is_ptr && rp_is_int) { 3346 ctfp = lp->dn_ctfp; 3347 type = lp->dn_type; 3348 uref = lp->dn_flags & DT_NF_USERLAND; 3349 } else if (lp_is_int && rp_is_ptr && op == DT_TOK_ADD) { 3350 ctfp = rp->dn_ctfp; 3351 type = rp->dn_type; 3352 uref = rp->dn_flags & DT_NF_USERLAND; 3353 } else if (lp_is_ptr && rp_is_ptr && op == DT_TOK_SUB && 3354 dt_node_is_ptrcompat(lp, rp, NULL, NULL)) { 3355 ctfp = dtp->dt_ddefs->dm_ctfp; 3356 type = ctf_lookup_by_name(ctfp, "ptrdiff_t"); 3357 uref = 0; 3358 } else { 3359 xyerror(D_OP_INCOMPAT, "operands have incompatible " 3360 "types: \"%s\" %s \"%s\"\n", 3361 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 3362 dt_node_type_name(rp, n2, sizeof (n2))); 3363 } 3364 3365 dt_node_type_assign(dnp, ctfp, type); 3366 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3367 3368 if (uref) 3369 dnp->dn_flags |= DT_NF_USERLAND; 3370 break; 3371 } 3372 3373 case DT_TOK_OR_EQ: 3374 case DT_TOK_XOR_EQ: 3375 case DT_TOK_AND_EQ: 3376 case DT_TOK_LSH_EQ: 3377 case DT_TOK_RSH_EQ: 3378 case DT_TOK_MOD_EQ: 3379 if (lp->dn_kind == DT_NODE_IDENT) { 3380 dt_xcook_ident(lp, dtp->dt_globals, 3381 DT_IDENT_SCALAR, B_TRUE); 3382 } 3383 3384 lp = dnp->dn_left = 3385 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 3386 3387 rp = dnp->dn_right = 3388 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 3389 3390 if (!dt_node_is_integer(lp) || !dt_node_is_integer(rp)) { 3391 xyerror(D_OP_INT, "operator %s requires operands of " 3392 "integral type\n", opstr(op)); 3393 } 3394 goto asgn_common; 3395 3396 case DT_TOK_MUL_EQ: 3397 case DT_TOK_DIV_EQ: 3398 if (lp->dn_kind == DT_NODE_IDENT) { 3399 dt_xcook_ident(lp, dtp->dt_globals, 3400 DT_IDENT_SCALAR, B_TRUE); 3401 } 3402 3403 lp = dnp->dn_left = 3404 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 3405 3406 rp = dnp->dn_right = 3407 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 3408 3409 if (!dt_node_is_arith(lp) || !dt_node_is_arith(rp)) { 3410 xyerror(D_OP_ARITH, "operator %s requires operands of " 3411 "arithmetic type\n", opstr(op)); 3412 } 3413 goto asgn_common; 3414 3415 case DT_TOK_ASGN: 3416 /* 3417 * If the left-hand side is an identifier, attempt to resolve 3418 * it as either an aggregation or scalar variable. We pass 3419 * B_TRUE to dt_xcook_ident to indicate that a new variable can 3420 * be created if no matching variable exists in the namespace. 3421 */ 3422 if (lp->dn_kind == DT_NODE_IDENT) { 3423 if (lp->dn_op == DT_TOK_AGG) { 3424 dt_xcook_ident(lp, dtp->dt_aggs, 3425 DT_IDENT_AGG, B_TRUE); 3426 } else { 3427 dt_xcook_ident(lp, dtp->dt_globals, 3428 DT_IDENT_SCALAR, B_TRUE); 3429 } 3430 } 3431 3432 lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */ 3433 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3434 3435 /* 3436 * If the left-hand side is an aggregation, verify that we are 3437 * assigning it the result of an aggregating function. Once 3438 * we've done so, hide the func node in the aggregation and 3439 * return the aggregation itself up to the parse tree parent. 3440 * This transformation is legal since the assigned function 3441 * cannot change identity across disjoint cooking passes and 3442 * the argument list subtree is retained for later cooking. 3443 */ 3444 if (lp->dn_kind == DT_NODE_AGG) { 3445 const char *aname = lp->dn_ident->di_name; 3446 dt_ident_t *oid = lp->dn_ident->di_iarg; 3447 3448 if (rp->dn_kind != DT_NODE_FUNC || 3449 rp->dn_ident->di_kind != DT_IDENT_AGGFUNC) { 3450 xyerror(D_AGG_FUNC, 3451 "@%s must be assigned the result of " 3452 "an aggregating function\n", aname); 3453 } 3454 3455 if (oid != NULL && oid != rp->dn_ident) { 3456 xyerror(D_AGG_REDEF, 3457 "aggregation redefined: @%s\n\t " 3458 "current: @%s = %s( )\n\tprevious: @%s = " 3459 "%s( ) : line %d\n", aname, aname, 3460 rp->dn_ident->di_name, aname, oid->di_name, 3461 lp->dn_ident->di_lineno); 3462 } else if (oid == NULL) 3463 lp->dn_ident->di_iarg = rp->dn_ident; 3464 3465 /* 3466 * Do not allow multiple aggregation assignments in a 3467 * single statement, e.g. (@a = count()) = count(); 3468 * We produce a message as if the result of aggregating 3469 * function does not propagate DT_NF_LVALUE. 3470 */ 3471 if (lp->dn_aggfun != NULL) { 3472 xyerror(D_OP_LVAL, "operator = requires " 3473 "modifiable lvalue as an operand\n"); 3474 } 3475 3476 lp->dn_aggfun = rp; 3477 lp = dt_node_cook(lp, DT_IDFLG_MOD); 3478 3479 dnp->dn_left = dnp->dn_right = NULL; 3480 dt_node_free(dnp); 3481 3482 return (lp); 3483 } 3484 3485 /* 3486 * If the right-hand side is a dynamic variable that is the 3487 * output of a translator, our result is the translated type. 3488 */ 3489 if ((idp = dt_node_resolve(rp, DT_IDENT_XLSOU)) != NULL) { 3490 ctfp = idp->di_ctfp; 3491 type = idp->di_type; 3492 uref = idp->di_flags & DT_IDFLG_USER; 3493 } else { 3494 ctfp = rp->dn_ctfp; 3495 type = rp->dn_type; 3496 uref = rp->dn_flags & DT_NF_USERLAND; 3497 } 3498 3499 /* 3500 * If the left-hand side of an assignment statement is a virgin 3501 * variable created by this compilation pass, reset the type of 3502 * this variable to the type of the right-hand side. 3503 */ 3504 if (lp->dn_kind == DT_NODE_VAR && 3505 dt_ident_unref(lp->dn_ident)) { 3506 dt_node_type_assign(lp, ctfp, type); 3507 dt_ident_type_assign(lp->dn_ident, ctfp, type); 3508 3509 if (uref) { 3510 lp->dn_flags |= DT_NF_USERLAND; 3511 lp->dn_ident->di_flags |= DT_IDFLG_USER; 3512 } 3513 } 3514 3515 if (lp->dn_kind == DT_NODE_VAR) 3516 lp->dn_ident->di_flags |= DT_IDFLG_MOD; 3517 3518 /* 3519 * The rules for type checking for the assignment operators are 3520 * described in the ANSI-C spec (see K&R[A7.17]). We share 3521 * most of this code with the argument list checking code. 3522 */ 3523 if (!dt_node_is_string(lp)) { 3524 kind = ctf_type_kind(lp->dn_ctfp, 3525 ctf_type_resolve(lp->dn_ctfp, lp->dn_type)); 3526 3527 if (kind == CTF_K_ARRAY || kind == CTF_K_FUNCTION) { 3528 xyerror(D_OP_ARRFUN, "operator %s may not be " 3529 "applied to operand of type \"%s\"\n", 3530 opstr(op), 3531 dt_node_type_name(lp, n1, sizeof (n1))); 3532 } 3533 } 3534 3535 if (idp != NULL && idp->di_kind == DT_IDENT_XLSOU && 3536 ctf_type_compat(lp->dn_ctfp, lp->dn_type, ctfp, type)) 3537 goto asgn_common; 3538 3539 if (dt_node_is_argcompat(lp, rp)) 3540 goto asgn_common; 3541 3542 xyerror(D_OP_INCOMPAT, 3543 "operands have incompatible types: \"%s\" %s \"%s\"\n", 3544 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 3545 dt_node_type_name(rp, n2, sizeof (n2))); 3546 /*NOTREACHED*/ 3547 3548 case DT_TOK_ADD_EQ: 3549 case DT_TOK_SUB_EQ: 3550 if (lp->dn_kind == DT_NODE_IDENT) { 3551 dt_xcook_ident(lp, dtp->dt_globals, 3552 DT_IDENT_SCALAR, B_TRUE); 3553 } 3554 3555 lp = dnp->dn_left = 3556 dt_node_cook(lp, DT_IDFLG_REF | DT_IDFLG_MOD); 3557 3558 rp = dnp->dn_right = 3559 dt_node_cook(rp, DT_IDFLG_REF | DT_IDFLG_MOD); 3560 3561 if (dt_node_is_string(lp) || dt_node_is_string(rp)) { 3562 xyerror(D_OP_INCOMPAT, "operands have " 3563 "incompatible types: \"%s\" %s \"%s\"\n", 3564 dt_node_type_name(lp, n1, sizeof (n1)), opstr(op), 3565 dt_node_type_name(rp, n2, sizeof (n2))); 3566 } 3567 3568 /* 3569 * The rules for type checking for the assignment operators are 3570 * described in the ANSI-C spec (see K&R[A7.17]). To these 3571 * rules we add that only writable D nodes can be modified. 3572 */ 3573 if (dt_node_is_integer(lp) == 0 || 3574 dt_node_is_integer(rp) == 0) { 3575 if (!dt_node_is_pointer(lp) || dt_node_is_vfptr(lp)) { 3576 xyerror(D_OP_VFPTR, 3577 "operator %s requires left-hand scalar " 3578 "operand of known size\n", opstr(op)); 3579 } else if (dt_node_is_integer(rp) == 0 && 3580 dt_node_is_ptrcompat(lp, rp, NULL, NULL) == 0) { 3581 xyerror(D_OP_INCOMPAT, "operands have " 3582 "incompatible types: \"%s\" %s \"%s\"\n", 3583 dt_node_type_name(lp, n1, sizeof (n1)), 3584 opstr(op), 3585 dt_node_type_name(rp, n2, sizeof (n2))); 3586 } 3587 } 3588 asgn_common: 3589 dt_assign_common(dnp); 3590 break; 3591 3592 case DT_TOK_PTR: 3593 /* 3594 * If the left-hand side of operator -> is the name "self", 3595 * then we permit a TLS variable to be created or referenced. 3596 */ 3597 if (lp->dn_kind == DT_NODE_IDENT && 3598 strcmp(lp->dn_string, "self") == 0) { 3599 if (rp->dn_kind != DT_NODE_VAR) { 3600 dt_xcook_ident(rp, dtp->dt_tls, 3601 DT_IDENT_SCALAR, B_TRUE); 3602 } 3603 3604 if (idflags != 0) 3605 rp = dt_node_cook(rp, idflags); 3606 3607 dnp->dn_right = dnp->dn_left; /* avoid freeing rp */ 3608 dt_node_free(dnp); 3609 return (rp); 3610 } 3611 3612 /* 3613 * If the left-hand side of operator -> is the name "this", 3614 * then we permit a local variable to be created or referenced. 3615 */ 3616 if (lp->dn_kind == DT_NODE_IDENT && 3617 strcmp(lp->dn_string, "this") == 0) { 3618 if (rp->dn_kind != DT_NODE_VAR) { 3619 dt_xcook_ident(rp, yypcb->pcb_locals, 3620 DT_IDENT_SCALAR, B_TRUE); 3621 } 3622 3623 if (idflags != 0) 3624 rp = dt_node_cook(rp, idflags); 3625 3626 dnp->dn_right = dnp->dn_left; /* avoid freeing rp */ 3627 dt_node_free(dnp); 3628 return (rp); 3629 } 3630 3631 /*FALLTHRU*/ 3632 3633 case DT_TOK_DOT: 3634 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3635 3636 if (rp->dn_kind != DT_NODE_IDENT) { 3637 xyerror(D_OP_IDENT, "operator %s must be followed by " 3638 "an identifier\n", opstr(op)); 3639 } 3640 3641 if ((idp = dt_node_resolve(lp, DT_IDENT_XLSOU)) != NULL || 3642 (idp = dt_node_resolve(lp, DT_IDENT_XLPTR)) != NULL) { 3643 /* 3644 * If the left-hand side is a translated struct or ptr, 3645 * the type of the left is the translation output type. 3646 */ 3647 dt_xlator_t *dxp = idp->di_data; 3648 3649 if (dt_xlator_member(dxp, rp->dn_string) == NULL) { 3650 xyerror(D_XLATE_NOCONV, 3651 "translator does not define conversion " 3652 "for member: %s\n", rp->dn_string); 3653 } 3654 3655 ctfp = idp->di_ctfp; 3656 type = ctf_type_resolve(ctfp, idp->di_type); 3657 uref = idp->di_flags & DT_IDFLG_USER; 3658 } else { 3659 ctfp = lp->dn_ctfp; 3660 type = ctf_type_resolve(ctfp, lp->dn_type); 3661 uref = lp->dn_flags & DT_NF_USERLAND; 3662 } 3663 3664 kind = ctf_type_kind(ctfp, type); 3665 3666 if (op == DT_TOK_PTR) { 3667 if (kind != CTF_K_POINTER) { 3668 xyerror(D_OP_PTR, "operator %s must be " 3669 "applied to a pointer\n", opstr(op)); 3670 } 3671 type = ctf_type_reference(ctfp, type); 3672 type = ctf_type_resolve(ctfp, type); 3673 kind = ctf_type_kind(ctfp, type); 3674 } 3675 3676 /* 3677 * If we follow a reference to a forward declaration tag, 3678 * search the entire type space for the actual definition. 3679 */ 3680 while (kind == CTF_K_FORWARD) { 3681 char *tag = ctf_type_name(ctfp, type, n1, sizeof (n1)); 3682 dtrace_typeinfo_t dtt; 3683 3684 if (tag != NULL && dt_type_lookup(tag, &dtt) == 0 && 3685 (dtt.dtt_ctfp != ctfp || dtt.dtt_type != type)) { 3686 ctfp = dtt.dtt_ctfp; 3687 type = ctf_type_resolve(ctfp, dtt.dtt_type); 3688 kind = ctf_type_kind(ctfp, type); 3689 } else { 3690 xyerror(D_OP_INCOMPLETE, 3691 "operator %s cannot be applied to a " 3692 "forward declaration: no %s definition " 3693 "is available\n", opstr(op), tag); 3694 } 3695 } 3696 3697 if (kind != CTF_K_STRUCT && kind != CTF_K_UNION) { 3698 if (op == DT_TOK_PTR) { 3699 xyerror(D_OP_SOU, "operator -> cannot be " 3700 "applied to pointer to type \"%s\"; must " 3701 "be applied to a struct or union pointer\n", 3702 ctf_type_name(ctfp, type, n1, sizeof (n1))); 3703 } else { 3704 xyerror(D_OP_SOU, "operator %s cannot be " 3705 "applied to type \"%s\"; must be applied " 3706 "to a struct or union\n", opstr(op), 3707 ctf_type_name(ctfp, type, n1, sizeof (n1))); 3708 } 3709 } 3710 3711 if (ctf_member_info(ctfp, type, rp->dn_string, &m) == CTF_ERR) { 3712 xyerror(D_TYPE_MEMBER, 3713 "%s is not a member of %s\n", rp->dn_string, 3714 ctf_type_name(ctfp, type, n1, sizeof (n1))); 3715 } 3716 3717 type = ctf_type_resolve(ctfp, m.ctm_type); 3718 kind = ctf_type_kind(ctfp, type); 3719 3720 dt_node_type_assign(dnp, ctfp, m.ctm_type); 3721 dt_node_attr_assign(dnp, lp->dn_attr); 3722 3723 if (op == DT_TOK_PTR && (kind != CTF_K_ARRAY || 3724 dt_node_is_string(dnp))) 3725 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */ 3726 3727 if (op == DT_TOK_DOT && (lp->dn_flags & DT_NF_LVALUE) && 3728 (kind != CTF_K_ARRAY || dt_node_is_string(dnp))) 3729 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */ 3730 3731 if (lp->dn_flags & DT_NF_WRITABLE) 3732 dnp->dn_flags |= DT_NF_WRITABLE; 3733 3734 if (uref && (kind == CTF_K_POINTER || 3735 (dnp->dn_flags & DT_NF_REF))) 3736 dnp->dn_flags |= DT_NF_USERLAND; 3737 break; 3738 3739 case DT_TOK_LBRAC: { 3740 /* 3741 * If op is DT_TOK_LBRAC, we know from the special-case code at 3742 * the top that lp is either a D variable or an aggregation. 3743 */ 3744 dt_node_t *lnp; 3745 3746 /* 3747 * If the left-hand side is an aggregation, just set dn_aggtup 3748 * to the right-hand side and return the cooked aggregation. 3749 * This transformation is legal since we are just collapsing 3750 * nodes to simplify later processing, and the entire aggtup 3751 * parse subtree is retained for subsequent cooking passes. 3752 */ 3753 if (lp->dn_kind == DT_NODE_AGG) { 3754 if (lp->dn_aggtup != NULL) { 3755 xyerror(D_AGG_MDIM, "improper attempt to " 3756 "reference @%s as a multi-dimensional " 3757 "array\n", lp->dn_ident->di_name); 3758 } 3759 3760 lp->dn_aggtup = rp; 3761 lp = dt_node_cook(lp, 0); 3762 3763 dnp->dn_left = dnp->dn_right = NULL; 3764 dt_node_free(dnp); 3765 3766 return (lp); 3767 } 3768 3769 assert(lp->dn_kind == DT_NODE_VAR); 3770 idp = lp->dn_ident; 3771 3772 /* 3773 * If the left-hand side is a non-global scalar that hasn't yet 3774 * been referenced or modified, it was just created by self-> 3775 * or this-> and we can convert it from scalar to assoc array. 3776 */ 3777 if (idp->di_kind == DT_IDENT_SCALAR && dt_ident_unref(idp) && 3778 (idp->di_flags & (DT_IDFLG_LOCAL | DT_IDFLG_TLS)) != 0) { 3779 3780 if (idp->di_flags & DT_IDFLG_LOCAL) { 3781 xyerror(D_ARR_LOCAL, 3782 "local variables may not be used as " 3783 "associative arrays: %s\n", idp->di_name); 3784 } 3785 3786 dt_dprintf("morph variable %s (id %u) from scalar to " 3787 "array\n", idp->di_name, idp->di_id); 3788 3789 dt_ident_morph(idp, DT_IDENT_ARRAY, 3790 &dt_idops_assc, NULL); 3791 } 3792 3793 if (idp->di_kind != DT_IDENT_ARRAY) { 3794 xyerror(D_IDENT_BADREF, "%s '%s' may not be referenced " 3795 "as %s\n", dt_idkind_name(idp->di_kind), 3796 idp->di_name, dt_idkind_name(DT_IDENT_ARRAY)); 3797 } 3798 3799 /* 3800 * Now that we've confirmed our left-hand side is a DT_NODE_VAR 3801 * of idkind DT_IDENT_ARRAY, we need to splice the [ node from 3802 * the parse tree and leave a cooked DT_NODE_VAR in its place 3803 * where dn_args for the VAR node is the right-hand 'rp' tree, 3804 * as shown in the parse tree diagram below: 3805 * 3806 * / / 3807 * [ OP2 "[" ]=dnp [ VAR ]=dnp 3808 * / \ => | 3809 * / \ +- dn_args -> [ ??? ]=rp 3810 * [ VAR ]=lp [ ??? ]=rp 3811 * 3812 * Since the final dt_node_cook(dnp) can fail using longjmp we 3813 * must perform the transformations as a group first by over- 3814 * writing 'dnp' to become the VAR node, so that the parse tree 3815 * is guaranteed to be in a consistent state if the cook fails. 3816 */ 3817 assert(lp->dn_kind == DT_NODE_VAR); 3818 assert(lp->dn_args == NULL); 3819 3820 lnp = dnp->dn_link; 3821 bcopy(lp, dnp, sizeof (dt_node_t)); 3822 dnp->dn_link = lnp; 3823 3824 dnp->dn_args = rp; 3825 dnp->dn_list = NULL; 3826 3827 dt_node_free(lp); 3828 return (dt_node_cook(dnp, idflags)); 3829 } 3830 3831 case DT_TOK_XLATE: { 3832 dt_xlator_t *dxp; 3833 3834 assert(lp->dn_kind == DT_NODE_TYPE); 3835 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3836 dxp = dt_xlator_lookup(dtp, rp, lp, DT_XLATE_FUZZY); 3837 3838 if (dxp == NULL) { 3839 xyerror(D_XLATE_NONE, 3840 "cannot translate from \"%s\" to \"%s\"\n", 3841 dt_node_type_name(rp, n1, sizeof (n1)), 3842 dt_node_type_name(lp, n2, sizeof (n2))); 3843 } 3844 3845 dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type); 3846 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 3847 dt_node_attr_assign(dnp, 3848 dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr)); 3849 break; 3850 } 3851 3852 case DT_TOK_LPAR: { 3853 ctf_id_t ltype, rtype; 3854 uint_t lkind, rkind; 3855 3856 assert(lp->dn_kind == DT_NODE_TYPE); 3857 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3858 3859 ltype = ctf_type_resolve(lp->dn_ctfp, lp->dn_type); 3860 lkind = ctf_type_kind(lp->dn_ctfp, ltype); 3861 3862 rtype = ctf_type_resolve(rp->dn_ctfp, rp->dn_type); 3863 rkind = ctf_type_kind(rp->dn_ctfp, rtype); 3864 3865 /* 3866 * The rules for casting are loosely explained in K&R[A7.5] 3867 * and K&R[A6]. Basically, we can cast to the same type or 3868 * same base type, between any kind of scalar values, from 3869 * arrays to pointers, and we can cast anything to void. 3870 * To these rules D adds casts from scalars to strings. 3871 */ 3872 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 3873 rp->dn_ctfp, rp->dn_type)) 3874 /*EMPTY*/; 3875 else if (dt_node_is_scalar(lp) && 3876 (dt_node_is_scalar(rp) || rkind == CTF_K_FUNCTION)) 3877 /*EMPTY*/; 3878 else if (dt_node_is_void(lp)) 3879 /*EMPTY*/; 3880 else if (lkind == CTF_K_POINTER && dt_node_is_pointer(rp)) 3881 /*EMPTY*/; 3882 else if (dt_node_is_string(lp) && (dt_node_is_scalar(rp) || 3883 dt_node_is_pointer(rp) || dt_node_is_strcompat(rp))) 3884 /*EMPTY*/; 3885 else { 3886 xyerror(D_CAST_INVAL, 3887 "invalid cast expression: \"%s\" to \"%s\"\n", 3888 dt_node_type_name(rp, n1, sizeof (n1)), 3889 dt_node_type_name(lp, n2, sizeof (n2))); 3890 } 3891 3892 dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */ 3893 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3894 3895 /* 3896 * If it's a pointer then should be able to (attempt to) 3897 * assign to it. 3898 */ 3899 if (lkind == CTF_K_POINTER) 3900 dnp->dn_flags |= DT_NF_WRITABLE; 3901 3902 break; 3903 } 3904 3905 case DT_TOK_COMMA: 3906 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF); 3907 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF); 3908 3909 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) { 3910 xyerror(D_OP_DYN, "operator %s operands " 3911 "cannot be of dynamic type\n", opstr(op)); 3912 } 3913 3914 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) { 3915 xyerror(D_OP_ACT, "operator %s operands " 3916 "cannot be actions\n", opstr(op)); 3917 } 3918 3919 dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */ 3920 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr)); 3921 break; 3922 3923 default: 3924 xyerror(D_UNKNOWN, "invalid binary op %s\n", opstr(op)); 3925 } 3926 3927 /* 3928 * Complete the conversion of E1[E2] to *((E1)+(E2)) that we started 3929 * at the top of our switch() above (see K&R[A7.3.1]). Since E2 is 3930 * parsed as an argument_expression_list by dt_grammar.y, we can 3931 * end up with a comma-separated list inside of a non-associative 3932 * array reference. We check for this and report an appropriate error. 3933 */ 3934 if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) { 3935 dt_node_t *pnp; 3936 3937 if (rp->dn_list != NULL) { 3938 xyerror(D_ARR_BADREF, 3939 "cannot access %s as an associative array\n", 3940 dt_node_name(lp, n1, sizeof (n1))); 3941 } 3942 3943 dnp->dn_op = DT_TOK_ADD; 3944 pnp = dt_node_op1(DT_TOK_DEREF, dnp); 3945 3946 /* 3947 * Cook callbacks are not typically permitted to allocate nodes. 3948 * When we do, we must insert them in the middle of an existing 3949 * allocation list rather than having them appended to the pcb 3950 * list because the sub-expression may be part of a definition. 3951 */ 3952 assert(yypcb->pcb_list == pnp); 3953 yypcb->pcb_list = pnp->dn_link; 3954 3955 pnp->dn_link = dnp->dn_link; 3956 dnp->dn_link = pnp; 3957 3958 return (dt_node_cook(pnp, DT_IDFLG_REF)); 3959 } 3960 3961 return (dnp); 3962 } 3963 3964 /*ARGSUSED*/ 3965 static dt_node_t * 3966 dt_cook_op3(dt_node_t *dnp, uint_t idflags) 3967 { 3968 dt_node_t *lp, *rp; 3969 ctf_file_t *ctfp; 3970 ctf_id_t type; 3971 3972 dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF); 3973 lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF); 3974 rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF); 3975 3976 if (!dt_node_is_scalar(dnp->dn_expr)) { 3977 xyerror(D_OP_SCALAR, 3978 "operator ?: expression must be of scalar type\n"); 3979 } 3980 3981 if (dt_node_is_dynamic(lp) || dt_node_is_dynamic(rp)) { 3982 xyerror(D_OP_DYN, 3983 "operator ?: operands cannot be of dynamic type\n"); 3984 } 3985 3986 /* 3987 * The rules for type checking for the ternary operator are complex and 3988 * are described in the ANSI-C spec (see K&R[A7.16]). We implement 3989 * the various tests in order from least to most expensive. 3990 */ 3991 if (ctf_type_compat(lp->dn_ctfp, lp->dn_type, 3992 rp->dn_ctfp, rp->dn_type)) { 3993 ctfp = lp->dn_ctfp; 3994 type = lp->dn_type; 3995 } else if (dt_node_is_integer(lp) && dt_node_is_integer(rp)) { 3996 dt_type_promote(lp, rp, &ctfp, &type); 3997 } else if (dt_node_is_strcompat(lp) && dt_node_is_strcompat(rp) && 3998 (dt_node_is_string(lp) || dt_node_is_string(rp))) { 3999 ctfp = DT_STR_CTFP(yypcb->pcb_hdl); 4000 type = DT_STR_TYPE(yypcb->pcb_hdl); 4001 } else if (dt_node_is_ptrcompat(lp, rp, &ctfp, &type) == 0) { 4002 xyerror(D_OP_INCOMPAT, 4003 "operator ?: operands must have compatible types\n"); 4004 } 4005 4006 if (dt_node_is_actfunc(lp) || dt_node_is_actfunc(rp)) { 4007 xyerror(D_OP_ACT, "action cannot be " 4008 "used in a conditional context\n"); 4009 } 4010 4011 dt_node_type_assign(dnp, ctfp, type); 4012 dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr, 4013 dt_attr_min(lp->dn_attr, rp->dn_attr))); 4014 4015 return (dnp); 4016 } 4017 4018 static dt_node_t * 4019 dt_cook_statement(dt_node_t *dnp, uint_t idflags) 4020 { 4021 dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags); 4022 dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr); 4023 4024 return (dnp); 4025 } 4026 4027 /* 4028 * If dn_aggfun is set, this node is a collapsed aggregation assignment (see 4029 * the special case code for DT_TOK_ASGN in dt_cook_op2() above), in which 4030 * case we cook both the tuple and the function call. If dn_aggfun is NULL, 4031 * this node is just a reference to the aggregation's type and attributes. 4032 */ 4033 /*ARGSUSED*/ 4034 static dt_node_t * 4035 dt_cook_aggregation(dt_node_t *dnp, uint_t idflags) 4036 { 4037 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 4038 4039 if (dnp->dn_aggfun != NULL) { 4040 dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF); 4041 dt_node_attr_assign(dnp, dt_ident_cook(dnp, 4042 dnp->dn_ident, &dnp->dn_aggtup)); 4043 } else { 4044 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 4045 dt_node_attr_assign(dnp, dnp->dn_ident->di_attr); 4046 } 4047 4048 return (dnp); 4049 } 4050 4051 /* 4052 * Since D permits new variable identifiers to be instantiated in any program 4053 * expression, we may need to cook a clause's predicate either before or after 4054 * the action list depending on the program code in question. Consider: 4055 * 4056 * probe-description-list probe-description-list 4057 * /x++/ /x == 0/ 4058 * { { 4059 * trace(x); trace(x++); 4060 * } } 4061 * 4062 * In the left-hand example, the predicate uses operator ++ to instantiate 'x' 4063 * as a variable of type int64_t. The predicate must be cooked first because 4064 * otherwise the statement trace(x) refers to an unknown identifier. In the 4065 * right-hand example, the action list uses ++ to instantiate 'x'; the action 4066 * list must be cooked first because otherwise the predicate x == 0 refers to 4067 * an unknown identifier. In order to simplify programming, we support both. 4068 * 4069 * When cooking a clause, we cook the action statements before the predicate by 4070 * default, since it seems more common to create or modify identifiers in the 4071 * action list. If cooking fails due to an unknown identifier, we attempt to 4072 * cook the predicate (i.e. do it first) and then go back and cook the actions. 4073 * If this, too, fails (or if we get an error other than D_IDENT_UNDEF) we give 4074 * up and report failure back to the user. There are five possible paths: 4075 * 4076 * cook actions = OK, cook predicate = OK -> OK 4077 * cook actions = OK, cook predicate = ERR -> ERR 4078 * cook actions = ERR, cook predicate = ERR -> ERR 4079 * cook actions = ERR, cook predicate = OK, cook actions = OK -> OK 4080 * cook actions = ERR, cook predicate = OK, cook actions = ERR -> ERR 4081 * 4082 * The programmer can still defeat our scheme by creating circular definition 4083 * dependencies between predicates and actions, as in this example clause: 4084 * 4085 * probe-description-list 4086 * /x++ && y == 0/ 4087 * { 4088 * trace(x + y++); 4089 * } 4090 * 4091 * but it doesn't seem worth the complexity to handle such rare cases. The 4092 * user can simply use the D variable declaration syntax to work around them. 4093 */ 4094 static dt_node_t * 4095 dt_cook_clause(dt_node_t *dnp, uint_t idflags) 4096 { 4097 volatile int err, tries; 4098 jmp_buf ojb; 4099 4100 /* 4101 * Before assigning dn_ctxattr, temporarily assign the probe attribute 4102 * to 'dnp' itself to force an attribute check and minimum violation. 4103 */ 4104 dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr); 4105 dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr; 4106 4107 bcopy(yypcb->pcb_jmpbuf, ojb, sizeof (jmp_buf)); 4108 tries = 0; 4109 4110 if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) { 4111 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf)); 4112 if (tries++ != 0 || err != EDT_COMPILER || ( 4113 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_IDENT_UNDEF) && 4114 yypcb->pcb_hdl->dt_errtag != dt_errtag(D_VAR_UNDEF))) 4115 longjmp(yypcb->pcb_jmpbuf, err); 4116 } 4117 4118 if (tries == 0) { 4119 yylabel("action list"); 4120 4121 dt_node_attr_assign(dnp, 4122 dt_node_list_cook(&dnp->dn_acts, idflags)); 4123 4124 bcopy(ojb, yypcb->pcb_jmpbuf, sizeof (jmp_buf)); 4125 yylabel(NULL); 4126 } 4127 4128 if (dnp->dn_pred != NULL) { 4129 yylabel("predicate"); 4130 4131 dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags); 4132 dt_node_attr_assign(dnp, 4133 dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr)); 4134 4135 if (!dt_node_is_scalar(dnp->dn_pred)) { 4136 xyerror(D_PRED_SCALAR, 4137 "predicate result must be of scalar type\n"); 4138 } 4139 4140 yylabel(NULL); 4141 } 4142 4143 if (tries != 0) { 4144 yylabel("action list"); 4145 4146 dt_node_attr_assign(dnp, 4147 dt_node_list_cook(&dnp->dn_acts, idflags)); 4148 4149 yylabel(NULL); 4150 } 4151 4152 return (dnp); 4153 } 4154 4155 /*ARGSUSED*/ 4156 static dt_node_t * 4157 dt_cook_inline(dt_node_t *dnp, uint_t idflags) 4158 { 4159 dt_idnode_t *inp = dnp->dn_ident->di_iarg; 4160 dt_ident_t *rdp; 4161 4162 char n1[DT_TYPE_NAMELEN]; 4163 char n2[DT_TYPE_NAMELEN]; 4164 4165 assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE); 4166 assert(inp->din_root->dn_flags & DT_NF_COOKED); 4167 4168 /* 4169 * If we are inlining a translation, verify that the inline declaration 4170 * type exactly matches the type that is returned by the translation. 4171 * Otherwise just use dt_node_is_argcompat() to check the types. 4172 */ 4173 if ((rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLSOU)) != NULL || 4174 (rdp = dt_node_resolve(inp->din_root, DT_IDENT_XLPTR)) != NULL) { 4175 4176 ctf_file_t *lctfp = dnp->dn_ctfp; 4177 ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type); 4178 4179 dt_xlator_t *dxp = rdp->di_data; 4180 ctf_file_t *rctfp = dxp->dx_dst_ctfp; 4181 ctf_id_t rtype = dxp->dx_dst_base; 4182 4183 if (ctf_type_kind(lctfp, ltype) == CTF_K_POINTER) { 4184 ltype = ctf_type_reference(lctfp, ltype); 4185 ltype = ctf_type_resolve(lctfp, ltype); 4186 } 4187 4188 if (ctf_type_compat(lctfp, ltype, rctfp, rtype) == 0) { 4189 dnerror(dnp, D_OP_INCOMPAT, 4190 "inline %s definition uses incompatible types: " 4191 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name, 4192 dt_type_name(lctfp, ltype, n1, sizeof (n1)), 4193 dt_type_name(rctfp, rtype, n2, sizeof (n2))); 4194 } 4195 4196 } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) { 4197 dnerror(dnp, D_OP_INCOMPAT, 4198 "inline %s definition uses incompatible types: " 4199 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name, 4200 dt_node_type_name(dnp, n1, sizeof (n1)), 4201 dt_node_type_name(inp->din_root, n2, sizeof (n2))); 4202 } 4203 4204 return (dnp); 4205 } 4206 4207 static dt_node_t * 4208 dt_cook_member(dt_node_t *dnp, uint_t idflags) 4209 { 4210 dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags); 4211 dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr); 4212 return (dnp); 4213 } 4214 4215 /*ARGSUSED*/ 4216 static dt_node_t * 4217 dt_cook_xlator(dt_node_t *dnp, uint_t idflags) 4218 { 4219 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 4220 dt_xlator_t *dxp = dnp->dn_xlator; 4221 dt_node_t *mnp; 4222 4223 char n1[DT_TYPE_NAMELEN]; 4224 char n2[DT_TYPE_NAMELEN]; 4225 4226 dtrace_attribute_t attr = _dtrace_maxattr; 4227 ctf_membinfo_t ctm; 4228 4229 /* 4230 * Before cooking each translator member, we push a reference to the 4231 * hash containing translator-local identifiers on to pcb_globals to 4232 * temporarily interpose these identifiers in front of other globals. 4233 */ 4234 dt_idstack_push(&yypcb->pcb_globals, dxp->dx_locals); 4235 4236 for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) { 4237 if (ctf_member_info(dxp->dx_dst_ctfp, dxp->dx_dst_type, 4238 mnp->dn_membname, &ctm) == CTF_ERR) { 4239 xyerror(D_XLATE_MEMB, 4240 "translator member %s is not a member of %s\n", 4241 mnp->dn_membname, ctf_type_name(dxp->dx_dst_ctfp, 4242 dxp->dx_dst_type, n1, sizeof (n1))); 4243 } 4244 4245 (void) dt_node_cook(mnp, DT_IDFLG_REF); 4246 dt_node_type_assign(mnp, dxp->dx_dst_ctfp, ctm.ctm_type); 4247 attr = dt_attr_min(attr, mnp->dn_attr); 4248 4249 if (dt_node_is_argcompat(mnp, mnp->dn_membexpr) == 0) { 4250 xyerror(D_XLATE_INCOMPAT, 4251 "translator member %s definition uses " 4252 "incompatible types: \"%s\" = \"%s\"\n", 4253 mnp->dn_membname, 4254 dt_node_type_name(mnp, n1, sizeof (n1)), 4255 dt_node_type_name(mnp->dn_membexpr, 4256 n2, sizeof (n2))); 4257 } 4258 } 4259 4260 dt_idstack_pop(&yypcb->pcb_globals, dxp->dx_locals); 4261 4262 dxp->dx_souid.di_attr = attr; 4263 dxp->dx_ptrid.di_attr = attr; 4264 4265 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp)); 4266 dt_node_attr_assign(dnp, _dtrace_defattr); 4267 4268 return (dnp); 4269 } 4270 4271 static void 4272 dt_node_provider_cmp_argv(dt_provider_t *pvp, dt_node_t *pnp, const char *kind, 4273 uint_t old_argc, dt_node_t *old_argv, uint_t new_argc, dt_node_t *new_argv) 4274 { 4275 dt_probe_t *prp = pnp->dn_ident->di_data; 4276 uint_t i; 4277 4278 char n1[DT_TYPE_NAMELEN]; 4279 char n2[DT_TYPE_NAMELEN]; 4280 4281 if (old_argc != new_argc) { 4282 dnerror(pnp, D_PROV_INCOMPAT, 4283 "probe %s:%s %s prototype mismatch:\n" 4284 "\t current: %u arg%s\n\tprevious: %u arg%s\n", 4285 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, 4286 new_argc, new_argc != 1 ? "s" : "", 4287 old_argc, old_argc != 1 ? "s" : ""); 4288 } 4289 4290 for (i = 0; i < old_argc; i++, 4291 old_argv = old_argv->dn_list, new_argv = new_argv->dn_list) { 4292 if (ctf_type_cmp(old_argv->dn_ctfp, old_argv->dn_type, 4293 new_argv->dn_ctfp, new_argv->dn_type) == 0) 4294 continue; 4295 4296 dnerror(pnp, D_PROV_INCOMPAT, 4297 "probe %s:%s %s prototype argument #%u mismatch:\n" 4298 "\t current: %s\n\tprevious: %s\n", 4299 pvp->pv_desc.dtvd_name, prp->pr_ident->di_name, kind, i + 1, 4300 dt_node_type_name(new_argv, n1, sizeof (n1)), 4301 dt_node_type_name(old_argv, n2, sizeof (n2))); 4302 } 4303 } 4304 4305 /* 4306 * Compare a new probe declaration with an existing probe definition (either 4307 * from a previous declaration or cached from the kernel). If the existing 4308 * definition and declaration both have an input and output parameter list, 4309 * compare both lists. Otherwise compare only the output parameter lists. 4310 */ 4311 static void 4312 dt_node_provider_cmp(dt_provider_t *pvp, dt_node_t *pnp, 4313 dt_probe_t *old, dt_probe_t *new) 4314 { 4315 dt_node_provider_cmp_argv(pvp, pnp, "output", 4316 old->pr_xargc, old->pr_xargs, new->pr_xargc, new->pr_xargs); 4317 4318 if (old->pr_nargs != old->pr_xargs && new->pr_nargs != new->pr_xargs) { 4319 dt_node_provider_cmp_argv(pvp, pnp, "input", 4320 old->pr_nargc, old->pr_nargs, new->pr_nargc, new->pr_nargs); 4321 } 4322 4323 if (old->pr_nargs == old->pr_xargs && new->pr_nargs != new->pr_xargs) { 4324 if (pvp->pv_flags & DT_PROVIDER_IMPL) { 4325 dnerror(pnp, D_PROV_INCOMPAT, 4326 "provider interface mismatch: %s\n" 4327 "\t current: probe %s:%s has an output prototype\n" 4328 "\tprevious: probe %s:%s has no output prototype\n", 4329 pvp->pv_desc.dtvd_name, pvp->pv_desc.dtvd_name, 4330 new->pr_ident->di_name, pvp->pv_desc.dtvd_name, 4331 old->pr_ident->di_name); 4332 } 4333 4334 if (old->pr_ident->di_gen == yypcb->pcb_hdl->dt_gen) 4335 old->pr_ident->di_flags |= DT_IDFLG_ORPHAN; 4336 4337 dt_idhash_delete(pvp->pv_probes, old->pr_ident); 4338 dt_probe_declare(pvp, new); 4339 } 4340 } 4341 4342 static void 4343 dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp) 4344 { 4345 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 4346 dt_probe_t *prp = dnp->dn_ident->di_data; 4347 4348 dt_xlator_t *dxp; 4349 uint_t i; 4350 4351 char n1[DT_TYPE_NAMELEN]; 4352 char n2[DT_TYPE_NAMELEN]; 4353 4354 if (prp->pr_nargs == prp->pr_xargs) 4355 return; 4356 4357 for (i = 0; i < prp->pr_xargc; i++) { 4358 dt_node_t *xnp = prp->pr_xargv[i]; 4359 dt_node_t *nnp = prp->pr_nargv[prp->pr_mapping[i]]; 4360 4361 if ((dxp = dt_xlator_lookup(dtp, 4362 nnp, xnp, DT_XLATE_FUZZY)) != NULL) { 4363 if (dt_provider_xref(dtp, pvp, dxp->dx_id) != 0) 4364 longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM); 4365 continue; 4366 } 4367 4368 if (dt_node_is_argcompat(nnp, xnp)) 4369 continue; /* no translator defined and none required */ 4370 4371 dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output " 4372 "argument #%u from %s to %s is not defined\n", 4373 pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1, 4374 dt_node_type_name(nnp, n1, sizeof (n1)), 4375 dt_node_type_name(xnp, n2, sizeof (n2))); 4376 } 4377 } 4378 4379 /*ARGSUSED*/ 4380 static dt_node_t * 4381 dt_cook_provider(dt_node_t *dnp, uint_t idflags) 4382 { 4383 dt_provider_t *pvp = dnp->dn_provider; 4384 dt_node_t *pnp; 4385 4386 /* 4387 * If we're declaring a provider for the first time and it is unknown 4388 * to dtrace(7D), insert the probe definitions into the provider's hash. 4389 * If we're redeclaring a known provider, verify the interface matches. 4390 */ 4391 for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) { 4392 const char *probename = pnp->dn_ident->di_name; 4393 dt_probe_t *prp = dt_probe_lookup(pvp, probename); 4394 4395 assert(pnp->dn_kind == DT_NODE_PROBE); 4396 4397 if (prp != NULL && dnp->dn_provred) { 4398 dt_node_provider_cmp(pvp, pnp, 4399 prp, pnp->dn_ident->di_data); 4400 } else if (prp == NULL && dnp->dn_provred) { 4401 dnerror(pnp, D_PROV_INCOMPAT, 4402 "provider interface mismatch: %s\n" 4403 "\t current: probe %s:%s defined\n" 4404 "\tprevious: probe %s:%s not defined\n", 4405 dnp->dn_provname, dnp->dn_provname, 4406 probename, dnp->dn_provname, probename); 4407 } else if (prp != NULL) { 4408 dnerror(pnp, D_PROV_PRDUP, "probe redeclared: %s:%s\n", 4409 dnp->dn_provname, probename); 4410 } else 4411 dt_probe_declare(pvp, pnp->dn_ident->di_data); 4412 4413 dt_cook_probe(pnp, pvp); 4414 } 4415 4416 return (dnp); 4417 } 4418 4419 /*ARGSUSED*/ 4420 static dt_node_t * 4421 dt_cook_none(dt_node_t *dnp, uint_t idflags) 4422 { 4423 return (dnp); 4424 } 4425 4426 static dt_node_t *(*dt_cook_funcs[])(dt_node_t *, uint_t) = { 4427 dt_cook_none, /* DT_NODE_FREE */ 4428 dt_cook_none, /* DT_NODE_INT */ 4429 dt_cook_none, /* DT_NODE_STRING */ 4430 dt_cook_ident, /* DT_NODE_IDENT */ 4431 dt_cook_var, /* DT_NODE_VAR */ 4432 dt_cook_none, /* DT_NODE_SYM */ 4433 dt_cook_none, /* DT_NODE_TYPE */ 4434 dt_cook_func, /* DT_NODE_FUNC */ 4435 dt_cook_op1, /* DT_NODE_OP1 */ 4436 dt_cook_op2, /* DT_NODE_OP2 */ 4437 dt_cook_op3, /* DT_NODE_OP3 */ 4438 dt_cook_statement, /* DT_NODE_DEXPR */ 4439 dt_cook_statement, /* DT_NODE_DFUNC */ 4440 dt_cook_aggregation, /* DT_NODE_AGG */ 4441 dt_cook_none, /* DT_NODE_PDESC */ 4442 dt_cook_clause, /* DT_NODE_CLAUSE */ 4443 dt_cook_inline, /* DT_NODE_INLINE */ 4444 dt_cook_member, /* DT_NODE_MEMBER */ 4445 dt_cook_xlator, /* DT_NODE_XLATOR */ 4446 dt_cook_none, /* DT_NODE_PROBE */ 4447 dt_cook_provider, /* DT_NODE_PROVIDER */ 4448 dt_cook_none /* DT_NODE_PROG */ 4449 }; 4450 4451 /* 4452 * Recursively cook the parse tree starting at the specified node. The idflags 4453 * parameter is used to indicate the type of reference (r/w) and is applied to 4454 * the resulting identifier if it is a D variable or D aggregation. 4455 */ 4456 dt_node_t * 4457 dt_node_cook(dt_node_t *dnp, uint_t idflags) 4458 { 4459 int oldlineno = yylineno; 4460 4461 yylineno = dnp->dn_line; 4462 4463 dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags); 4464 dnp->dn_flags |= DT_NF_COOKED; 4465 4466 if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG) 4467 dnp->dn_ident->di_flags |= idflags; 4468 4469 yylineno = oldlineno; 4470 return (dnp); 4471 } 4472 4473 dtrace_attribute_t 4474 dt_node_list_cook(dt_node_t **pnp, uint_t idflags) 4475 { 4476 dtrace_attribute_t attr = _dtrace_defattr; 4477 dt_node_t *dnp, *nnp; 4478 4479 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 4480 nnp = dnp->dn_list; 4481 dnp = *pnp = dt_node_cook(dnp, idflags); 4482 attr = dt_attr_min(attr, dnp->dn_attr); 4483 dnp->dn_list = nnp; 4484 pnp = &dnp->dn_list; 4485 } 4486 4487 return (attr); 4488 } 4489 4490 void 4491 dt_node_list_free(dt_node_t **pnp) 4492 { 4493 dt_node_t *dnp, *nnp; 4494 4495 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 4496 nnp = dnp->dn_list; 4497 dt_node_free(dnp); 4498 } 4499 4500 if (pnp != NULL) 4501 *pnp = NULL; 4502 } 4503 4504 void 4505 dt_node_link_free(dt_node_t **pnp) 4506 { 4507 dt_node_t *dnp, *nnp; 4508 4509 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 4510 nnp = dnp->dn_link; 4511 dt_node_free(dnp); 4512 } 4513 4514 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) { 4515 nnp = dnp->dn_link; 4516 free(dnp); 4517 } 4518 4519 if (pnp != NULL) 4520 *pnp = NULL; 4521 } 4522 4523 dt_node_t * 4524 dt_node_link(dt_node_t *lp, dt_node_t *rp) 4525 { 4526 dt_node_t *dnp; 4527 4528 if (lp == NULL) 4529 return (rp); 4530 else if (rp == NULL) 4531 return (lp); 4532 4533 for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list) 4534 continue; 4535 4536 dnp->dn_list = rp; 4537 return (lp); 4538 } 4539 4540 /* 4541 * Compute the DOF dtrace_diftype_t representation of a node's type. This is 4542 * called from a variety of places in the library so it cannot assume yypcb 4543 * is valid: any references to handle-specific data must be made through 'dtp'. 4544 */ 4545 void 4546 dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp) 4547 { 4548 if (dnp->dn_ctfp == DT_STR_CTFP(dtp) && 4549 dnp->dn_type == DT_STR_TYPE(dtp)) { 4550 tp->dtdt_kind = DIF_TYPE_STRING; 4551 tp->dtdt_ckind = CTF_K_UNKNOWN; 4552 } else { 4553 tp->dtdt_kind = DIF_TYPE_CTF; 4554 tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp, 4555 ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type)); 4556 } 4557 4558 tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ? DIF_TF_BYREF : 0; 4559 tp->dtdt_pad = 0; 4560 tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type); 4561 } 4562 4563 void 4564 dt_node_printr(dt_node_t *dnp, FILE *fp, int depth) 4565 { 4566 char n[DT_TYPE_NAMELEN], buf[BUFSIZ], a[8]; 4567 const dtrace_syminfo_t *dts; 4568 const dt_idnode_t *inp; 4569 dt_node_t *arg; 4570 4571 (void) fprintf(fp, "%*s", depth * 2, ""); 4572 (void) dt_attr_str(dnp->dn_attr, a, sizeof (a)); 4573 4574 if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR && 4575 ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) { 4576 (void) snprintf(buf, BUFSIZ, "type=<%s> attr=%s flags=", n, a); 4577 } else { 4578 (void) snprintf(buf, BUFSIZ, "type=<%ld> attr=%s flags=", 4579 dnp->dn_type, a); 4580 } 4581 4582 if (dnp->dn_flags != 0) { 4583 n[0] = '\0'; 4584 if (dnp->dn_flags & DT_NF_SIGNED) 4585 (void) strcat(n, ",SIGN"); 4586 if (dnp->dn_flags & DT_NF_COOKED) 4587 (void) strcat(n, ",COOK"); 4588 if (dnp->dn_flags & DT_NF_REF) 4589 (void) strcat(n, ",REF"); 4590 if (dnp->dn_flags & DT_NF_LVALUE) 4591 (void) strcat(n, ",LVAL"); 4592 if (dnp->dn_flags & DT_NF_WRITABLE) 4593 (void) strcat(n, ",WRITE"); 4594 if (dnp->dn_flags & DT_NF_BITFIELD) 4595 (void) strcat(n, ",BITF"); 4596 if (dnp->dn_flags & DT_NF_USERLAND) 4597 (void) strcat(n, ",USER"); 4598 (void) strcat(buf, n + 1); 4599 } else 4600 (void) strcat(buf, "0"); 4601 4602 switch (dnp->dn_kind) { 4603 case DT_NODE_FREE: 4604 (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp); 4605 break; 4606 4607 case DT_NODE_INT: 4608 (void) fprintf(fp, "INT 0x%llx (%s)\n", 4609 (u_longlong_t)dnp->dn_value, buf); 4610 break; 4611 4612 case DT_NODE_STRING: 4613 (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf); 4614 break; 4615 4616 case DT_NODE_IDENT: 4617 (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf); 4618 break; 4619 4620 case DT_NODE_VAR: 4621 (void) fprintf(fp, "VARIABLE %s%s (%s)\n", 4622 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" : 4623 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "", 4624 dnp->dn_ident->di_name, buf); 4625 4626 if (dnp->dn_args != NULL) 4627 (void) fprintf(fp, "%*s[\n", depth * 2, ""); 4628 4629 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) { 4630 dt_node_printr(arg, fp, depth + 1); 4631 if (arg->dn_list != NULL) 4632 (void) fprintf(fp, "%*s,\n", depth * 2, ""); 4633 } 4634 4635 if (dnp->dn_args != NULL) 4636 (void) fprintf(fp, "%*s]\n", depth * 2, ""); 4637 break; 4638 4639 case DT_NODE_SYM: 4640 dts = dnp->dn_ident->di_data; 4641 (void) fprintf(fp, "SYMBOL %s`%s (%s)\n", 4642 dts->dts_object, dts->dts_name, buf); 4643 break; 4644 4645 case DT_NODE_TYPE: 4646 if (dnp->dn_string != NULL) { 4647 (void) fprintf(fp, "TYPE (%s) %s\n", 4648 buf, dnp->dn_string); 4649 } else 4650 (void) fprintf(fp, "TYPE (%s)\n", buf); 4651 break; 4652 4653 case DT_NODE_FUNC: 4654 (void) fprintf(fp, "FUNC %s (%s)\n", 4655 dnp->dn_ident->di_name, buf); 4656 4657 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) { 4658 dt_node_printr(arg, fp, depth + 1); 4659 if (arg->dn_list != NULL) 4660 (void) fprintf(fp, "%*s,\n", depth * 2, ""); 4661 } 4662 break; 4663 4664 case DT_NODE_OP1: 4665 (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf); 4666 dt_node_printr(dnp->dn_child, fp, depth + 1); 4667 break; 4668 4669 case DT_NODE_OP2: 4670 (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf); 4671 dt_node_printr(dnp->dn_left, fp, depth + 1); 4672 dt_node_printr(dnp->dn_right, fp, depth + 1); 4673 break; 4674 4675 case DT_NODE_OP3: 4676 (void) fprintf(fp, "OP3 (%s)\n", buf); 4677 dt_node_printr(dnp->dn_expr, fp, depth + 1); 4678 (void) fprintf(fp, "%*s?\n", depth * 2, ""); 4679 dt_node_printr(dnp->dn_left, fp, depth + 1); 4680 (void) fprintf(fp, "%*s:\n", depth * 2, ""); 4681 dt_node_printr(dnp->dn_right, fp, depth + 1); 4682 break; 4683 4684 case DT_NODE_DEXPR: 4685 case DT_NODE_DFUNC: 4686 (void) fprintf(fp, "D EXPRESSION attr=%s\n", a); 4687 dt_node_printr(dnp->dn_expr, fp, depth + 1); 4688 break; 4689 4690 case DT_NODE_AGG: 4691 (void) fprintf(fp, "AGGREGATE @%s attr=%s [\n", 4692 dnp->dn_ident->di_name, a); 4693 4694 for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) { 4695 dt_node_printr(arg, fp, depth + 1); 4696 if (arg->dn_list != NULL) 4697 (void) fprintf(fp, "%*s,\n", depth * 2, ""); 4698 } 4699 4700 if (dnp->dn_aggfun) { 4701 (void) fprintf(fp, "%*s] = ", depth * 2, ""); 4702 dt_node_printr(dnp->dn_aggfun, fp, depth + 1); 4703 } else 4704 (void) fprintf(fp, "%*s]\n", depth * 2, ""); 4705 4706 if (dnp->dn_aggfun) 4707 (void) fprintf(fp, "%*s)\n", depth * 2, ""); 4708 break; 4709 4710 case DT_NODE_PDESC: 4711 (void) fprintf(fp, "PDESC %s:%s:%s:%s [%u]\n", 4712 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod, 4713 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name, 4714 dnp->dn_desc->dtpd_id); 4715 break; 4716 4717 case DT_NODE_CLAUSE: 4718 (void) fprintf(fp, "CLAUSE attr=%s\n", a); 4719 4720 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list) 4721 dt_node_printr(arg, fp, depth + 1); 4722 4723 (void) fprintf(fp, "%*sCTXATTR %s\n", depth * 2, "", 4724 dt_attr_str(dnp->dn_ctxattr, a, sizeof (a))); 4725 4726 if (dnp->dn_pred != NULL) { 4727 (void) fprintf(fp, "%*sPREDICATE /\n", depth * 2, ""); 4728 dt_node_printr(dnp->dn_pred, fp, depth + 1); 4729 (void) fprintf(fp, "%*s/\n", depth * 2, ""); 4730 } 4731 4732 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list) 4733 dt_node_printr(arg, fp, depth + 1); 4734 break; 4735 4736 case DT_NODE_INLINE: 4737 inp = dnp->dn_ident->di_iarg; 4738 4739 (void) fprintf(fp, "INLINE %s (%s)\n", 4740 dnp->dn_ident->di_name, buf); 4741 dt_node_printr(inp->din_root, fp, depth + 1); 4742 break; 4743 4744 case DT_NODE_MEMBER: 4745 (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf); 4746 if (dnp->dn_membexpr) 4747 dt_node_printr(dnp->dn_membexpr, fp, depth + 1); 4748 break; 4749 4750 case DT_NODE_XLATOR: 4751 (void) fprintf(fp, "XLATOR (%s)", buf); 4752 4753 if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp, 4754 dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL) 4755 (void) fprintf(fp, " from <%s>", n); 4756 4757 if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp, 4758 dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL) 4759 (void) fprintf(fp, " to <%s>", n); 4760 4761 (void) fprintf(fp, "\n"); 4762 4763 for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list) 4764 dt_node_printr(arg, fp, depth + 1); 4765 break; 4766 4767 case DT_NODE_PROBE: 4768 (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name); 4769 break; 4770 4771 case DT_NODE_PROVIDER: 4772 (void) fprintf(fp, "PROVIDER %s (%s)\n", 4773 dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl"); 4774 for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list) 4775 dt_node_printr(arg, fp, depth + 1); 4776 break; 4777 4778 case DT_NODE_PROG: 4779 (void) fprintf(fp, "PROGRAM attr=%s\n", a); 4780 for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list) 4781 dt_node_printr(arg, fp, depth + 1); 4782 break; 4783 4784 default: 4785 (void) fprintf(fp, "<bad node %p, kind %d>\n", 4786 (void *)dnp, dnp->dn_kind); 4787 } 4788 } 4789 4790 int 4791 dt_node_root(dt_node_t *dnp) 4792 { 4793 yypcb->pcb_root = dnp; 4794 return (0); 4795 } 4796 4797 /*PRINTFLIKE3*/ 4798 void 4799 dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...) 4800 { 4801 int oldlineno = yylineno; 4802 va_list ap; 4803 4804 yylineno = dnp->dn_line; 4805 4806 va_start(ap, format); 4807 xyvwarn(tag, format, ap); 4808 va_end(ap); 4809 4810 yylineno = oldlineno; 4811 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 4812 } 4813 4814 /*PRINTFLIKE3*/ 4815 void 4816 dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...) 4817 { 4818 int oldlineno = yylineno; 4819 va_list ap; 4820 4821 yylineno = dnp->dn_line; 4822 4823 va_start(ap, format); 4824 xyvwarn(tag, format, ap); 4825 va_end(ap); 4826 4827 yylineno = oldlineno; 4828 } 4829 4830 /*PRINTFLIKE2*/ 4831 void 4832 xyerror(dt_errtag_t tag, const char *format, ...) 4833 { 4834 va_list ap; 4835 4836 va_start(ap, format); 4837 xyvwarn(tag, format, ap); 4838 va_end(ap); 4839 4840 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 4841 } 4842 4843 /*PRINTFLIKE2*/ 4844 void 4845 xywarn(dt_errtag_t tag, const char *format, ...) 4846 { 4847 va_list ap; 4848 4849 va_start(ap, format); 4850 xyvwarn(tag, format, ap); 4851 va_end(ap); 4852 } 4853 4854 void 4855 xyvwarn(dt_errtag_t tag, const char *format, va_list ap) 4856 { 4857 if (yypcb == NULL) 4858 return; /* compiler is not currently active: act as a no-op */ 4859 4860 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(tag), yypcb->pcb_region, 4861 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap); 4862 } 4863 4864 /*PRINTFLIKE1*/ 4865 void 4866 yyerror(const char *format, ...) 4867 { 4868 va_list ap; 4869 4870 va_start(ap, format); 4871 yyvwarn(format, ap); 4872 va_end(ap); 4873 4874 longjmp(yypcb->pcb_jmpbuf, EDT_COMPILER); 4875 } 4876 4877 /*PRINTFLIKE1*/ 4878 void 4879 yywarn(const char *format, ...) 4880 { 4881 va_list ap; 4882 4883 va_start(ap, format); 4884 yyvwarn(format, ap); 4885 va_end(ap); 4886 } 4887 4888 void 4889 yyvwarn(const char *format, va_list ap) 4890 { 4891 if (yypcb == NULL) 4892 return; /* compiler is not currently active: act as a no-op */ 4893 4894 dt_set_errmsg(yypcb->pcb_hdl, dt_errtag(D_SYNTAX), yypcb->pcb_region, 4895 yypcb->pcb_filetag, yypcb->pcb_fileptr ? yylineno : 0, format, ap); 4896 4897 if (strchr(format, '\n') == NULL) { 4898 dtrace_hdl_t *dtp = yypcb->pcb_hdl; 4899 size_t len = strlen(dtp->dt_errmsg); 4900 char *p, *s = dtp->dt_errmsg + len; 4901 size_t n = sizeof (dtp->dt_errmsg) - len; 4902 4903 if (yytext[0] == '\0') 4904 (void) snprintf(s, n, " near end of input"); 4905 else if (yytext[0] == '\n') 4906 (void) snprintf(s, n, " near end of line"); 4907 else { 4908 if ((p = strchr(yytext, '\n')) != NULL) 4909 *p = '\0'; /* crop at newline */ 4910 (void) snprintf(s, n, " near \"%s\"", yytext); 4911 } 4912 } 4913 } 4914 4915 void 4916 yylabel(const char *label) 4917 { 4918 dt_dprintf("set label to <%s>\n", label ? label : "NULL"); 4919 yypcb->pcb_region = label; 4920 } 4921 4922 int 4923 yywrap(void) 4924 { 4925 return (1); /* indicate that lex should return a zero token for EOF */ 4926 } 4927