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) 2011, Joyent Inc. All rights reserved.
25 */
26
27#include <assert.h>
28#include <strings.h>
29#include <alloca.h>
30#include <fcntl.h>
31#include <stdlib.h>
32#include <stdio.h>
33
34#include <sys/types.h>
35#include <sys/stat.h>
36
37#include <dt_parser.h>
38#include <dt_impl.h>
39#include <dt_provider.h>
40#include <dt_module.h>
41
42/*
43 * This callback function is installed in a given identifier hash to search for
44 * and apply deferred pragmas that are pending for a given new identifier name.
45 * Multiple pragmas may be pending for a given name; we processs all of them.
46 */
47/*ARGSUSED*/
48static void
49dt_pragma_apply(dt_idhash_t *dhp, dt_ident_t *idp)
50{
51	dt_idhash_t *php;
52	dt_ident_t *pdp;
53
54	if ((php = yypcb->pcb_pragmas) == NULL)
55		return; /* no pragmas pending for current compilation pass */
56
57	while ((pdp = dt_idhash_lookup(php, idp->di_name)) != NULL) {
58		switch (pdp->di_kind) {
59		case DT_IDENT_PRAGAT:
60			idp->di_attr = pdp->di_attr;
61			break;
62		case DT_IDENT_PRAGBN:
63			idp->di_vers = pdp->di_vers;
64			break;
65		}
66		dt_idhash_delete(php, pdp);
67	}
68}
69
70/*
71 * The #pragma attributes directive can be used to reset stability attributes
72 * on a global identifier or inline definition.  If the identifier is already
73 * defined, we can just change di_attr.  If not, we insert the pragma into a
74 * hash table of the current pcb's deferred pragmas for later processing.
75 */
76static void
77dt_pragma_attributes(const char *prname, dt_node_t *dnp)
78{
79	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
80	dtrace_attribute_t attr, *a;
81	dt_provider_t *pvp;
82	const char *name, *part;
83	dt_ident_t *idp;
84
85	if (dnp == NULL || dnp->dn_kind != DT_NODE_IDENT ||
86	    dnp->dn_list == NULL || dnp->dn_list->dn_kind != DT_NODE_IDENT) {
87		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
88		    "<attributes> <ident>\n", prname);
89	}
90
91	if (dtrace_str2attr(dnp->dn_string, &attr) == -1) {
92		xyerror(D_PRAGMA_INVAL, "invalid attributes "
93		    "specified by #pragma %s\n", prname);
94	}
95
96	dnp = dnp->dn_list;
97	name = dnp->dn_string;
98
99	if (strcmp(name, "provider") == 0) {
100		dnp = dnp->dn_list;
101		name = dnp->dn_string;
102
103		dnp = dnp->dn_list;
104		part = dnp->dn_string;
105
106		if ((pvp = dt_provider_lookup(dtp, name)) != NULL) {
107			if (strcmp(part, "provider") == 0) {
108				a = &pvp->pv_desc.dtvd_attr.dtpa_provider;
109			} else if (strcmp(part, "module") == 0) {
110				a = &pvp->pv_desc.dtvd_attr.dtpa_mod;
111			} else if (strcmp(part, "function") == 0) {
112				a = &pvp->pv_desc.dtvd_attr.dtpa_func;
113			} else if (strcmp(part, "name") == 0) {
114				a = &pvp->pv_desc.dtvd_attr.dtpa_name;
115			} else if (strcmp(part, "args") == 0) {
116				a = &pvp->pv_desc.dtvd_attr.dtpa_args;
117			} else {
118				xyerror(D_PRAGMA_INVAL, "invalid component "
119				    "\"%s\" in attribute #pragma "
120				    "for provider %s\n", name, part);
121			}
122
123			*a = attr;
124			return;
125		}
126
127	} else if ((idp = dt_idstack_lookup(
128	    &yypcb->pcb_globals, name)) != NULL) {
129
130		if (idp->di_gen != dtp->dt_gen) {
131			xyerror(D_PRAGMA_SCOPE, "#pragma %s cannot modify "
132			    "entity defined outside program scope\n", prname);
133		}
134
135		idp->di_attr = attr;
136		return;
137	}
138
139	if (yypcb->pcb_pragmas == NULL && (yypcb->pcb_pragmas =
140	    dt_idhash_create("pragma", NULL, 0, 0)) == NULL)
141		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
142
143	idp = dt_idhash_insert(yypcb->pcb_pragmas, name, DT_IDENT_PRAGAT, 0, 0,
144	    attr, 0, &dt_idops_thaw, (void *)prname, dtp->dt_gen);
145
146	if (idp == NULL)
147		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
148
149	if (dtp->dt_globals->dh_defer == NULL)
150		dtp->dt_globals->dh_defer = &dt_pragma_apply;
151}
152
153/*
154 * The #pragma binding directive can be used to reset the version binding
155 * on a global identifier or inline definition.  If the identifier is already
156 * defined, we can just change di_vers.  If not, we insert the pragma into a
157 * hash table of the current pcb's deferred pragmas for later processing.
158 */
159static void
160dt_pragma_binding(const char *prname, dt_node_t *dnp)
161{
162	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
163	dt_version_t vers;
164	const char *name;
165	dt_ident_t *idp;
166
167	if (dnp == NULL || dnp->dn_kind != DT_NODE_STRING ||
168	    dnp->dn_list == NULL || dnp->dn_list->dn_kind != DT_NODE_IDENT) {
169		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
170		    "\"version\" <ident>\n", prname);
171	}
172
173	if (dt_version_str2num(dnp->dn_string, &vers) == -1) {
174		xyerror(D_PRAGMA_INVAL, "invalid version string "
175		    "specified by #pragma %s\n", prname);
176	}
177
178	name = dnp->dn_list->dn_string;
179	idp = dt_idstack_lookup(&yypcb->pcb_globals, name);
180
181	if (idp != NULL) {
182		if (idp->di_gen != dtp->dt_gen) {
183			xyerror(D_PRAGMA_SCOPE, "#pragma %s cannot modify "
184			    "entity defined outside program scope\n", prname);
185		}
186		idp->di_vers = vers;
187		return;
188	}
189
190	if (yypcb->pcb_pragmas == NULL && (yypcb->pcb_pragmas =
191	    dt_idhash_create("pragma", NULL, 0, 0)) == NULL)
192		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
193
194	idp = dt_idhash_insert(yypcb->pcb_pragmas, name, DT_IDENT_PRAGBN, 0, 0,
195	    _dtrace_defattr, vers, &dt_idops_thaw, (void *)prname, dtp->dt_gen);
196
197	if (idp == NULL)
198		longjmp(yypcb->pcb_jmpbuf, EDT_NOMEM);
199
200	if (dtp->dt_globals->dh_defer == NULL)
201		dtp->dt_globals->dh_defer = &dt_pragma_apply;
202}
203
204static void
205dt_pragma_depends_finddep(dtrace_hdl_t *dtp, const char *lname, char *lib,
206    size_t len)
207{
208	dt_dirpath_t *dirp;
209	struct stat sbuf;
210	int found = 0;
211
212	for (dirp = dt_list_next(&dtp->dt_lib_path); dirp != NULL;
213	    dirp = dt_list_next(dirp)) {
214		(void) snprintf(lib, len, "%s/%s", dirp->dir_path, lname);
215
216		if (stat(lib, &sbuf) == 0) {
217			found = 1;
218			break;
219		}
220	}
221
222	if (!found)
223		xyerror(D_PRAGMA_DEPEND,
224		    "failed to find dependency in libpath: %s", lname);
225}
226
227/*
228 * The #pragma depends_on directive can be used to express a dependency on a
229 * module, provider or library which if not present will cause processing to
230 * abort.
231 */
232static void
233dt_pragma_depends(const char *prname, dt_node_t *cnp)
234{
235	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
236	dt_node_t *nnp = cnp ? cnp->dn_list : NULL;
237	int found;
238	dt_lib_depend_t *dld;
239	char lib[MAXPATHLEN];
240
241	if (cnp == NULL || nnp == NULL ||
242	    cnp->dn_kind != DT_NODE_IDENT || nnp->dn_kind != DT_NODE_IDENT) {
243		xyerror(D_PRAGMA_MALFORM, "malformed #pragma %s "
244		    "<class> <name>\n", prname);
245	}
246
247	if (strcmp(cnp->dn_string, "provider") == 0)
248		found = dt_provider_lookup(dtp, nnp->dn_string) != NULL;
249	else if (strcmp(cnp->dn_string, "module") == 0) {
250		dt_module_t *mp = dt_module_lookup_by_name(dtp, nnp->dn_string);
251		found = mp != NULL && dt_module_getctf(dtp, mp) != NULL;
252	} else if (strcmp(cnp->dn_string, "library") == 0) {
253		if (yypcb->pcb_cflags & DTRACE_C_CTL) {
254			assert(dtp->dt_filetag != NULL);
255
256			dt_pragma_depends_finddep(dtp, nnp->dn_string, lib,
257			    sizeof (lib));
258
259			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep,
260			    dtp->dt_filetag);
261			assert(dld != NULL);
262
263			if ((dt_lib_depend_add(dtp, &dld->dtld_dependencies,
264			    lib)) != 0) {
265				xyerror(D_PRAGMA_DEPEND,
266				    "failed to add dependency %s:%s\n", lib,
267				    dtrace_errmsg(dtp, dtrace_errno(dtp)));
268			}
269		} else {
270			/*
271			 * By this point we have already performed a topological
272			 * sort of the dependencies; we process this directive
273			 * as satisfied as long as the dependency was properly
274			 * loaded.
275			 */
276			if (dtp->dt_filetag == NULL)
277				xyerror(D_PRAGMA_DEPEND, "main program may "
278				    "not explicitly depend on a library");
279
280			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep,
281			    dtp->dt_filetag);
282			assert(dld != NULL);
283
284			dt_pragma_depends_finddep(dtp, nnp->dn_string, lib,
285			    sizeof (lib));
286			dld = dt_lib_depend_lookup(&dtp->dt_lib_dep_sorted,
287			    lib);
288			assert(dld != NULL);
289
290			if (!dld->dtld_loaded)
291				xyerror(D_PRAGMA_DEPEND, "program requires "
292				    "library \"%s\" which failed to load",
293				    lib);
294		}
295
296		found = B_TRUE;
297	} else {
298		xyerror(D_PRAGMA_INVAL, "invalid class %s "
299		    "specified by #pragma %s\n", cnp->dn_string, prname);
300	}
301
302	if (!found) {
303		xyerror(D_PRAGMA_DEPEND, "program requires %s %s\n",
304		    cnp->dn_string, nnp->dn_string);
305	}
306}
307
308/*
309 * The #pragma error directive can be followed by any list of tokens, which we
310 * just concatenate and print as part of our error message.
311 */
312static void
313dt_pragma_error(const char *prname, dt_node_t *dnp)
314{
315	dt_node_t *enp;
316	size_t n = 0;
317	char *s;
318
319	for (enp = dnp; enp != NULL; enp = enp->dn_list) {
320		if (enp->dn_kind == DT_NODE_IDENT ||
321		    enp->dn_kind == DT_NODE_STRING)
322			n += strlen(enp->dn_string) + 1;
323	}
324
325	s = alloca(n + 1);
326	s[0] = '\0';
327
328	for (enp = dnp; enp != NULL; enp = enp->dn_list) {
329		if (enp->dn_kind == DT_NODE_IDENT ||
330		    enp->dn_kind == DT_NODE_STRING) {
331			(void) strcat(s, enp->dn_string);
332			(void) strcat(s, " ");
333		}
334	}
335
336	xyerror(D_PRAGERR, "#%s: %s\n", prname, s);
337}
338
339/*ARGSUSED*/
340static void
341dt_pragma_ident(const char *prname, dt_node_t *dnp)
342{
343	/* ignore any #ident or #pragma ident lines */
344}
345
346static void
347dt_pragma_option(const char *prname, dt_node_t *dnp)
348{
349	dtrace_hdl_t *dtp = yypcb->pcb_hdl;
350	char *opt, *val;
351
352	if (dnp == NULL || dnp->dn_kind != DT_NODE_IDENT) {
353		xyerror(D_PRAGMA_MALFORM,
354		    "malformed #pragma %s <option>=<val>\n", prname);
355	}
356
357	if (dnp->dn_list != NULL) {
358		xyerror(D_PRAGMA_MALFORM,
359		    "superfluous arguments specified for #pragma %s\n", prname);
360	}
361
362	opt = strdupa(dnp->dn_string);
363
364	if ((val = strchr(opt, '=')) != NULL)
365		*val++ = '\0';
366
367	if (dtrace_setopt(dtp, opt, val) == -1) {
368		if (val == NULL) {
369			xyerror(D_PRAGMA_OPTSET,
370			    "failed to set option '%s': %s\n", opt,
371			    dtrace_errmsg(dtp, dtrace_errno(dtp)));
372		} else {
373			xyerror(D_PRAGMA_OPTSET,
374			    "failed to set option '%s' to '%s': %s\n",
375			    opt, val, dtrace_errmsg(dtp, dtrace_errno(dtp)));
376		}
377	}
378}
379
380/*
381 * The #line directive is used to reset the input line number and to optionally
382 * note the file name for use in error messages.  Sun cpp(1) also produces a
383 * third integer token after the filename which is one of the following:
384 *
385 * 0 - line change has nothing to do with an #include file
386 * 1 - line change because we just entered a #include file
387 * 2 - line change because we just exited a #include file
388 *
389 * We use these state tokens to adjust pcb_idepth, which in turn controls
390 * whether type lookups access the global type space or not.
391 */
392static void
393dt_pragma_line(const char *prname, dt_node_t *dnp)
394{
395	dt_node_t *fnp = dnp ? dnp->dn_list : NULL;
396	dt_node_t *inp = fnp ? fnp->dn_list : NULL;
397
398	if ((dnp == NULL || dnp->dn_kind != DT_NODE_INT) ||
399	    (fnp != NULL && fnp->dn_kind != DT_NODE_STRING) ||
400	    (inp != NULL && inp->dn_kind != DT_NODE_INT)) {
401		xyerror(D_PRAGMA_MALFORM, "malformed #%s "
402		    "<line> [ [\"file\"] state ]\n", prname);
403	}
404
405	/*
406	 * If a file is specified, free any old pcb_filetag and swap fnp's
407	 * dn_string into pcb_filetag as the new filename for error messages.
408	 */
409	if (fnp != NULL) {
410		if (yypcb->pcb_filetag != NULL)
411			free(yypcb->pcb_filetag);
412
413		/*
414		 * This is not pretty, but is a necessary evil until we either
415		 * write "dpp" or get a useful standalone cpp from DevPro.  If
416		 * the filename begins with /dev/fd, we know it's the master
417		 * input file (see dt_preproc() in dt_cc.c), so just clear the
418		 * dt_filetag pointer so error messages refer to the main file.
419		 */
420		if (strncmp(fnp->dn_string, "/dev/fd/", 8) != 0) {
421			yypcb->pcb_filetag = fnp->dn_string;
422			fnp->dn_string = NULL;
423		} else
424			yypcb->pcb_filetag = NULL;
425	}
426
427	if (inp != NULL) {
428		if (inp->dn_value == 1)
429			yypcb->pcb_idepth++;
430		else if (inp->dn_value == 2 && yypcb->pcb_idepth != 0)
431			yypcb->pcb_idepth--;
432	}
433
434	yylineno = dnp->dn_value;
435}
436
437/*
438 * D compiler pragma types range from control directives to common pragmas to
439 * D custom pragmas, in order of specificity.  Similar to gcc, we use #pragma D
440 * as a special prefix for our pragmas so they can be used in mixed headers.
441 */
442#define	DT_PRAGMA_DIR	0	/* pragma directive may be used after naked # */
443#define	DT_PRAGMA_SUB	1	/* pragma directive may be used after #pragma */
444#define	DT_PRAGMA_DCP	2	/* pragma may only be used after #pragma D */
445
446static const struct dt_pragmadesc {
447	const char *dpd_name;
448	void (*dpd_func)(const char *, dt_node_t *);
449	int dpd_kind;
450} dt_pragmas[] = {
451	{ "attributes", dt_pragma_attributes, DT_PRAGMA_DCP },
452	{ "binding", dt_pragma_binding, DT_PRAGMA_DCP },
453	{ "depends_on", dt_pragma_depends, DT_PRAGMA_DCP },
454	{ "error", dt_pragma_error, DT_PRAGMA_DIR },
455	{ "ident", dt_pragma_ident, DT_PRAGMA_DIR },
456	{ "line", dt_pragma_line, DT_PRAGMA_DIR },
457	{ "option", dt_pragma_option, DT_PRAGMA_DCP },
458	{ NULL, NULL }
459};
460
461/*
462 * Process a control line #directive by looking up the directive name in our
463 * lookup table and invoking the corresponding function with the token list.
464 * According to K&R[A12.9], we silently ignore null directive lines.
465 */
466void
467dt_pragma(dt_node_t *pnp)
468{
469	const struct dt_pragmadesc *dpd;
470	dt_node_t *dnp;
471	int kind = DT_PRAGMA_DIR;
472
473	for (dnp = pnp; dnp != NULL; dnp = dnp->dn_list) {
474		if (dnp->dn_kind == DT_NODE_INT) {
475			dt_pragma_line("line", dnp);
476			break;
477		}
478
479		if (dnp->dn_kind != DT_NODE_IDENT)
480			xyerror(D_PRAGCTL_INVAL, "invalid control directive\n");
481
482		if (kind == DT_PRAGMA_DIR &&
483		    strcmp(dnp->dn_string, "pragma") == 0) {
484			kind = DT_PRAGMA_SUB;
485			continue;
486		}
487
488		if (kind == DT_PRAGMA_SUB &&
489		    strcmp(dnp->dn_string, "D") == 0) {
490			kind = DT_PRAGMA_DCP;
491			continue;
492		}
493
494		for (dpd = dt_pragmas; dpd->dpd_name != NULL; dpd++) {
495			if (dpd->dpd_kind <= kind &&
496			    strcmp(dpd->dpd_name, dnp->dn_string) == 0)
497				break;
498		}
499
500		yylineno--; /* since we've already seen \n */
501
502		if (dpd->dpd_name != NULL) {
503			dpd->dpd_func(dpd->dpd_name, dnp->dn_list);
504			yylineno++;
505			break;
506		}
507
508		switch (kind) {
509		case DT_PRAGMA_DIR:
510			xyerror(D_PRAGCTL_INVAL, "invalid control directive: "
511			    "#%s\n", dnp->dn_string);
512			/*NOTREACHED*/
513		case DT_PRAGMA_SUB:
514			break; /* K&R[A12.8] says to ignore unknown pragmas */
515		case DT_PRAGMA_DCP:
516		default:
517			xyerror(D_PRAGMA_INVAL, "invalid D pragma: %s\n",
518			    dnp->dn_string);
519		}
520
521		yylineno++;
522		break;
523	}
524
525	dt_node_list_free(&pnp);
526}
527