/*
* CDDL HEADER START
*
* This file and its contents are supplied under the terms of the
* Common Development and Distribution License ("CDDL"), version 1.0.
* You may only use this file in accordance with the terms of version
* 1.0 of the CDDL.
*
* A full copy of the text of the CDDL should have accompanied this
* source. A copy of the CDDL is also available via the Internet at
* http://www.illumos.org/license/CDDL.
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2012, 2016 by Delphix. All rights reserved.
*/
/*
* Syntactic sugar features are implemented by transforming the D parse tree
* such that it only uses the subset of D that is supported by the rest of the
* compiler / the kernel. A clause containing these language features is
* referred to as a "super-clause", and its transformation typically entails
* creating several "sub-clauses" to implement it. For diagnosability, the
* sub-clauses will be printed if the "-xtree=8" flag is specified.
*
* Currently, the only syntactic sugar feature is "if/else" statements. Each
* basic block (e.g. the body of the "if" and "else" statements, and the
* statements before and after) is turned into its own sub-clause, with a
* predicate that causes it to be executed only if the code flows to this point.
* Nested if/else statements are supported.
*
* This infrastructure is designed to accommodate other syntactic sugar features
* in the future.
*/
#include <sys/types.h>
#include <sys/wait.h>
#include <sys/sysmacros.h>
#include <assert.h>
#include <strings.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <dt_module.h>
#include <dt_program.h>
#include <dt_provider.h>
#include <dt_printf.h>
#include <dt_pid.h>
#include <dt_grammar.h>
#include <dt_ident.h>
#include <dt_string.h>
#include <dt_impl.h>
typedef struct dt_sugar_parse {
dtrace_hdl_t *dtsp_dtp; /* dtrace handle */
dt_node_t *dtsp_pdescs; /* probe descriptions */
int dtsp_num_conditions; /* number of condition variables */
int dtsp_num_ifs; /* number of "if" statements */
dt_node_t *dtsp_clause_list; /* list of clauses */
} dt_sugar_parse_t;
static void dt_sugar_visit_stmts(dt_sugar_parse_t *, dt_node_t *, int);
/*
* Return a node for "self->%error".
*
* Note that the "%" is part of the variable name, and is included so that
* this variable name can not collide with any user-specified variable.
*
* This error variable is used to keep track of if there has been an error
* in any of the sub-clauses, and is used to prevent execution of subsequent
* sub-clauses following an error.
*/
static dt_node_t *
dt_sugar_new_error_var(void)
{
return (dt_node_op2(DT_TOK_PTR, dt_node_ident(strdup("self")),
dt_node_ident(strdup("%error"))));
}
/*
* Append this clause to the clause list.
*/
static void
dt_sugar_append_clause(dt_sugar_parse_t *dp, dt_node_t *clause)
{
dp->dtsp_clause_list = dt_node_link(dp->dtsp_clause_list, clause);
}
/*
* Prepend this clause to the clause list.
*/
static void
dt_sugar_prepend_clause(dt_sugar_parse_t *dp, dt_node_t *clause)
{
dp->dtsp_clause_list = dt_node_link(clause, dp->dtsp_clause_list);
}
/*
* Return a node for "this->%condition_<condid>", or NULL if condid==0.
*
* Note that the "%" is part of the variable name, and is included so that
* this variable name can not collide with any user-specified variable.
*/
static dt_node_t *
dt_sugar_new_condition_var(int condid)
{
char *str;
if (condid == 0)
return (NULL);
assert(condid > 0);
(void) asprintf(&str, "%%condition_%d", ABS(condid));
return (dt_node_op2(DT_TOK_PTR, dt_node_ident(strdup("this")),
dt_node_ident(str)));
}
/*
* Return new clause to evaluate predicate and set newcond. condid is
* the condition that we are already under, or 0 if none.
* The new clause will be of the form:
*
* dp_pdescs
* /!self->%error/
* {
* this->%condition_<newcond> =
* (this->%condition_<condid> && pred);
* }
*
* Note: if condid==0, we will instead do "... = (1 && pred)", to effectively
* convert the pred to a boolean.
*
* Note: Unless an error has been encountered, we always set the condition
* variable (either to 0 or 1). This lets us avoid resetting the condition
* variables back to 0 when the super-clause completes.
*/
static dt_node_t *
dt_sugar_new_condition_impl(dt_sugar_parse_t *dp,
dt_node_t *pred, int condid, int newcond)
{
dt_node_t *value, *body, *newpred;
/* predicate is !self->%error */
newpred = dt_node_op1(DT_TOK_LNEG, dt_sugar_new_error_var());
if (condid == 0) {
/*
* value is (1 && pred)
*
* Note, D doesn't allow a probe-local "this" variable to
* be reused as a different type, even from a different probe.
* Therefore, value can't simply be <pred>, because then
* its type could be different when we reuse this condid
* in a different meta-clause.
*/
value = dt_node_op2(DT_TOK_LAND, dt_node_int(1), pred);
} else {
/* value is (this->%condition_<condid> && pred) */
value = dt_node_op2(DT_TOK_LAND,
dt_sugar_new_condition_var(condid), pred);
}
/* body is "this->%condition_<retval> = <value>;" */
body = dt_node_statement(dt_node_op2(DT_TOK_ASGN,
dt_sugar_new_condition_var(newcond), value));
return (dt_node_clause(dp->dtsp_pdescs, newpred, body));
}
/*
* Generate a new clause to evaluate predicate and set a new condition variable,
* whose ID will be returned. The new clause will be appended to
* dp_first_new_clause.
*/
static int
dt_sugar_new_condition(dt_sugar_parse_t *dp, dt_node_t *pred, int condid)
{
dp->dtsp_num_conditions++;
dt_sugar_append_clause(dp, dt_sugar_new_condition_impl(dp,
pred, condid, dp->dtsp_num_conditions));
return (dp->dtsp_num_conditions);
}
/*
* Visit the specified node and all of its descendants. Currently this is only
* used to count the number of "if" statements (dtsp_num_ifs).
*/
static void
dt_sugar_visit_all(dt_sugar_parse_t *dp, dt_node_t *dnp)
{
dt_node_t *arg;
switch (dnp->dn_kind) {
case DT_NODE_FREE:
case DT_NODE_INT:
case DT_NODE_STRING:
case DT_NODE_SYM:
case DT_NODE_TYPE:
case DT_NODE_PROBE:
case DT_NODE_PDESC:
case DT_NODE_IDENT:
break;
case DT_NODE_FUNC:
for (arg = dnp->dn_args; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
case DT_NODE_OP1:
dt_sugar_visit_all(dp, dnp->dn_child);
break;
case DT_NODE_OP2:
dt_sugar_visit_all(dp, dnp->dn_left);
dt_sugar_visit_all(dp, dnp->dn_right);
if (dnp->dn_op == DT_TOK_LBRAC) {
dt_node_t *ln = dnp->dn_right;
while (ln->dn_list != NULL) {
dt_sugar_visit_all(dp, ln->dn_list);
ln = ln->dn_list;
}
}
break;
case DT_NODE_OP3:
dt_sugar_visit_all(dp, dnp->dn_expr);
dt_sugar_visit_all(dp, dnp->dn_left);
dt_sugar_visit_all(dp, dnp->dn_right);
break;
case DT_NODE_DEXPR:
case DT_NODE_DFUNC:
dt_sugar_visit_all(dp, dnp->dn_expr);
break;
case DT_NODE_AGG:
for (arg = dnp->dn_aggtup; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
if (dnp->dn_aggfun)
dt_sugar_visit_all(dp, dnp->dn_aggfun);
break;
case DT_NODE_CLAUSE:
for (arg = dnp->dn_pdescs; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
if (dnp->dn_pred != NULL)
dt_sugar_visit_all(dp, dnp->dn_pred);
for (arg = dnp->dn_acts; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
case DT_NODE_INLINE: {
const dt_idnode_t *inp = dnp->dn_ident->di_iarg;
dt_sugar_visit_all(dp, inp->din_root);
break;
}
case DT_NODE_MEMBER:
if (dnp->dn_membexpr)
dt_sugar_visit_all(dp, dnp->dn_membexpr);
break;
case DT_NODE_XLATOR:
for (arg = dnp->dn_members; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
case DT_NODE_PROVIDER:
for (arg = dnp->dn_probes; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
case DT_NODE_PROG:
for (arg = dnp->dn_list; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
case DT_NODE_IF:
dp->dtsp_num_ifs++;
dt_sugar_visit_all(dp, dnp->dn_conditional);
for (arg = dnp->dn_body; arg != NULL; arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
for (arg = dnp->dn_alternate_body; arg != NULL;
arg = arg->dn_list)
dt_sugar_visit_all(dp, arg);
break;
default:
(void) dnerror(dnp, D_UNKNOWN, "bad node %p, kind %d\n",
(void *)dnp, dnp->dn_kind);
}
}
/*
* Return a new clause which resets the error variable to zero:
*
* dp_pdescs{ self->%error = 0; }
*
* This clause will be executed at the beginning of each meta-clause, to
* ensure the error variable is unset (in case the previous meta-clause
* failed).
*/
static dt_node_t *
dt_sugar_new_clearerror_clause(dt_sugar_parse_t *dp)
{
dt_node_t *stmt = dt_node_statement(dt_node_op2(DT_TOK_ASGN,
dt_sugar_new_error_var(), dt_node_int(0)));
return (dt_node_clause(dp->dtsp_pdescs, NULL, stmt));
}
/*
* Evaluate the conditional, and recursively visit the body of the "if"
* statement (and the "else", if present).
*/
static void
dt_sugar_do_if(dt_sugar_parse_t *dp, dt_node_t *if_stmt, int precondition)
{
int newid;
assert(if_stmt->dn_kind == DT_NODE_IF);
/* condition */
newid = dt_sugar_new_condition(dp,
if_stmt->dn_conditional, precondition);
/* body of if */
dt_sugar_visit_stmts(dp, if_stmt->dn_body, newid);
/*
* Visit the body of the "else" statement, if present. Note that we
* generate a new condition which is the inverse of the previous
* condition.
*/
if (if_stmt->dn_alternate_body != NULL) {
dt_node_t *pred =
dt_node_op1(DT_TOK_LNEG, dt_sugar_new_condition_var(newid));
dt_sugar_visit_stmts(dp, if_stmt->dn_alternate_body,
dt_sugar_new_condition(dp, pred, precondition));
}
}
/*
* Generate a new clause to evaluate the statements based on the condition.
* The new clause will be appended to dp_first_new_clause.
*
* dp_pdescs
* /!self->%error && this->%condition_<condid>/
* {
* stmts
* }
*/
static void
dt_sugar_new_basic_block(dt_sugar_parse_t *dp, int condid, dt_node_t *stmts)
{
dt_node_t *pred = NULL;
if (condid == 0) {
/*
* Don't bother with !error on the first clause, because if
* there is only one clause, we don't add the prelude to
* zero out %error.
*/
if (dp->dtsp_num_conditions != 0) {
pred = dt_node_op1(DT_TOK_LNEG,
dt_sugar_new_error_var());
}
} else {
pred = dt_node_op2(DT_TOK_LAND,
dt_node_op1(DT_TOK_LNEG, dt_sugar_new_error_var()),
dt_sugar_new_condition_var(condid));
}
dt_sugar_append_clause(dp,
dt_node_clause(dp->dtsp_pdescs, pred, stmts));
}
/*
* Visit all the statements in this list, and break them into basic blocks,
* generating new clauses for "if" and "else" statements.
*/
static void
dt_sugar_visit_stmts(dt_sugar_parse_t *dp, dt_node_t *stmts, int precondition)
{
dt_node_t *stmt;
dt_node_t *prev_stmt = NULL;
dt_node_t *next_stmt;
dt_node_t *first_stmt_in_basic_block = NULL;
for (stmt = stmts; stmt != NULL; stmt = next_stmt) {
next_stmt = stmt->dn_list;
if (stmt->dn_kind != DT_NODE_IF) {
if (first_stmt_in_basic_block == NULL)
first_stmt_in_basic_block = stmt;
prev_stmt = stmt;
continue;
}
/*
* Remove this and following statements from the previous
* clause.
*/
if (prev_stmt != NULL)
prev_stmt->dn_list = NULL;
/*
* Generate clause for statements preceding the "if"
*/
if (first_stmt_in_basic_block != NULL) {
dt_sugar_new_basic_block(dp, precondition,
first_stmt_in_basic_block);
}
dt_sugar_do_if(dp, stmt, precondition);
first_stmt_in_basic_block = NULL;
prev_stmt = stmt;
}
/* generate clause for statements after last "if". */
if (first_stmt_in_basic_block != NULL) {
dt_sugar_new_basic_block(dp, precondition,
first_stmt_in_basic_block);
}
}
/*
* Generate a new clause which will set the error variable when an error occurs.
* Only one of these clauses is created per program (e.g. script file).
* The clause is:
*
* dtrace:::ERROR{ self->%error = 1; }
*/
static dt_node_t *
dt_sugar_makeerrorclause(void)
{
dt_node_t *acts, *pdesc;
pdesc = dt_node_pdesc_by_name(strdup("dtrace:::ERROR"));
acts = dt_node_statement(dt_node_op2(DT_TOK_ASGN,
dt_sugar_new_error_var(), dt_node_int(1)));
return (dt_node_clause(pdesc, NULL, acts));
}
/*
* Transform the super-clause into straight-D, returning the new list of
* sub-clauses.
*/
dt_node_t *
dt_compile_sugar(dtrace_hdl_t *dtp, dt_node_t *clause)
{
dt_sugar_parse_t dp = { 0 };
int condid = 0;
dp.dtsp_dtp = dtp;
dp.dtsp_pdescs = clause->dn_pdescs;
/* make dt_node_int() generate an "int"-typed integer */
yyintdecimal = B_TRUE;
yyintsuffix[0] = '\0';
yyintprefix = 0;
dt_sugar_visit_all(&dp, clause);
if (dp.dtsp_num_ifs == 0 && dp.dtsp_num_conditions == 0) {
/*
* There is nothing that modifies the number of clauses. Use
* the existing clause as-is, with its predicate intact. This
* ensures that in the absence of D sugar, the body of the
* clause can create a variable that is referenced in the
* predicate.
*/
dt_sugar_append_clause(&dp, dt_node_clause(clause->dn_pdescs,
clause->dn_pred, clause->dn_acts));
} else {
if (clause->dn_pred != NULL) {
condid = dt_sugar_new_condition(&dp,
clause->dn_pred, condid);
}
if (clause->dn_acts == NULL) {
/*
* dt_sugar_visit_stmts() does not emit a clause with
* an empty body (e.g. if there's an empty "if" body),
* but we need the empty body here so that we
* continue to get the default tracing action.
*/
dt_sugar_new_basic_block(&dp, condid, NULL);
} else {
dt_sugar_visit_stmts(&dp, clause->dn_acts, condid);
}
}
if (dp.dtsp_num_conditions != 0) {
dt_sugar_prepend_clause(&dp,
dt_sugar_new_clearerror_clause(&dp));
}
if (dp.dtsp_clause_list != NULL &&
dp.dtsp_clause_list->dn_list != NULL && !dtp->dt_has_sugar) {
dtp->dt_has_sugar = B_TRUE;
dt_sugar_prepend_clause(&dp, dt_sugar_makeerrorclause());
}
return (dp.dtsp_clause_list);
}