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