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