Lines Matching defs:dnp
407 dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp)
409 dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type);
410 dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type, B_FALSE);
411 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
415 dt_node_name(const dt_node_t *dnp, char *buf, size_t len)
424 switch (dnp->dn_kind) {
427 (u_longlong_t)dnp->dn_value);
430 s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
432 s != NULL ? s : dnp->dn_string);
436 (void) snprintf(buf, len, "identifier %s", dnp->dn_string);
442 switch (dnp->dn_ident->di_kind) {
453 dt_idkind_name(dnp->dn_ident->di_kind),
454 prefix, dnp->dn_ident->di_name, suffix);
457 dts = dnp->dn_ident->di_data;
463 dt_node_type_name(dnp, n1, sizeof (n1)));
468 (void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op));
472 if (dnp->dn_expr)
473 return (dt_node_name(dnp->dn_expr, buf, len));
477 if (dnp->dn_desc->dtpd_id == 0) {
480 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
481 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
484 dnp->dn_desc->dtpd_id);
491 (void) snprintf(buf, len, "member %s", dnp->dn_membname);
495 dt_type_name(dnp->dn_xlator->dx_dst_ctfp,
496 dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)),
497 dt_type_name(dnp->dn_xlator->dx_src_ctfp,
498 dnp->dn_xlator->dx_src_type, n2, sizeof (n2)));
504 (void) snprintf(buf, len, "node <%u>", dnp->dn_kind);
518 dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t));
520 if (dnp == NULL)
523 dnp->dn_ctfp = NULL;
524 dnp->dn_type = CTF_ERR;
525 dnp->dn_kind = (uchar_t)kind;
526 dnp->dn_flags = 0;
527 dnp->dn_op = 0;
528 dnp->dn_line = -1;
529 dnp->dn_reg = -1;
530 dnp->dn_attr = _dtrace_defattr;
531 dnp->dn_list = NULL;
532 dnp->dn_link = NULL;
533 bzero(&dnp->dn_u, sizeof (dnp->dn_u));
535 return (dnp);
547 dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind);
549 if (dnp == NULL)
552 dnp->dn_line = yylineno;
553 dnp->dn_link = yypcb->pcb_list;
554 yypcb->pcb_list = dnp;
556 return (dnp);
560 dt_node_free(dt_node_t *dnp)
562 uchar_t kind = dnp->dn_kind;
564 dnp->dn_kind = DT_NODE_FREE;
570 free(dnp->dn_string);
571 dnp->dn_string = NULL;
577 if (dnp->dn_ident != NULL) {
578 if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN)
579 dt_ident_destroy(dnp->dn_ident);
580 dnp->dn_ident = NULL;
582 dt_node_list_free(&dnp->dn_args);
586 if (dnp->dn_child != NULL) {
587 dt_node_free(dnp->dn_child);
588 dnp->dn_child = NULL;
593 if (dnp->dn_expr != NULL) {
594 dt_node_free(dnp->dn_expr);
595 dnp->dn_expr = NULL;
599 if (dnp->dn_left != NULL) {
600 dt_node_free(dnp->dn_left);
601 dnp->dn_left = NULL;
603 if (dnp->dn_right != NULL) {
604 dt_node_free(dnp->dn_right);
605 dnp->dn_right = NULL;
611 if (dnp->dn_expr != NULL) {
612 dt_node_free(dnp->dn_expr);
613 dnp->dn_expr = NULL;
618 if (dnp->dn_aggfun != NULL) {
619 dt_node_free(dnp->dn_aggfun);
620 dnp->dn_aggfun = NULL;
622 dt_node_list_free(&dnp->dn_aggtup);
626 free(dnp->dn_spec);
627 dnp->dn_spec = NULL;
628 free(dnp->dn_desc);
629 dnp->dn_desc = NULL;
633 if (dnp->dn_pred != NULL)
634 dt_node_free(dnp->dn_pred);
635 if (dnp->dn_locals != NULL)
636 dt_idhash_destroy(dnp->dn_locals);
637 dt_node_list_free(&dnp->dn_pdescs);
638 dt_node_list_free(&dnp->dn_acts);
642 free(dnp->dn_membname);
643 dnp->dn_membname = NULL;
644 if (dnp->dn_membexpr != NULL) {
645 dt_node_free(dnp->dn_membexpr);
646 dnp->dn_membexpr = NULL;
651 dt_node_list_free(&dnp->dn_probes);
652 free(dnp->dn_provname);
653 dnp->dn_provname = NULL;
657 dt_node_list_free(&dnp->dn_list);
663 dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr)
670 dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than "
671 "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)),
675 dnp->dn_attr = attr;
679 dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type,
686 dnp->dn_flags &=
693 dnp->dn_flags |= DT_NF_BITFIELD;
696 dnp->dn_flags |= DT_NF_SIGNED;
701 dnp->dn_flags |= DT_NF_REF;
707 dnp->dn_flags |= DT_NF_REF;
710 dnp->dn_flags |= DT_NF_REF;
713 dnp->dn_flags |= DT_NF_USERLAND;
715 dnp->dn_flags |= DT_NF_COOKED;
716 dnp->dn_ctfp = fp;
717 dnp->dn_type = type;
730 dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len)
732 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) {
734 dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind));
738 if (dnp->dn_flags & DT_NF_USERLAND) {
741 (void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len);
745 return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len));
749 dt_node_type_size(const dt_node_t *dnp)
754 if (dnp->dn_kind == DT_NODE_STRING)
755 return (strlen(dnp->dn_string) + 1);
757 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL)
758 return (dt_ident_size(dnp->dn_ident));
760 base = ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type);
762 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_FORWARD)
773 if (ctf_type_kind(dnp->dn_ctfp, base) == CTF_K_POINTER &&
774 ctf_getmodel(dnp->dn_ctfp) == CTF_MODEL_ILP32 &&
775 !(dnp->dn_flags & DT_NF_USERLAND) &&
779 return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type));
788 dt_node_resolve(const dt_node_t *dnp, uint_t idkind)
792 switch (dnp->dn_kind) {
799 idp = dt_ident_resolve(dnp->dn_ident);
803 if (dt_node_is_dynamic(dnp)) {
804 idp = dt_ident_resolve(dnp->dn_ident);
812 dt_node_sizeof(const dt_node_t *dnp)
827 if (dnp->dn_kind != DT_NODE_SYM)
828 return (dt_node_type_size(dnp));
830 sip = dnp->dn_ident->di_data;
840 dt_node_is_integer(const dt_node_t *dnp)
842 ctf_file_t *fp = dnp->dn_ctfp;
847 assert(dnp->dn_flags & DT_NF_COOKED);
849 type = ctf_type_resolve(fp, dnp->dn_type);
860 dt_node_is_float(const dt_node_t *dnp)
862 ctf_file_t *fp = dnp->dn_ctfp;
867 assert(dnp->dn_flags & DT_NF_COOKED);
869 type = ctf_type_resolve(fp, dnp->dn_type);
873 ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && (
879 dt_node_is_scalar(const dt_node_t *dnp)
881 ctf_file_t *fp = dnp->dn_ctfp;
886 assert(dnp->dn_flags & DT_NF_COOKED);
888 type = ctf_type_resolve(fp, dnp->dn_type);
900 dt_node_is_arith(const dt_node_t *dnp)
902 ctf_file_t *fp = dnp->dn_ctfp;
907 assert(dnp->dn_flags & DT_NF_COOKED);
909 type = ctf_type_resolve(fp, dnp->dn_type);
919 dt_node_is_vfptr(const dt_node_t *dnp)
921 ctf_file_t *fp = dnp->dn_ctfp;
926 assert(dnp->dn_flags & DT_NF_COOKED);
928 type = ctf_type_resolve(fp, dnp->dn_type);
940 dt_node_is_dynamic(const dt_node_t *dnp)
942 if (dnp->dn_kind == DT_NODE_VAR &&
943 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
944 const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
948 return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
949 dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl));
953 dt_node_is_string(const dt_node_t *dnp)
955 return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) &&
956 dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl));
960 dt_node_is_stack(const dt_node_t *dnp)
962 return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) &&
963 dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl));
967 dt_node_is_symaddr(const dt_node_t *dnp)
969 return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) &&
970 dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl));
974 dt_node_is_usymaddr(const dt_node_t *dnp)
976 return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) &&
977 dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl));
981 dt_node_is_strcompat(const dt_node_t *dnp)
983 ctf_file_t *fp = dnp->dn_ctfp;
989 assert(dnp->dn_flags & DT_NF_COOKED);
991 base = ctf_type_resolve(fp, dnp->dn_type);
1009 dt_node_is_pointer(const dt_node_t *dnp)
1011 ctf_file_t *fp = dnp->dn_ctfp;
1014 assert(dnp->dn_flags & DT_NF_COOKED);
1016 if (dt_node_is_string(dnp))
1019 kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type));
1024 dt_node_is_void(const dt_node_t *dnp)
1026 ctf_file_t *fp = dnp->dn_ctfp;
1030 if (dt_node_is_dynamic(dnp))
1033 if (dt_node_is_stack(dnp))
1036 if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp))
1039 type = ctf_type_resolve(fp, dnp->dn_type);
1219 dt_node_is_posconst(const dt_node_t *dnp)
1221 return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && (
1222 (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0));
1226 dt_node_is_actfunc(const dt_node_t *dnp)
1228 return (dnp->dn_kind == DT_NODE_FUNC &&
1229 dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC);
1265 dt_node_t *dnp = dt_node_alloc(DT_NODE_INT);
1274 dnp->dn_op = DT_TOK_INT;
1275 dnp->dn_value = value;
1286 dt_node_type_assign(dnp,
1296 return (dt_node_op1(DT_TOK_IPOS, dnp));
1298 return (dt_node_op1(DT_TOK_INEG, dnp));
1300 return (dnp);
1315 dt_node_t *dnp;
1320 dnp = dt_node_alloc(DT_NODE_STRING);
1321 dnp->dn_op = DT_TOK_STRING;
1322 dnp->dn_string = string;
1323 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp), B_FALSE);
1325 return (dnp);
1332 dt_node_t *dnp;
1351 dnp = dt_node_alloc(DT_NODE_INT);
1352 dnp->dn_op = DT_TOK_INT;
1353 dnp->dn_value = inp->din_root->dn_value;
1354 dt_node_type_propagate(inp->din_root, dnp);
1356 return (dnp);
1360 dnp = dt_node_alloc(DT_NODE_IDENT);
1361 dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT;
1362 dnp->dn_string = name;
1364 return (dnp);
1377 dt_node_t *dnp;
1396 dnp = dt_node_alloc(DT_NODE_TYPE);
1397 dnp->dn_op = DT_TOK_IDENT;
1398 dnp->dn_string = name;
1400 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, dtt.dtt_flags);
1404 dt_node_attr_assign(dnp, _dtrace_defattr);
1406 dt_node_attr_assign(dnp, _dtrace_typattr);
1408 return (dnp);
1418 dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE);
1420 dnp->dn_op = DT_TOK_IDENT;
1421 dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
1422 dnp->dn_type = CTF_ERR;
1423 dnp->dn_attr = _dtrace_defattr;
1425 return (dnp);
1673 dt_node_t *dnp = ddp->dd_node;
1676 for (; dnp != NULL; dnp = dnp->dn_list, argc++) {
1682 if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type,
1692 dt_node_type_name(dnp, n1, sizeof (n1)),
1779 dt_node_func(dt_node_t *dnp, dt_node_t *args)
1783 if (dnp->dn_kind != DT_NODE_IDENT) {
1788 idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string);
1792 "undefined function name: %s\n", dnp->dn_string);
1802 free(dnp->dn_string);
1803 dnp->dn_string = NULL;
1805 dnp->dn_kind = DT_NODE_FUNC;
1806 dnp->dn_flags &= ~DT_NF_COOKED;
1807 dnp->dn_ident = idp;
1808 dnp->dn_args = args;
1809 dnp->dn_list = NULL;
1811 return (dnp);
1868 dt_node_t *dnp;
1921 dnp = dt_node_alloc(DT_NODE_OP1);
1923 dnp->dn_op = (ushort_t)op;
1924 dnp->dn_child = cp;
1926 return (dnp);
1965 dt_node_t *dnp;
1984 dnp = dt_node_int(0); /* allocate new integer node for result */
1988 dnp->dn_value = l || r;
1989 dt_node_type_assign(dnp,
1993 dnp->dn_value = (l != 0) ^ (r != 0);
1994 dt_node_type_assign(dnp,
1998 dnp->dn_value = l && r;
1999 dt_node_type_assign(dnp,
2003 dnp->dn_value = l | r;
2004 dt_node_promote(lp, rp, dnp);
2007 dnp->dn_value = l ^ r;
2008 dt_node_promote(lp, rp, dnp);
2011 dnp->dn_value = l & r;
2012 dt_node_promote(lp, rp, dnp);
2015 dnp->dn_value = l == r;
2016 dt_node_type_assign(dnp,
2020 dnp->dn_value = l != r;
2021 dt_node_type_assign(dnp,
2025 dt_node_promote(lp, rp, dnp);
2026 if (dnp->dn_flags & DT_NF_SIGNED)
2027 dnp->dn_value = (intmax_t)l < (intmax_t)r;
2029 dnp->dn_value = l < r;
2030 dt_node_type_assign(dnp,
2034 dt_node_promote(lp, rp, dnp);
2035 if (dnp->dn_flags & DT_NF_SIGNED)
2036 dnp->dn_value = (intmax_t)l <= (intmax_t)r;
2038 dnp->dn_value = l <= r;
2039 dt_node_type_assign(dnp,
2043 dt_node_promote(lp, rp, dnp);
2044 if (dnp->dn_flags & DT_NF_SIGNED)
2045 dnp->dn_value = (intmax_t)l > (intmax_t)r;
2047 dnp->dn_value = l > r;
2048 dt_node_type_assign(dnp,
2052 dt_node_promote(lp, rp, dnp);
2053 if (dnp->dn_flags & DT_NF_SIGNED)
2054 dnp->dn_value = (intmax_t)l >= (intmax_t)r;
2056 dnp->dn_value = l >= r;
2057 dt_node_type_assign(dnp,
2061 dnp->dn_value = l << r;
2062 dt_node_type_propagate(lp, dnp);
2067 dnp->dn_value = l >> r;
2068 dt_node_type_propagate(lp, dnp);
2073 dnp->dn_value = l + r;
2074 dt_node_promote(lp, rp, dnp);
2077 dnp->dn_value = l - r;
2078 dt_node_promote(lp, rp, dnp);
2081 dnp->dn_value = l * r;
2082 dt_node_promote(lp, rp, dnp);
2085 dt_node_promote(lp, rp, dnp);
2086 if (dnp->dn_flags & DT_NF_SIGNED)
2087 dnp->dn_value = (intmax_t)l / (intmax_t)r;
2089 dnp->dn_value = l / r;
2092 dt_node_promote(lp, rp, dnp);
2093 if (dnp->dn_flags & DT_NF_SIGNED)
2094 dnp->dn_value = (intmax_t)l % (intmax_t)r;
2096 dnp->dn_value = l % r;
2099 dt_node_free(dnp);
2100 dnp = NULL;
2103 if (dnp != NULL) {
2106 return (dnp);
2124 dnp = dt_node_alloc(DT_NODE_OP2);
2126 dnp->dn_op = (ushort_t)op;
2127 dnp->dn_left = lp;
2128 dnp->dn_right = rp;
2130 return (dnp);
2136 dt_node_t *dnp;
2141 dnp = dt_node_alloc(DT_NODE_OP3);
2142 dnp->dn_op = DT_TOK_QUESTION;
2143 dnp->dn_expr = expr;
2144 dnp->dn_left = lp;
2145 dnp->dn_right = rp;
2147 return (dnp);
2153 dt_node_t *dnp;
2160 dnp = dt_node_alloc(DT_NODE_DFUNC);
2162 dnp = dt_node_alloc(DT_NODE_DEXPR);
2164 dnp->dn_expr = expr;
2165 return (dnp);
2171 dt_node_t *dnp = dt_node_alloc(DT_NODE_IF);
2172 dnp->dn_conditional = pred;
2173 dnp->dn_body = acts;
2174 dnp->dn_alternate_body = else_acts;
2176 return (dnp);
2183 dt_node_t *dnp;
2188 dnp = dt_node_alloc(DT_NODE_PDESC);
2189 dnp->dn_spec = spec;
2190 dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t));
2192 if (dnp->dn_desc == NULL)
2195 if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec,
2196 yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) {
2198 dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2201 free(dnp->dn_spec);
2202 dnp->dn_spec = NULL;
2204 return (dnp);
2215 dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC);
2217 if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL)
2231 if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) {
2236 return (dnp);
2242 dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE);
2244 dnp->dn_pdescs = pdescs;
2245 dnp->dn_pred = pred;
2246 dnp->dn_acts = acts;
2248 return (dnp);
2263 dt_node_t *dnp;
2308 dnp = dt_node_alloc(DT_NODE_INLINE);
2309 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
2310 dt_node_attr_assign(dnp, _dtrace_defattr);
2312 if (dt_node_is_void(dnp)) {
2317 if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve(
2318 dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) {
2321 dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident);
2329 idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident,
2423 (void) dt_ident_cook(dnp, idp, &ddp->dd_node);
2438 * visible, and then cook 'dnp' to check its type against 'expr'.
2441 return (dt_node_cook(dnp, DT_IDFLG_REF));
2448 dt_node_t *dnp;
2459 dnp = dt_node_alloc(DT_NODE_MEMBER);
2460 dnp->dn_membname = name;
2461 dnp->dn_membexpr = expr;
2464 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2467 return (dnp);
2477 dt_node_t *dnp;
2528 dnp = dt_node_alloc(DT_NODE_XLATOR);
2529 dnp->dn_xlator = dxp;
2530 dnp->dn_members = members;
2532 return (dt_node_cook(dnp, DT_IDFLG_REF));
2540 dt_node_t *dnp;
2559 dnp = dt_node_alloc(DT_NODE_PROBE);
2561 dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE,
2581 if (dnp->dn_ident == NULL || dt_probe_create(dtp,
2582 dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL)
2585 return (dnp);
2592 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER);
2596 dnp->dn_provname = name;
2597 dnp->dn_probes = probes;
2600 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2605 dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d "
2610 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2620 if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL)
2621 dnp->dn_provred = B_TRUE;
2622 else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL)
2625 dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF;
2630 * Note that if dnp->dn_provred is true, we may end up storing dups of
2638 lnp->dn_link = dnp->dn_provider->pv_nodes;
2639 dnp->dn_provider->pv_nodes = yypcb->pcb_list;
2642 return (dnp);
2648 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG);
2649 dnp->dn_list = lnp;
2650 return (dnp);
2662 dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create)
2685 if ((name = strrchr(dnp->dn_string, '`')) != NULL) {
2686 if (name > dnp->dn_string && name[-1] == '`') {
2691 if (name == dnp->dn_string + uref)
2694 scope = dnp->dn_string;
2701 name = dnp->dn_string + 1;
2705 name = dnp->dn_string;
2742 attr = dt_ident_cook(dnp, idp, NULL);
2744 dt_node_type_assign(dnp,
2749 free(dnp->dn_string);
2750 dnp->dn_string = NULL;
2751 dnp->dn_kind = dnkind;
2752 dnp->dn_ident = idp;
2753 dnp->dn_flags |= DT_NF_LVALUE;
2756 dnp->dn_flags |= DT_NF_WRITABLE;
2758 dt_node_attr_assign(dnp, attr);
2815 free(dnp->dn_string);
2816 dnp->dn_string = NULL;
2817 dnp->dn_kind = DT_NODE_SYM;
2818 dnp->dn_ident = idp;
2819 dnp->dn_flags |= DT_NF_LVALUE;
2821 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
2823 dt_node_attr_assign(dnp, _dtrace_symattr);
2827 dnp->dn_flags |= DT_NF_USERLAND;
2867 attr = dt_ident_cook(dnp, idp, NULL);
2869 dt_node_type_assign(dnp,
2874 free(dnp->dn_string);
2875 dnp->dn_string = NULL;
2876 dnp->dn_kind = dnkind;
2877 dnp->dn_ident = idp;
2878 dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE;
2880 dt_node_attr_assign(dnp, attr);
2884 dnp->dn_string, mark, name,
2888 dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2893 dt_cook_ident(dt_node_t *dnp, uint_t idflags)
2897 if (dnp->dn_op == DT_TOK_AGG)
2898 dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE);
2900 dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE);
2902 return (dt_node_cook(dnp, idflags));
2912 dt_cook_var(dt_node_t *dnp, uint_t idflags)
2914 dt_ident_t *idp = dnp->dn_ident;
2917 dnerror(dnp, D_VAR_UNDEF,
2924 dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args));
2925 return (dnp);
2930 dt_cook_func(dt_node_t *dnp, uint_t idflags)
2932 dt_node_attr_assign(dnp,
2933 dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args));
2935 return (dnp);
2939 dt_cook_op1(dt_node_t *dnp, uint_t idflags)
2942 dt_node_t *cp = dnp->dn_child;
2953 if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC ||
2954 dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC)
2966 cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */
2980 switch (dnp->dn_op) {
2989 dnp->dn_ident = &dxp->dx_souid;
2990 dt_node_type_assign(dnp,
2991 dnp->dn_ident->di_ctfp, dnp->dn_ident->di_type,
3012 dt_node_type_assign(dnp, cp->dn_ctfp, type,
3028 if (kind != CTF_K_ARRAY || dt_node_is_string(dnp))
3029 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */
3041 dnp->dn_flags |= DT_NF_WRITABLE;
3044 (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF)))
3045 dnp->dn_flags |= DT_NF_USERLAND;
3052 "of arithmetic type\n", opstr(dnp->dn_op));
3054 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3060 "integral type\n", opstr(dnp->dn_op));
3062 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
3068 "of scalar type\n", opstr(dnp->dn_op));
3070 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3105 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type,
3120 dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp,
3132 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp),
3142 "scalar type\n", opstr(dnp->dn_op));
3147 "of known size\n", opstr(dnp->dn_op));
3152 "lvalue as an operand\n", opstr(dnp->dn_op));
3157 "to a writable variable\n", opstr(dnp->dn_op));
3160 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */
3164 xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op));
3167 dt_node_attr_assign(dnp, cp->dn_attr);
3168 return (dnp);
3172 dt_assign_common(dt_node_t *dnp)
3174 dt_node_t *lp = dnp->dn_left;
3175 dt_node_t *rp = dnp->dn_right;
3176 int op = dnp->dn_op;
3192 dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */
3193 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3197 dt_cook_op2(dt_node_t *dnp, uint_t idflags)
3200 dt_node_t *lp = dnp->dn_left;
3201 dt_node_t *rp = dnp->dn_right;
3202 int op = dnp->dn_op;
3241 lp = dnp->dn_left = dt_node_cook(lp, 0);
3268 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3269 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3276 dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */
3281 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3282 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3289 dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */
3290 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3294 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3295 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3302 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3307 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3308 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3315 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3321 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3322 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3329 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3331 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3348 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3379 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3407 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp),
3409 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3422 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3423 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3456 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
3457 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3460 dnp->dn_flags |= DT_NF_USERLAND;
3475 lp = dnp->dn_left =
3478 rp = dnp->dn_right =
3494 lp = dnp->dn_left =
3497 rp = dnp->dn_right =
3523 lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */
3524 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3570 dnp->dn_left = dnp->dn_right = NULL;
3571 dt_node_free(dnp);
3646 lp = dnp->dn_left =
3649 rp = dnp->dn_right =
3680 dt_assign_common(dnp);
3707 dnp->dn_right = dnp->dn_left;
3708 dt_node_free(dnp);
3714 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3800 dt_node_type_assign(dnp, ctfp, m.ctm_type, B_FALSE);
3801 dt_node_attr_assign(dnp, lp->dn_attr);
3804 dt_node_is_string(dnp)))
3805 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3808 (kind != CTF_K_ARRAY || dt_node_is_string(dnp)))
3809 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3812 dnp->dn_flags |= DT_NF_WRITABLE;
3815 (dnp->dn_flags & DT_NF_REF)))
3816 dnp->dn_flags |= DT_NF_USERLAND;
3843 dnp->dn_left = dnp->dn_right = NULL;
3844 dt_node_free(dnp);
3887 * [ OP2 "[" ]=dnp [ VAR ]=dnp
3892 * Since the final dt_node_cook(dnp) can fail using longjmp we
3894 * writing 'dnp' to become the VAR node, so that the parse tree
3900 lnp = dnp->dn_link;
3901 bcopy(lp, dnp, sizeof (dt_node_t));
3902 dnp->dn_link = lnp;
3904 dnp->dn_args = rp;
3905 dnp->dn_list = NULL;
3908 return (dt_node_cook(dnp, idflags));
3915 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3925 dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type);
3926 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
3928 dt_node_attr_assign(dnp,
3929 dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr));
3938 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3973 dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */
3974 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3981 dnp->dn_flags |= DT_NF_WRITABLE;
3987 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3988 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
4000 dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */
4001 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
4015 if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) {
4024 dnp->dn_op = DT_TOK_ADD;
4025 pnp = dt_node_op1(DT_TOK_DEREF, dnp);
4036 pnp->dn_link = dnp->dn_link;
4037 dnp->dn_link = pnp;
4042 return (dnp);
4047 dt_cook_op3(dt_node_t *dnp, uint_t idflags)
4053 dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF);
4054 lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF);
4055 rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF);
4057 if (!dt_node_is_scalar(dnp->dn_expr)) {
4092 dt_node_type_assign(dnp, ctfp, type, B_FALSE);
4093 dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr,
4096 return (dnp);
4100 dt_cook_statement(dt_node_t *dnp, uint_t idflags)
4102 dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags);
4103 dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr);
4105 return (dnp);
4116 dt_cook_aggregation(dt_node_t *dnp, uint_t idflags)
4120 if (dnp->dn_aggfun != NULL) {
4121 dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF);
4122 dt_node_attr_assign(dnp, dt_ident_cook(dnp,
4123 dnp->dn_ident, &dnp->dn_aggtup));
4125 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp),
4127 dt_node_attr_assign(dnp, dnp->dn_ident->di_attr);
4130 return (dnp);
4177 dt_cook_clause(dt_node_t *dnp, uint_t idflags)
4184 * to 'dnp' itself to force an attribute check and minimum violation.
4186 dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr);
4187 dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr;
4192 if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) {
4203 dt_node_attr_assign(dnp,
4204 dt_node_list_cook(&dnp->dn_acts, idflags));
4210 if (dnp->dn_pred != NULL) {
4213 dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags);
4214 dt_node_attr_assign(dnp,
4215 dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr));
4217 if (!dt_node_is_scalar(dnp->dn_pred)) {
4228 dt_node_attr_assign(dnp,
4229 dt_node_list_cook(&dnp->dn_acts, idflags));
4234 return (dnp);
4239 dt_cook_inline(dt_node_t *dnp, uint_t idflags)
4241 dt_idnode_t *inp = dnp->dn_ident->di_iarg;
4247 assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE);
4258 ctf_file_t *lctfp = dnp->dn_ctfp;
4259 ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type);
4271 dnerror(dnp, D_OP_INCOMPAT,
4273 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4278 } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) {
4279 dnerror(dnp, D_OP_INCOMPAT,
4281 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4282 dt_node_type_name(dnp, n1, sizeof (n1)),
4286 return (dnp);
4290 dt_cook_member(dt_node_t *dnp, uint_t idflags)
4292 dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags);
4293 dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr);
4294 return (dnp);
4299 dt_cook_xlator(dt_node_t *dnp, uint_t idflags)
4302 dt_xlator_t *dxp = dnp->dn_xlator;
4318 for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
4348 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp), B_FALSE);
4349 dt_node_attr_assign(dnp, _dtrace_defattr);
4351 return (dnp);
4426 dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp)
4429 dt_probe_t *prp = dnp->dn_ident->di_data;
4454 dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output "
4456 pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1,
4464 dt_cook_provider(dt_node_t *dnp, uint_t idflags)
4466 dt_provider_t *pvp = dnp->dn_provider;
4474 for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) {
4480 if (prp != NULL && dnp->dn_provred) {
4483 } else if (prp == NULL && dnp->dn_provred) {
4488 dnp->dn_provname, dnp->dn_provname,
4489 probename, dnp->dn_provname, probename);
4492 dnp->dn_provname, probename);
4499 return (dnp);
4504 dt_cook_none(dt_node_t *dnp, uint_t idflags)
4506 return (dnp);
4541 dt_node_cook(dt_node_t *dnp, uint_t idflags)
4545 yylineno = dnp->dn_line;
4547 assert(dnp->dn_kind <
4549 dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags);
4550 dnp->dn_flags |= DT_NF_COOKED;
4552 if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG)
4553 dnp->dn_ident->di_flags |= idflags;
4556 return (dnp);
4563 dt_node_t *dnp, *nnp;
4565 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4566 nnp = dnp->dn_list;
4567 dnp = *pnp = dt_node_cook(dnp, idflags);
4568 attr = dt_attr_min(attr, dnp->dn_attr);
4569 dnp->dn_list = nnp;
4570 pnp = &dnp->dn_list;
4579 dt_node_t *dnp, *nnp;
4581 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4582 nnp = dnp->dn_list;
4583 dt_node_free(dnp);
4593 dt_node_t *dnp, *nnp;
4595 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4596 nnp = dnp->dn_link;
4597 dt_node_free(dnp);
4600 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4601 nnp = dnp->dn_link;
4602 free(dnp);
4612 dt_node_t *dnp;
4619 for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list)
4622 dnp->dn_list = rp;
4632 dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp)
4634 if (dnp->dn_ctfp == DT_STR_CTFP(dtp) &&
4635 dnp->dn_type == DT_STR_TYPE(dtp)) {
4640 tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp,
4641 ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type));
4644 tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ?
4645 (dnp->dn_flags & DT_NF_USERLAND) ? DIF_TF_BYUREF :
4648 tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type);
4667 dt_printd(dt_node_t *dnp, FILE *fp, int depth)
4671 switch (dnp->dn_kind) {
4673 (void) fprintf(fp, "0x%llx", (u_longlong_t)dnp->dn_value);
4674 if (!(dnp->dn_flags & DT_NF_SIGNED))
4679 char *escd = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
4686 (void) fprintf(fp, "%s", dnp->dn_string);
4691 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4692 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4693 dnp->dn_ident->di_name);
4695 if (dnp->dn_args != NULL) {
4698 for (arg = dnp->dn_args; arg != NULL;
4710 const dtrace_syminfo_t *dts = dnp->dn_ident->di_data;
4715 (void) fprintf(fp, "%s(", dnp->dn_ident->di_name);
4717 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4726 (void) fprintf(fp, "%s(", opstr(dnp->dn_op));
4727 dt_printd(dnp->dn_child, fp, 0);
4733 dt_printd(dnp->dn_left, fp, 0);
4734 if (dnp->dn_op == DT_TOK_LPAR) {
4736 dt_printd(dnp->dn_right, fp, 0);
4739 if (dnp->dn_op == DT_TOK_PTR || dnp->dn_op == DT_TOK_DOT ||
4740 dnp->dn_op == DT_TOK_LBRAC)
4741 (void) fprintf(fp, "%s", opstr(dnp->dn_op));
4743 (void) fprintf(fp, " %s ", opstr(dnp->dn_op));
4744 dt_printd(dnp->dn_right, fp, 0);
4745 if (dnp->dn_op == DT_TOK_LBRAC) {
4746 dt_node_t *ln = dnp->dn_right;
4759 dt_printd(dnp->dn_expr, fp, 0);
4761 dt_printd(dnp->dn_left, fp, 0);
4763 dt_printd(dnp->dn_right, fp, 0);
4770 dt_printd(dnp->dn_expr, fp, depth + 1);
4776 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4777 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
4781 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list) {
4788 if (dnp->dn_pred != NULL) {
4790 dt_printd(dnp->dn_pred, fp, 0);
4795 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
4803 dt_printd(dnp->dn_conditional, fp, 0);
4806 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
4808 if (dnp->dn_alternate_body == NULL) {
4812 for (arg = dnp->dn_alternate_body; arg != NULL;
4822 (void *)dnp, dnp->dn_kind);
4827 dt_node_printr(dt_node_t *dnp, FILE *fp, int depth)
4835 (void) dt_attr_str(dnp->dn_attr, a, sizeof (a));
4837 if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR &&
4838 ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) {
4842 dnp->dn_type, a);
4845 if (dnp->dn_flags != 0) {
4847 if (dnp->dn_flags & DT_NF_SIGNED)
4849 if (dnp->dn_flags & DT_NF_COOKED)
4851 if (dnp->dn_flags & DT_NF_REF)
4853 if (dnp->dn_flags & DT_NF_LVALUE)
4855 if (dnp->dn_flags & DT_NF_WRITABLE)
4857 if (dnp->dn_flags & DT_NF_BITFIELD)
4859 if (dnp->dn_flags & DT_NF_USERLAND)
4865 switch (dnp->dn_kind) {
4867 (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp);
4872 (u_longlong_t)dnp->dn_value, buf);
4876 (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf);
4880 (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf);
4885 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4886 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4887 dnp->dn_ident->di_name, buf);
4889 if (dnp->dn_args != NULL)
4892 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4898 if (dnp->dn_args != NULL)
4903 dts = dnp->dn_ident->di_data;
4909 if (dnp->dn_string != NULL) {
4911 buf, dnp->dn_string);
4918 dnp->dn_ident->di_name, buf);
4920 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4928 (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf);
4929 dt_node_printr(dnp->dn_child, fp, depth + 1);
4933 (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf);
4934 dt_node_printr(dnp->dn_left, fp, depth + 1);
4935 dt_node_printr(dnp->dn_right, fp, depth + 1);
4936 if (dnp->dn_op == DT_TOK_LBRAC) {
4937 dt_node_t *ln = dnp->dn_right;
4947 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4949 dt_node_printr(dnp->dn_left, fp, depth + 1);
4951 dt_node_printr(dnp->dn_right, fp, depth + 1);
4957 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4962 dnp->dn_ident->di_name, a);
4964 for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) {
4970 if (dnp->dn_aggfun) {
4972 dt_node_printr(dnp->dn_aggfun, fp, depth + 1);
4976 if (dnp->dn_aggfun)
4982 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4983 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name,
4984 dnp->dn_desc->dtpd_id);
4990 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
4994 dt_attr_str(dnp->dn_ctxattr, a, sizeof (a)));
4996 if (dnp->dn_pred != NULL) {
4998 dt_node_printr(dnp->dn_pred, fp, depth + 1);
5002 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
5008 inp = dnp->dn_ident->di_iarg;
5011 dnp->dn_ident->di_name, buf);
5016 (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf);
5017 if (dnp->dn_membexpr)
5018 dt_node_printr(dnp->dn_membexpr, fp, depth + 1);
5024 if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp,
5025 dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL)
5028 if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp,
5029 dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL)
5034 for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
5039 (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name);
5044 dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl");
5045 for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
5051 for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
5058 dt_node_printr(dnp->dn_conditional, fp, depth + 1);
5061 for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
5064 if (dnp->dn_alternate_body != NULL) {
5066 for (arg = dnp->dn_alternate_body; arg != NULL;
5075 (void *)dnp, dnp->dn_kind);
5080 dt_node_root(dt_node_t *dnp)
5082 yypcb->pcb_root = dnp;
5088 dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5093 yylineno = dnp->dn_line;
5105 dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
5110 yylineno = dnp->dn_line;