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