VirtualBox

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

Last change on this file since 67954 was 66779, checked in by vboxsync, 7 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"
28extern "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. */
50int 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
73static 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*********************************************************************************************************************************/
107static bool MyPassGateCallback(void);
108static unsigned int MyPassExecuteCallback(void);
109static tree AttributeHandler(tree *, tree, tree, int, bool *);
110
111
112/*********************************************************************************************************************************
113* Global Variables *
114*********************************************************************************************************************************/
115/** Plug-in info. */
116static 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. */
123static 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. */
147static 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. */
157static 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 */
192static 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 */
214static 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
237static 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
293static 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 */
339DECL_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 */
480static 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 */
523static 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 */
624static 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 */
641static 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 */
663static 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 */
680int 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
709void 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
722void 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
736void 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
764bool 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
794bool 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
805bool 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
816bool 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
827void 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
839const char *VFmtChkGetFmtLocFile(PVFMTCHKSTATE pState)
840{
841 return LOCATION_FILE(pState->hFmtLoc);
842}
843
844
845unsigned int VFmtChkGetFmtLocLine(PVFMTCHKSTATE pState)
846{
847 return LOCATION_LINE(pState->hFmtLoc);
848}
849
850
851unsigned 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.

© 2023 Oracle
Contact – Privacy policy – Terms of Use