VBoxCompilerPlugInsGcc.cpp@ 69091

Last change on this file since 69091 was 69091, checked in by vboxsync, 7 years ago
gccplugin: va_arg workaround
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 33.4 KB

Line
1	/* $Id: VBoxCompilerPlugInsGcc.cpp 69091 2017-10-14 02:41:12Z vboxsync $ */
2	/** @file
3	* gccplugin - GCC plugin for checking IPRT format strings.
4	*/
5
6	/*
7	* Copyright (C) 2006-2017 Oracle Corporation
8	*
9	* This file is part of VirtualBox Open Source Edition (OSE), as
10	* available from http://www.virtualbox.org. This file is free software;
11	* you can redistribute it and/or modify it under the terms of the GNU
12	* General Public License (GPL) as published by the Free Software
13	* Foundation, in version 2 as it comes in the "COPYING" file of the
14	* VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15	* hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16	*/
17
18
19	/*********************************************************************************************************************************
20	* Header Files *
21	*********************************************************************************************************************************/
22	#include <stdio.h>
23	#include <iprt/cdefs.h>
24	#include <iprt/stdarg.h>
25
26	#if RT_GNUC_PREREQ(5, 1)
27	# include "gcc-plugin.h"
28	# include "plugin-version.h"
29	#endif
30	#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
31	# include "gmp.h"
32	extern "C" {
33	#endif
34	#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
35	# include "coretypes.h"
36	#endif
37	#include "plugin.h"
38	#include "basic-block.h"
39	#include "tree.h"
40	#include "tree-pass.h"
41	#include "gimple.h"
42	#if RT_GNUC_PREREQ(4, 9)
43	# include "gimple-iterator.h"
44	# include "context.h" /* for g */
45	#endif
46	#include "cp/cp-tree.h"
47	#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
48	}
49	#endif
50
51	#include "VBoxCompilerPlugIns.h"
52
53
54	/*********************************************************************************************************************************
55	* Global Variables *
56	*********************************************************************************************************************************/
57	/** License indicator. */
58	int plugin_is_GPL_compatible;
59
60
61	/*********************************************************************************************************************************
62	* Defined Constants And Macros *
63	*********************************************************************************************************************************/
64	/** Convencience macro not present in earlier gcc versions. */
65	#ifndef VAR_P
66	# define VAR_P(a_hNode) (TREE_CODE(a_hNode) == VAR_DECL)
67	#endif
68	/** Replacement for the 4.9.0 get_tree_code_name function. */
69	#if !RT_GNUC_PREREQ(4, 9)
70	# define get_tree_code_name(a_enmTreeCode) (tree_code_name[a_enmTreeCode])
71	#endif
72
73
74	/** For use with messages.
75	* @todo needs some more work... Actually, seems we're a bit handicapped by
76	* working on gimplified stuff. */
77	#define MY_LOC(a_hPreferred, a_pState) EXPR_LOC_OR_LOC(a_hPreferred, (a_pState)->hFmtLoc)
78
79	/** @name Compatibility glue
80	* @{ */
81	#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
82	# define linemap_location_from_macro_expansion_p(a, b) false
83	#endif
84	#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
85	static tree gimple_call_fntype(gimple hStmt)
86	{
87	tree hDecl = gimple_call_fndecl(hStmt);
88	if (hDecl)
89	return TREE_TYPE(hDecl);
90	hDecl = gimple_call_fn(hStmt);
91	if (TREE_CODE(hDecl) == OBJ_TYPE_REF)
92	hDecl = OBJ_TYPE_REF_EXPR(hDecl);
93	if (DECL_P(hDecl))
94	{
95	tree hType = TREE_TYPE(hDecl);
96	if (POINTER_TYPE_P(hType))
97	hType = TREE_TYPE(hType);
98	return hType;
99	}
100	return NULL_TREE; /* caller bitches about this*/
101	}
102	#endif
103
104	///* Integer to HOST_WIDE_INT conversion fun. */
105	//#if RT_GNUC_PREREQ(4, 6)
106	//# define MY_INT_FITS_SHWI(hNode) (hNode).fits_shwi()
107	//# define MY_INT_TO_SHWI(hNode) (hNode).to_shwi()
108	//#else
109	//# define MY_INT_FITS_SHWI(hNode) double_int_fits_in_shwi_p(hNode)
110	//# define MY_INT_TO_SHWI(hNode) double_int_to_shwi(hNode)
111	//#endif
112
113	/* Integer to HOST_WIDE_INT conversion fun. */
114	#if RT_GNUC_PREREQ(5, 1)
115	# define MY_DOUBLE_INT_FITS_SHWI(hNode) tree_fits_shwi_p(hNode)
116	# define MY_DOUBLE_INT_TO_SHWI(hNode) tree_to_shwi(hNode)
117	#elif RT_GNUC_PREREQ(4, 6)
118	# define MY_DOUBLE_INT_FITS_SHWI(hNode) (TREE_INT_CST(hNode).fits_shwi())
119	# define MY_DOUBLE_INT_TO_SHWI(hNode) (TREE_INT_CST(hNode).to_shwi())
120	#else
121	# define MY_DOUBLE_INT_FITS_SHWI(hNode) double_int_fits_in_shwi_p(TREE_INT_CST(hNode))
122	# define MY_DOUBLE_INT_TO_SHWI(hNode) double_int_to_shwi(TREE_INT_CST(hNode))
123	#endif
124
125	#ifndef EXPR_LOC_OR_LOC
126	# define EXPR_LOC_OR_LOC(a,b) (b)
127	#endif
128	/** @} */
129
130
131	/*********************************************************************************************************************************
132	* Internal Functions *
133	*********************************************************************************************************************************/
134	static bool MyPassGateCallback(void);
135	static unsigned int MyPassExecuteCallback(void);
136	static unsigned int MyPassExecuteCallbackWithFunction(struct function *pFun);
137	static tree AttributeHandler(tree , tree, tree, int, bool );
138
139
140	/*********************************************************************************************************************************
141	* Global Variables *
142	*********************************************************************************************************************************/
143	/** Plug-in info. */
144	static const struct plugin_info g_PlugInInfo =
145	{
146	version: "0.0.0-ALPHA",
147	help : "Implements the __iprt_format__ attribute for checking format strings and arguments."
148	};
149
150	#if RT_GNUC_PREREQ(4, 9)
151	/** My pass. */
152	static const pass_data g_MyPassData =
153	{
154	type : GIMPLE_PASS,
155	name : "iprt-format-checks", / asterisk = no dump */
156	optinfo_flags : 0,
157	tv_id : TV_NONE,
158	properties_required : 0,
159	properties_provided : 0,
160	properties_destroyed : 0,
161	todo_flags_start : 0,
162	todo_flags_finish : 0,
163	};
164
165	class MyPass : public gimple_opt_pass
166	{
167	public:
168	MyPass(gcc::context *pCtx) : gimple_opt_pass(g_MyPassData, pCtx)
169	{ }
170
171	virtual bool gate(function *pFun)
172	{
173	NOREF(pFun);
174	return MyPassGateCallback();
175	}
176
177	virtual unsigned int execute(function *pFun)
178	{
179	NOREF(pFun);
180	return MyPassExecuteCallbackWithFunction(pFun);
181	}
182	};
183
184	#else /* < 4.9.0 */
185
186	/** My pass. */
187	static struct gimple_opt_pass g_MyPass =
188	{
189	pass:
190	{
191	type : GIMPLE_PASS,
192	name : "iprt-format-checks", / asterisk = no dump */
193	# if __GNUC__ != 4 \|\| __GNUC_MINOR__ != 5
194	optinfo_flags : 0,
195	# endif
196	gate : MyPassGateCallback,
197	execute : MyPassExecuteCallback,
198	sub : NULL,
199	next : NULL,
200	static_pass_number : 0,
201	tv_id : TV_NONE,
202	properties_required : 0,
203	properties_provided : 0,
204	properties_destroyed : 0,
205	todo_flags_start : 0,
206	todo_flags_finish : 0,
207	}
208	};
209
210	/** The registration info for my pass. */
211	static const struct register_pass_info g_MyPassInfo =
212	{
213	pass : &g_MyPass.pass,
214	reference_pass_name : "ssa",
215	ref_pass_instance_number : 1,
216	pos_op : PASS_POS_INSERT_BEFORE,
217	};
218
219	#endif /* < 4.9.0 */
220
221
222	/** Attribute specifications. */
223	static const struct attribute_spec g_AttribSpecs[] =
224	{
225	{
226	name : "iprt_format",
227	min_length : 2,
228	max_length : 2,
229	decl_required : false,
230	type_required : true,
231	function_type_required : true,
232	handler : AttributeHandler,
233	#if __GNUC__ != 4 \|\| __GNUC_MINOR__ != 5
234	affects_type_identity : false
235	#endif
236	},
237	{
238	name : "iprt_format_maybe_null",
239	min_length : 2,
240	max_length : 2,
241	decl_required : false,
242	type_required : true,
243	function_type_required : true,
244	handler : AttributeHandler,
245	#if __GNUC__ != 4 \|\| __GNUC_MINOR__ != 5
246	affects_type_identity : false
247	#endif
248	}
249	};
250
251
252	#ifdef DEBUG
253
254	/**
255	* Debug function for printing the scope of a decl.
256	* @param hDecl Declaration to print scope for.
257	*/
258	static void dprintScope(tree hDecl)
259	{
260	# if 0 /* later? */
261	tree hScope = CP_DECL_CONTEXT(hDecl);
262	if (hScope == global_namespace)
263	return;
264	if (TREE_CODE(hScope) == RECORD_TYPE)
265	hScope = TYPE_NAME(hScope);
266
267	/* recurse */
268	dprintScope(hScope);
269
270	/* name the scope. */
271	dprintf("::%s", DECL_NAME(hScope) ? IDENTIFIER_POINTER(DECL_NAME(hScope)) : "<noname>");
272	# endif
273	}
274
275
276	/**
277	* Debug function for printing a declaration.
278	* @param hDecl The declaration to print.
279	*/
280	static void dprintDecl(tree hDecl)
281	{
282	enum tree_code const enmDeclCode = TREE_CODE(hDecl);
283	tree const hType = TREE_TYPE(hDecl);
284	enum tree_code const enmTypeCode = hType ? TREE_CODE(hType) : (enum tree_code)-1;
285	#if 0
286	if ( enmTypeCode == RECORD_TYPE
287	&& enmDeclCode == TYPE_DECL
288	&& DECL_ARTIFICIAL(hDecl))
289	dprint_class(hType);
290	#endif
291
292	dprintf("%s ", get_tree_code_name(enmDeclCode));
293	dprintScope(hDecl);
294	dprintf("::%s", DECL_NAME(hDecl) ? IDENTIFIER_POINTER(DECL_NAME(hDecl)) : "<noname>");
295	if (hType)
296	dprintf(" type %s", get_tree_code_name(enmTypeCode));
297	dprintf(" @%s:%d", DECL_SOURCE_FILE(hDecl), DECL_SOURCE_LINE(hDecl));
298	}
299
300	#endif /* DEBUG */
301
302
303	static location_t MyGetLocationPlusColumnOffset(location_t hLoc, unsigned int offColumn)
304	{
305	/*
306	* Skip NOOPs, reserved locations and macro expansion.
307	*/
308	if ( offColumn != 0
309	&& hLoc >= RESERVED_LOCATION_COUNT
310	&& !linemap_location_from_macro_expansion_p(line_table, hLoc))
311	{
312	#if __GNUC__ >= 5 /** @todo figure this... */
313	/*
314	* There is an API for doing this, nice.
315	*/
316	location_t hNewLoc = linemap_position_for_loc_and_offset(line_table, hLoc, offColumn);
317	if (hNewLoc && hNewLoc != hLoc)
318	{
319	dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u\n", hNewLoc, hLoc, offColumn);
320	return hNewLoc;
321	}
322
323	#elif __GNUC_MINOR__ > 5
324	/*
325	* Have to do the job ourselves, it seems. This is a bit hairy...
326	*/
327	line_map const *pMap = NULL;
328	location_t hLoc2 = linemap_resolve_location(line_table, hLoc, LRK_SPELLING_LOCATION, &pMap);
329	if (hLoc2)
330	hLoc = hLoc2;
331
332	/* Guard against wrap arounds and overlaps. */
333	if ( hLoc + offColumn > MAP_START_LOCATION(pMap) /** @todo Use MAX_SOURCE_LOCATION? */
334	&& ( pMap == LINEMAPS_LAST_ORDINARY_MAP(line_table)
335	\|\| hLoc + offColumn < MAP_START_LOCATION((pMap + 1))))
336	{
337	/* Calc new column and check that it's within the valid range. */
338	unsigned int uColumn = SOURCE_COLUMN(pMap, hLoc) + offColumn;
339	if (uColumn < RT_BIT_32(ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(pMap)))
340	{
341	/* Try add the position. If we get a valid result, replace the location. */
342	source_location hNewLoc = linemap_position_for_line_and_column((line_map *)pMap, SOURCE_LINE(pMap, hLoc), uColumn);
343	if ( hNewLoc <= line_table->highest_location
344	&& linemap_lookup(line_table, hNewLoc) != NULL)
345	{
346	dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u uColumn=%u\n",
347	hNewLoc, hLoc, offColumn, uColumn);
348	return hNewLoc;
349	}
350	}
351	}
352	#endif
353	}
354	dprintf("MyGetLocationPlusColumnOffset: taking fallback\n");
355	return hLoc;
356	}
357
358
359	static location_t MyGetFormatStringLocation(PVFMTCHKSTATE pState, const char *pszLoc)
360	{
361	location_t hLoc = pState->hFmtLoc;
362	#if RT_GNUC_PREREQ(4,6)
363	intptr_t offString = pszLoc - pState->pszFmt;
364	if ( offString >= 0
365	&& !linemap_location_from_macro_expansion_p(line_table, hLoc))
366	{
367	unsigned uCol = 1 + offString;
368	expanded_location XLoc = expand_location_to_spelling_point(hLoc);
369	int cchLine = 0;
370	# if RT_GNUC_PREREQ(5,0)
371	const char *pszLine = location_get_source_line(XLoc.file, XLoc.line, &cchLine);
372	# else
373	const char *pszLine = location_get_source_line(XLoc);
374	if (pszLine)
375	{
376	const char *pszEol = strpbrk(pszLine, "\n\r");
377	if (!pszEol)
378	pszEol = strchr(pszLine, '\0');
379	cchLine = (int)(pszEol - pszLine);
380	}
381	# endif
382	if (pszLine)
383	{
384	/** @todo Adjust the position by parsing the source. */
385	pszLine += XLoc.column - 1;
386	cchLine -= XLoc.column - 1;
387	}
388
389	hLoc = MyGetLocationPlusColumnOffset(hLoc, uCol);
390	}
391	#endif
392	return hLoc;
393	}
394
395
396	/**
397	* Non-recursive worker for MyCheckFormatRecursive.
398	*
399	* This will attempt to result @a hFmtArg into a string literal which it then
400	* passes on to MyCheckFormatString for the actual analyzis.
401	*
402	* @param pState The format string checking state.
403	* @param hFmtArg The format string node.
404	*/
405	DECL_NO_INLINE(static, void) MyCheckFormatNonRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
406	{
407	dprintf("checker: hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
408
409	/*
410	* Try resolve variables into constant strings.
411	*/
412	if (VAR_P(hFmtArg))
413	{
414	hFmtArg = decl_constant_value(hFmtArg);
415	STRIP_NOPS(hFmtArg); /* Used as argument and assigned call result. */
416	dprintf("checker1: variable => hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
417	}
418
419	/*
420	* Fend off NULLs.
421	*/
422	if (integer_zerop(hFmtArg))
423	{
424	if (pState->fMaybeNull)
425	VFmtChkVerifyEndOfArgs(pState, 0);
426	else
427	error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
428	}
429	/*
430	* Need address expression to get any further.
431	*/
432	else if (TREE_CODE(hFmtArg) != ADDR_EXPR)
433	dprintf("checker1: Not address expression (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
434	else
435	{
436	pState->hFmtLoc = EXPR_LOC_OR_LOC(hFmtArg, pState->hFmtLoc);
437	hFmtArg = TREE_OPERAND(hFmtArg, 0);
438
439	/*
440	* Deal with fixed string indexing, if possible.
441	*/
442	HOST_WIDE_INT off = 0;
443	if ( TREE_CODE(hFmtArg) == ARRAY_REF
444	&& MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1))
445	&& MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1)) )
446	{
447	off = MY_DOUBLE_INT_TO_SHWI(TREE_OPERAND(hFmtArg, 1));
448	if (off < 0)
449	{
450	dprintf("checker1: ARRAY_REF, off=%ld\n", off);
451	return;
452	}
453	hFmtArg = TREE_OPERAND(hFmtArg, 0);
454	dprintf("checker1: ARRAY_REF => hFmtArg=%p %s, off=%ld\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)), off);
455	}
456
457	/*
458	* Deal with static const char g_szFmt[] = "qwerty"; Take care as
459	* the actual string constant may not necessarily include the terminator.
460	*/
461	tree hArraySize = NULL_TREE;
462	if ( VAR_P(hFmtArg)
463	&& TREE_CODE(TREE_TYPE(hFmtArg)) == ARRAY_TYPE)
464	{
465	tree hArrayInitializer = decl_constant_value(hFmtArg);
466	if ( hArrayInitializer != hFmtArg
467	&& TREE_CODE(hArrayInitializer) == STRING_CST)
468	{
469	hArraySize = DECL_SIZE_UNIT(hFmtArg);
470	hFmtArg = hArrayInitializer;
471	}
472	}
473
474	/*
475	* Are we dealing with a string literal now?
476	*/
477	if (TREE_CODE(hFmtArg) != STRING_CST)
478	dprintf("checker1: Not string literal (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
479	else if (TYPE_MAIN_VARIANT(TREE_TYPE(TREE_TYPE(hFmtArg))) != char_type_node)
480	warning_at(pState->hFmtLoc, 0, "expected 'char' type string literal");
481	else
482	{
483	/*
484	* Yes we are, so get the pointer to the string and its length.
485	*/
486	const char *pszFmt = TREE_STRING_POINTER(hFmtArg);
487	int cchFmt = TREE_STRING_LENGTH(hFmtArg);
488
489	/* Adjust cchFmt to the initialized array size if appropriate. */
490	if (hArraySize != NULL_TREE)
491	{
492	if (TREE_CODE(hArraySize) != INTEGER_CST)
493	warning_at(pState->hFmtLoc, 0, "Expected integer array size (not %s)", get_tree_code_name(TREE_CODE(hArraySize)));
494	else if (!MY_DOUBLE_INT_FITS_SHWI(hArraySize))
495	warning_at(pState->hFmtLoc, 0, "Unexpected integer overflow in array size constant");
496	else
497	{
498	HOST_WIDE_INT cbArray = MY_DOUBLE_INT_TO_SHWI(hArraySize);
499	if ( cbArray <= 0
500	\|\| cbArray != (int)cbArray)
501	warning_at(pState->hFmtLoc, 0, "Unexpected integer array size constant value: %ld", cbArray);
502	else if (cchFmt > cbArray)
503	{
504	dprintf("checker1: cchFmt=%d => cchFmt=%ld (=cbArray)\n", cchFmt, cbArray);
505	cchFmt = (int)cbArray;
506	}
507	}
508	}
509
510	/* Apply the offset, if given. */
511	if (off)
512	{
513	if (off >= cchFmt)
514	{
515	dprintf("checker1: off=%ld >= cchFmt=%d -> skipping\n", off, cchFmt);
516	return;
517	}
518	pszFmt += off;
519	cchFmt -= (int)off;
520	}
521
522	/*
523	* Check for unterminated strings.
524	*/
525	if ( cchFmt < 1
526	\|\| pszFmt[cchFmt - 1] != '\0')
527	warning_at(pState->hFmtLoc, 0, "Unterminated format string (cchFmt=%d)", cchFmt);
528	/*
529	* Call worker to check the actual string.
530	*/
531	else
532	MyCheckFormatCString(pState, pszFmt);
533	}
534	}
535	}
536
537
538	/**
539	* Deal recursively with special format string constructs.
540	*
541	* This will call MyCheckFormatNonRecursive to validate each format string.
542	*
543	* @param pState The format string checking state.
544	* @param hFmtArg The format string node.
545	*/
546	static void MyCheckFormatRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
547	{
548	/*
549	* Catch wrong attribute use.
550	*/
551	if (hFmtArg == NULL_TREE)
552	error_at(pState->hFmtLoc, "IPRT format attribute is probably used incorrectly (hFmtArg is NULL)");
553	/*
554	* NULL format strings may cause crashes.
555	*/
556	else if (integer_zerop(hFmtArg))
557	{
558	if (pState->fMaybeNull)
559	VFmtChkVerifyEndOfArgs(pState, 0);
560	else
561	error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
562	}
563	/*
564	* Check both branches of a ternary operator.
565	*/
566	else if (TREE_CODE(hFmtArg) == COND_EXPR)
567	{
568	MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 1));
569	MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 2));
570	}
571	/*
572	* Strip coercion.
573	*/
574	else if ( CONVERT_EXPR_P(hFmtArg)
575	&& TYPE_PRECISION(TREE_TYPE(hFmtArg)) == TYPE_PRECISION(TREE_TYPE(TREE_OPERAND(hFmtArg, 0))) )
576	MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 0));
577	/*
578	* We're good, hand it to the non-recursive worker.
579	*/
580	else
581	MyCheckFormatNonRecursive(pState, hFmtArg);
582	}
583
584
585	#if !RT_GNUC_PREREQ(4, 9)
586	/**
587	* Execute my pass.
588	* @returns Flags indicates stuff todo, we return 0.
589	*/
590	static unsigned int MyPassExecuteCallback(void)
591	{
592	return MyPassExecuteCallbackWithFunction(cfun);
593	}
594	#endif
595
596	/**
597	* Execute my pass.
598	* @returns Flags indicates stuff todo, we return 0.
599	*/
600	static unsigned int MyPassExecuteCallbackWithFunction(struct function *pFun)
601	{
602	dprintf("MyPassExecuteCallback:\n");
603
604	/*
605	* Enumerate the basic blocks.
606	*/
607	basic_block hBasicBlock;
608	FOR_EACH_BB_FN(hBasicBlock, pFun)
609	{
610	dprintf(" hBasicBlock=%p\n", hBasicBlock);
611
612	/*
613	* Enumerate the statements in the current basic block.
614	* We're interested in calls to functions with the __iprt_format__ attribute.
615	*/
616	for (gimple_stmt_iterator hStmtItr = gsi_start_bb(hBasicBlock); !gsi_end_p(hStmtItr); gsi_next(&hStmtItr))
617	{
618	#if RT_GNUC_PREREQ(6, 0)
619	const gimple * const hStmt = gsi_stmt(hStmtItr);
620	#else
621	gimple const hStmt = gsi_stmt(hStmtItr);
622	#endif
623
624	enum gimple_code const enmCode = gimple_code(hStmt);
625	#ifdef DEBUG
626	unsigned const cOps = gimple_num_ops(hStmt);
627	dprintf(" hStmt=%p %s (%d) ops=%d\n", hStmt, gimple_code_name[enmCode], enmCode, cOps);
628	for (unsigned iOp = 0; iOp < cOps; iOp++)
629	{
630	tree const hOp = gimple_op(hStmt, iOp);
631	if (hOp)
632	dprintf(" %02d: %p, code %s(%d)\n", iOp, hOp, get_tree_code_name(TREE_CODE(hOp)), TREE_CODE(hOp));
633	else
634	dprintf(" %02d: NULL_TREE\n", iOp);
635	}
636	#endif
637	if (enmCode == GIMPLE_CALL)
638	{
639	/*
640	* Check if the function type has the __iprt_format__ attribute.
641	*/
642	tree const hFn = gimple_call_fn(hStmt);
643	dprintf(" hFn =%p %s(%d); args=%d\n",
644	hFn, hFn ? get_tree_code_name(TREE_CODE(hFn)) : NULL, hFn ? TREE_CODE(hFn) : - 1,
645	gimple_call_num_args(hStmt));
646	#ifdef DEBUG
647	if (hFn && DECL_P(hFn))
648	dprintf(" hFn is decl: %s %s:%d\n",
649	DECL_NAME(hFn) ? IDENTIFIER_POINTER(DECL_NAME(hFn)) : "<unamed>",
650	DECL_SOURCE_FILE(hFn), DECL_SOURCE_LINE(hFn));
651	#endif
652	tree const hFnDecl = gimple_call_fndecl(hStmt);
653	if (hFnDecl)
654	dprintf(" hFnDecl=%p %s(%d) %s type=%p %s:%d\n",
655	hFnDecl, get_tree_code_name(TREE_CODE(hFnDecl)), TREE_CODE(hFnDecl),
656	DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
657	TREE_TYPE(hFnDecl), DECL_SOURCE_FILE(hFnDecl), DECL_SOURCE_LINE(hFnDecl));
658	tree const hFnType = gimple_call_fntype(hStmt);
659	if (hFnType == NULL_TREE)
660	{
661	if ( hFnDecl == NULL_TREE
662	&& gimple_call_internal_p(hStmt) /* va_arg() kludge */)
663	continue;
664	error_at(gimple_location(hStmt), "Failed to resolve function type [fn=%s fndecl=%s]\n",
665	hFn ? get_tree_code_name(TREE_CODE(hFn)) : "<null>",
666	hFnDecl ? get_tree_code_name(TREE_CODE(hFnDecl)) : "<null>");
667	}
668	else if (POINTER_TYPE_P(hFnType))
669	error_at(gimple_location(hStmt), "Got a POINTER_TYPE when expecting a function type [fn=%s]\n",
670	get_tree_code_name(TREE_CODE(hFn)));
671	if (hFnType)
672	dprintf(" hFnType=%p %s(%d) %s\n", hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType),
673	TYPE_NAME(hFnType) && DECL_NAME(TYPE_NAME(hFnType))
674	? IDENTIFIER_POINTER(DECL_NAME(TYPE_NAME(hFnType))) : "<unamed>");
675
676	tree const hAttr = hFnType ? lookup_attribute("iprt_format", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
677	tree const hAttrMaybe0 = hFnType ? lookup_attribute("iprt_format_maybe_null", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
678	if (hAttr \|\| hAttrMaybe0)
679	{
680	/*
681	* Yeah, it has the attribute!
682	*/
683	tree const hAttrArgs = hAttr ? TREE_VALUE(hAttr) : TREE_VALUE(hAttrMaybe0);
684	VFMTCHKSTATE State;
685	State.iFmt = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
686	State.iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
687	State.pszFmt = NULL;
688	State.fMaybeNull = hAttr == NULL_TREE;
689	State.hStmt = hStmt;
690	State.hFmtLoc = gimple_location(hStmt);
691	dprintf(" %s() __iprt_format%s__(iFmt=%ld, iArgs=%ld)\n",
692	DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
693	State.fMaybeNull ? "_maybe_null" : "", State.iFmt, State.iArgs);
694
695	unsigned cCallArgs = gimple_call_num_args(hStmt);
696	if (cCallArgs >= State.iFmt)
697	MyCheckFormatRecursive(&State, gimple_call_arg(hStmt, State.iFmt - 1));
698	else
699	error_at(gimple_location(hStmt),
700	"Call has only %d arguments; %s() format string is argument #%u (1-based), thus missing\n",
701	cCallArgs, DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",State.iFmt);
702	}
703	}
704	}
705	}
706	return 0;
707	}
708
709
710	/**
711	* Gate callback for my pass that indicates whether it should execute or not.
712	* @returns true to execute.
713	*/
714	static bool MyPassGateCallback(void)
715	{
716	dprintf("MyPassGateCallback:\n");
717	return true;
718	}
719
720
721	/**
722	* Validate the use of an attribute.
723	*
724	* @returns ??
725	* @param phOnNode The node the attribute is being used on.
726	* @param hAttrName The attribute name.
727	* @param hAttrArgs The attribute arguments.
728	* @param fFlags Some kind of flags...
729	* @param pfDontAddAttrib Whether to add the attribute to this node or not.
730	*/
731	static tree AttributeHandler(tree phOnNode, tree hAttrName, tree hAttrArgs, int fFlags, bool pfDontAddAttrib)
732	{
733	dprintf("AttributeHandler: name=%s fFlags=%#x", IDENTIFIER_POINTER(hAttrName), fFlags);
734	long iFmt = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
735	long iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
736	dprintf(" iFmt=%ld iArgs=%ld", iFmt, iArgs);
737
738	tree hType = *phOnNode;
739	dprintf(" hType=%p %s(%d)\n", hType, get_tree_code_name(TREE_CODE(hType)), TREE_CODE(hType));
740
741	if (pfDontAddAttrib)
742	*pfDontAddAttrib = false;
743	return NULL_TREE;
744	}
745
746
747	/**
748	* Called when we can register attributes.
749	*
750	* @param pvEventData Ignored.
751	* @param pvUser Ignored.
752	*/
753	static void RegisterAttributesEvent(void pvEventData, void pvUser)
754	{
755	NOREF(pvEventData); NOREF(pvUser);
756	dprintf("RegisterAttributesEvent: pvEventData=%p\n", pvEventData);
757
758	register_attribute(&g_AttribSpecs[0]);
759	register_attribute(&g_AttribSpecs[1]);
760	}
761
762
763	/**
764	* The plug-in entry point.
765	*
766	* @returns 0 to indicate success?
767	* @param pPlugInInfo Plugin info structure.
768	* @param pGccVer GCC Version.
769	*/
770	int plugin_init(plugin_name_args pPlugInInfo, plugin_gcc_version pGccVer)
771	{
772	dprintf("plugin_init: %s\n", pPlugInInfo->full_name);
773	dprintf("gcc version: basever=%s datestamp=%s devphase=%s revision=%s\n",
774	pGccVer->basever, pGccVer->datestamp, pGccVer->devphase, pGccVer->revision);
775
776	/* Ask for callback in which we may register the attribute. */
777	register_callback(pPlugInInfo->base_name, PLUGIN_ATTRIBUTES, RegisterAttributesEvent, NULL /pvUser/);
778
779	/* Register our pass. */
780	#if RT_GNUC_PREREQ(4, 9)
781	/** The registration info for my pass. */
782	struct register_pass_info MyPassInfo;
783	MyPassInfo.pass = new MyPass(g);
784	MyPassInfo.reference_pass_name = "ssa";
785	MyPassInfo.ref_pass_instance_number = 1;
786	MyPassInfo.pos_op = PASS_POS_INSERT_BEFORE;
787	register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &MyPassInfo);
788	#else
789	register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, (void *)&g_MyPassInfo);
790	#endif
791
792	/* Register plug-in info. */
793	register_callback(pPlugInInfo->base_name, PLUGIN_INFO, NULL, (void *)&g_PlugInInfo);
794
795	return 0;
796	}
797
798
799
800
801	/*
802	*
803	* Functions used by the common code.
804	* Functions used by the common code.
805	* Functions used by the common code.
806	*
807	*/
808
809	void VFmtChkWarnFmt(PVFMTCHKSTATE pState, const char pszLoc, const char pszFormat, ...)
810	{
811	char szTmp[1024];
812	va_list va;
813	va_start(va, pszFormat);
814	vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
815	va_end(va);
816
817	/* display the warning. */
818	warning_at(MyGetFormatStringLocation(pState, pszLoc), 0, "%s", szTmp);
819	}
820
821
822	void VFmtChkErrFmt(PVFMTCHKSTATE pState, const char pszLoc, const char pszFormat, ...)
823	{
824	char szTmp[1024];
825	va_list va;
826	va_start(va, pszFormat);
827	vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
828	va_end(va);
829
830	/* display the warning. */
831	error_at(MyGetFormatStringLocation(pState, pszLoc), "%s", szTmp);
832	}
833
834
835
836	void VFmtChkVerifyEndOfArgs(PVFMTCHKSTATE pState, unsigned iArg)
837	{
838	dprintf("VFmtChkVerifyEndOfArgs: iArg=%u iArgs=%ld cArgs=%u\n", iArg, pState->iArgs, gimple_call_num_args(pState->hStmt));
839	if (pState->iArgs > 0)
840	{
841	iArg += pState->iArgs - 1;
842	unsigned cArgs = gimple_call_num_args(pState->hStmt);
843	if (iArg == cArgs)
844	{ /* fine */ }
845	else if (iArg < cArgs)
846	{
847	tree hArg = gimple_call_arg(pState->hStmt, iArg);
848	if (cArgs - iArg > 1)
849	error_at(MY_LOC(hArg, pState), "%u extra arguments not consumed by format string", cArgs - iArg);
850	else if ( TREE_CODE(hArg) != INTEGER_CST
851	\|\| !MY_DOUBLE_INT_FITS_SHWI(hArg)
852	\|\| MY_DOUBLE_INT_TO_SHWI(hArg) != -99) /* ignore final dummy argument: ..., -99); */
853	error_at(MY_LOC(hArg, pState), "one extra argument not consumed by format string");
854	}
855	/* This should be handled elsewhere, but just in case. */
856	else if (iArg - 1 == cArgs)
857	error_at(pState->hFmtLoc, "one argument too few");
858	else
859	error_at(pState->hFmtLoc, "%u arguments too few", iArg - cArgs);
860	}
861	}
862
863
864	bool VFmtChkRequirePresentArg(PVFMTCHKSTATE pState, const char pszLoc, unsigned iArg, const char pszMessage)
865	{
866	if (pState->iArgs > 0)
867	{
868	iArg += pState->iArgs - 1;
869	unsigned cArgs = gimple_call_num_args(pState->hStmt);
870	if (iArg >= cArgs)
871	{
872	VFmtChkErrFmt(pState, pszLoc, "Missing argument! %s", pszMessage);
873	return false;
874	}
875
876	tree hArg = gimple_call_arg(pState->hStmt, iArg);
877	tree hType = TREE_TYPE(hArg);
878	dprintf("arg%u: hArg=%p [%s] hType=%p [%s] cls=%s\n", iArg, hArg, get_tree_code_name(TREE_CODE(hArg)),
879	hType, get_tree_code_name(TREE_CODE(hType)), tree_code_class_strings[TREE_CODE_CLASS(TREE_CODE(hType))]);
880	dprintf(" nm=%p\n", TYPE_NAME(hType));
881	dprintf(" cb=%p %s value=%ld\n", TYPE_SIZE(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE(hType))),
882	MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(hType)) );
883	dprintf(" unit=%p %s value=%ld\n", TYPE_SIZE_UNIT(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE_UNIT(hType))),
884	MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE_UNIT(hType)) );
885	tree hTypeNm = TYPE_NAME(hType);
886	if (hTypeNm)
887	dprintf(" typenm=%p %s '%s'\n", hTypeNm, get_tree_code_name(TREE_CODE(hTypeNm)),
888	IDENTIFIER_POINTER(DECL_NAME(hTypeNm)));
889	}
890	return true;
891	}
892
893
894	bool VFmtChkRequireIntArg(PVFMTCHKSTATE pState, const char pszLoc, unsigned iArg, const char pszMessage)
895	{
896	if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
897	{
898	/** @todo type check. */
899	return true;
900	}
901	return false;
902	}
903
904
905	bool VFmtChkRequireStringArg(PVFMTCHKSTATE pState, const char pszLoc, unsigned iArg, const char pszMessage)
906	{
907	if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
908	{
909	/** @todo type check. */
910	return true;
911	}
912	return false;
913	}
914
915
916	bool VFmtChkRequireVaListPtrArg(PVFMTCHKSTATE pState, const char pszLoc, unsigned iArg, const char pszMessage)
917	{
918	if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
919	{
920	/** @todo type check. */
921	return true;
922	}
923	return false;
924	}
925
926
927	void VFmtChkHandleReplacementFormatString(PVFMTCHKSTATE pState, const char *pszPctM, unsigned iArg)
928	{
929	if (pState->iArgs > 0)
930	{
931	pState->iFmt = pState->iArgs + iArg;
932	pState->iArgs = pState->iFmt + 1;
933	pState->fMaybeNull = false;
934	MyCheckFormatRecursive(pState, gimple_call_arg(pState->hStmt, pState->iFmt - 1));
935	}
936	}
937
938
939	const char *VFmtChkGetFmtLocFile(PVFMTCHKSTATE pState)
940	{
941	return LOCATION_FILE(pState->hFmtLoc);
942	}
943
944
945	unsigned int VFmtChkGetFmtLocLine(PVFMTCHKSTATE pState)
946	{
947	return LOCATION_LINE(pState->hFmtLoc);
948	}
949
950
951	unsigned int VFmtChkGetFmtLocColumn(PVFMTCHKSTATE pState)
952	{
953	#ifdef LOCATION_COLUMN
954	return LOCATION_COLUMN(pState->hFmtLoc);
955	#else
956	return 1;
957	#endif
958	}
959

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/bldprogs/VBoxCompilerPlugInsGcc.cpp@ 69091

Download in other formats: