Lines Matching refs:dnp
382 dt_node_promote(dt_node_t *lp, dt_node_t *rp, dt_node_t *dnp)
384 dt_type_promote(lp, rp, &dnp->dn_ctfp, &dnp->dn_type);
385 dt_node_type_assign(dnp, dnp->dn_ctfp, dnp->dn_type);
386 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
390 dt_node_name(const dt_node_t *dnp, char *buf, size_t len)
399 switch (dnp->dn_kind) {
402 (u_longlong_t)dnp->dn_value);
405 s = strchr2esc(dnp->dn_string, strlen(dnp->dn_string));
407 s != NULL ? s : dnp->dn_string);
411 (void) snprintf(buf, len, "identifier %s", dnp->dn_string);
417 switch (dnp->dn_ident->di_kind) {
428 dt_idkind_name(dnp->dn_ident->di_kind),
429 prefix, dnp->dn_ident->di_name, suffix);
432 dts = dnp->dn_ident->di_data;
438 dt_node_type_name(dnp, n1, sizeof (n1)));
443 (void) snprintf(buf, len, "operator %s", opstr(dnp->dn_op));
447 if (dnp->dn_expr)
448 return (dt_node_name(dnp->dn_expr, buf, len));
452 if (dnp->dn_desc->dtpd_id == 0) {
455 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
456 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name);
459 dnp->dn_desc->dtpd_id);
466 (void) snprintf(buf, len, "member %s", dnp->dn_membname);
470 dt_type_name(dnp->dn_xlator->dx_dst_ctfp,
471 dnp->dn_xlator->dx_dst_type, n1, sizeof (n1)),
472 dt_type_name(dnp->dn_xlator->dx_src_ctfp,
473 dnp->dn_xlator->dx_src_type, n2, sizeof (n2)));
479 (void) snprintf(buf, len, "node <%u>", dnp->dn_kind);
493 dt_node_t *dnp = dt_alloc(dtp, sizeof (dt_node_t));
495 if (dnp == NULL)
498 dnp->dn_ctfp = NULL;
499 dnp->dn_type = CTF_ERR;
500 dnp->dn_kind = (uchar_t)kind;
501 dnp->dn_flags = 0;
502 dnp->dn_op = 0;
503 dnp->dn_line = -1;
504 dnp->dn_reg = -1;
505 dnp->dn_attr = _dtrace_defattr;
506 dnp->dn_list = NULL;
507 dnp->dn_link = NULL;
508 bzero(&dnp->dn_u, sizeof (dnp->dn_u));
510 return (dnp);
522 dt_node_t *dnp = dt_node_xalloc(yypcb->pcb_hdl, kind);
524 if (dnp == NULL)
527 dnp->dn_line = yylineno;
528 dnp->dn_link = yypcb->pcb_list;
529 yypcb->pcb_list = dnp;
531 return (dnp);
535 dt_node_free(dt_node_t *dnp)
537 uchar_t kind = dnp->dn_kind;
539 dnp->dn_kind = DT_NODE_FREE;
545 free(dnp->dn_string);
546 dnp->dn_string = NULL;
552 if (dnp->dn_ident != NULL) {
553 if (dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN)
554 dt_ident_destroy(dnp->dn_ident);
555 dnp->dn_ident = NULL;
557 dt_node_list_free(&dnp->dn_args);
561 if (dnp->dn_child != NULL) {
562 dt_node_free(dnp->dn_child);
563 dnp->dn_child = NULL;
568 if (dnp->dn_expr != NULL) {
569 dt_node_free(dnp->dn_expr);
570 dnp->dn_expr = NULL;
574 if (dnp->dn_left != NULL) {
575 dt_node_free(dnp->dn_left);
576 dnp->dn_left = NULL;
578 if (dnp->dn_right != NULL) {
579 dt_node_free(dnp->dn_right);
580 dnp->dn_right = NULL;
586 if (dnp->dn_expr != NULL) {
587 dt_node_free(dnp->dn_expr);
588 dnp->dn_expr = NULL;
593 if (dnp->dn_aggfun != NULL) {
594 dt_node_free(dnp->dn_aggfun);
595 dnp->dn_aggfun = NULL;
597 dt_node_list_free(&dnp->dn_aggtup);
601 free(dnp->dn_spec);
602 dnp->dn_spec = NULL;
603 free(dnp->dn_desc);
604 dnp->dn_desc = NULL;
608 if (dnp->dn_pred != NULL)
609 dt_node_free(dnp->dn_pred);
610 if (dnp->dn_locals != NULL)
611 dt_idhash_destroy(dnp->dn_locals);
612 dt_node_list_free(&dnp->dn_pdescs);
613 dt_node_list_free(&dnp->dn_acts);
617 free(dnp->dn_membname);
618 dnp->dn_membname = NULL;
619 if (dnp->dn_membexpr != NULL) {
620 dt_node_free(dnp->dn_membexpr);
621 dnp->dn_membexpr = NULL;
626 dt_node_list_free(&dnp->dn_probes);
627 free(dnp->dn_provname);
628 dnp->dn_provname = NULL;
632 dt_node_list_free(&dnp->dn_list);
638 dt_node_attr_assign(dt_node_t *dnp, dtrace_attribute_t attr)
645 dnerror(dnp, D_ATTR_MIN, "attributes for %s (%s) are less than "
646 "predefined minimum\n", dt_node_name(dnp, s, sizeof (s)),
650 dnp->dn_attr = attr;
654 dt_node_type_assign(dt_node_t *dnp, ctf_file_t *fp, ctf_id_t type)
660 dnp->dn_flags &=
667 dnp->dn_flags |= DT_NF_BITFIELD;
670 dnp->dn_flags |= DT_NF_SIGNED;
675 dnp->dn_flags |= DT_NF_REF;
681 dnp->dn_flags |= DT_NF_REF;
684 dnp->dn_flags |= DT_NF_REF;
686 dnp->dn_flags |= DT_NF_COOKED;
687 dnp->dn_ctfp = fp;
688 dnp->dn_type = type;
701 dt_node_type_name(const dt_node_t *dnp, char *buf, size_t len)
703 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL) {
705 dt_idkind_name(dt_ident_resolve(dnp->dn_ident)->di_kind));
709 if (dnp->dn_flags & DT_NF_USERLAND) {
712 (void) dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf + n, len);
716 return (dt_type_name(dnp->dn_ctfp, dnp->dn_type, buf, len));
720 dt_node_type_size(const dt_node_t *dnp)
722 if (dnp->dn_kind == DT_NODE_STRING)
723 return (strlen(dnp->dn_string) + 1);
725 if (dt_node_is_dynamic(dnp) && dnp->dn_ident != NULL)
726 return (dt_ident_size(dnp->dn_ident));
728 return (ctf_type_size(dnp->dn_ctfp, dnp->dn_type));
737 dt_node_resolve(const dt_node_t *dnp, uint_t idkind)
741 switch (dnp->dn_kind) {
748 idp = dt_ident_resolve(dnp->dn_ident);
752 if (dt_node_is_dynamic(dnp)) {
753 idp = dt_ident_resolve(dnp->dn_ident);
761 dt_node_sizeof(const dt_node_t *dnp)
776 if (dnp->dn_kind != DT_NODE_SYM)
777 return (dt_node_type_size(dnp));
779 sip = dnp->dn_ident->di_data;
789 dt_node_is_integer(const dt_node_t *dnp)
791 ctf_file_t *fp = dnp->dn_ctfp;
796 assert(dnp->dn_flags & DT_NF_COOKED);
798 type = ctf_type_resolve(fp, dnp->dn_type);
809 dt_node_is_float(const dt_node_t *dnp)
811 ctf_file_t *fp = dnp->dn_ctfp;
816 assert(dnp->dn_flags & DT_NF_COOKED);
818 type = ctf_type_resolve(fp, dnp->dn_type);
822 ctf_type_encoding(dnp->dn_ctfp, type, &e) == 0 && (
828 dt_node_is_scalar(const dt_node_t *dnp)
830 ctf_file_t *fp = dnp->dn_ctfp;
835 assert(dnp->dn_flags & DT_NF_COOKED);
837 type = ctf_type_resolve(fp, dnp->dn_type);
849 dt_node_is_arith(const dt_node_t *dnp)
851 ctf_file_t *fp = dnp->dn_ctfp;
856 assert(dnp->dn_flags & DT_NF_COOKED);
858 type = ctf_type_resolve(fp, dnp->dn_type);
868 dt_node_is_vfptr(const dt_node_t *dnp)
870 ctf_file_t *fp = dnp->dn_ctfp;
875 assert(dnp->dn_flags & DT_NF_COOKED);
877 type = ctf_type_resolve(fp, dnp->dn_type);
889 dt_node_is_dynamic(const dt_node_t *dnp)
891 if (dnp->dn_kind == DT_NODE_VAR &&
892 (dnp->dn_ident->di_flags & DT_IDFLG_INLINE)) {
893 const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
897 return (dnp->dn_ctfp == DT_DYN_CTFP(yypcb->pcb_hdl) &&
898 dnp->dn_type == DT_DYN_TYPE(yypcb->pcb_hdl));
902 dt_node_is_string(const dt_node_t *dnp)
904 return (dnp->dn_ctfp == DT_STR_CTFP(yypcb->pcb_hdl) &&
905 dnp->dn_type == DT_STR_TYPE(yypcb->pcb_hdl));
909 dt_node_is_stack(const dt_node_t *dnp)
911 return (dnp->dn_ctfp == DT_STACK_CTFP(yypcb->pcb_hdl) &&
912 dnp->dn_type == DT_STACK_TYPE(yypcb->pcb_hdl));
916 dt_node_is_symaddr(const dt_node_t *dnp)
918 return (dnp->dn_ctfp == DT_SYMADDR_CTFP(yypcb->pcb_hdl) &&
919 dnp->dn_type == DT_SYMADDR_TYPE(yypcb->pcb_hdl));
923 dt_node_is_usymaddr(const dt_node_t *dnp)
925 return (dnp->dn_ctfp == DT_USYMADDR_CTFP(yypcb->pcb_hdl) &&
926 dnp->dn_type == DT_USYMADDR_TYPE(yypcb->pcb_hdl));
930 dt_node_is_strcompat(const dt_node_t *dnp)
932 ctf_file_t *fp = dnp->dn_ctfp;
938 assert(dnp->dn_flags & DT_NF_COOKED);
940 base = ctf_type_resolve(fp, dnp->dn_type);
958 dt_node_is_pointer(const dt_node_t *dnp)
960 ctf_file_t *fp = dnp->dn_ctfp;
963 assert(dnp->dn_flags & DT_NF_COOKED);
965 if (dt_node_is_string(dnp))
968 kind = ctf_type_kind(fp, ctf_type_resolve(fp, dnp->dn_type));
973 dt_node_is_void(const dt_node_t *dnp)
975 ctf_file_t *fp = dnp->dn_ctfp;
979 if (dt_node_is_dynamic(dnp))
982 if (dt_node_is_stack(dnp))
985 if (dt_node_is_symaddr(dnp) || dt_node_is_usymaddr(dnp))
988 type = ctf_type_resolve(fp, dnp->dn_type);
1145 dt_node_is_posconst(const dt_node_t *dnp)
1147 return (dnp->dn_kind == DT_NODE_INT && dnp->dn_value != 0 && (
1148 (dnp->dn_flags & DT_NF_SIGNED) == 0 || (int64_t)dnp->dn_value > 0));
1152 dt_node_is_actfunc(const dt_node_t *dnp)
1154 return (dnp->dn_kind == DT_NODE_FUNC &&
1155 dnp->dn_ident->di_kind == DT_IDENT_ACTFUNC);
1191 dt_node_t *dnp = dt_node_alloc(DT_NODE_INT);
1200 dnp->dn_op = DT_TOK_INT;
1201 dnp->dn_value = value;
1212 dt_node_type_assign(dnp,
1222 return (dt_node_op1(DT_TOK_IPOS, dnp));
1224 return (dt_node_op1(DT_TOK_INEG, dnp));
1226 return (dnp);
1241 dt_node_t *dnp;
1246 dnp = dt_node_alloc(DT_NODE_STRING);
1247 dnp->dn_op = DT_TOK_STRING;
1248 dnp->dn_string = string;
1249 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp));
1251 return (dnp);
1258 dt_node_t *dnp;
1277 dnp = dt_node_alloc(DT_NODE_INT);
1278 dnp->dn_op = DT_TOK_INT;
1279 dnp->dn_value = inp->din_root->dn_value;
1280 dt_node_type_propagate(inp->din_root, dnp);
1282 return (dnp);
1286 dnp = dt_node_alloc(DT_NODE_IDENT);
1287 dnp->dn_op = name[0] == '@' ? DT_TOK_AGG : DT_TOK_IDENT;
1288 dnp->dn_string = name;
1290 return (dnp);
1303 dt_node_t *dnp;
1322 dnp = dt_node_alloc(DT_NODE_TYPE);
1323 dnp->dn_op = DT_TOK_IDENT;
1324 dnp->dn_string = name;
1325 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
1329 dt_node_attr_assign(dnp, _dtrace_defattr);
1331 dt_node_attr_assign(dnp, _dtrace_typattr);
1333 return (dnp);
1343 dt_node_t *dnp = dt_node_alloc(DT_NODE_TYPE);
1345 dnp->dn_op = DT_TOK_IDENT;
1346 dnp->dn_ctfp = yypcb->pcb_hdl->dt_cdefs->dm_ctfp;
1347 dnp->dn_type = CTF_ERR;
1348 dnp->dn_attr = _dtrace_defattr;
1350 return (dnp);
1597 dt_node_t *dnp = ddp->dd_node;
1600 for (; dnp != NULL; dnp = dnp->dn_list, argc++) {
1606 if (ctf_type_cmp(dnp->dn_ctfp, dnp->dn_type,
1616 dt_node_type_name(dnp, n1, sizeof (n1)),
1703 dt_node_func(dt_node_t *dnp, dt_node_t *args)
1707 if (dnp->dn_kind != DT_NODE_IDENT) {
1712 idp = dt_idstack_lookup(&yypcb->pcb_globals, dnp->dn_string);
1716 "undefined function name: %s\n", dnp->dn_string);
1726 free(dnp->dn_string);
1727 dnp->dn_string = NULL;
1729 dnp->dn_kind = DT_NODE_FUNC;
1730 dnp->dn_flags &= ~DT_NF_COOKED;
1731 dnp->dn_ident = idp;
1732 dnp->dn_args = args;
1733 dnp->dn_list = NULL;
1735 return (dnp);
1791 dt_node_t *dnp;
1843 dnp = dt_node_alloc(DT_NODE_OP1);
1845 dnp->dn_op = (ushort_t)op;
1846 dnp->dn_child = cp;
1848 return (dnp);
1855 dt_node_t *dnp;
1874 dnp = dt_node_int(0); /* allocate new integer node for result */
1878 dnp->dn_value = l || r;
1879 dt_node_type_assign(dnp,
1883 dnp->dn_value = (l != 0) ^ (r != 0);
1884 dt_node_type_assign(dnp,
1888 dnp->dn_value = l && r;
1889 dt_node_type_assign(dnp,
1893 dnp->dn_value = l | r;
1894 dt_node_promote(lp, rp, dnp);
1897 dnp->dn_value = l ^ r;
1898 dt_node_promote(lp, rp, dnp);
1901 dnp->dn_value = l & r;
1902 dt_node_promote(lp, rp, dnp);
1905 dnp->dn_value = l == r;
1906 dt_node_type_assign(dnp,
1910 dnp->dn_value = l != r;
1911 dt_node_type_assign(dnp,
1915 dt_node_promote(lp, rp, dnp);
1916 if (dnp->dn_flags & DT_NF_SIGNED)
1917 dnp->dn_value = (intmax_t)l < (intmax_t)r;
1919 dnp->dn_value = l < r;
1920 dt_node_type_assign(dnp,
1924 dt_node_promote(lp, rp, dnp);
1925 if (dnp->dn_flags & DT_NF_SIGNED)
1926 dnp->dn_value = (intmax_t)l <= (intmax_t)r;
1928 dnp->dn_value = l <= r;
1929 dt_node_type_assign(dnp,
1933 dt_node_promote(lp, rp, dnp);
1934 if (dnp->dn_flags & DT_NF_SIGNED)
1935 dnp->dn_value = (intmax_t)l > (intmax_t)r;
1937 dnp->dn_value = l > r;
1938 dt_node_type_assign(dnp,
1942 dt_node_promote(lp, rp, dnp);
1943 if (dnp->dn_flags & DT_NF_SIGNED)
1944 dnp->dn_value = (intmax_t)l >= (intmax_t)r;
1946 dnp->dn_value = l >= r;
1947 dt_node_type_assign(dnp,
1951 dnp->dn_value = l << r;
1952 dt_node_type_propagate(lp, dnp);
1957 dnp->dn_value = l >> r;
1958 dt_node_type_propagate(lp, dnp);
1963 dnp->dn_value = l + r;
1964 dt_node_promote(lp, rp, dnp);
1967 dnp->dn_value = l - r;
1968 dt_node_promote(lp, rp, dnp);
1971 dnp->dn_value = l * r;
1972 dt_node_promote(lp, rp, dnp);
1975 dt_node_promote(lp, rp, dnp);
1976 if (dnp->dn_flags & DT_NF_SIGNED)
1977 dnp->dn_value = (intmax_t)l / (intmax_t)r;
1979 dnp->dn_value = l / r;
1982 dt_node_promote(lp, rp, dnp);
1983 if (dnp->dn_flags & DT_NF_SIGNED)
1984 dnp->dn_value = (intmax_t)l % (intmax_t)r;
1986 dnp->dn_value = l % r;
1989 dt_node_free(dnp);
1990 dnp = NULL;
1993 if (dnp != NULL) {
1996 return (dnp);
2037 dnp = dt_node_alloc(DT_NODE_OP2);
2039 dnp->dn_op = (ushort_t)op;
2040 dnp->dn_left = lp;
2041 dnp->dn_right = rp;
2043 return (dnp);
2049 dt_node_t *dnp;
2054 dnp = dt_node_alloc(DT_NODE_OP3);
2055 dnp->dn_op = DT_TOK_QUESTION;
2056 dnp->dn_expr = expr;
2057 dnp->dn_left = lp;
2058 dnp->dn_right = rp;
2060 return (dnp);
2066 dt_node_t *dnp;
2073 dnp = dt_node_alloc(DT_NODE_DFUNC);
2075 dnp = dt_node_alloc(DT_NODE_DEXPR);
2077 dnp->dn_expr = expr;
2078 return (dnp);
2085 dt_node_t *dnp;
2090 dnp = dt_node_alloc(DT_NODE_PDESC);
2091 dnp->dn_spec = spec;
2092 dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t));
2094 if (dnp->dn_desc == NULL)
2097 if (dtrace_xstr2desc(dtp, yypcb->pcb_pspec, dnp->dn_spec,
2098 yypcb->pcb_sargc, yypcb->pcb_sargv, dnp->dn_desc) != 0) {
2100 dnp->dn_spec, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2103 free(dnp->dn_spec);
2104 dnp->dn_spec = NULL;
2106 return (dnp);
2117 dt_node_t *dnp = dt_node_alloc(DT_NODE_PDESC);
2119 if ((dnp->dn_desc = malloc(sizeof (dtrace_probedesc_t))) == NULL)
2133 if (dtrace_id2desc(dtp, (dtrace_id_t)id, dnp->dn_desc) != 0) {
2138 return (dnp);
2144 dt_node_t *dnp = dt_node_alloc(DT_NODE_CLAUSE);
2146 dnp->dn_pdescs = pdescs;
2147 dnp->dn_pred = pred;
2148 dnp->dn_acts = acts;
2151 return (dnp);
2166 dt_node_t *dnp;
2211 dnp = dt_node_alloc(DT_NODE_INLINE);
2212 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
2213 dt_node_attr_assign(dnp, _dtrace_defattr);
2215 if (dt_node_is_void(dnp)) {
2220 if (ctf_type_kind(dnp->dn_ctfp, ctf_type_resolve(
2221 dnp->dn_ctfp, dnp->dn_type)) == CTF_K_FORWARD) {
2224 dt_node_type_name(dnp, n, sizeof (n)), dsp->ds_ident);
2232 idp = dnp->dn_ident = dt_ident_create(dsp->ds_ident,
2328 (void) dt_ident_cook(dnp, idp, &ddp->dd_node);
2343 * visible, and then cook 'dnp' to check its type against 'expr'.
2346 return (dt_node_cook(dnp, DT_IDFLG_REF));
2353 dt_node_t *dnp;
2364 dnp = dt_node_alloc(DT_NODE_MEMBER);
2365 dnp->dn_membname = name;
2366 dnp->dn_membexpr = expr;
2369 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
2371 return (dnp);
2381 dt_node_t *dnp;
2432 dnp = dt_node_alloc(DT_NODE_XLATOR);
2433 dnp->dn_xlator = dxp;
2434 dnp->dn_members = members;
2436 return (dt_node_cook(dnp, DT_IDFLG_REF));
2444 dt_node_t *dnp;
2463 dnp = dt_node_alloc(DT_NODE_PROBE);
2465 dnp->dn_ident = dt_ident_create(name, DT_IDENT_PROBE,
2485 if (dnp->dn_ident == NULL || dt_probe_create(dtp,
2486 dnp->dn_ident, protoc, nargs, nargc, xargs, xargc) == NULL)
2489 return (dnp);
2496 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROVIDER);
2500 dnp->dn_provname = name;
2501 dnp->dn_probes = probes;
2504 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2509 dnerror(dnp, D_PROV_BADNAME, "provider name may not exceed %d "
2514 dnerror(dnp, D_PROV_BADNAME, "provider name may not "
2524 if ((dnp->dn_provider = dt_provider_lookup(dtp, name)) != NULL)
2525 dnp->dn_provred = B_TRUE;
2526 else if ((dnp->dn_provider = dt_provider_create(dtp, name)) == NULL)
2529 dnp->dn_provider->pv_flags |= DT_PROVIDER_INTF;
2534 * Note that if dnp->dn_provred is true, we may end up storing dups of
2542 lnp->dn_link = dnp->dn_provider->pv_nodes;
2543 dnp->dn_provider->pv_nodes = yypcb->pcb_list;
2546 return (dnp);
2552 dt_node_t *dnp = dt_node_alloc(DT_NODE_PROG);
2553 dnp->dn_list = lnp;
2554 return (dnp);
2566 dt_xcook_ident(dt_node_t *dnp, dt_idhash_t *dhp, uint_t idkind, int create)
2589 if ((name = strrchr(dnp->dn_string, '`')) != NULL) {
2590 if (name > dnp->dn_string && name[-1] == '`') {
2595 if (name == dnp->dn_string + uref)
2598 scope = dnp->dn_string;
2605 name = dnp->dn_string + 1;
2609 name = dnp->dn_string;
2646 attr = dt_ident_cook(dnp, idp, NULL);
2648 dt_node_type_assign(dnp,
2653 free(dnp->dn_string);
2654 dnp->dn_string = NULL;
2655 dnp->dn_kind = dnkind;
2656 dnp->dn_ident = idp;
2657 dnp->dn_flags |= DT_NF_LVALUE;
2660 dnp->dn_flags |= DT_NF_WRITABLE;
2662 dt_node_attr_assign(dnp, attr);
2719 free(dnp->dn_string);
2720 dnp->dn_string = NULL;
2721 dnp->dn_kind = DT_NODE_SYM;
2722 dnp->dn_ident = idp;
2723 dnp->dn_flags |= DT_NF_LVALUE;
2725 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
2726 dt_node_attr_assign(dnp, _dtrace_symattr);
2730 dnp->dn_flags |= DT_NF_USERLAND;
2770 attr = dt_ident_cook(dnp, idp, NULL);
2772 dt_node_type_assign(dnp,
2777 free(dnp->dn_string);
2778 dnp->dn_string = NULL;
2779 dnp->dn_kind = dnkind;
2780 dnp->dn_ident = idp;
2781 dnp->dn_flags |= DT_NF_LVALUE | DT_NF_WRITABLE;
2783 dt_node_attr_assign(dnp, attr);
2787 dnp->dn_string, mark, name,
2791 dnp->dn_string, dtrace_errmsg(dtp, dtrace_errno(dtp)));
2796 dt_cook_ident(dt_node_t *dnp, uint_t idflags)
2800 if (dnp->dn_op == DT_TOK_AGG)
2801 dt_xcook_ident(dnp, dtp->dt_aggs, DT_IDENT_AGG, B_FALSE);
2803 dt_xcook_ident(dnp, dtp->dt_globals, DT_IDENT_SCALAR, B_FALSE);
2805 return (dt_node_cook(dnp, idflags));
2815 dt_cook_var(dt_node_t *dnp, uint_t idflags)
2817 dt_ident_t *idp = dnp->dn_ident;
2820 dnerror(dnp, D_VAR_UNDEF,
2827 dt_node_attr_assign(dnp, dt_ident_cook(dnp, idp, &dnp->dn_args));
2828 return (dnp);
2833 dt_cook_func(dt_node_t *dnp, uint_t idflags)
2835 dt_node_attr_assign(dnp,
2836 dt_ident_cook(dnp, dnp->dn_ident, &dnp->dn_args));
2838 return (dnp);
2842 dt_cook_op1(dt_node_t *dnp, uint_t idflags)
2845 dt_node_t *cp = dnp->dn_child;
2856 if (dnp->dn_op == DT_TOK_PREINC || dnp->dn_op == DT_TOK_POSTINC ||
2857 dnp->dn_op == DT_TOK_PREDEC || dnp->dn_op == DT_TOK_POSTDEC)
2869 cp = dnp->dn_child = dt_node_cook(cp, 0); /* don't set idflags yet */
2882 switch (dnp->dn_op) {
2891 dnp->dn_ident = &dxp->dx_souid;
2892 dt_node_type_assign(dnp,
2913 dt_node_type_assign(dnp, cp->dn_ctfp, type);
2928 if (kind != CTF_K_ARRAY || dt_node_is_string(dnp))
2929 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.4.3] */
2941 dnp->dn_flags |= DT_NF_WRITABLE;
2944 (kind == CTF_K_POINTER || (dnp->dn_flags & DT_NF_REF)))
2945 dnp->dn_flags |= DT_NF_USERLAND;
2952 "of arithmetic type\n", opstr(dnp->dn_op));
2954 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
2960 "integral type\n", opstr(dnp->dn_op));
2962 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.4-6] */
2968 "of scalar type\n", opstr(dnp->dn_op));
2970 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
3003 dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type);
3006 dnp->dn_flags |= DT_NF_USERLAND;
3020 dt_node_type_assign(dnp, dtp->dt_ddefs->dm_ctfp,
3031 dt_node_type_assign(dnp, DT_STR_CTFP(dtp), DT_STR_TYPE(dtp));
3040 "scalar type\n", opstr(dnp->dn_op));
3045 "of known size\n", opstr(dnp->dn_op));
3050 "lvalue as an operand\n", opstr(dnp->dn_op));
3055 "to a writable variable\n", opstr(dnp->dn_op));
3058 dt_node_type_propagate(cp, dnp); /* see K&R[A7.4.1] */
3062 xyerror(D_UNKNOWN, "invalid unary op %s\n", opstr(dnp->dn_op));
3065 dt_node_attr_assign(dnp, cp->dn_attr);
3066 return (dnp);
3070 dt_cook_op2(dt_node_t *dnp, uint_t idflags)
3073 dt_node_t *lp = dnp->dn_left;
3074 dt_node_t *rp = dnp->dn_right;
3075 int op = dnp->dn_op;
3114 lp = dnp->dn_left = dt_node_cook(lp, 0);
3138 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3139 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3146 dt_node_promote(lp, rp, dnp); /* see K&R[A7.11-13] */
3151 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3152 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3159 dt_node_type_propagate(lp, dnp); /* see K&R[A7.8] */
3160 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3164 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3165 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3172 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3177 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3178 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3185 dt_node_promote(lp, rp, dnp); /* see K&R[A7.6] */
3191 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3192 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3199 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
3200 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3217 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3247 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3275 dt_node_type_assign(dnp, DT_INT_CTFP(dtp), DT_INT_TYPE(dtp));
3276 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3289 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3290 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3323 dt_node_type_assign(dnp, ctfp, type);
3324 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3327 dnp->dn_flags |= DT_NF_USERLAND;
3342 lp = dnp->dn_left =
3345 rp = dnp->dn_right =
3361 lp = dnp->dn_left =
3364 rp = dnp->dn_right =
3390 lp = dnp->dn_left = dt_node_cook(lp, 0); /* don't set mod yet */
3391 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3437 dnp->dn_left = dnp->dn_right = NULL;
3438 dt_node_free(dnp);
3513 lp = dnp->dn_left =
3516 rp = dnp->dn_right =
3558 dt_node_type_propagate(lp, dnp); /* see K&R[A7.17] */
3559 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3577 dnp->dn_right = dnp->dn_left; /* avoid freeing rp */
3578 dt_node_free(dnp);
3596 dnp->dn_right = dnp->dn_left; /* avoid freeing rp */
3597 dt_node_free(dnp);
3604 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3690 dt_node_type_assign(dnp, ctfp, m.ctm_type);
3691 dt_node_attr_assign(dnp, lp->dn_attr);
3694 dt_node_is_string(dnp)))
3695 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3698 (kind != CTF_K_ARRAY || dt_node_is_string(dnp)))
3699 dnp->dn_flags |= DT_NF_LVALUE; /* see K&R[A7.3.3] */
3702 dnp->dn_flags |= DT_NF_WRITABLE;
3705 (dnp->dn_flags & DT_NF_REF)))
3706 dnp->dn_flags |= DT_NF_USERLAND;
3733 dnp->dn_left = dnp->dn_right = NULL;
3734 dt_node_free(dnp);
3777 * [ OP2 "[" ]=dnp [ VAR ]=dnp
3782 * Since the final dt_node_cook(dnp) can fail using longjmp we
3784 * writing 'dnp' to become the VAR node, so that the parse tree
3790 lnp = dnp->dn_link;
3791 bcopy(lp, dnp, sizeof (dt_node_t));
3792 dnp->dn_link = lnp;
3794 dnp->dn_args = rp;
3795 dnp->dn_list = NULL;
3798 return (dt_node_cook(dnp, idflags));
3805 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3815 dnp->dn_ident = dt_xlator_ident(dxp, lp->dn_ctfp, lp->dn_type);
3816 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
3817 dt_node_attr_assign(dnp,
3818 dt_attr_min(rp->dn_attr, dnp->dn_ident->di_attr));
3827 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3862 dt_node_type_propagate(lp, dnp); /* see K&R[A7.5] */
3863 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3868 lp = dnp->dn_left = dt_node_cook(lp, DT_IDFLG_REF);
3869 rp = dnp->dn_right = dt_node_cook(rp, DT_IDFLG_REF);
3881 dt_node_type_propagate(rp, dnp); /* see K&R[A7.18] */
3882 dt_node_attr_assign(dnp, dt_attr_min(lp->dn_attr, rp->dn_attr));
3896 if (dnp->dn_op == DT_TOK_LBRAC && op == DT_TOK_ADD) {
3905 dnp->dn_op = DT_TOK_ADD;
3906 pnp = dt_node_op1(DT_TOK_DEREF, dnp);
3917 pnp->dn_link = dnp->dn_link;
3918 dnp->dn_link = pnp;
3923 return (dnp);
3928 dt_cook_op3(dt_node_t *dnp, uint_t idflags)
3934 dnp->dn_expr = dt_node_cook(dnp->dn_expr, DT_IDFLG_REF);
3935 lp = dnp->dn_left = dt_node_cook(dnp->dn_left, DT_IDFLG_REF);
3936 rp = dnp->dn_right = dt_node_cook(dnp->dn_right, DT_IDFLG_REF);
3938 if (!dt_node_is_scalar(dnp->dn_expr)) {
3973 dt_node_type_assign(dnp, ctfp, type);
3974 dt_node_attr_assign(dnp, dt_attr_min(dnp->dn_expr->dn_attr,
3977 return (dnp);
3981 dt_cook_statement(dt_node_t *dnp, uint_t idflags)
3983 dnp->dn_expr = dt_node_cook(dnp->dn_expr, idflags);
3984 dt_node_attr_assign(dnp, dnp->dn_expr->dn_attr);
3986 return (dnp);
3997 dt_cook_aggregation(dt_node_t *dnp, uint_t idflags)
4001 if (dnp->dn_aggfun != NULL) {
4002 dnp->dn_aggfun = dt_node_cook(dnp->dn_aggfun, DT_IDFLG_REF);
4003 dt_node_attr_assign(dnp, dt_ident_cook(dnp,
4004 dnp->dn_ident, &dnp->dn_aggtup));
4006 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
4007 dt_node_attr_assign(dnp, dnp->dn_ident->di_attr);
4010 return (dnp);
4057 dt_cook_clause(dt_node_t *dnp, uint_t idflags)
4064 * to 'dnp' itself to force an attribute check and minimum violation.
4066 dt_node_attr_assign(dnp, yypcb->pcb_pinfo.dtp_attr);
4067 dnp->dn_ctxattr = yypcb->pcb_pinfo.dtp_attr;
4072 if (dnp->dn_pred != NULL && (err = setjmp(yypcb->pcb_jmpbuf)) != 0) {
4083 dt_node_attr_assign(dnp,
4084 dt_node_list_cook(&dnp->dn_acts, idflags));
4090 if (dnp->dn_pred != NULL) {
4093 dnp->dn_pred = dt_node_cook(dnp->dn_pred, idflags);
4094 dt_node_attr_assign(dnp,
4095 dt_attr_min(dnp->dn_attr, dnp->dn_pred->dn_attr));
4097 if (!dt_node_is_scalar(dnp->dn_pred)) {
4108 dt_node_attr_assign(dnp,
4109 dt_node_list_cook(&dnp->dn_acts, idflags));
4114 return (dnp);
4119 dt_cook_inline(dt_node_t *dnp, uint_t idflags)
4121 dt_idnode_t *inp = dnp->dn_ident->di_iarg;
4127 assert(dnp->dn_ident->di_flags & DT_IDFLG_INLINE);
4138 ctf_file_t *lctfp = dnp->dn_ctfp;
4139 ctf_id_t ltype = ctf_type_resolve(lctfp, dnp->dn_type);
4151 dnerror(dnp, D_OP_INCOMPAT,
4153 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4158 } else if (dt_node_is_argcompat(dnp, inp->din_root) == 0) {
4159 dnerror(dnp, D_OP_INCOMPAT,
4161 "\"%s\" = \"%s\"\n", dnp->dn_ident->di_name,
4162 dt_node_type_name(dnp, n1, sizeof (n1)),
4166 return (dnp);
4170 dt_cook_member(dt_node_t *dnp, uint_t idflags)
4172 dnp->dn_membexpr = dt_node_cook(dnp->dn_membexpr, idflags);
4173 dt_node_attr_assign(dnp, dnp->dn_membexpr->dn_attr);
4174 return (dnp);
4179 dt_cook_xlator(dt_node_t *dnp, uint_t idflags)
4182 dt_xlator_t *dxp = dnp->dn_xlator;
4198 for (mnp = dnp->dn_members; mnp != NULL; mnp = mnp->dn_list) {
4227 dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
4228 dt_node_attr_assign(dnp, _dtrace_defattr);
4230 return (dnp);
4305 dt_cook_probe(dt_node_t *dnp, dt_provider_t *pvp)
4308 dt_probe_t *prp = dnp->dn_ident->di_data;
4333 dnerror(dnp, D_PROV_PRXLATOR, "translator for %s:%s output "
4335 pvp->pv_desc.dtvd_name, dnp->dn_ident->di_name, i + 1,
4343 dt_cook_provider(dt_node_t *dnp, uint_t idflags)
4345 dt_provider_t *pvp = dnp->dn_provider;
4353 for (pnp = dnp->dn_probes; pnp != NULL; pnp = pnp->dn_list) {
4359 if (prp != NULL && dnp->dn_provred) {
4362 } else if (prp == NULL && dnp->dn_provred) {
4367 dnp->dn_provname, dnp->dn_provname,
4368 probename, dnp->dn_provname, probename);
4371 dnp->dn_provname, probename);
4378 return (dnp);
4383 dt_cook_none(dt_node_t *dnp, uint_t idflags)
4385 return (dnp);
4416 dt_node_t *dnp;
4418 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL;
4419 dnp = dnp->dn_list) {
4420 dt_node_copy_locals(dnp);
4436 dt_node_copy_locals(dt_node_t *dnp)
4438 switch (dnp->dn_kind) {
4442 if (dnp->dn_ident != NULL &&
4443 dnp->dn_ident->di_flags & DT_IDFLG_LOCAL)
4444 dnp->dn_ident = dt_ident_copy(dnp->dn_ident);
4446 dt_node_list_copy_locals(&dnp->dn_args);
4450 if (dnp->dn_child != NULL)
4451 dt_node_copy_locals(dnp->dn_child);
4456 if (dnp->dn_expr != NULL)
4457 dt_node_copy_locals(dnp->dn_expr);
4461 if (dnp->dn_left != NULL)
4462 dt_node_copy_locals(dnp->dn_left);
4464 if (dnp->dn_right != NULL)
4465 dt_node_copy_locals(dnp->dn_right);
4471 if (dnp->dn_expr != NULL)
4472 dt_node_copy_locals(dnp->dn_expr);
4477 if (dnp->dn_aggfun != NULL)
4478 dt_node_copy_locals(dnp->dn_aggfun);
4480 dt_node_list_copy_locals(&dnp->dn_aggtup);
4484 if (dnp->dn_pred != NULL)
4485 dt_node_copy_locals(dnp->dn_pred);
4487 dt_node_list_copy_locals(&dnp->dn_pdescs);
4488 dt_node_list_copy_locals(&dnp->dn_acts);
4492 if (dnp->dn_membexpr != NULL)
4493 dt_node_copy_locals(dnp->dn_membexpr);
4498 dt_node_list_copy_locals(&dnp->dn_probes);
4502 dt_node_list_copy_locals(&dnp->dn_list);
4513 dt_node_cook(dt_node_t *dnp, uint_t idflags)
4517 yylineno = dnp->dn_line;
4519 dnp = dt_cook_funcs[dnp->dn_kind](dnp, idflags);
4520 dnp->dn_flags |= DT_NF_COOKED;
4522 if (dnp->dn_kind == DT_NODE_VAR || dnp->dn_kind == DT_NODE_AGG)
4523 dnp->dn_ident->di_flags |= idflags;
4526 return (dnp);
4533 dt_node_t *dnp, *nnp;
4535 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4536 nnp = dnp->dn_list;
4537 dnp = *pnp = dt_node_cook(dnp, idflags);
4538 attr = dt_attr_min(attr, dnp->dn_attr);
4539 dnp->dn_list = nnp;
4540 pnp = &dnp->dn_list;
4549 dt_node_t *dnp, *nnp;
4551 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4552 nnp = dnp->dn_list;
4553 dt_node_free(dnp);
4563 dt_node_t *dnp, *nnp;
4565 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4566 nnp = dnp->dn_link;
4567 dt_node_free(dnp);
4570 for (dnp = (pnp != NULL ? *pnp : NULL); dnp != NULL; dnp = nnp) {
4571 nnp = dnp->dn_link;
4572 free(dnp);
4582 dt_node_t *dnp;
4589 for (dnp = lp; dnp->dn_list != NULL; dnp = dnp->dn_list)
4592 dnp->dn_list = rp;
4602 dt_node_diftype(dtrace_hdl_t *dtp, const dt_node_t *dnp, dtrace_diftype_t *tp)
4604 if (dnp->dn_ctfp == DT_STR_CTFP(dtp) &&
4605 dnp->dn_type == DT_STR_TYPE(dtp)) {
4610 tp->dtdt_ckind = ctf_type_kind(dnp->dn_ctfp,
4611 ctf_type_resolve(dnp->dn_ctfp, dnp->dn_type));
4614 tp->dtdt_flags = (dnp->dn_flags & DT_NF_REF) ? DIF_TF_BYREF : 0;
4616 tp->dtdt_size = ctf_type_size(dnp->dn_ctfp, dnp->dn_type);
4620 dt_node_printr(dt_node_t *dnp, FILE *fp, int depth)
4628 (void) dt_attr_str(dnp->dn_attr, a, sizeof (a));
4630 if (dnp->dn_ctfp != NULL && dnp->dn_type != CTF_ERR &&
4631 ctf_type_name(dnp->dn_ctfp, dnp->dn_type, n, sizeof (n)) != NULL) {
4635 dnp->dn_type, a);
4638 if (dnp->dn_flags != 0) {
4640 if (dnp->dn_flags & DT_NF_SIGNED)
4642 if (dnp->dn_flags & DT_NF_COOKED)
4644 if (dnp->dn_flags & DT_NF_REF)
4646 if (dnp->dn_flags & DT_NF_LVALUE)
4648 if (dnp->dn_flags & DT_NF_WRITABLE)
4650 if (dnp->dn_flags & DT_NF_BITFIELD)
4652 if (dnp->dn_flags & DT_NF_USERLAND)
4658 switch (dnp->dn_kind) {
4660 (void) fprintf(fp, "FREE <node %p>\n", (void *)dnp);
4665 (u_longlong_t)dnp->dn_value, buf);
4669 (void) fprintf(fp, "STRING \"%s\" (%s)\n", dnp->dn_string, buf);
4673 (void) fprintf(fp, "IDENT %s (%s)\n", dnp->dn_string, buf);
4678 (dnp->dn_ident->di_flags & DT_IDFLG_LOCAL) ? "this->" :
4679 (dnp->dn_ident->di_flags & DT_IDFLG_TLS) ? "self->" : "",
4680 dnp->dn_ident->di_name, buf);
4682 if (dnp->dn_args != NULL)
4685 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4691 if (dnp->dn_args != NULL)
4696 dts = dnp->dn_ident->di_data;
4702 if (dnp->dn_string != NULL) {
4704 buf, dnp->dn_string);
4711 dnp->dn_ident->di_name, buf);
4713 for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list) {
4721 (void) fprintf(fp, "OP1 %s (%s)\n", opstr(dnp->dn_op), buf);
4722 dt_node_printr(dnp->dn_child, fp, depth + 1);
4726 (void) fprintf(fp, "OP2 %s (%s)\n", opstr(dnp->dn_op), buf);
4727 dt_node_printr(dnp->dn_left, fp, depth + 1);
4728 dt_node_printr(dnp->dn_right, fp, depth + 1);
4733 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4735 dt_node_printr(dnp->dn_left, fp, depth + 1);
4737 dt_node_printr(dnp->dn_right, fp, depth + 1);
4743 dt_node_printr(dnp->dn_expr, fp, depth + 1);
4748 dnp->dn_ident->di_name, a);
4750 for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list) {
4756 if (dnp->dn_aggfun) {
4758 dt_node_printr(dnp->dn_aggfun, fp, depth + 1);
4762 if (dnp->dn_aggfun)
4768 dnp->dn_desc->dtpd_provider, dnp->dn_desc->dtpd_mod,
4769 dnp->dn_desc->dtpd_func, dnp->dn_desc->dtpd_name,
4770 dnp->dn_desc->dtpd_id);
4776 for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
4780 dt_attr_str(dnp->dn_ctxattr, a, sizeof (a)));
4782 if (dnp->dn_pred != NULL) {
4784 dt_node_printr(dnp->dn_pred, fp, depth + 1);
4788 for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
4793 inp = dnp->dn_ident->di_iarg;
4796 dnp->dn_ident->di_name, buf);
4801 (void) fprintf(fp, "MEMBER %s (%s)\n", dnp->dn_membname, buf);
4802 if (dnp->dn_membexpr)
4803 dt_node_printr(dnp->dn_membexpr, fp, depth + 1);
4809 if (ctf_type_name(dnp->dn_xlator->dx_src_ctfp,
4810 dnp->dn_xlator->dx_src_type, n, sizeof (n)) != NULL)
4813 if (ctf_type_name(dnp->dn_xlator->dx_dst_ctfp,
4814 dnp->dn_xlator->dx_dst_type, n, sizeof (n)) != NULL)
4819 for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
4824 (void) fprintf(fp, "PROBE %s\n", dnp->dn_ident->di_name);
4829 dnp->dn_provname, dnp->dn_provred ? "redecl" : "decl");
4830 for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
4836 for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
4842 (void *)dnp, dnp->dn_kind);
4847 dt_node_root(dt_node_t *dnp)
4849 yypcb->pcb_root = dnp;
4855 dnerror(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
4860 yylineno = dnp->dn_line;
4872 dnwarn(const dt_node_t *dnp, dt_errtag_t tag, const char *format, ...)
4877 yylineno = dnp->dn_line;