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