VirtualBox

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

Last change on this file since 106400 was 106061, checked in by vboxsync, 3 months ago

Copyright year updates by scm.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 46.0 KB
Line 
1/* $Id: VBoxCompilerPlugInsGcc.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
2/** @file
3 * gccplugin - GCC plugin for checking IPRT format strings.
4 */
5
6/*
7 * Copyright (C) 2006-2024 Oracle and/or its affiliates.
8 *
9 * This file is part of VirtualBox base platform packages, as
10 * available from https://www.virtualbox.org.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation, in version 3 of the
15 * License.
16 *
17 * This program is distributed in the hope that it will be useful, but
18 * WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 * General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, see <https://www.gnu.org/licenses>.
24 *
25 * SPDX-License-Identifier: GPL-3.0-only
26 */
27
28
29/*********************************************************************************************************************************
30* Header Files *
31*********************************************************************************************************************************/
32#include <stdio.h>
33#include <iprt/cdefs.h>
34#include <iprt/stdarg.h>
35
36#if RT_GNUC_PREREQ(5, 1)
37# include "gcc-plugin.h"
38# include "plugin-version.h"
39#endif
40#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
41# include "gmp.h"
42extern "C" {
43#endif
44#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
45# include "coretypes.h"
46#endif
47#include "plugin.h"
48#include "basic-block.h"
49#include "tree.h"
50#include "tree-pass.h"
51#include "tree-pretty-print.h"
52#if __GNUC__ == 5 && __GNUC_MINOR__ == 4
53# include "tree-ssa-alias.h"
54# include "gimple-expr.h"
55#endif
56#include "gimple.h"
57#if RT_GNUC_PREREQ(4, 9)
58# include "gimple-iterator.h"
59# include "context.h" /* for g */
60#endif
61#include "cp/cp-tree.h"
62#if RT_GNUC_PREREQ(9, 4)
63# include "stringpool.h"
64# include "attribs.h"
65#endif
66#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
67}
68#endif
69
70#include "VBoxCompilerPlugIns.h"
71
72
73/*********************************************************************************************************************************
74* Global Variables *
75*********************************************************************************************************************************/
76/** License indicator. */
77int plugin_is_GPL_compatible;
78
79
80/*********************************************************************************************************************************
81* Defined Constants And Macros *
82*********************************************************************************************************************************/
83/** Convencience macro not present in earlier gcc versions. */
84#ifndef VAR_P
85# define VAR_P(a_hNode) (TREE_CODE(a_hNode) == VAR_DECL)
86#endif
87/** Replacement for the 4.9.0 get_tree_code_name function. */
88#if !RT_GNUC_PREREQ(4, 9)
89# define get_tree_code_name(a_enmTreeCode) (tree_code_name[a_enmTreeCode])
90#endif
91
92
93/** For use with messages.
94 * @todo needs some more work... Actually, seems we're a bit handicapped by
95 * working on gimplified stuff. */
96#define MY_LOC(a_hPreferred, a_pState) EXPR_LOC_OR_LOC(a_hPreferred, (a_pState)->hFmtLoc)
97
98/** @name Compatibility glue
99 * @{ */
100#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
101# define linemap_location_from_macro_expansion_p(a, b) false
102#endif
103#if __GNUC__ == 4 && __GNUC_MINOR__ == 5
104static tree gimple_call_fntype(gimple hStmt)
105{
106 tree hDecl = gimple_call_fndecl(hStmt);
107 if (hDecl)
108 return TREE_TYPE(hDecl);
109 hDecl = gimple_call_fn(hStmt);
110 if (TREE_CODE(hDecl) == OBJ_TYPE_REF)
111 hDecl = OBJ_TYPE_REF_EXPR(hDecl);
112 if (DECL_P(hDecl))
113 {
114 tree hType = TREE_TYPE(hDecl);
115 if (POINTER_TYPE_P(hType))
116 hType = TREE_TYPE(hType);
117 return hType;
118 }
119 return NULL_TREE; /* caller bitches about this*/
120}
121#endif
122
123///* Integer to HOST_WIDE_INT conversion fun. */
124//#if RT_GNUC_PREREQ(4, 6)
125//# define MY_INT_FITS_SHWI(hNode) (hNode).fits_shwi()
126//# define MY_INT_TO_SHWI(hNode) (hNode).to_shwi()
127//#else
128//# define MY_INT_FITS_SHWI(hNode) double_int_fits_in_shwi_p(hNode)
129//# define MY_INT_TO_SHWI(hNode) double_int_to_shwi(hNode)
130//#endif
131
132/* Integer to HOST_WIDE_INT conversion fun. */
133#if RT_GNUC_PREREQ(5, 1)
134# define MY_DOUBLE_INT_FITS_SHWI(hNode) tree_fits_shwi_p(hNode)
135# define MY_DOUBLE_INT_TO_SHWI(hNode) tree_to_shwi(hNode)
136#elif RT_GNUC_PREREQ(4, 6)
137# define MY_DOUBLE_INT_FITS_SHWI(hNode) (TREE_INT_CST(hNode).fits_shwi())
138# define MY_DOUBLE_INT_TO_SHWI(hNode) (TREE_INT_CST(hNode).to_shwi())
139#else
140# define MY_DOUBLE_INT_FITS_SHWI(hNode) double_int_fits_in_shwi_p(TREE_INT_CST(hNode))
141# define MY_DOUBLE_INT_TO_SHWI(hNode) double_int_to_shwi(TREE_INT_CST(hNode))
142#endif
143
144#ifndef EXPR_LOC_OR_LOC
145# define EXPR_LOC_OR_LOC(a,b) (b)
146#endif
147/** @} */
148
149
150/*********************************************************************************************************************************
151* Structures and Typedefs *
152*********************************************************************************************************************************/
153/** gimple statement handle. */
154#if RT_GNUC_PREREQ(6, 0)
155typedef const gimple *MY_GIMPLE_HSTMT_T;
156#else
157typedef gimple MY_GIMPLE_HSTMT_T;
158#endif
159
160
161/*********************************************************************************************************************************
162* Internal Functions *
163*********************************************************************************************************************************/
164static bool MyPassGateCallback(void);
165static unsigned int MyPassExecuteCallback(void);
166static unsigned int MyPassExecuteCallbackWithFunction(struct function *pFun);
167static tree AttributeHandlerFormat(tree *, tree, tree, int, bool *);
168static tree AttributeHandlerCallReq(tree *, tree, tree, int, bool *);
169
170
171/*********************************************************************************************************************************
172* Global Variables *
173*********************************************************************************************************************************/
174/** Plug-in info. */
175static const struct plugin_info g_PlugInInfo =
176{
177 version: "0.0.0-ALPHA",
178 help : "Implements the __iprt_format__ attribute for checking format strings and arguments."
179};
180
181#if RT_GNUC_PREREQ(4, 9)
182
183/** My pass. */
184static const pass_data g_MyPassData =
185{
186 type : GIMPLE_PASS,
187 name : "*iprt-format-checks", /* asterisk = no dump */
188# if RT_GNUC_PREREQ(9, 4)
189 optinfo_flags : OPTGROUP_NONE,
190# else
191 optinfo_flags : 0,
192# endif
193 tv_id : TV_NONE,
194 properties_required : 0,
195 properties_provided : 0,
196 properties_destroyed : 0,
197 todo_flags_start : 0,
198 todo_flags_finish : 0,
199};
200
201class MyPass : public gimple_opt_pass
202{
203public:
204 MyPass(gcc::context *pCtx) : gimple_opt_pass(g_MyPassData, pCtx)
205 { }
206
207 virtual bool gate(function *pFun)
208 {
209 NOREF(pFun);
210 return MyPassGateCallback();
211 }
212
213 virtual unsigned int execute(function *pFun)
214 {
215 NOREF(pFun);
216 return MyPassExecuteCallbackWithFunction(pFun);
217 }
218};
219
220#else /* < 4.9.0 */
221
222/** My pass. */
223static struct gimple_opt_pass g_MyPass =
224{
225 pass:
226 {
227 type : GIMPLE_PASS,
228 name : "*iprt-format-and-callreq-checks", /* asterisk = no dump */
229# if RT_GNUC_PREREQ(4, 6)
230 optinfo_flags : 0,
231# endif
232 gate : MyPassGateCallback,
233 execute : MyPassExecuteCallback,
234 sub : NULL,
235 next : NULL,
236 static_pass_number : 0,
237 tv_id : TV_NONE,
238 properties_required : 0,
239 properties_provided : 0,
240 properties_destroyed : 0,
241 todo_flags_start : 0,
242 todo_flags_finish : 0,
243 }
244};
245
246/** The registration info for my pass. */
247static const struct register_pass_info g_MyPassInfo =
248{
249 pass : &g_MyPass.pass,
250 reference_pass_name : "ssa",
251 ref_pass_instance_number : 1,
252 pos_op : PASS_POS_INSERT_BEFORE,
253};
254
255#endif /* < 4.9.0 */
256
257
258/** Attribute specifications. */
259static const struct attribute_spec g_aAttribSpecs[] =
260{
261 {
262 name : "iprt_format",
263 min_length : 2,
264 max_length : 2,
265 decl_required : false,
266 type_required : true,
267 function_type_required : true,
268// gcc 6.3 at least moves this field to after "handler", and with 8.3 it is back
269#if RT_GNUC_PREREQ(4, 6) && !(RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0))
270 affects_type_identity : false,
271#endif
272 handler : AttributeHandlerFormat,
273#if RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0)
274 affects_type_identity : false,
275#endif
276#if RT_GNUC_PREREQ(8, 0)
277 exclude : NULL,
278#endif
279 },
280 {
281 name : "iprt_format_maybe_null",
282 min_length : 2,
283 max_length : 2,
284 decl_required : false,
285 type_required : true,
286 function_type_required : true,
287#if RT_GNUC_PREREQ(4, 6) && !(RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0))
288 affects_type_identity : false,
289#endif
290 handler : AttributeHandlerFormat,
291#if RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0)
292 affects_type_identity : false,
293#endif
294#if RT_GNUC_PREREQ(8, 0)
295 exclude : NULL,
296#endif
297 },
298 {
299 name : "iprt_callreq",
300 min_length : 3,
301 max_length : 3,
302 decl_required : false,
303 type_required : true,
304 function_type_required : true,
305#if RT_GNUC_PREREQ(4, 6) && !(RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0))
306 affects_type_identity : false,
307#endif
308 handler : AttributeHandlerCallReq,
309#if RT_GNUC_PREREQ(6, 3) && !RT_GNUC_PREREQ(8, 0)
310 affects_type_identity : false,
311#endif
312#if RT_GNUC_PREREQ(8, 0)
313 exclude : NULL,
314#endif
315 }
316};
317
318
319#ifdef DEBUG
320
321/**
322 * Debug function for printing the scope of a decl.
323 * @param hDecl Declaration to print scope for.
324 */
325static void dprintScope(tree hDecl)
326{
327# if 0 /* later? */
328 tree hScope = CP_DECL_CONTEXT(hDecl);
329 if (hScope == global_namespace)
330 return;
331 if (TREE_CODE(hScope) == RECORD_TYPE)
332 hScope = TYPE_NAME(hScope);
333
334 /* recurse */
335 dprintScope(hScope);
336
337 /* name the scope. */
338 dprintf("::%s", DECL_NAME(hScope) ? IDENTIFIER_POINTER(DECL_NAME(hScope)) : "<noname>");
339# endif
340}
341
342
343/**
344 * Debug function for printing a declaration.
345 * @param hDecl The declaration to print.
346 */
347static void dprintDecl(tree hDecl)
348{
349 enum tree_code const enmDeclCode = TREE_CODE(hDecl);
350 tree const hType = TREE_TYPE(hDecl);
351 enum tree_code const enmTypeCode = hType ? TREE_CODE(hType) : (enum tree_code)-1;
352# if 0
353 if ( enmTypeCode == RECORD_TYPE
354 && enmDeclCode == TYPE_DECL
355 && DECL_ARTIFICIAL(hDecl))
356 dprint_class(hType);
357# endif
358
359 dprintf("%s ", get_tree_code_name(enmDeclCode));
360 dprintScope(hDecl);
361 dprintf("::%s", DECL_NAME(hDecl) ? IDENTIFIER_POINTER(DECL_NAME(hDecl)) : "<noname>");
362 if (hType)
363 dprintf(" type %s", get_tree_code_name(enmTypeCode));
364 dprintf(" @%s:%d", DECL_SOURCE_FILE(hDecl), DECL_SOURCE_LINE(hDecl));
365}
366
367#endif /* DEBUG */
368
369
370static location_t MyGetLocationPlusColumnOffset(location_t hLoc, unsigned int offColumn)
371{
372 /*
373 * Skip NOOPs, reserved locations and macro expansion.
374 */
375 if ( offColumn != 0
376 && hLoc >= RESERVED_LOCATION_COUNT
377 && !linemap_location_from_macro_expansion_p(line_table, hLoc))
378 {
379#if __GNUC__ >= 5 /** @todo figure this... */
380 /*
381 * There is an API for doing this, nice.
382 */
383 location_t hNewLoc = linemap_position_for_loc_and_offset(line_table, hLoc, offColumn);
384 if (hNewLoc && hNewLoc != hLoc)
385 {
386 dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u\n", hNewLoc, hLoc, offColumn);
387 return hNewLoc;
388 }
389
390#elif __GNUC_MINOR__ > 5
391 /*
392 * Have to do the job ourselves, it seems. This is a bit hairy...
393 */
394 line_map const *pMap = NULL;
395 location_t hLoc2 = linemap_resolve_location(line_table, hLoc, LRK_SPELLING_LOCATION, &pMap);
396 if (hLoc2)
397 hLoc = hLoc2;
398
399 /* Guard against wrap arounds and overlaps. */
400 if ( hLoc + offColumn > MAP_START_LOCATION(pMap) /** @todo Use MAX_SOURCE_LOCATION? */
401 && ( pMap == LINEMAPS_LAST_ORDINARY_MAP(line_table)
402 || hLoc + offColumn < MAP_START_LOCATION((pMap + 1))))
403 {
404 /* Calc new column and check that it's within the valid range. */
405 unsigned int uColumn = SOURCE_COLUMN(pMap, hLoc) + offColumn;
406 if (uColumn < RT_BIT_32(ORDINARY_MAP_NUMBER_OF_COLUMN_BITS(pMap)))
407 {
408 /* Try add the position. If we get a valid result, replace the location. */
409 source_location hNewLoc = linemap_position_for_line_and_column((line_map *)pMap, SOURCE_LINE(pMap, hLoc), uColumn);
410 if ( hNewLoc <= line_table->highest_location
411 && linemap_lookup(line_table, hNewLoc) != NULL)
412 {
413 dprintf("MyGetLocationPlusColumnOffset: hNewLoc=%#x hLoc=%#x offColumn=%u uColumn=%u\n",
414 hNewLoc, hLoc, offColumn, uColumn);
415 return hNewLoc;
416 }
417 }
418 }
419#endif
420 }
421 dprintf("MyGetLocationPlusColumnOffset: taking fallback\n");
422 return hLoc;
423}
424
425
426#if 0
427DECLINLINE(int) MyGetLineLength(const char *pszLine)
428{
429 if (pszLine)
430 {
431 const char *pszEol = strpbrk(pszLine, "\n\r");
432 if (!pszEol)
433 pszEol = strchr(pszLine, '\0');
434 return (int)(pszEol - pszLine);
435 }
436 return 0;
437}
438#endif
439
440static location_t MyGetFormatStringLocation(PVFMTCHKSTATE pState, const char *pszLoc)
441{
442 location_t hLoc = pState->hFmtLoc;
443#if RT_GNUC_PREREQ(4,6)
444 intptr_t offString = pszLoc - pState->pszFmt;
445 if ( offString >= 0
446 && !linemap_location_from_macro_expansion_p(line_table, hLoc))
447 {
448 unsigned uCol = 1 + offString;
449# if 0 /* apparently not needed */
450 expanded_location XLoc = expand_location_to_spelling_point(hLoc);
451# if RT_GNUC_PREREQ(10,0)
452 char_span Span = location_get_source_line(XLoc.file, XLoc.line);
453 const char *pszLine = Span.m_ptr; /** @todo if enabled */
454 int cchLine = (int)Span.m_n_elts;
455# elif RT_GNUC_PREREQ(6,0)
456 int cchLine = 0;
457 const char *pszLine = location_get_source_line(XLoc.file, XLoc.line, &cchLine);
458# elif RT_GNUC_PREREQ(5,0)
459 int cchLine = 0;
460 const char *pszLine = location_get_source_line(XLoc, &cchLine);
461# else
462 const char *pszLine = location_get_source_line(XLoc);
463 int cchLine = MyGetLineLength(pszLine);
464# endif
465 if (pszLine)
466 {
467 /** @todo Adjust the position by parsing the source. */
468 pszLine += XLoc.column - 1;
469 cchLine -= XLoc.column - 1;
470 }
471# endif
472
473 hLoc = MyGetLocationPlusColumnOffset(hLoc, uCol);
474 }
475#endif
476 return hLoc;
477}
478
479
480/**
481 * Non-recursive worker for MyCheckFormatRecursive.
482 *
483 * This will attempt to result @a hFmtArg into a string literal which it then
484 * passes on to MyCheckFormatString for the actual analyzis.
485 *
486 * @param pState The format string checking state.
487 * @param hFmtArg The format string node.
488 */
489DECL_NO_INLINE(static, void) MyCheckFormatNonRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
490{
491 dprintf("checker: hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
492
493 /*
494 * Try resolve variables into constant strings.
495 */
496 if (VAR_P(hFmtArg))
497 {
498 hFmtArg = decl_constant_value(hFmtArg);
499 STRIP_NOPS(hFmtArg); /* Used as argument and assigned call result. */
500 dprintf("checker1: variable => hFmtArg=%p %s\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)));
501 }
502
503 /*
504 * Fend off NULLs.
505 */
506 if (integer_zerop(hFmtArg))
507 {
508 if (pState->fMaybeNull)
509 VFmtChkVerifyEndOfArgs(pState, 0);
510 else
511 error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
512 }
513 /*
514 * Need address expression to get any further.
515 */
516 else if (TREE_CODE(hFmtArg) != ADDR_EXPR)
517 dprintf("checker1: Not address expression (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
518 else
519 {
520 pState->hFmtLoc = EXPR_LOC_OR_LOC(hFmtArg, pState->hFmtLoc);
521 hFmtArg = TREE_OPERAND(hFmtArg, 0);
522
523 /*
524 * Deal with fixed string indexing, if possible.
525 */
526 HOST_WIDE_INT off = 0;
527 if ( TREE_CODE(hFmtArg) == ARRAY_REF
528 && MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1))
529 && MY_DOUBLE_INT_FITS_SHWI(TREE_OPERAND(hFmtArg, 1)) )
530 {
531 off = MY_DOUBLE_INT_TO_SHWI(TREE_OPERAND(hFmtArg, 1));
532 if (off < 0)
533 {
534 dprintf("checker1: ARRAY_REF, off=%ld\n", off);
535 return;
536 }
537 hFmtArg = TREE_OPERAND(hFmtArg, 0);
538 dprintf("checker1: ARRAY_REF => hFmtArg=%p %s, off=%ld\n", hFmtArg, get_tree_code_name(TREE_CODE(hFmtArg)), off);
539 }
540
541 /*
542 * Deal with static const char g_szFmt[] = "qwerty"; Take care as
543 * the actual string constant may not necessarily include the terminator.
544 */
545 tree hArraySize = NULL_TREE;
546 if ( VAR_P(hFmtArg)
547 && TREE_CODE(TREE_TYPE(hFmtArg)) == ARRAY_TYPE)
548 {
549 tree hArrayInitializer = decl_constant_value(hFmtArg);
550 if ( hArrayInitializer != hFmtArg
551 && TREE_CODE(hArrayInitializer) == STRING_CST)
552 {
553 hArraySize = DECL_SIZE_UNIT(hFmtArg);
554 hFmtArg = hArrayInitializer;
555 }
556 }
557
558 /*
559 * Are we dealing with a string literal now?
560 */
561 if (TREE_CODE(hFmtArg) != STRING_CST)
562 dprintf("checker1: Not string literal (%s)\n", get_tree_code_name(TREE_CODE(hFmtArg)));
563 else if (TYPE_MAIN_VARIANT(TREE_TYPE(TREE_TYPE(hFmtArg))) != char_type_node)
564 warning_at(pState->hFmtLoc, 0, "expected 'char' type string literal");
565 else
566 {
567 /*
568 * Yes we are, so get the pointer to the string and its length.
569 */
570 const char *pszFmt = TREE_STRING_POINTER(hFmtArg);
571 int cchFmt = TREE_STRING_LENGTH(hFmtArg);
572
573 /* Adjust cchFmt to the initialized array size if appropriate. */
574 if (hArraySize != NULL_TREE)
575 {
576 if (TREE_CODE(hArraySize) != INTEGER_CST)
577 warning_at(pState->hFmtLoc, 0, "Expected integer array size (not %s)", get_tree_code_name(TREE_CODE(hArraySize)));
578 else if (!MY_DOUBLE_INT_FITS_SHWI(hArraySize))
579 warning_at(pState->hFmtLoc, 0, "Unexpected integer overflow in array size constant");
580 else
581 {
582 HOST_WIDE_INT cbArray = MY_DOUBLE_INT_TO_SHWI(hArraySize);
583 if ( cbArray <= 0
584 || cbArray != (int)cbArray)
585 warning_at(pState->hFmtLoc, 0, "Unexpected integer array size constant value: %ld", cbArray);
586 else if (cchFmt > cbArray)
587 {
588 dprintf("checker1: cchFmt=%d => cchFmt=%ld (=cbArray)\n", cchFmt, cbArray);
589 cchFmt = (int)cbArray;
590 }
591 }
592 }
593
594 /* Apply the offset, if given. */
595 if (off)
596 {
597 if (off >= cchFmt)
598 {
599 dprintf("checker1: off=%ld >= cchFmt=%d -> skipping\n", off, cchFmt);
600 return;
601 }
602 pszFmt += off;
603 cchFmt -= (int)off;
604 }
605
606 /*
607 * Check for unterminated strings.
608 */
609 if ( cchFmt < 1
610 || pszFmt[cchFmt - 1] != '\0')
611 warning_at(pState->hFmtLoc, 0, "Unterminated format string (cchFmt=%d)", cchFmt);
612 /*
613 * Call worker to check the actual string.
614 */
615 else
616 MyCheckFormatCString(pState, pszFmt);
617 }
618 }
619}
620
621
622/**
623 * Deal recursively with special format string constructs.
624 *
625 * This will call MyCheckFormatNonRecursive to validate each format string.
626 *
627 * @param pState The format string checking state.
628 * @param hFmtArg The format string node.
629 */
630static void MyCheckFormatRecursive(PVFMTCHKSTATE pState, tree hFmtArg)
631{
632 /*
633 * Catch wrong attribute use.
634 */
635 if (hFmtArg == NULL_TREE)
636 error_at(pState->hFmtLoc, "IPRT format attribute is probably used incorrectly (hFmtArg is NULL)");
637 /*
638 * NULL format strings may cause crashes.
639 */
640 else if (integer_zerop(hFmtArg))
641 {
642 if (pState->fMaybeNull)
643 VFmtChkVerifyEndOfArgs(pState, 0);
644 else
645 error_at(MY_LOC(hFmtArg, pState), "Format string should not be NULL");
646 }
647 /*
648 * Check both branches of a ternary operator.
649 */
650 else if (TREE_CODE(hFmtArg) == COND_EXPR)
651 {
652 MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 1));
653 MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 2));
654 }
655 /*
656 * Strip coercion.
657 */
658 else if ( CONVERT_EXPR_P(hFmtArg)
659 && TYPE_PRECISION(TREE_TYPE(hFmtArg)) == TYPE_PRECISION(TREE_TYPE(TREE_OPERAND(hFmtArg, 0))) )
660 MyCheckFormatRecursive(pState, TREE_OPERAND(hFmtArg, 0));
661 /*
662 * We're good, hand it to the non-recursive worker.
663 */
664 else
665 MyCheckFormatNonRecursive(pState, hFmtArg);
666}
667
668
669/**
670 * Check VMR3ReqCallU stuff.
671 *
672 * @param pState The checking state.
673 */
674static void MyCheckCallReq(MY_GIMPLE_HSTMT_T const hStmt, location_t const hStmtLoc,
675 long const idxFn, long const idxArgc, long const idxArgs, unsigned const cCallArgs)
676{
677#ifdef DEBUG
678 expanded_location const XLoc = expand_location_to_spelling_point(hStmtLoc);
679 dprintf("checker-call: cCallArgs=%#lx - %s:%u\n", cCallArgs, XLoc.file ? XLoc.file : "<nofile>", XLoc.line);
680#endif
681
682 /*
683 * Catch incorrect attribute use.
684 */
685 if (idxFn > cCallArgs)
686 {
687 error_at(hStmtLoc, "Incorrect function argument number (first param) in IPRT call attribute: %lu (max %u)",
688 idxFn, cCallArgs);
689 return;
690 }
691 if (idxArgc > cCallArgs)
692 {
693 error_at(hStmtLoc, "Incorrect argument count argument number (second param) in IPRT call attribute: %lu (max %u)",
694 idxArgc, cCallArgs);
695 return;
696 }
697 if (idxArgs > cCallArgs + 1)
698 {
699 error_at(hStmtLoc, "Incorrect arguments argument number (last param) in IPRT call attribute: %lu (max %u)",
700 idxArgs, cCallArgs + 1);
701 return;
702 }
703
704 /*
705 * Get the argument count argument and check how it compares to cCallArgs if constant.
706 */
707 tree hArgCount = gimple_call_arg(hStmt, idxArgc - 1);
708 if (!hArgCount)
709 {
710 error_at(hStmtLoc, "Failed to get the parameter counter argument (%lu)", idxArgc);
711 return;
712 }
713 HOST_WIDE_INT cArgsValue = -1;
714 if (TREE_CODE(hArgCount) == INTEGER_CST)
715 {
716 if (!MY_DOUBLE_INT_FITS_SHWI(hArgCount))
717 error_at(hStmtLoc, "Unexpected integer overflow in argument count constant");
718 else
719 {
720 cArgsValue = MY_DOUBLE_INT_TO_SHWI(hArgCount);
721 if ( cArgsValue < 0
722 || cArgsValue != (int)cArgsValue)
723 error_at(hStmtLoc, "Unexpected integer argument count constant value: %ld", cArgsValue);
724 else
725 {
726 /* HARD CODED MAX and constants */
727 dprintf("checker-call: cArgsValue=%#lx\n", cArgsValue);
728 if ( cArgsValue <= 9
729 || ((cArgsValue & 0x8000) && ((unsigned)cArgsValue & ~(unsigned)0x8000) <= 15) )
730 { /* likely */ }
731 else
732 error_at(hStmtLoc, "Bad integer argument count constant value: %lx (max is 9, or 15 with flag)",
733 cArgsValue);
734
735 cArgsValue = (unsigned)cArgsValue & ~(unsigned)0x8000;
736 if (idxArgs != 0 && idxArgs + cArgsValue - 1 != (long)cCallArgs)
737 error_at(hStmtLoc, "Argument count %ld starting at %ld (1-based) does not match argument count: %u",
738 cArgsValue, idxArgs, cCallArgs);
739 }
740 }
741 }
742
743 /*
744 * Get the function pointer statement and strip any coercion.
745 */
746 tree const hFnArg = gimple_call_arg(hStmt, idxFn - 1);
747 if (!hFnArg)
748 {
749 error_at(hStmtLoc, "Failed to get function argument (%lu)", idxFn);
750 return;
751 }
752 tree hFnType = 0;
753 if (TREE_CODE(hFnArg) == SSA_NAME)
754 {
755 dprintf(" * hFnArg=%p %s(%d) %s (SSA)\n", hFnArg, get_tree_code_name(TREE_CODE(hFnArg)), TREE_CODE(hFnArg),
756 SSA_NAME_IDENTIFIER(hFnArg) ? IDENTIFIER_POINTER(SSA_NAME_IDENTIFIER(hFnArg)) : "<unnamed-ssa-name>");
757 hFnType = TREE_TYPE(hFnArg);
758 if (hFnType && TREE_CODE(hFnType) != POINTER_TYPE)
759 {
760 error_at(hStmtLoc, "Expected pointer_type for hFnType=%p, not %s(%d)",
761 hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType));
762 return;
763 }
764 if (hFnType)
765 hFnType = TREE_TYPE(hFnType);
766 }
767 else
768 {
769 dprintf(" * hFnArg=%p %s(%d)\n", hFnArg, get_tree_code_name(TREE_CODE(hFnArg)), TREE_CODE(hFnArg));
770 tree const hFnDecl = gimple_call_addr_fndecl(hFnArg);
771 if (hFnDecl)
772 {
773#ifdef DEBUG
774 dprintDecl(hFnDecl);
775 dprintf("\n");
776#endif
777 hFnType = TREE_TYPE(hFnDecl);
778 }
779 }
780 if (hFnType)
781 {
782 dprintf(" * hFnType=%p %s(%d)\n", hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType));
783 if (TREE_CODE(hFnType) != FUNCTION_TYPE)
784 {
785 error_at(hStmtLoc, "Expected function_type for hFnType=%p, not %s(%d)",
786 hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType));
787 return;
788 }
789
790 /* Count the arguments. */
791 unsigned cFnTypeArgs = 0;
792 tree const hArgList = TYPE_ARG_TYPES(hFnType);
793 dprintf(" * hArgList=%p %s(%d)\n", hFnType, get_tree_code_name(TREE_CODE(hArgList)), TREE_CODE(hArgList));
794 if (!hArgList)
795 error_at(hStmtLoc, "Using unprototyped function (arg %lu)?", idxFn);
796 else if (hArgList != void_list_node)
797 for (tree hArg = hArgList; hArg && hArg != void_list_node; hArg = TREE_CHAIN(hArg))
798 cFnTypeArgs++;
799
800 /* Check that it matches the argument value. */
801 if ((long)cFnTypeArgs != cArgsValue && cArgsValue >= 0)
802 error_at(hStmtLoc, "Function prototype takes %u arguments, but %u specified in the call request",
803 cFnTypeArgs, (unsigned)cArgsValue);
804
805 /*
806 * Check that there are no oversized arguments in the function type.
807 * If there are more than 9 arguments, also check the size of the lasts
808 * ones, up to but not including the last argument.
809 */
810 HOST_WIDE_INT const cPtrBits = MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(TREE_TYPE(null_pointer_node)));
811 HOST_WIDE_INT const cIntBits = MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(integer_type_node));
812 unsigned iArg = 0;
813 for (tree hArg = hArgList; hArg && hArg != void_list_node; hArg = TREE_CHAIN(hArg), iArg++)
814 {
815 tree const hArgType = TREE_VALUE(hArg);
816 HOST_WIDE_INT const cArgBits = MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(hArgType));
817 if (cArgBits > cPtrBits)
818 error_at(hStmtLoc, "Argument #%u (1-based) is too large: %lu bits, max %lu", iArg + 1, cArgBits, cPtrBits);
819 if (cArgBits != cPtrBits && iArg >= 8 && iArg != cFnTypeArgs - 1)
820 error_at(hStmtLoc, "Argument #%u (1-based) must be pointer sized: %lu bits, expect %lu",
821 iArg + 1, cArgBits, cPtrBits);
822
823 if (idxArgs > 0)
824 {
825 tree const hArgPassed = gimple_call_arg(hStmt, idxArgs - 1 + iArg);
826 tree hArgPassedType = TREE_TYPE(hArgPassed);
827
828 HOST_WIDE_INT const cArgPassedBits = MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(hArgPassedType));
829 if ( cArgPassedBits != cArgBits
830 && ( cArgPassedBits != cIntBits /* expected promotion target is INT */
831 || cArgBits > cIntBits /* no promotion required */ ))
832 error_at(hStmtLoc,
833 "Argument #%u (1-based) passed to call request differs in size from target type: %lu bits, expect %lu",
834 iArg + 1, cArgPassedBits, cArgBits);
835 }
836 }
837
838 /** @todo check that the arguments passed in the VMR3ReqXxxx call matches. */
839 }
840 else if (idxArgs != 0)
841 error_at(hStmtLoc, "Failed to get function declaration (%lu) for non-va_list call", idxFn);
842}
843
844
845#if !RT_GNUC_PREREQ(4, 9)
846/**
847 * Execute my pass.
848 * @returns Flags indicates stuff todo, we return 0.
849 */
850static unsigned int MyPassExecuteCallback(void)
851{
852 return MyPassExecuteCallbackWithFunction(cfun);
853}
854#endif
855
856/**
857 * Execute my pass.
858 * @returns Flags indicates stuff todo, we return 0.
859 */
860static unsigned int MyPassExecuteCallbackWithFunction(struct function *pFun)
861{
862 dprintf("MyPassExecuteCallback:\n");
863
864 /*
865 * Enumerate the basic blocks.
866 */
867 basic_block hBasicBlock;
868 FOR_EACH_BB_FN(hBasicBlock, pFun)
869 {
870 dprintf(" hBasicBlock=%p\n", hBasicBlock);
871
872 /*
873 * Enumerate the statements in the current basic block.
874 *
875 * We're interested in calls to functions with the __iprt_format__,
876 * iprt_format_maybe_null and __iprt_callreq__ attributes.
877 */
878 for (gimple_stmt_iterator hStmtItr = gsi_start_bb(hBasicBlock); !gsi_end_p(hStmtItr); gsi_next(&hStmtItr))
879 {
880#if RT_GNUC_PREREQ(6, 0)
881 const gimple * const hStmt = gsi_stmt(hStmtItr);
882#else
883 gimple const hStmt = gsi_stmt(hStmtItr);
884#endif
885
886 enum gimple_code const enmCode = gimple_code(hStmt);
887#ifdef DEBUG
888 unsigned const cOps = gimple_num_ops(hStmt);
889 dprintf(" hStmt=%p %s (%d) ops=%d\n", hStmt, gimple_code_name[enmCode], enmCode, cOps);
890 for (unsigned iOp = 0; iOp < cOps; iOp++)
891 {
892 tree const hOp = gimple_op(hStmt, iOp);
893 if (hOp)
894 dprintf(" %02d: %p, code %s(%d)\n", iOp, hOp, get_tree_code_name(TREE_CODE(hOp)), TREE_CODE(hOp));
895 else
896 dprintf(" %02d: NULL_TREE\n", iOp);
897 }
898#endif
899 if (enmCode == GIMPLE_CALL)
900 {
901 /*
902 * Check if the function type has the __iprt_format__ attribute.
903 */
904 tree const hFn = gimple_call_fn(hStmt);
905 dprintf(" hFn =%p %s(%d); args=%d\n",
906 hFn, hFn ? get_tree_code_name(TREE_CODE(hFn)) : NULL, hFn ? TREE_CODE(hFn) : - 1,
907 gimple_call_num_args(hStmt));
908#ifdef DEBUG
909 if (hFn && DECL_P(hFn))
910 dprintf(" hFn is decl: %s %s:%d\n",
911 DECL_NAME(hFn) ? IDENTIFIER_POINTER(DECL_NAME(hFn)) : "<unamed>",
912 DECL_SOURCE_FILE(hFn), DECL_SOURCE_LINE(hFn));
913#endif
914 tree const hFnDecl = gimple_call_fndecl(hStmt);
915 if (hFnDecl)
916 dprintf(" hFnDecl=%p %s(%d) %s type=%p %s:%d\n",
917 hFnDecl, get_tree_code_name(TREE_CODE(hFnDecl)), TREE_CODE(hFnDecl),
918 DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
919 TREE_TYPE(hFnDecl), DECL_SOURCE_FILE(hFnDecl), DECL_SOURCE_LINE(hFnDecl));
920 tree const hFnType = gimple_call_fntype(hStmt);
921 if (hFnType == NULL_TREE)
922 {
923 if ( hFnDecl == NULL_TREE
924 && gimple_call_internal_p(hStmt) /* va_arg() kludge */)
925 continue;
926 error_at(gimple_location(hStmt), "Failed to resolve function type [fn=%s fndecl=%s]",
927 hFn ? get_tree_code_name(TREE_CODE(hFn)) : "<null>",
928 hFnDecl ? get_tree_code_name(TREE_CODE(hFnDecl)) : "<null>");
929 }
930 else if (POINTER_TYPE_P(hFnType))
931 error_at(gimple_location(hStmt), "Got a POINTER_TYPE when expecting a function type [fn=%s]",
932 get_tree_code_name(TREE_CODE(hFn)));
933 if (hFnType)
934 dprintf(" hFnType=%p %s(%d) %s\n", hFnType, get_tree_code_name(TREE_CODE(hFnType)), TREE_CODE(hFnType),
935 TYPE_NAME(hFnType) && DECL_NAME(TYPE_NAME(hFnType))
936 ? IDENTIFIER_POINTER(DECL_NAME(TYPE_NAME(hFnType))) : "<unamed>");
937
938 tree const hAttrCall = hFnType ? lookup_attribute("iprt_callreq", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
939 tree const hAttrFmt = hFnType ? lookup_attribute("iprt_format", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
940 tree const hAttrFmtMaybe0 = hFnType ? lookup_attribute("iprt_format_maybe_null", TYPE_ATTRIBUTES(hFnType)) : NULL_TREE;
941 if (hAttrCall || hAttrFmt || hAttrFmtMaybe0)
942 {
943 /*
944 * Yeah, it has one of the attributes!
945 */
946 unsigned const cCallArgs = gimple_call_num_args(hStmt);
947 tree hAttrArgs;
948 if (hAttrCall)
949 {
950 hAttrArgs = TREE_VALUE(hAttrCall);
951 long const idxFn = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
952 long const idxArgc = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
953 long const idxArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(TREE_CHAIN(hAttrArgs))));
954 dprintf(" %s() __iprt_callreq__(idxFn=%ld, idxArgc=%ld, idxArgs=%ld)\n",
955 hFnDecl && DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
956 idxFn, idxArgc, idxArgs);
957 MyCheckCallReq(hStmt, gimple_location(hStmt), idxFn, idxArgc, idxArgs, cCallArgs);
958 }
959 else
960 {
961 hAttrArgs = hAttrFmt ? TREE_VALUE(hAttrFmt) : TREE_VALUE(hAttrFmtMaybe0);
962 VFMTCHKSTATE State;
963 State.hStmt = hStmt;
964 State.hFmtLoc = gimple_location(hStmt);
965 State.fMaybeNull = hAttrFmt ? false : true;
966 State.iFmt = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
967 State.iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
968 State.pszFmt = NULL;
969 dprintf(" %s() __iprt_format%s__(iFmt=%ld, iArgs=%ld)\n",
970 hFnDecl && DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
971 State.fMaybeNull ? "_maybe_null" : "", State.iFmt, State.iArgs);
972 if (cCallArgs >= State.iFmt)
973 MyCheckFormatRecursive(&State, gimple_call_arg(hStmt, State.iFmt - 1));
974 else
975 error_at(gimple_location(hStmt),
976 "Call has only %d arguments; %s() format string is argument #%lu (1-based), thus missing",
977 cCallArgs, DECL_NAME(hFnDecl) ? IDENTIFIER_POINTER(DECL_NAME(hFnDecl)) : "<unamed>",
978 State.iFmt);
979 }
980 }
981 }
982 }
983 }
984 return 0;
985}
986
987
988/**
989 * Gate callback for my pass that indicates whether it should execute or not.
990 * @returns true to execute.
991 */
992static bool MyPassGateCallback(void)
993{
994 dprintf("MyPassGateCallback:\n");
995 return true;
996}
997
998
999/**
1000 * Validate the use of an format attribute.
1001 *
1002 * @returns ??
1003 * @param phOnNode The node the attribute is being used on.
1004 * @param hAttrName The attribute name.
1005 * @param hAttrArgs The attribute arguments.
1006 * @param fFlags Some kind of flags...
1007 * @param pfDontAddAttrib Whether to add the attribute to this node or not.
1008 */
1009static tree AttributeHandlerFormat(tree *phOnNode, tree hAttrName, tree hAttrArgs, int fFlags, bool *pfDontAddAttrib)
1010{
1011 dprintf("AttributeHandlerFormat: name=%s fFlags=%#x", IDENTIFIER_POINTER(hAttrName), fFlags);
1012 long iFmt = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
1013 long iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
1014 dprintf(" iFmt=%ld iArgs=%ld", iFmt, iArgs);
1015
1016 tree hType = *phOnNode;
1017 dprintf(" hType=%p %s(%d)\n", hType, get_tree_code_name(TREE_CODE(hType)), TREE_CODE(hType));
1018
1019 if (pfDontAddAttrib)
1020 *pfDontAddAttrib = false;
1021 return NULL_TREE;
1022}
1023
1024
1025/**
1026 * Validate the use of an call request attribute.
1027 *
1028 * @returns ??
1029 * @param phOnNode The node the attribute is being used on.
1030 * @param hAttrName The attribute name.
1031 * @param hAttrArgs The attribute arguments.
1032 * @param fFlags Some kind of flags...
1033 * @param pfDontAddAttrib Whether to add the attribute to this node or not.
1034 */
1035static tree AttributeHandlerCallReq(tree *phOnNode, tree hAttrName, tree hAttrArgs, int fFlags, bool *pfDontAddAttrib)
1036{
1037 dprintf("AttributeHandlerCallReq: name=%s fFlags=%#x", IDENTIFIER_POINTER(hAttrName), fFlags);
1038 long iFn = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(hAttrArgs));
1039 long iArgc = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(hAttrArgs)));
1040 long iArgs = MY_DOUBLE_INT_TO_SHWI(TREE_VALUE(TREE_CHAIN(TREE_CHAIN(hAttrArgs))));
1041 dprintf(" iFn=%ld iArgc=%ld iArgs=%ld", iFn, iArgc, iArgs);
1042
1043 tree hType = *phOnNode;
1044 dprintf(" hType=%p %s(%d)\n", hType, get_tree_code_name(TREE_CODE(hType)), TREE_CODE(hType));
1045
1046 if (pfDontAddAttrib)
1047 *pfDontAddAttrib = false;
1048 return NULL_TREE;
1049}
1050
1051
1052/**
1053 * Called when we can register attributes.
1054 *
1055 * @param pvEventData Ignored.
1056 * @param pvUser Ignored.
1057 */
1058static void RegisterAttributesEvent(void *pvEventData, void *pvUser)
1059{
1060 NOREF(pvEventData); NOREF(pvUser);
1061 dprintf("RegisterAttributesEvent: pvEventData=%p\n", pvEventData);
1062
1063 for (unsigned i = 0; i < RT_ELEMENTS(g_aAttribSpecs); i++)
1064 register_attribute(&g_aAttribSpecs[i]);
1065}
1066
1067
1068/**
1069 * The plug-in entry point.
1070 *
1071 * @returns 0 to indicate success?
1072 * @param pPlugInInfo Plugin info structure.
1073 * @param pGccVer GCC Version.
1074 */
1075int plugin_init(plugin_name_args *pPlugInInfo, plugin_gcc_version *pGccVer)
1076{
1077 dprintf("plugin_init: %s\n", pPlugInInfo->full_name);
1078 dprintf("gcc version: basever=%s datestamp=%s devphase=%s revision=%s\n",
1079 pGccVer->basever, pGccVer->datestamp, pGccVer->devphase, pGccVer->revision);
1080
1081 /* Ask for callback in which we may register the attribute. */
1082 register_callback(pPlugInInfo->base_name, PLUGIN_ATTRIBUTES, RegisterAttributesEvent, NULL /*pvUser*/);
1083
1084 /* Register our pass. */
1085#if RT_GNUC_PREREQ(4, 9)
1086 /** The registration info for my pass. */
1087 struct register_pass_info MyPassInfo;
1088 MyPassInfo.pass = new MyPass(g);
1089 MyPassInfo.reference_pass_name = "ssa";
1090 MyPassInfo.ref_pass_instance_number = 1;
1091 MyPassInfo.pos_op = PASS_POS_INSERT_BEFORE;
1092 register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, &MyPassInfo);
1093#else
1094 register_callback(pPlugInInfo->base_name, PLUGIN_PASS_MANAGER_SETUP, NULL, (void *)&g_MyPassInfo);
1095#endif
1096
1097 /* Register plug-in info. */
1098 register_callback(pPlugInInfo->base_name, PLUGIN_INFO, NULL, (void *)&g_PlugInInfo);
1099
1100 return 0;
1101}
1102
1103
1104
1105
1106/*
1107 *
1108 * Functions used by the common code.
1109 * Functions used by the common code.
1110 * Functions used by the common code.
1111 *
1112 */
1113
1114void VFmtChkWarnFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...)
1115{
1116 char szTmp[1024];
1117 va_list va;
1118 va_start(va, pszFormat);
1119 vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
1120 va_end(va);
1121
1122 /* display the warning. */
1123 warning_at(MyGetFormatStringLocation(pState, pszLoc), 0, "%s", szTmp);
1124}
1125
1126
1127void VFmtChkErrFmt(PVFMTCHKSTATE pState, const char *pszLoc, const char *pszFormat, ...)
1128{
1129 char szTmp[1024];
1130 va_list va;
1131 va_start(va, pszFormat);
1132 vsnprintf(szTmp, sizeof(szTmp), pszFormat, va);
1133 va_end(va);
1134
1135 /* display the warning. */
1136 error_at(MyGetFormatStringLocation(pState, pszLoc), "%s", szTmp);
1137}
1138
1139
1140
1141void VFmtChkVerifyEndOfArgs(PVFMTCHKSTATE pState, unsigned iArg)
1142{
1143 dprintf("VFmtChkVerifyEndOfArgs: iArg=%u iArgs=%ld cArgs=%u\n", iArg, pState->iArgs, gimple_call_num_args(pState->hStmt));
1144 if (pState->iArgs > 0)
1145 {
1146 iArg += pState->iArgs - 1;
1147 unsigned cArgs = gimple_call_num_args(pState->hStmt);
1148 if (iArg == cArgs)
1149 { /* fine */ }
1150 else if (iArg < cArgs)
1151 {
1152 tree hArg = gimple_call_arg(pState->hStmt, iArg);
1153 if (cArgs - iArg > 1)
1154 error_at(MY_LOC(hArg, pState), "%u extra arguments not consumed by format string", cArgs - iArg);
1155 else if ( TREE_CODE(hArg) != INTEGER_CST
1156 || !MY_DOUBLE_INT_FITS_SHWI(hArg)
1157 || MY_DOUBLE_INT_TO_SHWI(hArg) != -99) /* ignore final dummy argument: ..., -99); */
1158 error_at(MY_LOC(hArg, pState), "one extra argument not consumed by format string");
1159 }
1160 /* This should be handled elsewhere, but just in case. */
1161 else if (iArg - 1 == cArgs)
1162 error_at(pState->hFmtLoc, "one argument too few");
1163 else
1164 error_at(pState->hFmtLoc, "%u arguments too few", iArg - cArgs);
1165 }
1166}
1167
1168
1169bool VFmtChkRequirePresentArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
1170{
1171 if (pState->iArgs > 0)
1172 {
1173 iArg += pState->iArgs - 1;
1174 unsigned cArgs = gimple_call_num_args(pState->hStmt);
1175 if (iArg >= cArgs)
1176 {
1177 VFmtChkErrFmt(pState, pszLoc, "Missing argument! %s", pszMessage);
1178 return false;
1179 }
1180
1181 tree hArg = gimple_call_arg(pState->hStmt, iArg);
1182 tree hType = TREE_TYPE(hArg);
1183 dprintf("arg%u: hArg=%p [%s] hType=%p [%s] cls=%s\n", iArg, hArg, get_tree_code_name(TREE_CODE(hArg)),
1184 hType, get_tree_code_name(TREE_CODE(hType)), tree_code_class_strings[TREE_CODE_CLASS(TREE_CODE(hType))]);
1185 dprintf(" nm=%p\n", TYPE_NAME(hType));
1186 dprintf(" cBits=%p %s value=%ld\n", TYPE_SIZE(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE(hType))),
1187 MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE(hType)) );
1188 dprintf(" unit=%p %s value=%ld\n", TYPE_SIZE_UNIT(hType), get_tree_code_name(TREE_CODE(TYPE_SIZE_UNIT(hType))),
1189 MY_DOUBLE_INT_TO_SHWI(TYPE_SIZE_UNIT(hType)) );
1190 tree hTypeNm = TYPE_NAME(hType);
1191 if (hTypeNm)
1192 dprintf(" typenm=%p %s '%s'\n", hTypeNm, get_tree_code_name(TREE_CODE(hTypeNm)),
1193 IDENTIFIER_POINTER(DECL_NAME(hTypeNm)));
1194 }
1195 return true;
1196}
1197
1198
1199bool VFmtChkRequireIntArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
1200{
1201 if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
1202 {
1203 /** @todo type check. */
1204 return true;
1205 }
1206 return false;
1207}
1208
1209
1210bool VFmtChkRequireStringArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
1211{
1212 if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
1213 {
1214 /** @todo type check. */
1215 return true;
1216 }
1217 return false;
1218}
1219
1220
1221bool VFmtChkRequireVaListPtrArg(PVFMTCHKSTATE pState, const char *pszLoc, unsigned iArg, const char *pszMessage)
1222{
1223 if (VFmtChkRequirePresentArg(pState, pszLoc, iArg, pszMessage))
1224 {
1225 /** @todo type check. */
1226 return true;
1227 }
1228 return false;
1229}
1230
1231
1232void VFmtChkHandleReplacementFormatString(PVFMTCHKSTATE pState, const char *pszPctM, unsigned iArg)
1233{
1234 if (pState->iArgs > 0)
1235 {
1236 pState->iFmt = pState->iArgs + iArg;
1237 pState->iArgs = pState->iFmt + 1;
1238 pState->fMaybeNull = false;
1239 MyCheckFormatRecursive(pState, gimple_call_arg(pState->hStmt, pState->iFmt - 1));
1240 }
1241}
1242
1243
1244const char *VFmtChkGetFmtLocFile(PVFMTCHKSTATE pState)
1245{
1246 return LOCATION_FILE(pState->hFmtLoc);
1247}
1248
1249
1250unsigned int VFmtChkGetFmtLocLine(PVFMTCHKSTATE pState)
1251{
1252 return LOCATION_LINE(pState->hFmtLoc);
1253}
1254
1255
1256unsigned int VFmtChkGetFmtLocColumn(PVFMTCHKSTATE pState)
1257{
1258#ifdef LOCATION_COLUMN
1259 return LOCATION_COLUMN(pState->hFmtLoc);
1260#else
1261 return 1;
1262#endif
1263}
1264
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette