VBoxCompilerPlugInsGcc.cpp@ 68389

Last change on this file since 68389 was 66779, checked in by vboxsync, 8 years ago
gccplugin: crash fix attempt
Property svn:eol-style set to `native` Property svn:keywords set to `Author Date Id Revision`
File size: 30.4 KB

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

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

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

Download in other formats: