/*
* Cook an associative array identifier. If this is the first time we are
* cooking this array, create its signature based on the argument list.
* Otherwise validate the argument list against the existing signature.
*/
static void
dt_idcook_assc(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
{
if (idp->di_data == NULL) {
dt_idsig_t *isp = idp->di_data = malloc(sizeof (dt_idsig_t));
char n[DT_TYPE_NAMELEN];
int i;
if (isp == NULL)
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
isp->dis_varargs = -1;
isp->dis_optargs = -1;
isp->dis_argc = argc;
isp->dis_args = NULL;
isp->dis_auxinfo = 0;
if (argc != 0 && (isp->dis_args = calloc(argc,
sizeof (dt_node_t))) == NULL) {
idp->di_data = NULL;
free(isp);
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
}
/*
* If this identifier has not been explicitly declared earlier,
* set the identifier's base type to be our special type <DYN>.
* If this ident is an aggregation, it will remain as is. If
* this ident is an associative array, it will be reassigned
* based on the result type of the first assignment statement.
*/
if (!(idp->di_flags & DT_IDFLG_DECL)) {
idp->di_ctfp = DT_DYN_CTFP(yypcb->pcb_hdl);
idp->di_type = DT_DYN_TYPE(yypcb->pcb_hdl);
}
for (i = 0; i < argc; i++, args = args->dn_list) {
if (dt_node_is_dynamic(args) || dt_node_is_void(args)) {
xyerror(D_KEY_TYPE, "%s expression may not be "
"used as %s index: key #%d\n",
dt_node_type_name(args, n, sizeof (n)),
dt_idkind_name(idp->di_kind), i + 1);
}
dt_node_type_propagate(args, &isp->dis_args[i]);
isp->dis_args[i].dn_list = &isp->dis_args[i + 1];
}
if (argc != 0)
isp->dis_args[argc - 1].dn_list = NULL;
dt_node_type_assign(dnp, idp->di_ctfp, idp->di_type);
} else {
dt_idcook_sign(dnp, idp, argc, args,
idp->di_kind == DT_IDENT_AGG ? "@" : "", "[ ]");
}
}
/*
* Lookup the dynamic translator type tag for the specified probe argument and
* assign the type to the specified node. If the type is not yet defined, add
* it to the "D" module's type container as a typedef for an unknown type.
*/
dt_node_t *
dt_probe_tag(dt_probe_t *prp, uint_t argn, dt_node_t *dnp)
{
dtrace_hdl_t *dtp = prp->pr_pvp->pv_hdl;
dtrace_typeinfo_t dtt;
size_t len;
char *tag;
len = snprintf(NULL, 0, "__dtrace_%s___%s_arg%u",
prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
tag = alloca(len + 1);
(void) snprintf(tag, len + 1, "__dtrace_%s___%s_arg%u",
prp->pr_pvp->pv_desc.dtvd_name, prp->pr_name, argn);
if (dtrace_lookup_by_type(dtp, DTRACE_OBJ_DDEFS, tag, &dtt) != 0) {
dtt.dtt_object = DTRACE_OBJ_DDEFS;
dtt.dtt_ctfp = DT_DYN_CTFP(dtp);
dtt.dtt_type = ctf_add_typedef(DT_DYN_CTFP(dtp),
CTF_ADD_ROOT, tag, DT_DYN_TYPE(dtp));
if (dtt.dtt_type == CTF_ERR ||
ctf_update(dtt.dtt_ctfp) == CTF_ERR) {
xyerror(D_UNKNOWN, "cannot define type %s: %s\n",
tag, ctf_errmsg(ctf_errno(dtt.dtt_ctfp)));
}
}
bzero(dnp, sizeof (dt_node_t));
dnp->dn_kind = DT_NODE_TYPE;
dt_node_type_assign(dnp, dtt.dtt_ctfp, dtt.dtt_type, B_FALSE);
dt_node_attr_assign(dnp, _dtrace_defattr);
return (dnp);
}
/*
* Cook a reference to the dynamically typed args[] array. We verify that the
* reference is using a single integer constant, and then construct a new ident
* representing the appropriate type or translation specifically for this node.
*/
static void
dt_idcook_args(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *ap)
{
dtrace_hdl_t *dtp = yypcb->pcb_hdl;
dt_probe_t *prp = yypcb->pcb_probe;
dt_node_t tag, *nnp, *xnp;
dt_xlator_t *dxp;
dt_ident_t *xidp;
char n1[DT_TYPE_NAMELEN];
char n2[DT_TYPE_NAMELEN];
if (argc != 1) {
xyerror(D_PROTO_LEN, "%s[ ] prototype mismatch: %d arg%s"
"passed, 1 expected\n", idp->di_name, argc,
argc == 1 ? " " : "s ");
}
if (ap->dn_kind != DT_NODE_INT) {
xyerror(D_PROTO_ARG, "%s[ ] argument #1 is incompatible with "
"prototype:\n\tprototype: %s\n\t argument: %s\n",
idp->di_name, "integer constant",
dt_type_name(ap->dn_ctfp, ap->dn_type, n1, sizeof (n1)));
}
if (yypcb->pcb_pdesc == NULL) {
xyerror(D_ARGS_NONE, "%s[ ] may not be referenced outside "
"of a probe clause\n", idp->di_name);
}
if (prp == NULL) {
xyerror(D_ARGS_MULTI,
"%s[ ] may not be referenced because probe description %s "
"matches an unstable set of probes\n", idp->di_name,
dtrace_desc2str(yypcb->pcb_pdesc, n1, sizeof (n1)));
}
if (ap->dn_value >= prp->pr_argc) {
xyerror(D_ARGS_IDX, "index %lld is out of range for %s %s[ ]\n",
(longlong_t)ap->dn_value, dtrace_desc2str(yypcb->pcb_pdesc,
n1, sizeof (n1)), idp->di_name);
}
/*
* Look up the native and translated argument types for the probe.
* If no translation is needed, these will be the same underlying node.
* If translation is needed, look up the appropriate translator. Once
* we have the appropriate node, create a new dt_ident_t for this node,
* assign it the appropriate attributes, and set the type of 'dnp'.
*/
xnp = prp->pr_xargv[ap->dn_value];
nnp = prp->pr_nargv[prp->pr_mapping[ap->dn_value]];
if (xnp->dn_type == CTF_ERR) {
xyerror(D_ARGS_TYPE, "failed to resolve translated type for "
"%s[%lld]\n", idp->di_name, (longlong_t)ap->dn_value);
}
if (nnp->dn_type == CTF_ERR) {
xyerror(D_ARGS_TYPE, "failed to resolve native type for "
"%s[%lld]\n", idp->di_name, (longlong_t)ap->dn_value);
}
if (dtp->dt_xlatemode == DT_XL_STATIC && (
nnp == xnp || dt_node_is_argcompat(nnp, xnp))) {
dnp->dn_ident = dt_ident_create(idp->di_name, idp->di_kind,
idp->di_flags | DT_IDFLG_ORPHAN, idp->di_id, idp->di_attr,
idp->di_vers, idp->di_ops, idp->di_iarg, idp->di_gen);
if (dnp->dn_ident == NULL)
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
dt_node_type_assign(dnp,
prp->pr_argv[ap->dn_value].dtt_ctfp,
prp->pr_argv[ap->dn_value].dtt_type);
} else if ((dxp = dt_xlator_lookup(dtp,
nnp, xnp, DT_XLATE_FUZZY)) != NULL || (
dxp = dt_xlator_lookup(dtp, dt_probe_tag(prp, ap->dn_value, &tag),
xnp, DT_XLATE_EXACT | DT_XLATE_EXTERN)) != NULL) {
xidp = dt_xlator_ident(dxp, xnp->dn_ctfp, xnp->dn_type);
dnp->dn_ident = dt_ident_create(idp->di_name, xidp->di_kind,
xidp->di_flags | DT_IDFLG_ORPHAN, idp->di_id, idp->di_attr,
idp->di_vers, idp->di_ops, idp->di_iarg, idp->di_gen);
if (dnp->dn_ident == NULL)
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
if (dt_xlator_dynamic(dxp))
dxp->dx_arg = (int)ap->dn_value;
/*
* Propagate relevant members from the translator's internal
* dt_ident_t. This code must be kept in sync with the state
* that is initialized for idents in dt_xlator_create().
*/
dnp->dn_ident->di_data = xidp->di_data;
dnp->dn_ident->di_ctfp = xidp->di_ctfp;
dnp->dn_ident->di_type = xidp->di_type;
dt_node_type_assign(dnp, DT_DYN_CTFP(dtp), DT_DYN_TYPE(dtp));
} else {
xyerror(D_ARGS_XLATOR, "translator for %s[%lld] from %s to %s "
"is not defined\n", idp->di_name, (longlong_t)ap->dn_value,
dt_node_type_name(nnp, n1, sizeof (n1)),
dt_node_type_name(xnp, n2, sizeof (n2)));
}
assert(dnp->dn_ident->di_flags & DT_IDFLG_ORPHAN);
assert(dnp->dn_ident->di_id == idp->di_id);
}
/*
* Cook a function call. If this is the first time we are cooking this
* identifier, create its type signature based on predefined prototype stored
* in di_iarg. We then validate the argument list against this signature.
*/
static void
dt_idcook_func(dt_node_t *dnp, dt_ident_t *idp, int argc, dt_node_t *args)
{
if (idp->di_data == NULL) {
dtrace_hdl_t *dtp = yypcb->pcb_hdl;
dtrace_typeinfo_t dtt;
dt_idsig_t *isp;
char *s, *p1, *p2;
int i = 0;
assert(idp->di_iarg != NULL);
s = alloca(strlen(idp->di_iarg) + 1);
(void) strcpy(s, idp->di_iarg);
if ((p2 = strrchr(s, ')')) != NULL)
*p2 = '\0'; /* mark end of parameter list string */
if ((p1 = strchr(s, '(')) != NULL)
*p1++ = '\0'; /* mark end of return type string */
if (p1 == NULL || p2 == NULL) {
xyerror(D_UNKNOWN, "internal error: malformed entry "
"for built-in function %s\n", idp->di_name);
}
for (p2 = p1; *p2 != '\0'; p2++) {
if (!isspace(*p2)) {
i++;
break;
}
}
for (p2 = strchr(p2, ','); p2++ != NULL; i++)
p2 = strchr(p2, ',');
/*
* We first allocate a new ident signature structure with the
* appropriate number of argument entries, and then look up
* the return type and store its CTF data in di_ctfp/type.
*/
if ((isp = idp->di_data = malloc(sizeof (dt_idsig_t))) == NULL)
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
isp->dis_varargs = -1;
isp->dis_optargs = -1;
isp->dis_argc = i;
isp->dis_args = NULL;
isp->dis_auxinfo = 0;
if (i != 0 && (isp->dis_args = calloc(i,
sizeof (dt_node_t))) == NULL) {
idp->di_data = NULL;
free(isp);
longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
}
if (dt_type_lookup(s, &dtt) == -1) {
xyerror(D_UNKNOWN, "failed to resolve type of %s (%s):"
" %s\n", idp->di_name, s,
dtrace_errmsg(dtp, dtrace_errno(dtp)));
}
if (idp->di_kind == DT_IDENT_AGGFUNC) {
idp->di_ctfp = DT_DYN_CTFP(dtp);
idp->di_type = DT_DYN_TYPE(dtp);
} else {
idp->di_ctfp = dtt.dtt_ctfp;
idp->di_type = dtt.dtt_type;
}
/*
* For each comma-delimited parameter in the prototype string,
* we look up the corresponding type and store its CTF data in
* the corresponding location in dis_args[]. We also recognize
* the special type string "@" to indicate that the specified
* parameter may be a D expression of *any* type (represented
* as a dis_args[] element with ctfp = NULL, type == CTF_ERR).
* If a varargs "..." is present, we record the argument index
* in dis_varargs for the benefit of dt_idcook_sign(), above.
* If the type of an argument is enclosed in square brackets
* (e.g. "[int]"), the argument is considered optional: the
* argument may be absent, but if it is present, it must be of
* the specified type. Note that varargs may not optional,
* optional arguments may not follow varargs, and non-optional
* arguments may not follow optional arguments.
*/
for (i = 0; i < isp->dis_argc; i++, p1 = p2) {
while (isspace(*p1))
p1++; /* skip leading whitespace */
if ((p2 = strchr(p1, ',')) == NULL)
p2 = p1 + strlen(p1);
else
*p2++ = '\0';
if (strcmp(p1, "@") == 0 || strcmp(p1, "...") == 0) {
isp->dis_args[i].dn_ctfp = NULL;
isp->dis_args[i].dn_type = CTF_ERR;
if (*p1 == '.')
isp->dis_varargs = i;
continue;
}
if (*p1 == '[' && p1[strlen(p1) - 1] == ']') {
if (isp->dis_varargs != -1) {
xyerror(D_UNKNOWN, "optional arg#%d "
"may not follow variable arg#%d\n",
i + 1, isp->dis_varargs + 1);
}
if (isp->dis_optargs == -1)
isp->dis_optargs = i;
p1[strlen(p1) - 1] = '\0';
p1++;
} else if (isp->dis_optargs != -1) {
xyerror(D_UNKNOWN, "required arg#%d may not "
"follow optional arg#%d\n", i + 1,
isp->dis_optargs + 1);
}
if (dt_type_lookup(p1, &dtt) == -1) {
xyerror(D_UNKNOWN, "failed to resolve type of "
"%s arg#%d (%s): %s\n", idp->di_name, i + 1,
p1, dtrace_errmsg(dtp, dtrace_errno(dtp)));
}
dt_node_type_assign(&isp->dis_args[i],
dtt.dtt_ctfp, dtt.dtt_type);
}
}
dt_idcook_sign(dnp, idp, argc, args, "", "( )");
}