Deleted Added
sdiff udiff text old ( 161660 ) new ( 169699 )
full compact
c-common.c (161660) c-common.c (169699)
1/* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
1/* Subroutines shared by all languages that are variants of C.
2 Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000,
3 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
3 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
4
5This file is part of GCC.
6
7GCC is free software; you can redistribute it and/or modify it under
8the terms of the GNU General Public License as published by the Free
9Software Foundation; either version 2, or (at your option) any later
10version.
11
12GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13WARRANTY; without even the implied warranty of MERCHANTABILITY or
14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
15for more details.
16
17You should have received a copy of the GNU General Public License
18along with GCC; see the file COPYING. If not, write to the Free
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA
2002111-1307, USA. */
19Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
2002110-1301, USA. */
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "intl.h"
27#include "tree.h"
28#include "flags.h"

--- 8 unchanged lines hidden (view full) ---

37#include "tm_p.h"
38#include "obstack.h"
39#include "cpplib.h"
40#include "target.h"
41#include "langhooks.h"
42#include "tree-inline.h"
43#include "c-tree.h"
44#include "toplev.h"
21
22#include "config.h"
23#include "system.h"
24#include "coretypes.h"
25#include "tm.h"
26#include "intl.h"
27#include "tree.h"
28#include "flags.h"

--- 8 unchanged lines hidden (view full) ---

37#include "tm_p.h"
38#include "obstack.h"
39#include "cpplib.h"
40#include "target.h"
41#include "langhooks.h"
42#include "tree-inline.h"
43#include "c-tree.h"
44#include "toplev.h"
45#include "tree-iterator.h"
46#include "hashtab.h"
47#include "tree-mudflap.h"
48#include "opts.h"
49#include "real.h"
50#include "cgraph.h"
45
46cpp_reader *parse_in; /* Declared in c-pragma.h. */
47
48/* We let tm.h override the types used here, to handle trivial differences
49 such as the choice of unsigned int or long unsigned int for size_t.
50 When machines start needing nontrivial differences in the size type,
51 it would be best to do something here to figure out automatically
52 from other information what type to use. */
53
54#ifndef SIZE_TYPE
55#define SIZE_TYPE "long unsigned int"
56#endif
57
51
52cpp_reader *parse_in; /* Declared in c-pragma.h. */
53
54/* We let tm.h override the types used here, to handle trivial differences
55 such as the choice of unsigned int or long unsigned int for size_t.
56 When machines start needing nontrivial differences in the size type,
57 it would be best to do something here to figure out automatically
58 from other information what type to use. */
59
60#ifndef SIZE_TYPE
61#define SIZE_TYPE "long unsigned int"
62#endif
63
64#ifndef PID_TYPE
65#define PID_TYPE "int"
66#endif
67
58#ifndef WCHAR_TYPE
59#define WCHAR_TYPE "int"
60#endif
61
62/* WCHAR_TYPE gets overridden by -fshort-wchar. */
63#define MODIFIED_WCHAR_TYPE \
64 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
65

--- 50 unchanged lines hidden (view full) ---

116 tree double_type_node;
117 tree long_double_type_node;
118
119 tree complex_integer_type_node;
120 tree complex_float_type_node;
121 tree complex_double_type_node;
122 tree complex_long_double_type_node;
123
68#ifndef WCHAR_TYPE
69#define WCHAR_TYPE "int"
70#endif
71
72/* WCHAR_TYPE gets overridden by -fshort-wchar. */
73#define MODIFIED_WCHAR_TYPE \
74 (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
75

--- 50 unchanged lines hidden (view full) ---

126 tree double_type_node;
127 tree long_double_type_node;
128
129 tree complex_integer_type_node;
130 tree complex_float_type_node;
131 tree complex_double_type_node;
132 tree complex_long_double_type_node;
133
134 tree dfloat32_type_node;
135 tree dfloat64_type_node;
136 tree_dfloat128_type_node;
137
124 tree intQI_type_node;
125 tree intHI_type_node;
126 tree intSI_type_node;
127 tree intDI_type_node;
128 tree intTI_type_node;
129
130 tree unsigned_intQI_type_node;
131 tree unsigned_intHI_type_node;

--- 45 unchanged lines hidden (view full) ---

177
178 Stack of nested function name VAR_DECLs.
179
180 tree saved_function_name_decls;
181
182*/
183
184tree c_global_trees[CTI_MAX];
138 tree intQI_type_node;
139 tree intHI_type_node;
140 tree intSI_type_node;
141 tree intDI_type_node;
142 tree intTI_type_node;
143
144 tree unsigned_intQI_type_node;
145 tree unsigned_intHI_type_node;

--- 45 unchanged lines hidden (view full) ---

191
192 Stack of nested function name VAR_DECLs.
193
194 tree saved_function_name_decls;
195
196*/
197
198tree c_global_trees[CTI_MAX];
185
186/* TRUE if a code represents a statement. The front end init
187 langhook should take care of initialization of this array. */
188
189bool statement_code_p[MAX_TREE_CODES];
190
191/* Switches common to the C front ends. */
192
193/* Nonzero if prepreprocessing only. */
194
195int flag_preprocess_only;
196
197/* Nonzero means don't output line number information. */

--- 8 unchanged lines hidden (view full) ---

206/* Nonzero means dump macros in some fashion. */
207
208char flag_dump_macros;
209
210/* Nonzero means pass #include lines through to the output. */
211
212char flag_dump_includes;
213
199
200/* Switches common to the C front ends. */
201
202/* Nonzero if prepreprocessing only. */
203
204int flag_preprocess_only;
205
206/* Nonzero means don't output line number information. */

--- 8 unchanged lines hidden (view full) ---

215/* Nonzero means dump macros in some fashion. */
216
217char flag_dump_macros;
218
219/* Nonzero means pass #include lines through to the output. */
220
221char flag_dump_includes;
222
223/* Nonzero means process PCH files while preprocessing. */
224
225bool flag_pch_preprocess;
226
214/* The file name to which we should write a precompiled header, or
215 NULL if no header will be written in this compile. */
216
217const char *pch_file;
218
219/* Nonzero if an ISO standard was selected. It rejects macros in the
220 user's namespace. */
221int flag_iso;

--- 21 unchanged lines hidden (view full) ---

243
244/* Nonzero means allow Microsoft extensions without warnings or errors. */
245int flag_ms_extensions;
246
247/* Nonzero means don't recognize the keyword `asm'. */
248
249int flag_no_asm;
250
227/* The file name to which we should write a precompiled header, or
228 NULL if no header will be written in this compile. */
229
230const char *pch_file;
231
232/* Nonzero if an ISO standard was selected. It rejects macros in the
233 user's namespace. */
234int flag_iso;

--- 21 unchanged lines hidden (view full) ---

256
257/* Nonzero means allow Microsoft extensions without warnings or errors. */
258int flag_ms_extensions;
259
260/* Nonzero means don't recognize the keyword `asm'. */
261
262int flag_no_asm;
263
251/* Nonzero means give string constants the type `const char *', as mandated
252 by the standard. */
253
254int flag_const_strings;
255
256/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
257
258int flag_signed_bitfields = 1;
264/* Nonzero means to treat bitfields as signed unless they say `unsigned'. */
265
266int flag_signed_bitfields = 1;
259int explicit_flag_signed_bitfields;
260
267
261/* Nonzero means warn about pointer casts that can drop a type qualifier
262 from the pointer target type. */
263
264int warn_cast_qual;
265
266/* Warn about functions which might be candidates for format attributes. */
267
268int warn_missing_format_attribute;
269
270/* Nonzero means warn about sizeof(function) or addition/subtraction
271 of function pointers. */
272
273int warn_pointer_arith;
274
275/* Nonzero means do not warn that K&R style main() is not a function prototype. */
276
277int flag_bsd_no_warn_kr_main;
278
279/* Nonzero means warn for any global function def
280 without separate previous prototype decl. */
281
282int warn_missing_prototypes;
283
284/* Warn if adding () is suggested. */
285
286int warn_parentheses;
287
288/* Warn if initializer is not completely bracketed. */
289
290int warn_missing_braces;
291
292/* Warn about comparison of signed and unsigned values.
293 If -1, neither -Wsign-compare nor -Wno-sign-compare has been specified
294 (in which case -Wextra gets to decide). */
295
296int warn_sign_compare = -1;
297
298/* Nonzero means warn about usage of long long when `-pedantic'. */
299
300int warn_long_long = 1;
301
302/* Nonzero means warn about deprecated conversion from string constant to
303 `char *'. */
304
305int warn_write_strings;
306
307/* Nonzero means warn about multiple (redundant) decls for the same single
308 variable or function. */
309
310int warn_redundant_decls;
311
312/* Warn about testing equality of floating point numbers. */
313
314int warn_float_equal;
315
316/* Warn about a subscript that has type char. */
317
318int warn_char_subscripts;
319
320/* Warn if a type conversion is done that might have confusing results. */
321
322int warn_conversion;
323
324/* Warn about #pragma directives that are not recognized. */
325
326int warn_unknown_pragmas; /* Tri state variable. */
327
328/* Warn about format/argument anomalies in calls to formatted I/O functions
329 (*printf, *scanf, strftime, strfmon, etc.). */
330
331int warn_format;
332
268/* Warn about #pragma directives that are not recognized. */
269
270int warn_unknown_pragmas; /* Tri state variable. */
271
272/* Warn about format/argument anomalies in calls to formatted I/O functions
273 (*printf, *scanf, strftime, strfmon, etc.). */
274
275int warn_format;
276
333/* Warn about Y2K problems with strftime formats. */
277/* Warn about using __null (as NULL in C++) as sentinel. For code compiled
278 with GCC this doesn't matter as __null is guaranteed to have the right
279 size. */
334
280
335int warn_format_y2k;
281int warn_strict_null_sentinel;
336
282
337/* Warn about excess arguments to formats. */
338
339int warn_format_extra_args;
340
341/* Warn about zero-length formats. */
342
343int warn_format_zero_length;
344
345/* Warn about non-literal format arguments. */
346
347int warn_format_nonliteral;
348
349/* Warn about possible security problems with calls to format functions. */
350
351int warn_format_security;
352
353/* Zero means that faster, ...NonNil variants of objc_msgSend...
354 calls will be used in ObjC; passing nil receivers to such calls
355 will most likely result in crashes. */
356int flag_nil_receivers = 1;
357
283/* Zero means that faster, ...NonNil variants of objc_msgSend...
284 calls will be used in ObjC; passing nil receivers to such calls
285 will most likely result in crashes. */
286int flag_nil_receivers = 1;
287
358/* Nonzero means that we will allow new ObjC exception syntax (@throw,
359 @try, etc.) in source code. */
360int flag_objc_exceptions = 0;
361
362/* Nonzero means that code generation will be altered to support
363 "zero-link" execution. This currently affects ObjC only, but may
364 affect other languages in the future. */
365int flag_zero_link = 0;
366
367/* Nonzero means emit an '__OBJC, __image_info' for the current translation
368 unit. It will inform the ObjC runtime that class definition(s) herein
369 contained are to replace one(s) previously loaded. */
370int flag_replace_objc_classes = 0;
288/* Nonzero means that code generation will be altered to support
289 "zero-link" execution. This currently affects ObjC only, but may
290 affect other languages in the future. */
291int flag_zero_link = 0;
292
293/* Nonzero means emit an '__OBJC, __image_info' for the current translation
294 unit. It will inform the ObjC runtime that class definition(s) herein
295 contained are to replace one(s) previously loaded. */
296int flag_replace_objc_classes = 0;
371
297
372/* C/ObjC language option variables. */
373
374
298/* C/ObjC language option variables. */
299
300
375/* Nonzero means message about use of implicit function declarations;
376 1 means warning; 2 means error. */
377
378int mesg_implicit_function_declaration = -1;
379
380/* Nonzero means allow type mismatches in conditional expressions;
381 just make their values `void'. */
382
383int flag_cond_mismatch;
384
385/* Nonzero means enable C89 Amendment 1 features. */
386
387int flag_isoc94;
388
389/* Nonzero means use the ISO C99 dialect of C. */
390
391int flag_isoc99;
392
301/* Nonzero means allow type mismatches in conditional expressions;
302 just make their values `void'. */
303
304int flag_cond_mismatch;
305
306/* Nonzero means enable C89 Amendment 1 features. */
307
308int flag_isoc94;
309
310/* Nonzero means use the ISO C99 dialect of C. */
311
312int flag_isoc99;
313
393/* Nonzero means allow the BSD kernel printf enhancements. */
394
395int flag_bsd_format;
396
397/* Nonzero means that we have builtin functions, and main is an int. */
398
399int flag_hosted = 1;
400
314/* Nonzero means that we have builtin functions, and main is an int. */
315
316int flag_hosted = 1;
317
401/* Nonzero means warn when casting a function call to a type that does
402 not match the return type (e.g. (float)sqrt() or (anything*)malloc()
403 when there is no previous declaration of sqrt or malloc. */
404
405int warn_bad_function_cast;
406
407/* Warn about traditional constructs whose meanings changed in ANSI C. */
408
409int warn_traditional;
410
411/* Nonzero means warn for a declaration found after a statement. */
412
413int warn_declaration_after_statement;
414
415/* Nonzero means warn for non-prototype function decls
416 or non-prototyped defs without previous prototype. */
417
418int warn_strict_prototypes;
419
420/* Nonzero means warn for any global function def
421 without separate previous decl. */
422
423int warn_missing_declarations;
424
425/* Nonzero means warn about declarations of objects not at
426 file-scope level and about *all* declarations of functions (whether
427 or static) not at file-scope level. Note that we exclude
428 implicit function declarations. To get warnings about those, use
429 -Wimplicit. */
430
431int warn_nested_externs;
432
433/* Warn if main is suspicious. */
434
435int warn_main;
436
318/* Warn if main is suspicious. */
319
320int warn_main;
321
437/* Nonzero means warn about possible violations of sequence point rules. */
438
322
439int warn_sequence_point;
440
441/* Nonzero means warn about uninitialized variable when it is initialized with itself.
442 For example: int i = i;, GCC will not warn about this when warn_init_self is nonzero. */
443
444int warn_init_self;
445
446/* Nonzero means to warn about compile-time division by zero. */
447int warn_div_by_zero = 1;
448
449/* Nonzero means warn about use of implicit int. */
450
451int warn_implicit_int;
452
453/* Warn about NULL being passed to argument slots marked as requiring
454 non-NULL. */
455
456int warn_nonnull;
457
458/* Warn about old-style parameter declaration. */
459
460int warn_old_style_definition;
461
462
463/* ObjC language option variables. */
464
465
466/* Open and close the file for outputting class declarations, if
467 requested (ObjC). */
468
469int flag_gen_declaration;
470
323/* ObjC language option variables. */
324
325
326/* Open and close the file for outputting class declarations, if
327 requested (ObjC). */
328
329int flag_gen_declaration;
330
471/* Generate code for GNU or NeXT runtime environment. */
472
473#ifdef NEXT_OBJC_RUNTIME
474int flag_next_runtime = 1;
475#else
476int flag_next_runtime = 0;
477#endif
478
479/* Tells the compiler that this is a special run. Do not perform any
480 compiling, instead we are to test some platform dependent features
481 and output a C header file with appropriate definitions. */
482
483int print_struct_values;
484
331/* Tells the compiler that this is a special run. Do not perform any
332 compiling, instead we are to test some platform dependent features
333 and output a C header file with appropriate definitions. */
334
335int print_struct_values;
336
485/* ???. Undocumented. */
337/* Tells the compiler what is the constant string class for Objc. */
486
487const char *constant_string_class_name;
488
338
339const char *constant_string_class_name;
340
489/* Warn if multiple methods are seen for the same selector, but with
490 different argument types. Performs the check on the whole selector
491 table at the end of compilation. */
492
341
493int warn_selector;
494
495/* Warn if a @selector() is found, and no method with that selector
496 has been previously declared. The check is done on each
497 @selector() as soon as it is found - so it warns about forward
498 declarations. */
499
500int warn_undeclared_selector;
501
502/* Warn if methods required by a protocol are not implemented in the
503 class adopting it. When turned off, methods inherited to that
504 class are also considered implemented. */
505
506int warn_protocol = 1;
507
508
509/* C++ language option variables. */
510
511
512/* Nonzero means don't recognize any extension keywords. */
513
514int flag_no_gnu_keywords;
515
516/* Nonzero means do emit exported implementations of functions even if

--- 69 unchanged lines hidden (view full) ---

586/* 0 means we want the preprocessor to not emit line directives for
587 the current working directory. 1 means we want it to do it. -1
588 means we should decide depending on whether debugging information
589 is being emitted or not. */
590
591int flag_working_directory = -1;
592
593/* Nonzero to use __cxa_atexit, rather than atexit, to register
342/* C++ language option variables. */
343
344
345/* Nonzero means don't recognize any extension keywords. */
346
347int flag_no_gnu_keywords;
348
349/* Nonzero means do emit exported implementations of functions even if

--- 69 unchanged lines hidden (view full) ---

419/* 0 means we want the preprocessor to not emit line directives for
420 the current working directory. 1 means we want it to do it. -1
421 means we should decide depending on whether debugging information
422 is being emitted or not. */
423
424int flag_working_directory = -1;
425
426/* Nonzero to use __cxa_atexit, rather than atexit, to register
594 destructors for local statics and global objects. */
427 destructors for local statics and global objects. '2' means it has been
428 set nonzero as a default, not by a command-line flag. */
595
596int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
597
429
430int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
431
432/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
433 code. '2' means it has not been set explicitly on the command line. */
434
435int flag_use_cxa_get_exception_ptr = 2;
436
598/* Nonzero means make the default pedwarns warnings instead of errors.
599 The value of this flag is ignored if -pedantic is specified. */
600
601int flag_permissive;
602
603/* Nonzero means to implement standard semantics for exception
604 specifications, calling unexpected if an exception is thrown that
605 doesn't match the specification. Zero means to treat them as
606 assertions and optimize accordingly, but not check them. */
607
608int flag_enforce_eh_specs = 1;
609
437/* Nonzero means make the default pedwarns warnings instead of errors.
438 The value of this flag is ignored if -pedantic is specified. */
439
440int flag_permissive;
441
442/* Nonzero means to implement standard semantics for exception
443 specifications, calling unexpected if an exception is thrown that
444 doesn't match the specification. Zero means to treat them as
445 assertions and optimize accordingly, but not check them. */
446
447int flag_enforce_eh_specs = 1;
448
610/* Nonzero means warn about things that will change when compiling
611 with an ABI-compliant compiler. */
449/* Nonzero means to generate thread-safe code for initializing local
450 statics. */
612
451
613int warn_abi = 0;
452int flag_threadsafe_statics = 1;
614
453
615/* Nonzero means warn about invalid uses of offsetof. */
616
617int warn_invalid_offsetof = 1;
618
619/* Nonzero means warn about implicit declarations. */
620
621int warn_implicit = 1;
622
454/* Nonzero means warn about implicit declarations. */
455
456int warn_implicit = 1;
457
623/* Nonzero means warn when all ctors or dtors are private, and the class
624 has no friends. */
625
626int warn_ctor_dtor_privacy = 0;
627
628/* Nonzero means warn in function declared in derived class has the
629 same name as a virtual in the base class, but fails to match the
630 type signature of any virtual function in the base class. */
631
632int warn_overloaded_virtual;
633
634/* Nonzero means warn when declaring a class that has a non virtual
635 destructor, when it really ought to have a virtual one. */
636
637int warn_nonvdtor;
638
639/* Nonzero means warn when the compiler will reorder code. */
640
641int warn_reorder;
642
643/* Nonzero means warn when synthesis behavior differs from Cfront's. */
644
645int warn_synth;
646
647/* Nonzero means warn when we convert a pointer to member function
648 into a pointer to (void or function). */
649
650int warn_pmf2ptr = 1;
651
652/* Nonzero means warn about violation of some Effective C++ style rules. */
653
654int warn_ecpp;
655
656/* Nonzero means warn where overload resolution chooses a promotion from
657 unsigned to signed over a conversion to an unsigned of the same size. */
658
659int warn_sign_promo;
660
661/* Nonzero means warn when an old-style cast is used. */
662
663int warn_old_style_cast;
664
665/* Nonzero means warn when non-templatized friend functions are
666 declared within a template */
667
668int warn_nontemplate_friend = 1;
669
670/* Nonzero means complain about deprecated features. */
671
672int warn_deprecated = 1;
673
674/* Maximum template instantiation depth. This limit is rather
675 arbitrary, but it exists to limit the time it takes to notice
676 infinite template instantiations. */
677
678int max_tinst_depth = 500;
679
680
681
682/* The elements of `ridpointers' are identifier nodes for the reserved
683 type names and storage classes. It is indexed by a RID_... value. */
684tree *ridpointers;
685
686tree (*make_fname_decl) (tree, int);
687
458/* Maximum template instantiation depth. This limit is rather
459 arbitrary, but it exists to limit the time it takes to notice
460 infinite template instantiations. */
461
462int max_tinst_depth = 500;
463
464
465
466/* The elements of `ridpointers' are identifier nodes for the reserved
467 type names and storage classes. It is indexed by a RID_... value. */
468tree *ridpointers;
469
470tree (*make_fname_decl) (tree, int);
471
688/* If non-NULL, the address of a language-specific function that takes
689 any action required right before expand_function_end is called. */
690void (*lang_expand_function_end) (void);
691
692/* Nonzero means the expression being parsed will never be evaluated.
693 This is a count, since unevaluated expressions can nest. */
694int skip_evaluation;
695
696/* Information about how a function name is generated. */
697struct fname_var_t
698{
699 tree *const decl; /* pointer to the VAR_DECL. */

--- 10 unchanged lines hidden (view full) ---

710 /* GCC __FUNCTION__ compliant. */
711 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
712 /* GCC __PRETTY_FUNCTION__ compliant. */
713 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
714 {NULL, 0, 0},
715};
716
717static int constant_fits_type_p (tree, tree);
472/* Nonzero means the expression being parsed will never be evaluated.
473 This is a count, since unevaluated expressions can nest. */
474int skip_evaluation;
475
476/* Information about how a function name is generated. */
477struct fname_var_t
478{
479 tree *const decl; /* pointer to the VAR_DECL. */

--- 10 unchanged lines hidden (view full) ---

490 /* GCC __FUNCTION__ compliant. */
491 {&function_name_decl_node, RID_FUNCTION_NAME, 0},
492 /* GCC __PRETTY_FUNCTION__ compliant. */
493 {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
494 {NULL, 0, 0},
495};
496
497static int constant_fits_type_p (tree, tree);
498static tree check_case_value (tree);
499static bool check_case_bounds (tree, tree, tree *, tree *);
718
500
719/* Keep a stack of if statements. We record the number of compound
720 statements seen up to the if keyword, as well as the line number
721 and file of the if. If a potentially ambiguous else is seen, that
722 fact is recorded; the warning is issued when we can be sure that
723 the enclosing if statement does not have an else branch. */
724typedef struct
725{
726 int compstmt_count;
727 location_t locus;
728 int needs_warning;
729 tree if_stmt;
730} if_elt;
731
732static if_elt *if_stack;
733
734/* Amount of space in the if statement stack. */
735static int if_stack_space = 0;
736
737/* Stack pointer. */
738static int if_stack_pointer = 0;
739
740static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
741static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
742static tree handle_common_attribute (tree *, tree, tree, int, bool *);
743static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
744static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
745static tree handle_always_inline_attribute (tree *, tree, tree, int,
746 bool *);
501static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
502static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
503static tree handle_common_attribute (tree *, tree, tree, int, bool *);
504static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
505static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
506static tree handle_always_inline_attribute (tree *, tree, tree, int,
507 bool *);
508static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
509 bool *);
510static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
747static tree handle_used_attribute (tree *, tree, tree, int, bool *);
748static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
511static tree handle_used_attribute (tree *, tree, tree, int, bool *);
512static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
513static tree handle_externally_visible_attribute (tree *, tree, tree, int,
514 bool *);
749static tree handle_const_attribute (tree *, tree, tree, int, bool *);
750static tree handle_transparent_union_attribute (tree *, tree, tree,
751 int, bool *);
752static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
753static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
754static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
755static tree handle_section_attribute (tree *, tree, tree, int, bool *);
756static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
757static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
758static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
515static tree handle_const_attribute (tree *, tree, tree, int, bool *);
516static tree handle_transparent_union_attribute (tree *, tree, tree,
517 int, bool *);
518static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
519static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
520static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
521static tree handle_section_attribute (tree *, tree, tree, int, bool *);
522static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
523static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
524static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
525static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
759static tree handle_visibility_attribute (tree *, tree, tree, int,
760 bool *);
761static tree handle_tls_model_attribute (tree *, tree, tree, int,
762 bool *);
763static tree handle_no_instrument_function_attribute (tree *, tree,
764 tree, int, bool *);
765static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
526static tree handle_visibility_attribute (tree *, tree, tree, int,
527 bool *);
528static tree handle_tls_model_attribute (tree *, tree, tree, int,
529 bool *);
530static tree handle_no_instrument_function_attribute (tree *, tree,
531 tree, int, bool *);
532static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
533static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
766static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
767 bool *);
768static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
534static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
535 bool *);
536static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
537static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
769static tree handle_deprecated_attribute (tree *, tree, tree, int,
770 bool *);
771static tree handle_vector_size_attribute (tree *, tree, tree, int,
772 bool *);
773static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
774static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
775static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
776static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
777 bool *);
538static tree handle_deprecated_attribute (tree *, tree, tree, int,
539 bool *);
540static tree handle_vector_size_attribute (tree *, tree, tree, int,
541 bool *);
542static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
543static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
544static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
545static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
546 bool *);
547static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
778
779static void check_function_nonnull (tree, tree);
780static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
781static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
782static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
783static int resort_field_decl_cmp (const void *, const void *);
784
785/* Table of machine-independent attributes common to all C-like languages. */

--- 14 unchanged lines hidden (view full) ---

800 { "noreturn", 0, 0, true, false, false,
801 handle_noreturn_attribute },
802 { "volatile", 0, 0, true, false, false,
803 handle_noreturn_attribute },
804 { "noinline", 0, 0, true, false, false,
805 handle_noinline_attribute },
806 { "always_inline", 0, 0, true, false, false,
807 handle_always_inline_attribute },
548
549static void check_function_nonnull (tree, tree);
550static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
551static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
552static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
553static int resort_field_decl_cmp (const void *, const void *);
554
555/* Table of machine-independent attributes common to all C-like languages. */

--- 14 unchanged lines hidden (view full) ---

570 { "noreturn", 0, 0, true, false, false,
571 handle_noreturn_attribute },
572 { "volatile", 0, 0, true, false, false,
573 handle_noreturn_attribute },
574 { "noinline", 0, 0, true, false, false,
575 handle_noinline_attribute },
576 { "always_inline", 0, 0, true, false, false,
577 handle_always_inline_attribute },
578 { "gnu_inline", 0, 0, true, false, false,
579 handle_gnu_inline_attribute },
580 { "flatten", 0, 0, true, false, false,
581 handle_flatten_attribute },
808 { "used", 0, 0, true, false, false,
809 handle_used_attribute },
810 { "unused", 0, 0, false, false, false,
811 handle_unused_attribute },
582 { "used", 0, 0, true, false, false,
583 handle_used_attribute },
584 { "unused", 0, 0, false, false, false,
585 handle_unused_attribute },
586 { "externally_visible", 0, 0, true, false, false,
587 handle_externally_visible_attribute },
812 /* The same comments as for noreturn attributes apply to const ones. */
813 { "const", 0, 0, true, false, false,
814 handle_const_attribute },
815 { "transparent_union", 0, 0, false, false, false,
816 handle_transparent_union_attribute },
817 { "constructor", 0, 0, true, false, false,
818 handle_constructor_attribute },
819 { "destructor", 0, 0, true, false, false,
820 handle_destructor_attribute },
821 { "mode", 1, 1, false, true, false,
822 handle_mode_attribute },
823 { "section", 1, 1, true, false, false,
824 handle_section_attribute },
825 { "aligned", 0, 1, false, false, false,
826 handle_aligned_attribute },
827 { "weak", 0, 0, true, false, false,
828 handle_weak_attribute },
829 { "alias", 1, 1, true, false, false,
830 handle_alias_attribute },
588 /* The same comments as for noreturn attributes apply to const ones. */
589 { "const", 0, 0, true, false, false,
590 handle_const_attribute },
591 { "transparent_union", 0, 0, false, false, false,
592 handle_transparent_union_attribute },
593 { "constructor", 0, 0, true, false, false,
594 handle_constructor_attribute },
595 { "destructor", 0, 0, true, false, false,
596 handle_destructor_attribute },
597 { "mode", 1, 1, false, true, false,
598 handle_mode_attribute },
599 { "section", 1, 1, true, false, false,
600 handle_section_attribute },
601 { "aligned", 0, 1, false, false, false,
602 handle_aligned_attribute },
603 { "weak", 0, 0, true, false, false,
604 handle_weak_attribute },
605 { "alias", 1, 1, true, false, false,
606 handle_alias_attribute },
607 { "weakref", 0, 1, true, false, false,
608 handle_weakref_attribute },
831 { "no_instrument_function", 0, 0, true, false, false,
832 handle_no_instrument_function_attribute },
833 { "malloc", 0, 0, true, false, false,
834 handle_malloc_attribute },
609 { "no_instrument_function", 0, 0, true, false, false,
610 handle_no_instrument_function_attribute },
611 { "malloc", 0, 0, true, false, false,
612 handle_malloc_attribute },
613 { "returns_twice", 0, 0, true, false, false,
614 handle_returns_twice_attribute },
835 { "no_stack_limit", 0, 0, true, false, false,
836 handle_no_limit_stack_attribute },
837 { "pure", 0, 0, true, false, false,
838 handle_pure_attribute },
615 { "no_stack_limit", 0, 0, true, false, false,
616 handle_no_limit_stack_attribute },
617 { "pure", 0, 0, true, false, false,
618 handle_pure_attribute },
619 /* For internal use (marking of builtins) only. The name contains space
620 to prevent its usage in source code. */
621 { "no vops", 0, 0, true, false, false,
622 handle_novops_attribute },
839 { "deprecated", 0, 0, false, false, false,
840 handle_deprecated_attribute },
841 { "vector_size", 1, 1, false, true, false,
842 handle_vector_size_attribute },
623 { "deprecated", 0, 0, false, false, false,
624 handle_deprecated_attribute },
625 { "vector_size", 1, 1, false, true, false,
626 handle_vector_size_attribute },
843 { "visibility", 1, 1, true, false, false,
627 { "visibility", 1, 1, false, false, false,
844 handle_visibility_attribute },
845 { "tls_model", 1, 1, true, false, false,
846 handle_tls_model_attribute },
847 { "nonnull", 0, -1, false, true, true,
848 handle_nonnull_attribute },
849 { "nothrow", 0, 0, true, false, false,
850 handle_nothrow_attribute },
851 { "may_alias", 0, 0, false, true, false, NULL },
852 { "cleanup", 1, 1, true, false, false,
853 handle_cleanup_attribute },
854 { "warn_unused_result", 0, 0, false, true, true,
855 handle_warn_unused_result_attribute },
628 handle_visibility_attribute },
629 { "tls_model", 1, 1, true, false, false,
630 handle_tls_model_attribute },
631 { "nonnull", 0, -1, false, true, true,
632 handle_nonnull_attribute },
633 { "nothrow", 0, 0, true, false, false,
634 handle_nothrow_attribute },
635 { "may_alias", 0, 0, false, true, false, NULL },
636 { "cleanup", 1, 1, true, false, false,
637 handle_cleanup_attribute },
638 { "warn_unused_result", 0, 0, false, true, true,
639 handle_warn_unused_result_attribute },
640 { "sentinel", 0, 1, false, true, true,
641 handle_sentinel_attribute },
856 { NULL, 0, 0, false, false, false, NULL }
857};
858
859/* Give the specifications for the format attributes, used by C and all
860 descendants. */
861
862const struct attribute_spec c_common_format_attribute_table[] =
863{
864 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
865 { "format", 3, 3, false, true, true,
866 handle_format_attribute },
867 { "format_arg", 1, 1, false, true, true,
868 handle_format_arg_attribute },
869 { NULL, 0, 0, false, false, false, NULL }
870};
871
642 { NULL, 0, 0, false, false, false, NULL }
643};
644
645/* Give the specifications for the format attributes, used by C and all
646 descendants. */
647
648const struct attribute_spec c_common_format_attribute_table[] =
649{
650 /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
651 { "format", 3, 3, false, true, true,
652 handle_format_attribute },
653 { "format_arg", 1, 1, false, true, true,
654 handle_format_arg_attribute },
655 { NULL, 0, 0, false, false, false, NULL }
656};
657
872/* Record the start of an if-then, and record the start of it
873 for ambiguous else detection.
874
875 COND is the condition for the if-then statement.
876
877 IF_STMT is the statement node that has already been created for
878 this if-then statement. It is created before parsing the
879 condition to keep line number information accurate. */
880
881void
882c_expand_start_cond (tree cond, int compstmt_count, tree if_stmt)
883{
884 /* Make sure there is enough space on the stack. */
885 if (if_stack_space == 0)
886 {
887 if_stack_space = 10;
888 if_stack = xmalloc (10 * sizeof (if_elt));
889 }
890 else if (if_stack_space == if_stack_pointer)
891 {
892 if_stack_space += 10;
893 if_stack = xrealloc (if_stack, if_stack_space * sizeof (if_elt));
894 }
895
896 IF_COND (if_stmt) = cond;
897 add_stmt (if_stmt);
898
899 /* Record this if statement. */
900 if_stack[if_stack_pointer].compstmt_count = compstmt_count;
901 if_stack[if_stack_pointer].locus = input_location;
902 if_stack[if_stack_pointer].needs_warning = 0;
903 if_stack[if_stack_pointer].if_stmt = if_stmt;
904 if_stack_pointer++;
905}
906
907/* Called after the then-clause for an if-statement is processed. */
908
909void
910c_finish_then (void)
911{
912 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
913 RECHAIN_STMTS (if_stmt, THEN_CLAUSE (if_stmt));
914}
915
916/* Record the end of an if-then. Optionally warn if a nested
917 if statement had an ambiguous else clause. */
918
919void
920c_expand_end_cond (void)
921{
922 if_stack_pointer--;
923 if (if_stack[if_stack_pointer].needs_warning)
924 warning ("%Hsuggest explicit braces to avoid ambiguous `else'",
925 &if_stack[if_stack_pointer].locus);
926 last_expr_type = NULL_TREE;
927}
928
929/* Called between the then-clause and the else-clause
930 of an if-then-else. */
931
932void
933c_expand_start_else (void)
934{
935 /* An ambiguous else warning must be generated for the enclosing if
936 statement, unless we see an else branch for that one, too. */
937 if (warn_parentheses
938 && if_stack_pointer > 1
939 && (if_stack[if_stack_pointer - 1].compstmt_count
940 == if_stack[if_stack_pointer - 2].compstmt_count))
941 if_stack[if_stack_pointer - 2].needs_warning = 1;
942
943 /* Even if a nested if statement had an else branch, it can't be
944 ambiguous if this one also has an else. So don't warn in that
945 case. Also don't warn for any if statements nested in this else. */
946 if_stack[if_stack_pointer - 1].needs_warning = 0;
947 if_stack[if_stack_pointer - 1].compstmt_count--;
948}
949
950/* Called after the else-clause for an if-statement is processed. */
951
952void
953c_finish_else (void)
954{
955 tree if_stmt = if_stack[if_stack_pointer - 1].if_stmt;
956 RECHAIN_STMTS (if_stmt, ELSE_CLAUSE (if_stmt));
957}
958
959/* Begin an if-statement. Returns a newly created IF_STMT if
960 appropriate.
961
962 Unlike the C++ front-end, we do not call add_stmt here; it is
963 probably safe to do so, but I am not very familiar with this
964 code so I am being extra careful not to change its behavior
965 beyond what is strictly necessary for correctness. */
966
967tree
968c_begin_if_stmt (void)
969{
970 tree r;
971 r = build_stmt (IF_STMT, NULL_TREE, NULL_TREE, NULL_TREE);
972 return r;
973}
974
975/* Begin a while statement. Returns a newly created WHILE_STMT if
976 appropriate.
977
978 Unlike the C++ front-end, we do not call add_stmt here; it is
979 probably safe to do so, but I am not very familiar with this
980 code so I am being extra careful not to change its behavior
981 beyond what is strictly necessary for correctness. */
982
983tree
984c_begin_while_stmt (void)
985{
986 tree r;
987 r = build_stmt (WHILE_STMT, NULL_TREE, NULL_TREE);
988 return r;
989}
990
991void
992c_finish_while_stmt_cond (tree cond, tree while_stmt)
993{
994 WHILE_COND (while_stmt) = cond;
995}
996
997/* Push current bindings for the function name VAR_DECLS. */
998
999void
1000start_fname_decls (void)
1001{
1002 unsigned ix;
1003 tree saved = NULL_TREE;
1004
1005 for (ix = 0; fname_vars[ix].decl; ix++)
1006 {
1007 tree decl = *fname_vars[ix].decl;
1008
1009 if (decl)
1010 {
658/* Push current bindings for the function name VAR_DECLS. */
659
660void
661start_fname_decls (void)
662{
663 unsigned ix;
664 tree saved = NULL_TREE;
665
666 for (ix = 0; fname_vars[ix].decl; ix++)
667 {
668 tree decl = *fname_vars[ix].decl;
669
670 if (decl)
671 {
1011 saved = tree_cons (decl, build_int_2 (ix, 0), saved);
672 saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
1012 *fname_vars[ix].decl = NULL_TREE;
1013 }
1014 }
1015 if (saved || saved_function_name_decls)
1016 /* Normally they'll have been NULL, so only push if we've got a
1017 stack, or they are non-NULL. */
1018 saved_function_name_decls = tree_cons (saved, NULL_TREE,
1019 saved_function_name_decls);
1020}
1021
673 *fname_vars[ix].decl = NULL_TREE;
674 }
675 }
676 if (saved || saved_function_name_decls)
677 /* Normally they'll have been NULL, so only push if we've got a
678 stack, or they are non-NULL. */
679 saved_function_name_decls = tree_cons (saved, NULL_TREE,
680 saved_function_name_decls);
681}
682
1022/* Finish up the current bindings, adding them into the
1023 current function's statement tree. This is done by wrapping the
1024 function's body in a COMPOUND_STMT containing these decls too. This
1025 must be done _before_ finish_stmt_tree is called. If there is no
1026 current function, we must be at file scope and no statements are
1027 involved. Pop the previous bindings. */
683/* Finish up the current bindings, adding them into the current function's
684 statement tree. This must be done _before_ finish_stmt_tree is called.
685 If there is no current function, we must be at file scope and no statements
686 are involved. Pop the previous bindings. */
1028
1029void
1030finish_fname_decls (void)
1031{
1032 unsigned ix;
687
688void
689finish_fname_decls (void)
690{
691 unsigned ix;
1033 tree body = NULL_TREE;
692 tree stmts = NULL_TREE;
1034 tree stack = saved_function_name_decls;
1035
1036 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
693 tree stack = saved_function_name_decls;
694
695 for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
1037 body = chainon (TREE_VALUE (stack), body);
696 append_to_statement_list (TREE_VALUE (stack), &stmts);
1038
697
1039 if (body)
698 if (stmts)
1040 {
699 {
1041 /* They were called into existence, so add to statement tree. Add
1042 the DECL_STMTs inside the outermost scope. */
1043 tree *p = &DECL_SAVED_TREE (current_function_decl);
1044 /* Skip the dummy EXPR_STMT and any EH_SPEC_BLOCK. */
1045 while (TREE_CODE (*p) != COMPOUND_STMT)
1046 {
1047 if (TREE_CODE (*p) == EXPR_STMT)
1048 p = &TREE_CHAIN (*p);
1049 else
1050 p = &TREE_OPERAND(*p, 0);
1051 }
700 tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
1052
701
1053 p = &COMPOUND_BODY (*p);
1054 if (TREE_CODE (*p) == SCOPE_STMT)
1055 p = &TREE_CHAIN (*p);
702 if (TREE_CODE (*bodyp) == BIND_EXPR)
703 bodyp = &BIND_EXPR_BODY (*bodyp);
1056
704
1057 body = chainon (body, *p);
1058 *p = body;
705 append_to_statement_list_force (*bodyp, &stmts);
706 *bodyp = stmts;
1059 }
1060
1061 for (ix = 0; fname_vars[ix].decl; ix++)
1062 *fname_vars[ix].decl = NULL_TREE;
1063
1064 if (stack)
1065 {
1066 /* We had saved values, restore them. */

--- 7 unchanged lines hidden (view full) ---

1074 *fname_vars[ix].decl = decl;
1075 }
1076 stack = TREE_CHAIN (stack);
1077 }
1078 saved_function_name_decls = stack;
1079}
1080
1081/* Return the text name of the current function, suitably prettified
707 }
708
709 for (ix = 0; fname_vars[ix].decl; ix++)
710 *fname_vars[ix].decl = NULL_TREE;
711
712 if (stack)
713 {
714 /* We had saved values, restore them. */

--- 7 unchanged lines hidden (view full) ---

722 *fname_vars[ix].decl = decl;
723 }
724 stack = TREE_CHAIN (stack);
725 }
726 saved_function_name_decls = stack;
727}
728
729/* Return the text name of the current function, suitably prettified
1082 by PRETTY_P. */
730 by PRETTY_P. Return string must be freed by caller. */
1083
1084const char *
1085fname_as_string (int pretty_p)
1086{
1087 const char *name = "top level";
731
732const char *
733fname_as_string (int pretty_p)
734{
735 const char *name = "top level";
736 char *namep;
1088 int vrb = 2;
1089
737 int vrb = 2;
738
1090 if (! pretty_p)
739 if (!pretty_p)
1091 {
1092 name = "";
1093 vrb = 0;
1094 }
1095
1096 if (current_function_decl)
740 {
741 name = "";
742 vrb = 0;
743 }
744
745 if (current_function_decl)
1097 name = (*lang_hooks.decl_printable_name) (current_function_decl, vrb);
746 name = lang_hooks.decl_printable_name (current_function_decl, vrb);
1098
747
1099 return name;
748 if (c_lex_string_translate)
749 {
750 int len = strlen (name) + 3; /* Two for '"'s. One for NULL. */
751 cpp_string cstr = { 0, 0 }, strname;
752
753 namep = XNEWVEC (char, len);
754 snprintf (namep, len, "\"%s\"", name);
755 strname.text = (unsigned char *) namep;
756 strname.len = len - 1;
757
758 if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
759 {
760 XDELETEVEC (namep);
761 return (char *) cstr.text;
762 }
763 }
764 else
765 namep = xstrdup (name);
766
767 return namep;
1100}
1101
768}
769
770/* Expand DECL if it declares an entity not handled by the
771 common code. */
772
773int
774c_expand_decl (tree decl)
775{
776 if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
777 {
778 /* Let the back-end know about this variable. */
779 if (!anon_aggr_type_p (TREE_TYPE (decl)))
780 emit_local_var (decl);
781 else
782 expand_anon_union_decl (decl, NULL_TREE,
783 DECL_ANON_UNION_ELEMS (decl));
784 }
785 else
786 return 0;
787
788 return 1;
789}
790
791
1102/* Return the VAR_DECL for a const char array naming the current
1103 function. If the VAR_DECL has not yet been created, create it
1104 now. RID indicates how it should be formatted and IDENTIFIER_NODE
1105 ID is its name (unfortunately C and C++ hold the RID values of
1106 keywords in different places, so we can't derive RID from ID in
1107 this language independent code. */
1108
1109tree

--- 4 unchanged lines hidden (view full) ---

1114
1115 for (ix = 0; fname_vars[ix].decl; ix++)
1116 if (fname_vars[ix].rid == rid)
1117 break;
1118
1119 decl = *fname_vars[ix].decl;
1120 if (!decl)
1121 {
792/* Return the VAR_DECL for a const char array naming the current
793 function. If the VAR_DECL has not yet been created, create it
794 now. RID indicates how it should be formatted and IDENTIFIER_NODE
795 ID is its name (unfortunately C and C++ hold the RID values of
796 keywords in different places, so we can't derive RID from ID in
797 this language independent code. */
798
799tree

--- 4 unchanged lines hidden (view full) ---

804
805 for (ix = 0; fname_vars[ix].decl; ix++)
806 if (fname_vars[ix].rid == rid)
807 break;
808
809 decl = *fname_vars[ix].decl;
810 if (!decl)
811 {
1122 tree saved_last_tree = last_tree;
1123 /* If a tree is built here, it would normally have the lineno of
1124 the current statement. Later this tree will be moved to the
1125 beginning of the function and this line number will be wrong.
1126 To avoid this problem set the lineno to 0 here; that prevents
1127 it from appearing in the RTL. */
812 /* If a tree is built here, it would normally have the lineno of
813 the current statement. Later this tree will be moved to the
814 beginning of the function and this line number will be wrong.
815 To avoid this problem set the lineno to 0 here; that prevents
816 it from appearing in the RTL. */
1128 int saved_lineno = input_line;
817 tree stmts;
818 location_t saved_location = input_location;
819#ifdef USE_MAPPED_LOCATION
820 input_location = UNKNOWN_LOCATION;
821#else
1129 input_line = 0;
822 input_line = 0;
823#endif
1130
824
825 stmts = push_stmt_list ();
1131 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
826 decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
1132 if (last_tree != saved_last_tree)
1133 {
1134 /* We created some statement tree for the decl. This belongs
1135 at the start of the function, so remove it now and reinsert
1136 it after the function is complete. */
1137 tree stmts = TREE_CHAIN (saved_last_tree);
1138
1139 TREE_CHAIN (saved_last_tree) = NULL_TREE;
1140 last_tree = saved_last_tree;
1141 saved_function_name_decls = tree_cons (decl, stmts,
1142 saved_function_name_decls);
1143 }
827 stmts = pop_stmt_list (stmts);
828 if (!IS_EMPTY_STMT (stmts))
829 saved_function_name_decls
830 = tree_cons (decl, stmts, saved_function_name_decls);
1144 *fname_vars[ix].decl = decl;
831 *fname_vars[ix].decl = decl;
1145 input_line = saved_lineno;
832 input_location = saved_location;
1146 }
1147 if (!ix && !current_function_decl)
833 }
834 if (!ix && !current_function_decl)
1148 pedwarn ("'%D' is not defined outside of function scope", decl);
835 pedwarn ("%qD is not defined outside of function scope", decl);
1149
1150 return decl;
1151}
1152
1153/* Given a STRING_CST, give it a suitable array-of-chars data type. */
1154
1155tree
1156fix_string_type (tree value)
1157{
1158 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
1159 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
836
837 return decl;
838}
839
840/* Given a STRING_CST, give it a suitable array-of-chars data type. */
841
842tree
843fix_string_type (tree value)
844{
845 const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
846 const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
1160 const int nchars_max = flag_isoc99 ? 4095 : 509;
1161 int length = TREE_STRING_LENGTH (value);
1162 int nchars;
847 int length = TREE_STRING_LENGTH (value);
848 int nchars;
849 tree e_type, i_type, a_type;
1163
1164 /* Compute the number of elements, for the array type. */
1165 nchars = wide_flag ? length / wchar_bytes : length;
1166
850
851 /* Compute the number of elements, for the array type. */
852 nchars = wide_flag ? length / wchar_bytes : length;
853
1167 if (pedantic && nchars - 1 > nchars_max && !c_dialect_cxx ())
1168 pedwarn ("string length `%d' is greater than the length `%d' ISO C%d compilers are required to support",
1169 nchars - 1, nchars_max, flag_isoc99 ? 99 : 89);
1170
1171 /* Create the array type for the string constant.
1172 -Wwrite-strings says make the string constant an array of const char
1173 so that copying it to a non-const pointer will get a warning.
1174 For C++, this is the standard behavior. */
1175 if (flag_const_strings && ! flag_writable_strings)
854 /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits). The analogous
855 limit in C++98 Annex B is very large (65536) and is not normative,
856 so we do not diagnose it (warn_overlength_strings is forced off
857 in c_common_post_options). */
858 if (warn_overlength_strings)
1176 {
859 {
1177 tree elements
1178 = build_type_variant (wide_flag ? wchar_type_node : char_type_node,
1179 1, 0);
1180 TREE_TYPE (value)
1181 = build_array_type (elements,
1182 build_index_type (build_int_2 (nchars - 1, 0)));
860 const int nchars_max = flag_isoc99 ? 4095 : 509;
861 const int relevant_std = flag_isoc99 ? 99 : 90;
862 if (nchars - 1 > nchars_max)
863 /* Translators: The %d after 'ISO C' will be 90 or 99. Do not
864 separate the %d from the 'C'. 'ISO' should not be
865 translated, but it may be moved after 'C%d' in languages
866 where modifiers follow nouns. */
867 pedwarn ("string length %qd is greater than the length %qd "
868 "ISO C%d compilers are required to support",
869 nchars - 1, nchars_max, relevant_std);
1183 }
870 }
1184 else
1185 TREE_TYPE (value)
1186 = build_array_type (wide_flag ? wchar_type_node : char_type_node,
1187 build_index_type (build_int_2 (nchars - 1, 0)));
1188
871
872 /* Create the array type for the string constant. The ISO C++
873 standard says that a string literal has type `const char[N]' or
874 `const wchar_t[N]'. We use the same logic when invoked as a C
875 front-end with -Wwrite-strings.
876 ??? We should change the type of an expression depending on the
877 state of a warning flag. We should just be warning -- see how
878 this is handled in the C++ front-end for the deprecated implicit
879 conversion from string literals to `char*' or `wchar_t*'.
880
881 The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
882 array type being the unqualified version of that type.
883 Therefore, if we are constructing an array of const char, we must
884 construct the matching unqualified array type first. The C front
885 end does not require this, but it does no harm, so we do it
886 unconditionally. */
887 e_type = wide_flag ? wchar_type_node : char_type_node;
888 i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
889 a_type = build_array_type (e_type, i_type);
890 if (c_dialect_cxx() || warn_write_strings)
891 a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
892
893 TREE_TYPE (value) = a_type;
1189 TREE_CONSTANT (value) = 1;
894 TREE_CONSTANT (value) = 1;
1190 TREE_READONLY (value) = ! flag_writable_strings;
895 TREE_INVARIANT (value) = 1;
896 TREE_READONLY (value) = 1;
1191 TREE_STATIC (value) = 1;
1192 return value;
1193}
1194
1195/* Print a warning if a constant expression had overflow in folding.
1196 Invoke this function on every expression that the language
1197 requires to be a constant expression.
1198 Note the ANSI C standard says it is erroneous for a
1199 constant expression to overflow. */
1200
1201void
1202constant_expression_warning (tree value)
1203{
1204 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1205 || TREE_CODE (value) == VECTOR_CST
1206 || TREE_CODE (value) == COMPLEX_CST)
897 TREE_STATIC (value) = 1;
898 return value;
899}
900
901/* Print a warning if a constant expression had overflow in folding.
902 Invoke this function on every expression that the language
903 requires to be a constant expression.
904 Note the ANSI C standard says it is erroneous for a
905 constant expression to overflow. */
906
907void
908constant_expression_warning (tree value)
909{
910 if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
911 || TREE_CODE (value) == VECTOR_CST
912 || TREE_CODE (value) == COMPLEX_CST)
1207 && TREE_CONSTANT_OVERFLOW (value) && pedantic)
913 && TREE_CONSTANT_OVERFLOW (value)
914 && warn_overflow
915 && pedantic)
1208 pedwarn ("overflow in constant expression");
1209}
1210
1211/* Print a warning if an expression had overflow in folding.
1212 Invoke this function on every expression that
1213 (1) appears in the source code, and
1214 (2) might be a constant expression that overflowed, and
1215 (3) is not already checked by convert_and_check;

--- 4 unchanged lines hidden (view full) ---

1220{
1221 if ((TREE_CODE (value) == INTEGER_CST
1222 || (TREE_CODE (value) == COMPLEX_CST
1223 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
1224 && TREE_OVERFLOW (value))
1225 {
1226 TREE_OVERFLOW (value) = 0;
1227 if (skip_evaluation == 0)
916 pedwarn ("overflow in constant expression");
917}
918
919/* Print a warning if an expression had overflow in folding.
920 Invoke this function on every expression that
921 (1) appears in the source code, and
922 (2) might be a constant expression that overflowed, and
923 (3) is not already checked by convert_and_check;

--- 4 unchanged lines hidden (view full) ---

928{
929 if ((TREE_CODE (value) == INTEGER_CST
930 || (TREE_CODE (value) == COMPLEX_CST
931 && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
932 && TREE_OVERFLOW (value))
933 {
934 TREE_OVERFLOW (value) = 0;
935 if (skip_evaluation == 0)
1228 warning ("integer overflow in expression");
936 warning (OPT_Woverflow, "integer overflow in expression");
1229 }
1230 else if ((TREE_CODE (value) == REAL_CST
1231 || (TREE_CODE (value) == COMPLEX_CST
1232 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
1233 && TREE_OVERFLOW (value))
1234 {
1235 TREE_OVERFLOW (value) = 0;
1236 if (skip_evaluation == 0)
937 }
938 else if ((TREE_CODE (value) == REAL_CST
939 || (TREE_CODE (value) == COMPLEX_CST
940 && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
941 && TREE_OVERFLOW (value))
942 {
943 TREE_OVERFLOW (value) = 0;
944 if (skip_evaluation == 0)
1237 warning ("floating point overflow in expression");
945 warning (OPT_Woverflow, "floating point overflow in expression");
1238 }
1239 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
1240 {
1241 TREE_OVERFLOW (value) = 0;
1242 if (skip_evaluation == 0)
946 }
947 else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
948 {
949 TREE_OVERFLOW (value) = 0;
950 if (skip_evaluation == 0)
1243 warning ("vector overflow in expression");
951 warning (OPT_Woverflow, "vector overflow in expression");
1244 }
1245}
1246
1247/* Print a warning if a large constant is truncated to unsigned,
1248 or if -Wconversion is used and a constant < 0 is converted to unsigned.
1249 Invoke this function on every expression that might be implicitly
1250 converted to an unsigned type. */
1251
952 }
953}
954
955/* Print a warning if a large constant is truncated to unsigned,
956 or if -Wconversion is used and a constant < 0 is converted to unsigned.
957 Invoke this function on every expression that might be implicitly
958 converted to an unsigned type. */
959
1252void
960static void
1253unsigned_conversion_warning (tree result, tree operand)
1254{
1255 tree type = TREE_TYPE (result);
1256
1257 if (TREE_CODE (operand) == INTEGER_CST
1258 && TREE_CODE (type) == INTEGER_TYPE
961unsigned_conversion_warning (tree result, tree operand)
962{
963 tree type = TREE_TYPE (result);
964
965 if (TREE_CODE (operand) == INTEGER_CST
966 && TREE_CODE (type) == INTEGER_TYPE
1259 && TREE_UNSIGNED (type)
967 && TYPE_UNSIGNED (type)
1260 && skip_evaluation == 0
1261 && !int_fits_type_p (operand, type))
1262 {
1263 if (!int_fits_type_p (operand, c_common_signed_type (type)))
1264 /* This detects cases like converting -129 or 256 to unsigned char. */
968 && skip_evaluation == 0
969 && !int_fits_type_p (operand, type))
970 {
971 if (!int_fits_type_p (operand, c_common_signed_type (type)))
972 /* This detects cases like converting -129 or 256 to unsigned char. */
1265 warning ("large integer implicitly truncated to unsigned type");
1266 else if (warn_conversion)
1267 warning ("negative integer implicitly converted to unsigned type");
973 warning (OPT_Woverflow,
974 "large integer implicitly truncated to unsigned type");
975 else
976 warning (OPT_Wconversion,
977 "negative integer implicitly converted to unsigned type");
1268 }
1269}
1270
978 }
979}
980
981/* Print a warning about casts that might indicate violation
982 of strict aliasing rules if -Wstrict-aliasing is used and
983 strict aliasing mode is in effect. OTYPE is the original
984 TREE_TYPE of EXPR, and TYPE the type we're casting to. */
985
986void
987strict_aliasing_warning (tree otype, tree type, tree expr)
988{
989 if (flag_strict_aliasing && warn_strict_aliasing
990 && POINTER_TYPE_P (type) && POINTER_TYPE_P (otype)
991 && TREE_CODE (expr) == ADDR_EXPR
992 && (DECL_P (TREE_OPERAND (expr, 0))
993 || handled_component_p (TREE_OPERAND (expr, 0)))
994 && !VOID_TYPE_P (TREE_TYPE (type)))
995 {
996 /* Casting the address of an object to non void pointer. Warn
997 if the cast breaks type based aliasing. */
998 if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
999 warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1000 "might break strict-aliasing rules");
1001 else
1002 {
1003 HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1004 HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1005
1006 if (!alias_sets_conflict_p (set1, set2))
1007 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1008 "pointer will break strict-aliasing rules");
1009 else if (warn_strict_aliasing > 1
1010 && !alias_sets_might_conflict_p (set1, set2))
1011 warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1012 "pointer might break strict-aliasing rules");
1013 }
1014 }
1015}
1016
1017
1018/* Print a warning about if (); or if () .. else; constructs
1019 via the special empty statement node that we create. INNER_THEN
1020 and INNER_ELSE are the statement lists of the if and the else
1021 block. */
1022
1023void
1024empty_body_warning (tree inner_then, tree inner_else)
1025{
1026 if (extra_warnings)
1027 {
1028 if (TREE_CODE (inner_then) == STATEMENT_LIST
1029 && STATEMENT_LIST_TAIL (inner_then))
1030 inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1031
1032 if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1033 && STATEMENT_LIST_TAIL (inner_else))
1034 inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1035
1036 if (IS_EMPTY_STMT (inner_then) && !inner_else)
1037 warning (OPT_Wextra, "%Hempty body in an if-statement",
1038 EXPR_LOCUS (inner_then));
1039
1040 if (inner_else && IS_EMPTY_STMT (inner_else))
1041 warning (OPT_Wextra, "%Hempty body in an else-statement",
1042 EXPR_LOCUS (inner_else));
1043 }
1044}
1045
1046
1271/* Nonzero if constant C has a value that is permissible
1272 for type TYPE (an INTEGER_TYPE). */
1273
1274static int
1275constant_fits_type_p (tree c, tree type)
1276{
1277 if (TREE_CODE (c) == INTEGER_CST)
1278 return int_fits_type_p (c, type);

--- 4 unchanged lines hidden (view full) ---

1283
1284/* Nonzero if vector types T1 and T2 can be converted to each other
1285 without an explicit cast. */
1286int
1287vector_types_convertible_p (tree t1, tree t2)
1288{
1289 return targetm.vector_opaque_p (t1)
1290 || targetm.vector_opaque_p (t2)
1047/* Nonzero if constant C has a value that is permissible
1048 for type TYPE (an INTEGER_TYPE). */
1049
1050static int
1051constant_fits_type_p (tree c, tree type)
1052{
1053 if (TREE_CODE (c) == INTEGER_CST)
1054 return int_fits_type_p (c, type);

--- 4 unchanged lines hidden (view full) ---

1059
1060/* Nonzero if vector types T1 and T2 can be converted to each other
1061 without an explicit cast. */
1062int
1063vector_types_convertible_p (tree t1, tree t2)
1064{
1065 return targetm.vector_opaque_p (t1)
1066 || targetm.vector_opaque_p (t2)
1291 || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1067 || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1068 && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1069 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1292 && INTEGRAL_TYPE_P (TREE_TYPE (t1))
1293 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
1294}
1295
1296/* Convert EXPR to TYPE, warning about conversion problems with constants.
1297 Invoke this function on every expression that is converted implicitly,
1298 i.e. because of language rules and not because of an explicit cast. */
1299

--- 4 unchanged lines hidden (view full) ---

1304 if (TREE_CODE (t) == INTEGER_CST)
1305 {
1306 if (TREE_OVERFLOW (t))
1307 {
1308 TREE_OVERFLOW (t) = 0;
1309
1310 /* Do not diagnose overflow in a constant expression merely
1311 because a conversion overflowed. */
1070 && INTEGRAL_TYPE_P (TREE_TYPE (t1))
1071 == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
1072}
1073
1074/* Convert EXPR to TYPE, warning about conversion problems with constants.
1075 Invoke this function on every expression that is converted implicitly,
1076 i.e. because of language rules and not because of an explicit cast. */
1077

--- 4 unchanged lines hidden (view full) ---

1082 if (TREE_CODE (t) == INTEGER_CST)
1083 {
1084 if (TREE_OVERFLOW (t))
1085 {
1086 TREE_OVERFLOW (t) = 0;
1087
1088 /* Do not diagnose overflow in a constant expression merely
1089 because a conversion overflowed. */
1312 TREE_CONSTANT_OVERFLOW (t) = TREE_CONSTANT_OVERFLOW (expr);
1090 TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
1091 && TREE_CONSTANT_OVERFLOW (expr);
1313
1314 /* No warning for converting 0x80000000 to int. */
1092
1093 /* No warning for converting 0x80000000 to int. */
1315 if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr))
1094 if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1316 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1317 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1318 /* If EXPR fits in the unsigned version of TYPE,
1319 don't warn unless pedantic. */
1320 if ((pedantic
1095 && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1096 && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1097 /* If EXPR fits in the unsigned version of TYPE,
1098 don't warn unless pedantic. */
1099 if ((pedantic
1321 || TREE_UNSIGNED (type)
1322 || ! constant_fits_type_p (expr,
1323 c_common_unsigned_type (type)))
1324 && skip_evaluation == 0)
1325 warning ("overflow in implicit constant conversion");
1100 || TYPE_UNSIGNED (type)
1101 || !constant_fits_type_p (expr,
1102 c_common_unsigned_type (type)))
1103 && skip_evaluation == 0)
1104 warning (OPT_Woverflow,
1105 "overflow in implicit constant conversion");
1326 }
1327 else
1328 unsigned_conversion_warning (t, expr);
1329 }
1330 return t;
1331}
1332
1333/* A node in a list that describes references to variables (EXPR), which are

--- 29 unchanged lines hidden (view full) ---

1363
1364static void add_tlist (struct tlist **, struct tlist *, tree, int);
1365static void merge_tlist (struct tlist **, struct tlist *, int);
1366static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1367static int warning_candidate_p (tree);
1368static void warn_for_collisions (struct tlist *);
1369static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1370static struct tlist *new_tlist (struct tlist *, tree, tree);
1106 }
1107 else
1108 unsigned_conversion_warning (t, expr);
1109 }
1110 return t;
1111}
1112
1113/* A node in a list that describes references to variables (EXPR), which are

--- 29 unchanged lines hidden (view full) ---

1143
1144static void add_tlist (struct tlist **, struct tlist *, tree, int);
1145static void merge_tlist (struct tlist **, struct tlist *, int);
1146static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1147static int warning_candidate_p (tree);
1148static void warn_for_collisions (struct tlist *);
1149static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1150static struct tlist *new_tlist (struct tlist *, tree, tree);
1371static void verify_sequence_points (tree);
1372
1373/* Create a new struct tlist and fill in its fields. */
1374static struct tlist *
1375new_tlist (struct tlist *next, tree t, tree writer)
1376{
1377 struct tlist *l;
1151
1152/* Create a new struct tlist and fill in its fields. */
1153static struct tlist *
1154new_tlist (struct tlist *next, tree t, tree writer)
1155{
1156 struct tlist *l;
1378 l = obstack_alloc (&tlist_obstack, sizeof *l);
1157 l = XOBNEW (&tlist_obstack, struct tlist);
1379 l->next = next;
1380 l->expr = t;
1381 l->writer = writer;
1382 return l;
1383}
1384
1385/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1386 is nonnull, we ignore any node we find which has a writer equal to it. */
1387
1388static void
1389add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1390{
1391 while (add)
1392 {
1393 struct tlist *next = add->next;
1158 l->next = next;
1159 l->expr = t;
1160 l->writer = writer;
1161 return l;
1162}
1163
1164/* Add duplicates of the nodes found in ADD to the list *TO. If EXCLUDE_WRITER
1165 is nonnull, we ignore any node we find which has a writer equal to it. */
1166
1167static void
1168add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1169{
1170 while (add)
1171 {
1172 struct tlist *next = add->next;
1394 if (! copy)
1173 if (!copy)
1395 add->next = *to;
1174 add->next = *to;
1396 if (! exclude_writer || add->writer != exclude_writer)
1175 if (!exclude_writer || add->writer != exclude_writer)
1397 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1398 add = next;
1399 }
1400}
1401
1402/* Merge the nodes of ADD into TO. This merging process is done so that for
1403 each variable that already exists in TO, no new node is added; however if
1404 there is a write access recorded in ADD, and an occurrence on TO is only

--- 13 unchanged lines hidden (view full) ---

1418 int found = 0;
1419 struct tlist *tmp2;
1420 struct tlist *next = add->next;
1421
1422 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1423 if (tmp2->expr == add->expr)
1424 {
1425 found = 1;
1176 *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1177 add = next;
1178 }
1179}
1180
1181/* Merge the nodes of ADD into TO. This merging process is done so that for
1182 each variable that already exists in TO, no new node is added; however if
1183 there is a write access recorded in ADD, and an occurrence on TO is only

--- 13 unchanged lines hidden (view full) ---

1197 int found = 0;
1198 struct tlist *tmp2;
1199 struct tlist *next = add->next;
1200
1201 for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1202 if (tmp2->expr == add->expr)
1203 {
1204 found = 1;
1426 if (! tmp2->writer)
1205 if (!tmp2->writer)
1427 tmp2->writer = add->writer;
1428 }
1206 tmp2->writer = add->writer;
1207 }
1429 if (! found)
1208 if (!found)
1430 {
1431 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1432 end = &(*end)->next;
1433 *end = 0;
1434 }
1435 add = next;
1436 }
1437}

--- 12 unchanged lines hidden (view full) ---

1450 for (tmp = warned_ids; tmp; tmp = tmp->next)
1451 if (tmp->expr == written)
1452 return;
1453
1454 while (list)
1455 {
1456 if (list->expr == written
1457 && list->writer != writer
1209 {
1210 *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1211 end = &(*end)->next;
1212 *end = 0;
1213 }
1214 add = next;
1215 }
1216}

--- 12 unchanged lines hidden (view full) ---

1229 for (tmp = warned_ids; tmp; tmp = tmp->next)
1230 if (tmp->expr == written)
1231 return;
1232
1233 while (list)
1234 {
1235 if (list->expr == written
1236 && list->writer != writer
1458 && (! only_writes || list->writer))
1237 && (!only_writes || list->writer)
1238 && DECL_NAME (list->expr))
1459 {
1460 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1239 {
1240 warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1461 warning ("operation on `%s' may be undefined",
1462 IDENTIFIER_POINTER (DECL_NAME (list->expr)));
1241 warning (0, "operation on %qE may be undefined", list->expr);
1463 }
1464 list = list->next;
1465 }
1466}
1467
1468/* Given a list LIST of references to variables, find whether any of these
1469 can cause conflicts due to missing sequence points. */
1470

--- 43 unchanged lines hidden (view full) ---

1514 way, so that no more than one access to B is recorded. */
1515
1516static void
1517verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1518 tree writer)
1519{
1520 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1521 enum tree_code code;
1242 }
1243 list = list->next;
1244 }
1245}
1246
1247/* Given a list LIST of references to variables, find whether any of these
1248 can cause conflicts due to missing sequence points. */
1249

--- 43 unchanged lines hidden (view full) ---

1293 way, so that no more than one access to B is recorded. */
1294
1295static void
1296verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1297 tree writer)
1298{
1299 struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1300 enum tree_code code;
1522 char class;
1301 enum tree_code_class cl;
1523
1524 /* X may be NULL if it is the operand of an empty statement expression
1525 ({ }). */
1526 if (x == NULL)
1527 return;
1528
1529 restart:
1530 code = TREE_CODE (x);
1302
1303 /* X may be NULL if it is the operand of an empty statement expression
1304 ({ }). */
1305 if (x == NULL)
1306 return;
1307
1308 restart:
1309 code = TREE_CODE (x);
1531 class = TREE_CODE_CLASS (code);
1310 cl = TREE_CODE_CLASS (code);
1532
1533 if (warning_candidate_p (x))
1534 {
1535 *pno_sp = new_tlist (*pno_sp, x, writer);
1536 return;
1537 }
1538
1539 switch (code)

--- 98 unchanged lines hidden (view full) ---

1638
1639 case SAVE_EXPR:
1640 {
1641 struct tlist_cache *t;
1642 for (t = save_expr_cache; t; t = t->next)
1643 if (t->expr == x)
1644 break;
1645
1311
1312 if (warning_candidate_p (x))
1313 {
1314 *pno_sp = new_tlist (*pno_sp, x, writer);
1315 return;
1316 }
1317
1318 switch (code)

--- 98 unchanged lines hidden (view full) ---

1417
1418 case SAVE_EXPR:
1419 {
1420 struct tlist_cache *t;
1421 for (t = save_expr_cache; t; t = t->next)
1422 if (t->expr == x)
1423 break;
1424
1646 if (! t)
1425 if (!t)
1647 {
1426 {
1648 t = obstack_alloc (&tlist_obstack, sizeof *t);
1427 t = XOBNEW (&tlist_obstack, struct tlist_cache);
1649 t->next = save_expr_cache;
1650 t->expr = x;
1651 save_expr_cache = t;
1652
1653 tmp_before = tmp_nosp = 0;
1654 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1655 warn_for_collisions (tmp_nosp);
1656

--- 6 unchanged lines hidden (view full) ---

1663 }
1664 t->cache_before_sp = tmp_before;
1665 t->cache_after_sp = tmp_list3;
1666 }
1667 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1668 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1669 return;
1670 }
1428 t->next = save_expr_cache;
1429 t->expr = x;
1430 save_expr_cache = t;
1431
1432 tmp_before = tmp_nosp = 0;
1433 verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1434 warn_for_collisions (tmp_nosp);
1435

--- 6 unchanged lines hidden (view full) ---

1442 }
1443 t->cache_before_sp = tmp_before;
1444 t->cache_after_sp = tmp_list3;
1445 }
1446 merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1447 add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1448 return;
1449 }
1450
1671 default:
1451 default:
1672 break;
1452 /* For other expressions, simply recurse on their operands.
1453 Manual tail recursion for unary expressions.
1454 Other non-expressions need not be processed. */
1455 if (cl == tcc_unary)
1456 {
1457 x = TREE_OPERAND (x, 0);
1458 writer = 0;
1459 goto restart;
1460 }
1461 else if (IS_EXPR_CODE_CLASS (cl))
1462 {
1463 int lp;
1464 int max = TREE_CODE_LENGTH (TREE_CODE (x));
1465 for (lp = 0; lp < max; lp++)
1466 {
1467 tmp_before = tmp_nosp = 0;
1468 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1469 merge_tlist (&tmp_nosp, tmp_before, 0);
1470 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1471 }
1472 }
1473 return;
1673 }
1474 }
1674
1675 if (class == '1')
1676 {
1677 if (first_rtl_op (code) == 0)
1678 return;
1679 x = TREE_OPERAND (x, 0);
1680 writer = 0;
1681 goto restart;
1682 }
1683
1684 switch (class)
1685 {
1686 case 'r':
1687 case '<':
1688 case '2':
1689 case 'b':
1690 case 'e':
1691 case 's':
1692 case 'x':
1693 {
1694 int lp;
1695 int max = first_rtl_op (TREE_CODE (x));
1696 for (lp = 0; lp < max; lp++)
1697 {
1698 tmp_before = tmp_nosp = 0;
1699 verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, NULL_TREE);
1700 merge_tlist (&tmp_nosp, tmp_before, 0);
1701 add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1702 }
1703 break;
1704 }
1705 }
1706}
1707
1708/* Try to warn for undefined behavior in EXPR due to missing sequence
1709 points. */
1710
1475}
1476
1477/* Try to warn for undefined behavior in EXPR due to missing sequence
1478 points. */
1479
1711static void
1480void
1712verify_sequence_points (tree expr)
1713{
1714 struct tlist *before_sp = 0, *after_sp = 0;
1715
1716 warned_ids = 0;
1717 save_expr_cache = 0;
1718 if (tlist_firstobj == 0)
1719 {
1720 gcc_obstack_init (&tlist_obstack);
1481verify_sequence_points (tree expr)
1482{
1483 struct tlist *before_sp = 0, *after_sp = 0;
1484
1485 warned_ids = 0;
1486 save_expr_cache = 0;
1487 if (tlist_firstobj == 0)
1488 {
1489 gcc_obstack_init (&tlist_obstack);
1721 tlist_firstobj = obstack_alloc (&tlist_obstack, 0);
1490 tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1722 }
1723
1724 verify_tree (expr, &before_sp, &after_sp, 0);
1725 warn_for_collisions (after_sp);
1726 obstack_free (&tlist_obstack, tlist_firstobj);
1727}
1491 }
1492
1493 verify_tree (expr, &before_sp, &after_sp, 0);
1494 warn_for_collisions (after_sp);
1495 obstack_free (&tlist_obstack, tlist_firstobj);
1496}
1728
1729tree
1730c_expand_expr_stmt (tree expr)
1731{
1732 /* Do default conversion if safe and possibly important,
1733 in case within ({...}). */
1734 if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE
1735 && (flag_isoc99 || lvalue_p (expr)))
1736 || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE)
1737 expr = default_conversion (expr);
1738
1739 if (warn_sequence_point)
1740 verify_sequence_points (expr);
1741
1742 if (TREE_TYPE (expr) != error_mark_node
1743 && !COMPLETE_OR_VOID_TYPE_P (TREE_TYPE (expr))
1744 && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE)
1745 error ("expression statement has incomplete type");
1746
1747 last_expr_type = TREE_TYPE (expr);
1748 return add_stmt (build_stmt (EXPR_STMT, expr));
1749}
1750
1751/* Validate the expression after `case' and apply default promotions. */
1752
1497
1498/* Validate the expression after `case' and apply default promotions. */
1499
1753tree
1500static tree
1754check_case_value (tree value)
1755{
1756 if (value == NULL_TREE)
1757 return value;
1758
1501check_case_value (tree value)
1502{
1503 if (value == NULL_TREE)
1504 return value;
1505
1759 /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */
1506 /* ??? Can we ever get nops here for a valid case value? We
1507 shouldn't for C. */
1760 STRIP_TYPE_NOPS (value);
1761 /* In C++, the following is allowed:
1762
1763 const int i = 3;
1764 switch (...) { case i: ... }
1765
1766 So, we try to reduce the VALUE to a constant that way. */
1767 if (c_dialect_cxx ())
1768 {
1769 value = decl_constant_value (value);
1770 STRIP_TYPE_NOPS (value);
1771 value = fold (value);
1772 }
1773
1508 STRIP_TYPE_NOPS (value);
1509 /* In C++, the following is allowed:
1510
1511 const int i = 3;
1512 switch (...) { case i: ... }
1513
1514 So, we try to reduce the VALUE to a constant that way. */
1515 if (c_dialect_cxx ())
1516 {
1517 value = decl_constant_value (value);
1518 STRIP_TYPE_NOPS (value);
1519 value = fold (value);
1520 }
1521
1774 if (TREE_CODE (value) != INTEGER_CST
1775 && value != error_mark_node)
1522 if (TREE_CODE (value) == INTEGER_CST)
1523 /* Promote char or short to int. */
1524 value = perform_integral_promotions (value);
1525 else if (value != error_mark_node)
1776 {
1777 error ("case label does not reduce to an integer constant");
1778 value = error_mark_node;
1779 }
1526 {
1527 error ("case label does not reduce to an integer constant");
1528 value = error_mark_node;
1529 }
1780 else
1781 /* Promote char or short to int. */
1782 value = default_conversion (value);
1783
1784 constant_expression_warning (value);
1785
1786 return value;
1787}
1788
1530
1531 constant_expression_warning (value);
1532
1533 return value;
1534}
1535
1536/* See if the case values LOW and HIGH are in the range of the original
1537 type (i.e. before the default conversion to int) of the switch testing
1538 expression.
1539 TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1540 the type before promoting it. CASE_LOW_P is a pointer to the lower
1541 bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1542 if the case is not a case range.
1543 The caller has to make sure that we are not called with NULL for
1544 CASE_LOW_P (i.e. the default case).
1545 Returns true if the case label is in range of ORIG_TYPE (saturated or
1546 untouched) or false if the label is out of range. */
1547
1548static bool
1549check_case_bounds (tree type, tree orig_type,
1550 tree *case_low_p, tree *case_high_p)
1551{
1552 tree min_value, max_value;
1553 tree case_low = *case_low_p;
1554 tree case_high = case_high_p ? *case_high_p : case_low;
1555
1556 /* If there was a problem with the original type, do nothing. */
1557 if (orig_type == error_mark_node)
1558 return true;
1559
1560 min_value = TYPE_MIN_VALUE (orig_type);
1561 max_value = TYPE_MAX_VALUE (orig_type);
1562
1563 /* Case label is less than minimum for type. */
1564 if (tree_int_cst_compare (case_low, min_value) < 0
1565 && tree_int_cst_compare (case_high, min_value) < 0)
1566 {
1567 warning (0, "case label value is less than minimum value for type");
1568 return false;
1569 }
1570
1571 /* Case value is greater than maximum for type. */
1572 if (tree_int_cst_compare (case_low, max_value) > 0
1573 && tree_int_cst_compare (case_high, max_value) > 0)
1574 {
1575 warning (0, "case label value exceeds maximum value for type");
1576 return false;
1577 }
1578
1579 /* Saturate lower case label value to minimum. */
1580 if (tree_int_cst_compare (case_high, min_value) >= 0
1581 && tree_int_cst_compare (case_low, min_value) < 0)
1582 {
1583 warning (0, "lower value in case label range"
1584 " less than minimum value for type");
1585 case_low = min_value;
1586 }
1587
1588 /* Saturate upper case label value to maximum. */
1589 if (tree_int_cst_compare (case_low, max_value) <= 0
1590 && tree_int_cst_compare (case_high, max_value) > 0)
1591 {
1592 warning (0, "upper value in case label range"
1593 " exceeds maximum value for type");
1594 case_high = max_value;
1595 }
1596
1597 if (*case_low_p != case_low)
1598 *case_low_p = convert (type, case_low);
1599 if (case_high_p && *case_high_p != case_high)
1600 *case_high_p = convert (type, case_high);
1601
1602 return true;
1603}
1604
1789/* Return an integer type with BITS bits of precision,
1790 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1791
1792tree
1793c_common_type_for_size (unsigned int bits, int unsignedp)
1794{
1795 if (bits == TYPE_PRECISION (integer_type_node))
1796 return unsignedp ? unsigned_type_node : integer_type_node;

--- 55 unchanged lines hidden (view full) ---

1852 if (mode == TYPE_MODE (long_integer_type_node))
1853 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1854
1855 if (mode == TYPE_MODE (long_long_integer_type_node))
1856 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1857
1858 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1859 return unsignedp ? widest_unsigned_literal_type_node
1605/* Return an integer type with BITS bits of precision,
1606 that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */
1607
1608tree
1609c_common_type_for_size (unsigned int bits, int unsignedp)
1610{
1611 if (bits == TYPE_PRECISION (integer_type_node))
1612 return unsignedp ? unsigned_type_node : integer_type_node;

--- 55 unchanged lines hidden (view full) ---

1668 if (mode == TYPE_MODE (long_integer_type_node))
1669 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1670
1671 if (mode == TYPE_MODE (long_long_integer_type_node))
1672 return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1673
1674 if (mode == TYPE_MODE (widest_integer_literal_type_node))
1675 return unsignedp ? widest_unsigned_literal_type_node
1860 : widest_integer_literal_type_node;
1676 : widest_integer_literal_type_node;
1861
1862 if (mode == QImode)
1863 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1864
1865 if (mode == HImode)
1866 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1867
1868 if (mode == SImode)

--- 13 unchanged lines hidden (view full) ---

1882 if (mode == TYPE_MODE (double_type_node))
1883 return double_type_node;
1884
1885 if (mode == TYPE_MODE (long_double_type_node))
1886 return long_double_type_node;
1887
1888 if (mode == TYPE_MODE (void_type_node))
1889 return void_type_node;
1677
1678 if (mode == QImode)
1679 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1680
1681 if (mode == HImode)
1682 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1683
1684 if (mode == SImode)

--- 13 unchanged lines hidden (view full) ---

1698 if (mode == TYPE_MODE (double_type_node))
1699 return double_type_node;
1700
1701 if (mode == TYPE_MODE (long_double_type_node))
1702 return long_double_type_node;
1703
1704 if (mode == TYPE_MODE (void_type_node))
1705 return void_type_node;
1890
1706
1891 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1707 if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1892 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1708 return (unsignedp
1709 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1710 : make_signed_type (GET_MODE_PRECISION (mode)));
1893
1894 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1711
1712 if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1895 return unsignedp ? make_unsigned_type (mode) : make_signed_type (mode);
1713 return (unsignedp
1714 ? make_unsigned_type (GET_MODE_PRECISION (mode))
1715 : make_signed_type (GET_MODE_PRECISION (mode)));
1896
1716
1897 switch (mode)
1717 if (COMPLEX_MODE_P (mode))
1898 {
1718 {
1899 case V16QImode:
1900 return unsignedp ? unsigned_V16QI_type_node : V16QI_type_node;
1901 case V8HImode:
1902 return unsignedp ? unsigned_V8HI_type_node : V8HI_type_node;
1903 case V4SImode:
1904 return unsignedp ? unsigned_V4SI_type_node : V4SI_type_node;
1905 case V2DImode:
1906 return unsignedp ? unsigned_V2DI_type_node : V2DI_type_node;
1907 case V2SImode:
1908 return unsignedp ? unsigned_V2SI_type_node : V2SI_type_node;
1909 case V2HImode:
1910 return unsignedp ? unsigned_V2HI_type_node : V2HI_type_node;
1911 case V4HImode:
1912 return unsignedp ? unsigned_V4HI_type_node : V4HI_type_node;
1913 case V8QImode:
1914 return unsignedp ? unsigned_V8QI_type_node : V8QI_type_node;
1915 case V1DImode:
1916 return unsignedp ? unsigned_V1DI_type_node : V1DI_type_node;
1917 case V16SFmode:
1918 return V16SF_type_node;
1919 case V4SFmode:
1920 return V4SF_type_node;
1921 case V2SFmode:
1922 return V2SF_type_node;
1923 case V2DFmode:
1924 return V2DF_type_node;
1925 case V4DFmode:
1926 return V4DF_type_node;
1927 default:
1928 break;
1719 enum machine_mode inner_mode;
1720 tree inner_type;
1721
1722 if (mode == TYPE_MODE (complex_float_type_node))
1723 return complex_float_type_node;
1724 if (mode == TYPE_MODE (complex_double_type_node))
1725 return complex_double_type_node;
1726 if (mode == TYPE_MODE (complex_long_double_type_node))
1727 return complex_long_double_type_node;
1728
1729 if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1730 return complex_integer_type_node;
1731
1732 inner_mode = GET_MODE_INNER (mode);
1733 inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1734 if (inner_type != NULL_TREE)
1735 return build_complex_type (inner_type);
1929 }
1736 }
1737 else if (VECTOR_MODE_P (mode))
1738 {
1739 enum machine_mode inner_mode = GET_MODE_INNER (mode);
1740 tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1741 if (inner_type != NULL_TREE)
1742 return build_vector_type_for_mode (inner_type, mode);
1743 }
1930
1744
1745 if (mode == TYPE_MODE (dfloat32_type_node))
1746 return dfloat32_type_node;
1747 if (mode == TYPE_MODE (dfloat64_type_node))
1748 return dfloat64_type_node;
1749 if (mode == TYPE_MODE (dfloat128_type_node))
1750 return dfloat128_type_node;
1751
1931 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1932 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1933 return TREE_VALUE (t);
1934
1935 return 0;
1936}
1937
1938/* Return an unsigned type the same as TYPE in other respects. */

--- 64 unchanged lines hidden (view full) ---

2003}
2004
2005/* Return a type the same as TYPE except unsigned or
2006 signed according to UNSIGNEDP. */
2007
2008tree
2009c_common_signed_or_unsigned_type (int unsignedp, tree type)
2010{
1752 for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1753 if (TYPE_MODE (TREE_VALUE (t)) == mode)
1754 return TREE_VALUE (t);
1755
1756 return 0;
1757}
1758
1759/* Return an unsigned type the same as TYPE in other respects. */

--- 64 unchanged lines hidden (view full) ---

1824}
1825
1826/* Return a type the same as TYPE except unsigned or
1827 signed according to UNSIGNEDP. */
1828
1829tree
1830c_common_signed_or_unsigned_type (int unsignedp, tree type)
1831{
2011 if (! INTEGRAL_TYPE_P (type)
2012 || TREE_UNSIGNED (type) == unsignedp)
1832 if (!INTEGRAL_TYPE_P (type)
1833 || TYPE_UNSIGNED (type) == unsignedp)
2013 return type;
2014
1834 return type;
1835
2015 /* Must check the mode of the types, not the precision. Enumeral types
2016 in C++ have precision set to match their range, but may use a wider
2017 mode to match an ABI. If we change modes, we may wind up with bad
2018 conversions. */
1836 /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1837 the precision; they have precision set to match their range, but
1838 may use a wider mode to match an ABI. If we change modes, we may
1839 wind up with bad conversions. For INTEGER_TYPEs in C, must check
1840 the precision as well, so as to yield correct results for
1841 bit-field types. C++ does not have these separate bit-field
1842 types, and producing a signed or unsigned variant of an
1843 ENUMERAL_TYPE may cause other problems as well. */
2019
1844
2020 if (TYPE_MODE (type) == TYPE_MODE (signed_char_type_node))
1845#define TYPE_OK(node) \
1846 (TYPE_MODE (type) == TYPE_MODE (node) \
1847 && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1848 if (TYPE_OK (signed_char_type_node))
2021 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1849 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2022 if (TYPE_MODE (type) == TYPE_MODE (integer_type_node))
1850 if (TYPE_OK (integer_type_node))
2023 return unsignedp ? unsigned_type_node : integer_type_node;
1851 return unsignedp ? unsigned_type_node : integer_type_node;
2024 if (TYPE_MODE (type) == TYPE_MODE (short_integer_type_node))
1852 if (TYPE_OK (short_integer_type_node))
2025 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1853 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2026 if (TYPE_MODE (type) == TYPE_MODE (long_integer_type_node))
1854 if (TYPE_OK (long_integer_type_node))
2027 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1855 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2028 if (TYPE_MODE (type) == TYPE_MODE (long_long_integer_type_node))
1856 if (TYPE_OK (long_long_integer_type_node))
2029 return (unsignedp ? long_long_unsigned_type_node
2030 : long_long_integer_type_node);
1857 return (unsignedp ? long_long_unsigned_type_node
1858 : long_long_integer_type_node);
2031 if (TYPE_MODE (type) == TYPE_MODE (widest_integer_literal_type_node))
1859 if (TYPE_OK (widest_integer_literal_type_node))
2032 return (unsignedp ? widest_unsigned_literal_type_node
2033 : widest_integer_literal_type_node);
2034
2035#if HOST_BITS_PER_WIDE_INT >= 64
1860 return (unsignedp ? widest_unsigned_literal_type_node
1861 : widest_integer_literal_type_node);
1862
1863#if HOST_BITS_PER_WIDE_INT >= 64
2036 if (TYPE_MODE (type) == TYPE_MODE (intTI_type_node))
1864 if (TYPE_OK (intTI_type_node))
2037 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2038#endif
1865 return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1866#endif
2039 if (TYPE_MODE (type) == TYPE_MODE (intDI_type_node))
1867 if (TYPE_OK (intDI_type_node))
2040 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1868 return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2041 if (TYPE_MODE (type) == TYPE_MODE (intSI_type_node))
1869 if (TYPE_OK (intSI_type_node))
2042 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1870 return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2043 if (TYPE_MODE (type) == TYPE_MODE (intHI_type_node))
1871 if (TYPE_OK (intHI_type_node))
2044 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1872 return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2045 if (TYPE_MODE (type) == TYPE_MODE (intQI_type_node))
1873 if (TYPE_OK (intQI_type_node))
2046 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1874 return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1875#undef TYPE_OK
2047
1876
2048 return type;
1877 if (c_dialect_cxx ())
1878 return type;
1879 else
1880 return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2049}
2050
1881}
1882
1883/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP. */
1884
1885tree
1886c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
1887{
1888 /* Extended integer types of the same width as a standard type have
1889 lesser rank, so those of the same width as int promote to int or
1890 unsigned int and are valid for printf formats expecting int or
1891 unsigned int. To avoid such special cases, avoid creating
1892 extended integer types for bit-fields if a standard integer type
1893 is available. */
1894 if (width == TYPE_PRECISION (integer_type_node))
1895 return unsignedp ? unsigned_type_node : integer_type_node;
1896 if (width == TYPE_PRECISION (signed_char_type_node))
1897 return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1898 if (width == TYPE_PRECISION (short_integer_type_node))
1899 return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1900 if (width == TYPE_PRECISION (long_integer_type_node))
1901 return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1902 if (width == TYPE_PRECISION (long_long_integer_type_node))
1903 return (unsignedp ? long_long_unsigned_type_node
1904 : long_long_integer_type_node);
1905 return build_nonstandard_integer_type (width, unsignedp);
1906}
1907
2051/* The C version of the register_builtin_type langhook. */
2052
2053void
2054c_register_builtin_type (tree type, const char* name)
2055{
2056 tree decl;
2057
2058 decl = build_decl (TYPE_DECL, get_identifier (name), type);

--- 15 unchanged lines hidden (view full) ---

2074 int log;
2075
2076 /* If the value is negative, compute its negative minus 1. The latter
2077 adjustment is because the absolute value of the largest negative value
2078 is one larger than the largest positive value. This is equivalent to
2079 a bit-wise negation, so use that operation instead. */
2080
2081 if (tree_int_cst_sgn (value) < 0)
1908/* The C version of the register_builtin_type langhook. */
1909
1910void
1911c_register_builtin_type (tree type, const char* name)
1912{
1913 tree decl;
1914
1915 decl = build_decl (TYPE_DECL, get_identifier (name), type);

--- 15 unchanged lines hidden (view full) ---

1931 int log;
1932
1933 /* If the value is negative, compute its negative minus 1. The latter
1934 adjustment is because the absolute value of the largest negative value
1935 is one larger than the largest positive value. This is equivalent to
1936 a bit-wise negation, so use that operation instead. */
1937
1938 if (tree_int_cst_sgn (value) < 0)
2082 value = fold (build1 (BIT_NOT_EXPR, TREE_TYPE (value), value));
1939 value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
2083
2084 /* Return the number of bits needed, taking into account the fact
2085 that we need one more bit for a signed than unsigned type. */
2086
2087 if (integer_zerop (value))
2088 log = 0;
2089 else
2090 log = tree_floor_log2 (value);
2091
1940
1941 /* Return the number of bits needed, taking into account the fact
1942 that we need one more bit for a signed than unsigned type. */
1943
1944 if (integer_zerop (value))
1945 log = 0;
1946 else
1947 log = tree_floor_log2 (value);
1948
2092 return log + 1 + ! unsignedp;
1949 return log + 1 + !unsignedp;
2093}
2094
2095/* Print an error message for invalid operands to arith operation
1950}
1951
1952/* Print an error message for invalid operands to arith operation
2096 CODE. NOP_EXPR is used as a special case (see
2097 c_common_truthvalue_conversion). */
1953 CODE. */
2098
2099void
2100binary_op_error (enum tree_code code)
2101{
2102 const char *opname;
2103
2104 switch (code)
2105 {
1954
1955void
1956binary_op_error (enum tree_code code)
1957{
1958 const char *opname;
1959
1960 switch (code)
1961 {
2106 case NOP_EXPR:
2107 error ("invalid truth-value expression");
2108 return;
2109
2110 case PLUS_EXPR:
2111 opname = "+"; break;
2112 case MINUS_EXPR:
2113 opname = "-"; break;
2114 case MULT_EXPR:
2115 opname = "*"; break;
2116 case MAX_EXPR:
2117 opname = "max"; break;

--- 26 unchanged lines hidden (view full) ---

2144 case BIT_IOR_EXPR:
2145 opname = "|"; break;
2146 case TRUTH_ANDIF_EXPR:
2147 opname = "&&"; break;
2148 case TRUTH_ORIF_EXPR:
2149 opname = "||"; break;
2150 case BIT_XOR_EXPR:
2151 opname = "^"; break;
1962 case PLUS_EXPR:
1963 opname = "+"; break;
1964 case MINUS_EXPR:
1965 opname = "-"; break;
1966 case MULT_EXPR:
1967 opname = "*"; break;
1968 case MAX_EXPR:
1969 opname = "max"; break;

--- 26 unchanged lines hidden (view full) ---

1996 case BIT_IOR_EXPR:
1997 opname = "|"; break;
1998 case TRUTH_ANDIF_EXPR:
1999 opname = "&&"; break;
2000 case TRUTH_ORIF_EXPR:
2001 opname = "||"; break;
2002 case BIT_XOR_EXPR:
2003 opname = "^"; break;
2152 case LROTATE_EXPR:
2153 case RROTATE_EXPR:
2154 opname = "rotate"; break;
2155 default:
2004 default:
2156 opname = "unknown"; break;
2005 gcc_unreachable ();
2157 }
2158 error ("invalid operands to binary %s", opname);
2159}
2160
2161/* Subroutine of build_binary_op, used for comparison operations.
2162 See if the operands have both been converted from subword integer types
2163 and, if so, perhaps change them both back to their original type.
2164 This function is also responsible for converting the two operands

--- 24 unchanged lines hidden (view full) ---

2189
2190 primop0 = get_narrower (op0, &unsignedp0);
2191 primop1 = get_narrower (op1, &unsignedp1);
2192
2193 /* Handle the case that OP0 does not *contain* a conversion
2194 but it *requires* conversion to FINAL_TYPE. */
2195
2196 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2006 }
2007 error ("invalid operands to binary %s", opname);
2008}
2009
2010/* Subroutine of build_binary_op, used for comparison operations.
2011 See if the operands have both been converted from subword integer types
2012 and, if so, perhaps change them both back to their original type.
2013 This function is also responsible for converting the two operands

--- 24 unchanged lines hidden (view full) ---

2038
2039 primop0 = get_narrower (op0, &unsignedp0);
2040 primop1 = get_narrower (op1, &unsignedp1);
2041
2042 /* Handle the case that OP0 does not *contain* a conversion
2043 but it *requires* conversion to FINAL_TYPE. */
2044
2045 if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2197 unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0));
2046 unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2198 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2047 if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2199 unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1));
2048 unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2200
2201 /* If one of the operands must be floated, we cannot optimize. */
2202 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2203 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2204
2205 /* If first arg is constant, swap the args (changing operation
2206 so value is preserved), for canonicalization. Don't do this if
2207 the second arg is 0. */
2208
2209 if (TREE_CONSTANT (primop0)
2049
2050 /* If one of the operands must be floated, we cannot optimize. */
2051 real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2052 real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2053
2054 /* If first arg is constant, swap the args (changing operation
2055 so value is preserved), for canonicalization. Don't do this if
2056 the second arg is 0. */
2057
2058 if (TREE_CONSTANT (primop0)
2210 && ! integer_zerop (primop1) && ! real_zerop (primop1))
2059 && !integer_zerop (primop1) && !real_zerop (primop1))
2211 {
2212 tree tem = primop0;
2213 int temi = unsignedp0;
2214 primop0 = primop1;
2215 primop1 = tem;
2216 tem = op0;
2217 op0 = op1;
2218 op1 = tem;

--- 44 unchanged lines hidden (view full) ---

2263
2264 if (!real1 && !real2
2265 && TREE_CODE (primop1) == INTEGER_CST
2266 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2267 {
2268 int min_gt, max_gt, min_lt, max_lt;
2269 tree maxval, minval;
2270 /* 1 if comparison is nominally unsigned. */
2060 {
2061 tree tem = primop0;
2062 int temi = unsignedp0;
2063 primop0 = primop1;
2064 primop1 = tem;
2065 tem = op0;
2066 op0 = op1;
2067 op1 = tem;

--- 44 unchanged lines hidden (view full) ---

2112
2113 if (!real1 && !real2
2114 && TREE_CODE (primop1) == INTEGER_CST
2115 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2116 {
2117 int min_gt, max_gt, min_lt, max_lt;
2118 tree maxval, minval;
2119 /* 1 if comparison is nominally unsigned. */
2271 int unsignedp = TREE_UNSIGNED (*restype_ptr);
2120 int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2272 tree val;
2273
2274 type = c_common_signed_or_unsigned_type (unsignedp0,
2275 TREE_TYPE (primop0));
2276
2121 tree val;
2122
2123 type = c_common_signed_or_unsigned_type (unsignedp0,
2124 TREE_TYPE (primop0));
2125
2277 /* In C, if TYPE is an enumeration, then we need to get its
2278 min/max values from it's underlying integral type, not the
2279 enumerated type itself. In C++, TYPE_MAX_VALUE and
2280 TYPE_MIN_VALUE have already been set correctly on the
2281 enumeration type. */
2282 if (!c_dialect_cxx() && TREE_CODE (type) == ENUMERAL_TYPE)
2283 type = c_common_type_for_size (TYPE_PRECISION (type), unsignedp0);
2284
2285 maxval = TYPE_MAX_VALUE (type);
2286 minval = TYPE_MIN_VALUE (type);
2287
2288 if (unsignedp && !unsignedp0)
2289 *restype_ptr = c_common_signed_type (*restype_ptr);
2290
2291 if (TREE_TYPE (primop1) != *restype_ptr)
2126 maxval = TYPE_MAX_VALUE (type);
2127 minval = TYPE_MIN_VALUE (type);
2128
2129 if (unsignedp && !unsignedp0)
2130 *restype_ptr = c_common_signed_type (*restype_ptr);
2131
2132 if (TREE_TYPE (primop1) != *restype_ptr)
2292 primop1 = convert (*restype_ptr, primop1);
2133 {
2134 /* Convert primop1 to target type, but do not introduce
2135 additional overflow. We know primop1 is an int_cst. */
2136 tree tmp = build_int_cst_wide (*restype_ptr,
2137 TREE_INT_CST_LOW (primop1),
2138 TREE_INT_CST_HIGH (primop1));
2139
2140 primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2141 TREE_CONSTANT_OVERFLOW (primop1));
2142 }
2293 if (type != *restype_ptr)
2294 {
2295 minval = convert (*restype_ptr, minval);
2296 maxval = convert (*restype_ptr, maxval);
2297 }
2298
2299 if (unsignedp && unsignedp0)
2300 {

--- 83 unchanged lines hidden (view full) ---

2384 break;
2385 }
2386 type = c_common_unsigned_type (type);
2387 }
2388
2389 if (TREE_CODE (primop0) != INTEGER_CST)
2390 {
2391 if (val == truthvalue_false_node)
2143 if (type != *restype_ptr)
2144 {
2145 minval = convert (*restype_ptr, minval);
2146 maxval = convert (*restype_ptr, maxval);
2147 }
2148
2149 if (unsignedp && unsignedp0)
2150 {

--- 83 unchanged lines hidden (view full) ---

2234 break;
2235 }
2236 type = c_common_unsigned_type (type);
2237 }
2238
2239 if (TREE_CODE (primop0) != INTEGER_CST)
2240 {
2241 if (val == truthvalue_false_node)
2392 warning ("comparison is always false due to limited range of data type");
2242 warning (0, "comparison is always false due to limited range of data type");
2393 if (val == truthvalue_true_node)
2243 if (val == truthvalue_true_node)
2394 warning ("comparison is always true due to limited range of data type");
2244 warning (0, "comparison is always true due to limited range of data type");
2395 }
2396
2397 if (val != 0)
2398 {
2399 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2400 if (TREE_SIDE_EFFECTS (primop0))
2245 }
2246
2247 if (val != 0)
2248 {
2249 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2250 if (TREE_SIDE_EFFECTS (primop0))
2401 return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2251 return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2402 return val;
2403 }
2404
2405 /* Value is not predetermined, but do the comparison
2406 in the type of the operand that is not constant.
2407 TYPE is already properly set. */
2408 }
2252 return val;
2253 }
2254
2255 /* Value is not predetermined, but do the comparison
2256 in the type of the operand that is not constant.
2257 TYPE is already properly set. */
2258 }
2259
2260 /* If either arg is decimal float and the other is float, find the
2261 proper common type to use for comparison. */
2409 else if (real1 && real2
2262 else if (real1 && real2
2263 && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2264 || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2265 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2266
2267 else if (real1 && real2
2410 && (TYPE_PRECISION (TREE_TYPE (primop0))
2411 == TYPE_PRECISION (TREE_TYPE (primop1))))
2412 type = TREE_TYPE (primop0);
2413
2414 /* If args' natural types are both narrower than nominal type
2415 and both extend in the same manner, compare them
2416 in the type of the wider arg.
2417 Otherwise must actually extend both to the nominal
2418 common type lest different ways of extending
2419 alter the result.
2420 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2421
2422 else if (unsignedp0 == unsignedp1 && real1 == real2
2423 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2424 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2425 {
2426 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2427 type = c_common_signed_or_unsigned_type (unsignedp0
2268 && (TYPE_PRECISION (TREE_TYPE (primop0))
2269 == TYPE_PRECISION (TREE_TYPE (primop1))))
2270 type = TREE_TYPE (primop0);
2271
2272 /* If args' natural types are both narrower than nominal type
2273 and both extend in the same manner, compare them
2274 in the type of the wider arg.
2275 Otherwise must actually extend both to the nominal
2276 common type lest different ways of extending
2277 alter the result.
2278 (eg, (short)-1 == (unsigned short)-1 should be 0.) */
2279
2280 else if (unsignedp0 == unsignedp1 && real1 == real2
2281 && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2282 && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2283 {
2284 type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2285 type = c_common_signed_or_unsigned_type (unsignedp0
2428 || TREE_UNSIGNED (*restype_ptr),
2286 || TYPE_UNSIGNED (*restype_ptr),
2429 type);
2430 /* Make sure shorter operand is extended the right way
2431 to match the longer operand. */
2432 primop0
2433 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2434 TREE_TYPE (primop0)),
2435 primop0);
2436 primop1

--- 5 unchanged lines hidden (view full) ---

2442 {
2443 /* Here we must do the comparison on the nominal type
2444 using the args exactly as we received them. */
2445 type = *restype_ptr;
2446 primop0 = op0;
2447 primop1 = op1;
2448
2449 if (!real1 && !real2 && integer_zerop (primop1)
2287 type);
2288 /* Make sure shorter operand is extended the right way
2289 to match the longer operand. */
2290 primop0
2291 = convert (c_common_signed_or_unsigned_type (unsignedp0,
2292 TREE_TYPE (primop0)),
2293 primop0);
2294 primop1

--- 5 unchanged lines hidden (view full) ---

2300 {
2301 /* Here we must do the comparison on the nominal type
2302 using the args exactly as we received them. */
2303 type = *restype_ptr;
2304 primop0 = op0;
2305 primop1 = op1;
2306
2307 if (!real1 && !real2 && integer_zerop (primop1)
2450 && TREE_UNSIGNED (*restype_ptr))
2308 && TYPE_UNSIGNED (*restype_ptr))
2451 {
2452 tree value = 0;
2453 switch (code)
2454 {
2455 case GE_EXPR:
2456 /* All unsigned values are >= 0, so we warn if extra warnings
2457 are requested. However, if OP0 is a constant that is
2458 >= 0, the signedness of the comparison isn't an issue,
2459 so suppress the warning. */
2460 if (extra_warnings && !in_system_header
2309 {
2310 tree value = 0;
2311 switch (code)
2312 {
2313 case GE_EXPR:
2314 /* All unsigned values are >= 0, so we warn if extra warnings
2315 are requested. However, if OP0 is a constant that is
2316 >= 0, the signedness of the comparison isn't an issue,
2317 so suppress the warning. */
2318 if (extra_warnings && !in_system_header
2461 && ! (TREE_CODE (primop0) == INTEGER_CST
2462 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2463 primop0))))
2464 warning ("comparison of unsigned expression >= 0 is always true");
2319 && !(TREE_CODE (primop0) == INTEGER_CST
2320 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2321 primop0))))
2322 warning (0, "comparison of unsigned expression >= 0 is always true");
2465 value = truthvalue_true_node;
2466 break;
2467
2468 case LT_EXPR:
2469 if (extra_warnings && !in_system_header
2323 value = truthvalue_true_node;
2324 break;
2325
2326 case LT_EXPR:
2327 if (extra_warnings && !in_system_header
2470 && ! (TREE_CODE (primop0) == INTEGER_CST
2471 && ! TREE_OVERFLOW (convert (c_common_signed_type (type),
2472 primop0))))
2473 warning ("comparison of unsigned expression < 0 is always false");
2328 && !(TREE_CODE (primop0) == INTEGER_CST
2329 && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2330 primop0))))
2331 warning (0, "comparison of unsigned expression < 0 is always false");
2474 value = truthvalue_false_node;
2475 break;
2476
2477 default:
2478 break;
2479 }
2480
2481 if (value != 0)
2482 {
2483 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2484 if (TREE_SIDE_EFFECTS (primop0))
2332 value = truthvalue_false_node;
2333 break;
2334
2335 default:
2336 break;
2337 }
2338
2339 if (value != 0)
2340 {
2341 /* Don't forget to evaluate PRIMOP0 if it has side effects. */
2342 if (TREE_SIDE_EFFECTS (primop0))
2485 return build (COMPOUND_EXPR, TREE_TYPE (value),
2486 primop0, value);
2343 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2344 primop0, value);
2487 return value;
2488 }
2489 }
2490 }
2491
2492 *op0_ptr = convert (type, primop0);
2493 *op1_ptr = convert (type, primop1);
2494
2495 *restype_ptr = truthvalue_type_node;
2496
2497 return 0;
2498}
2499
2500/* Return a tree for the sum or difference (RESULTCODE says which)
2501 of pointer PTROP and integer INTOP. */
2502
2503tree
2504pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2505{
2345 return value;
2346 }
2347 }
2348 }
2349
2350 *op0_ptr = convert (type, primop0);
2351 *op1_ptr = convert (type, primop1);
2352
2353 *restype_ptr = truthvalue_type_node;
2354
2355 return 0;
2356}
2357
2358/* Return a tree for the sum or difference (RESULTCODE says which)
2359 of pointer PTROP and integer INTOP. */
2360
2361tree
2362pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2363{
2506 tree size_exp;
2364 tree size_exp, ret;
2507
2365
2508 tree result;
2509 tree folded;
2510
2511 /* The result is a pointer of the same type that is being added. */
2512
2513 tree result_type = TREE_TYPE (ptrop);
2514
2515 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2516 {
2517 if (pedantic || warn_pointer_arith)
2366 /* The result is a pointer of the same type that is being added. */
2367
2368 tree result_type = TREE_TYPE (ptrop);
2369
2370 if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2371 {
2372 if (pedantic || warn_pointer_arith)
2518 pedwarn ("pointer of type `void *' used in arithmetic");
2373 pedwarn ("pointer of type %<void *%> used in arithmetic");
2519 size_exp = integer_one_node;
2520 }
2521 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2522 {
2523 if (pedantic || warn_pointer_arith)
2524 pedwarn ("pointer to a function used in arithmetic");
2525 size_exp = integer_one_node;
2526 }
2527 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2528 {
2529 if (pedantic || warn_pointer_arith)
2530 pedwarn ("pointer to member function used in arithmetic");
2531 size_exp = integer_one_node;
2532 }
2533 else
2534 size_exp = size_in_bytes (TREE_TYPE (result_type));
2535
2374 size_exp = integer_one_node;
2375 }
2376 else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2377 {
2378 if (pedantic || warn_pointer_arith)
2379 pedwarn ("pointer to a function used in arithmetic");
2380 size_exp = integer_one_node;
2381 }
2382 else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2383 {
2384 if (pedantic || warn_pointer_arith)
2385 pedwarn ("pointer to member function used in arithmetic");
2386 size_exp = integer_one_node;
2387 }
2388 else
2389 size_exp = size_in_bytes (TREE_TYPE (result_type));
2390
2391 /* We are manipulating pointer values, so we don't need to warn
2392 about relying on undefined signed overflow. We disable the
2393 warning here because we use integer types so fold won't know that
2394 they are really pointers. */
2395 fold_defer_overflow_warnings ();
2396
2536 /* If what we are about to multiply by the size of the elements
2537 contains a constant term, apply distributive law
2538 and multiply that constant term separately.
2539 This helps produce common subexpressions. */
2540
2541 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2397 /* If what we are about to multiply by the size of the elements
2398 contains a constant term, apply distributive law
2399 and multiply that constant term separately.
2400 This helps produce common subexpressions. */
2401
2402 if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2542 && ! TREE_CONSTANT (intop)
2403 && !TREE_CONSTANT (intop)
2543 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2544 && TREE_CONSTANT (size_exp)
2545 /* If the constant comes from pointer subtraction,
2546 skip this optimization--it would cause an error. */
2547 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2548 /* If the constant is unsigned, and smaller than the pointer size,
2549 then we must skip this optimization. This is because it could cause
2550 an overflow error if the constant is negative but INTOP is not. */
2404 && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2405 && TREE_CONSTANT (size_exp)
2406 /* If the constant comes from pointer subtraction,
2407 skip this optimization--it would cause an error. */
2408 && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2409 /* If the constant is unsigned, and smaller than the pointer size,
2410 then we must skip this optimization. This is because it could cause
2411 an overflow error if the constant is negative but INTOP is not. */
2551 && (! TREE_UNSIGNED (TREE_TYPE (intop))
2412 && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2552 || (TYPE_PRECISION (TREE_TYPE (intop))
2553 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2554 {
2555 enum tree_code subcode = resultcode;
2556 tree int_type = TREE_TYPE (intop);
2557 if (TREE_CODE (intop) == MINUS_EXPR)
2558 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2559 /* Convert both subexpression types to the type of intop,
2560 because weird cases involving pointer arithmetic
2561 can result in a sum or difference with different type args. */
2562 ptrop = build_binary_op (subcode, ptrop,
2563 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2564 intop = convert (int_type, TREE_OPERAND (intop, 0));
2565 }
2566
2567 /* Convert the integer argument to a type the same size as sizetype
2568 so the multiply won't overflow spuriously. */
2569
2570 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2413 || (TYPE_PRECISION (TREE_TYPE (intop))
2414 == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2415 {
2416 enum tree_code subcode = resultcode;
2417 tree int_type = TREE_TYPE (intop);
2418 if (TREE_CODE (intop) == MINUS_EXPR)
2419 subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2420 /* Convert both subexpression types to the type of intop,
2421 because weird cases involving pointer arithmetic
2422 can result in a sum or difference with different type args. */
2423 ptrop = build_binary_op (subcode, ptrop,
2424 convert (int_type, TREE_OPERAND (intop, 1)), 1);
2425 intop = convert (int_type, TREE_OPERAND (intop, 0));
2426 }
2427
2428 /* Convert the integer argument to a type the same size as sizetype
2429 so the multiply won't overflow spuriously. */
2430
2431 if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2571 || TREE_UNSIGNED (TREE_TYPE (intop)) != TREE_UNSIGNED (sizetype))
2432 || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2572 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2433 intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2573 TREE_UNSIGNED (sizetype)), intop);
2434 TYPE_UNSIGNED (sizetype)), intop);
2574
2575 /* Replace the integer argument with a suitable product by the object size.
2576 Do this multiplication as signed, then convert to the appropriate
2577 pointer type (actually unsigned integral). */
2578
2579 intop = convert (result_type,
2580 build_binary_op (MULT_EXPR, intop,
2581 convert (TREE_TYPE (intop), size_exp), 1));
2582
2583 /* Create the sum or difference. */
2435
2436 /* Replace the integer argument with a suitable product by the object size.
2437 Do this multiplication as signed, then convert to the appropriate
2438 pointer type (actually unsigned integral). */
2439
2440 intop = convert (result_type,
2441 build_binary_op (MULT_EXPR, intop,
2442 convert (TREE_TYPE (intop), size_exp), 1));
2443
2444 /* Create the sum or difference. */
2445 ret = fold_build2 (resultcode, result_type, ptrop, intop);
2584
2446
2585 result = build (resultcode, result_type, ptrop, intop);
2447 fold_undefer_and_ignore_overflow_warnings ();
2586
2448
2587 folded = fold (result);
2588 if (folded == result)
2589 TREE_CONSTANT (folded) = TREE_CONSTANT (ptrop) & TREE_CONSTANT (intop);
2590 return folded;
2449 return ret;
2591}
2592
2593/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2450}
2451
2452/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2594 or validate its data type for an `if' or `while' statement or ?..: exp.
2453 or for an `if' or `while' statement or ?..: exp. It should already
2454 have been validated to be of suitable type; otherwise, a bad
2455 diagnostic may result.
2595
2596 This preparation consists of taking the ordinary
2597 representation of an expression expr and producing a valid tree
2598 boolean expression describing whether expr is nonzero. We could
2599 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2600 but we optimize comparisons, &&, ||, and !.
2601
2602 The resulting type should always be `truthvalue_type_node'. */
2603
2604tree
2605c_common_truthvalue_conversion (tree expr)
2606{
2456
2457 This preparation consists of taking the ordinary
2458 representation of an expression expr and producing a valid tree
2459 boolean expression describing whether expr is nonzero. We could
2460 simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2461 but we optimize comparisons, &&, ||, and !.
2462
2463 The resulting type should always be `truthvalue_type_node'. */
2464
2465tree
2466c_common_truthvalue_conversion (tree expr)
2467{
2607 if (TREE_CODE (expr) == ERROR_MARK)
2608 return expr;
2609
2610 if (TREE_CODE (expr) == FUNCTION_DECL)
2611 expr = build_unary_op (ADDR_EXPR, expr, 0);
2612
2613#if 0 /* This appears to be wrong for C++. */
2614 /* These really should return error_mark_node after 2.4 is stable.
2615 But not all callers handle ERROR_MARK properly. */
2616 switch (TREE_CODE (TREE_TYPE (expr)))
2617 {
2618 case RECORD_TYPE:
2619 error ("struct type value used where scalar is required");
2620 return truthvalue_false_node;
2621
2622 case UNION_TYPE:
2623 error ("union type value used where scalar is required");
2624 return truthvalue_false_node;
2625
2626 case ARRAY_TYPE:
2627 error ("array type value used where scalar is required");
2628 return truthvalue_false_node;
2629
2630 default:
2631 break;
2632 }
2633#endif /* 0 */
2634
2635 switch (TREE_CODE (expr))
2636 {
2468 switch (TREE_CODE (expr))
2469 {
2637 case EQ_EXPR:
2638 case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2470 case EQ_EXPR: case NE_EXPR: case UNEQ_EXPR: case LTGT_EXPR:
2471 case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR:
2472 case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2473 case ORDERED_EXPR: case UNORDERED_EXPR:
2474 if (TREE_TYPE (expr) == truthvalue_type_node)
2475 return expr;
2476 return build2 (TREE_CODE (expr), truthvalue_type_node,
2477 TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2478
2639 case TRUTH_ANDIF_EXPR:
2640 case TRUTH_ORIF_EXPR:
2641 case TRUTH_AND_EXPR:
2642 case TRUTH_OR_EXPR:
2643 case TRUTH_XOR_EXPR:
2479 case TRUTH_ANDIF_EXPR:
2480 case TRUTH_ORIF_EXPR:
2481 case TRUTH_AND_EXPR:
2482 case TRUTH_OR_EXPR:
2483 case TRUTH_XOR_EXPR:
2484 if (TREE_TYPE (expr) == truthvalue_type_node)
2485 return expr;
2486 return build2 (TREE_CODE (expr), truthvalue_type_node,
2487 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2488 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2489
2644 case TRUTH_NOT_EXPR:
2490 case TRUTH_NOT_EXPR:
2645 TREE_TYPE (expr) = truthvalue_type_node;
2646 return expr;
2491 if (TREE_TYPE (expr) == truthvalue_type_node)
2492 return expr;
2493 return build1 (TREE_CODE (expr), truthvalue_type_node,
2494 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2647
2648 case ERROR_MARK:
2649 return expr;
2650
2651 case INTEGER_CST:
2495
2496 case ERROR_MARK:
2497 return expr;
2498
2499 case INTEGER_CST:
2652 return integer_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2500 /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW. */
2501 return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2502 ? truthvalue_true_node
2503 : truthvalue_false_node;
2653
2654 case REAL_CST:
2504
2505 case REAL_CST:
2655 return real_zerop (expr) ? truthvalue_false_node : truthvalue_true_node;
2506 return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2507 ? truthvalue_true_node
2508 : truthvalue_false_node;
2656
2509
2510 case FUNCTION_DECL:
2511 expr = build_unary_op (ADDR_EXPR, expr, 0);
2512 /* Fall through. */
2513
2657 case ADDR_EXPR:
2658 {
2514 case ADDR_EXPR:
2515 {
2659 if (TREE_CODE (TREE_OPERAND (expr, 0)) == FUNCTION_DECL
2660 && ! DECL_WEAK (TREE_OPERAND (expr, 0)))
2516 tree inner = TREE_OPERAND (expr, 0);
2517 if (DECL_P (inner)
2518 && (TREE_CODE (inner) == PARM_DECL
2519 || TREE_CODE (inner) == LABEL_DECL
2520 || !DECL_WEAK (inner)))
2661 {
2521 {
2662 /* Common Ada/Pascal programmer's mistake. We always warn
2522 /* Common Ada/Pascal programmer's mistake. We always warn
2663 about this since it is so bad. */
2523 about this since it is so bad. */
2664 warning ("the address of `%D', will always evaluate as `true'",
2665 TREE_OPERAND (expr, 0));
2524 warning (OPT_Waddress,
2525 "the address of %qD will always evaluate as %<true%>",
2526 inner);
2666 return truthvalue_true_node;
2667 }
2668
2669 /* If we are taking the address of an external decl, it might be
2670 zero if it is weak, so we cannot optimize. */
2527 return truthvalue_true_node;
2528 }
2529
2530 /* If we are taking the address of an external decl, it might be
2531 zero if it is weak, so we cannot optimize. */
2671 if (DECL_P (TREE_OPERAND (expr, 0))
2672 && DECL_EXTERNAL (TREE_OPERAND (expr, 0)))
2532 if (DECL_P (inner)
2533 && DECL_EXTERNAL (inner))
2673 break;
2674
2534 break;
2535
2675 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0)))
2676 return build (COMPOUND_EXPR, truthvalue_type_node,
2677 TREE_OPERAND (expr, 0), truthvalue_true_node);
2536 if (TREE_SIDE_EFFECTS (inner))
2537 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2538 inner, truthvalue_true_node);
2678 else
2679 return truthvalue_true_node;
2680 }
2681
2682 case COMPLEX_EXPR:
2683 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2684 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2685 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),

--- 6 unchanged lines hidden (view full) ---

2692 /* These don't change whether an object is nonzero or zero. */
2693 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2694
2695 case LROTATE_EXPR:
2696 case RROTATE_EXPR:
2697 /* These don't change whether an object is zero or nonzero, but
2698 we can't ignore them if their second arg has side-effects. */
2699 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2539 else
2540 return truthvalue_true_node;
2541 }
2542
2543 case COMPLEX_EXPR:
2544 return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2545 ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2546 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),

--- 6 unchanged lines hidden (view full) ---

2553 /* These don't change whether an object is nonzero or zero. */
2554 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2555
2556 case LROTATE_EXPR:
2557 case RROTATE_EXPR:
2558 /* These don't change whether an object is zero or nonzero, but
2559 we can't ignore them if their second arg has side-effects. */
2560 if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2700 return build (COMPOUND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 1),
2701 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2561 return build2 (COMPOUND_EXPR, truthvalue_type_node,
2562 TREE_OPERAND (expr, 1),
2563 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2702 else
2703 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2704
2705 case COND_EXPR:
2706 /* Distribute the conversion into the arms of a COND_EXPR. */
2564 else
2565 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2566
2567 case COND_EXPR:
2568 /* Distribute the conversion into the arms of a COND_EXPR. */
2707 return fold (build (COND_EXPR, truthvalue_type_node, TREE_OPERAND (expr, 0),
2569 return fold_build3 (COND_EXPR, truthvalue_type_node,
2570 TREE_OPERAND (expr, 0),
2708 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2571 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2709 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2))));
2572 c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2710
2711 case CONVERT_EXPR:
2573
2574 case CONVERT_EXPR:
2575 case NOP_EXPR:
2712 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2713 since that affects how `default_conversion' will behave. */
2714 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2715 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2716 break;
2576 /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2577 since that affects how `default_conversion' will behave. */
2578 if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2579 || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2580 break;
2717 /* Fall through.... */
2718 case NOP_EXPR:
2719 /* If this is widening the argument, we can ignore it. */
2720 if (TYPE_PRECISION (TREE_TYPE (expr))
2721 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2722 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2723 break;
2724
2581 /* If this is widening the argument, we can ignore it. */
2582 if (TYPE_PRECISION (TREE_TYPE (expr))
2583 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2584 return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2585 break;
2586
2725 case MINUS_EXPR:
2726 /* Perhaps reduce (x - y) != 0 to (x != y). The expressions
2727 aren't guaranteed to the be same for modes that can represent
2728 infinity, since if x and y are both +infinity, or both
2729 -infinity, then x - y is not a number.
2730
2731 Note that this transformation is safe when x or y is NaN.
2732 (x - y) is then NaN, and both (x - y) != 0 and x != y will
2733 be false. */
2734 if (HONOR_INFINITIES (TYPE_MODE (TREE_TYPE (TREE_OPERAND (expr, 0)))))
2735 break;
2736 /* Fall through.... */
2737 case BIT_XOR_EXPR:
2738 /* This and MINUS_EXPR can be changed into a comparison of the
2739 two objects. */
2740 if (TREE_TYPE (TREE_OPERAND (expr, 0))
2741 == TREE_TYPE (TREE_OPERAND (expr, 1)))
2742 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2743 TREE_OPERAND (expr, 1), 1);
2744 return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0),
2745 fold (build1 (NOP_EXPR,
2746 TREE_TYPE (TREE_OPERAND (expr, 0)),
2747 TREE_OPERAND (expr, 1))), 1);
2748
2749 case BIT_AND_EXPR:
2750 if (integer_onep (TREE_OPERAND (expr, 1))
2751 && TREE_TYPE (expr) != truthvalue_type_node)
2752 /* Using convert here would cause infinite recursion. */
2753 return build1 (NOP_EXPR, truthvalue_type_node, expr);
2754 break;
2755
2756 case MODIFY_EXPR:
2587 case MODIFY_EXPR:
2757 if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR)
2758 warning ("suggest parentheses around assignment used as truth value");
2588 if (!TREE_NO_WARNING (expr))
2589 warning (OPT_Wparentheses,
2590 "suggest parentheses around assignment used as truth value");
2759 break;
2760
2761 default:
2762 break;
2763 }
2764
2765 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2766 {

--- 4 unchanged lines hidden (view full) ---

2771 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2772 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2773 0));
2774 }
2775
2776 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2777}
2778
2591 break;
2592
2593 default:
2594 break;
2595 }
2596
2597 if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2598 {

--- 4 unchanged lines hidden (view full) ---

2603 c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2604 c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2605 0));
2606 }
2607
2608 return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2609}
2610
2779static tree builtin_function_2 (const char *, const char *, tree, tree,
2780 int, enum built_in_class, int, int,
2781 tree);
2611static void def_builtin_1 (enum built_in_function fncode,
2612 const char *name,
2613 enum built_in_class fnclass,
2614 tree fntype, tree libtype,
2615 bool both_p, bool fallback_p, bool nonansi_p,
2616 tree fnattrs, bool implicit_p);
2782
2783/* Make a variant type in the proper way for C/C++, propagating qualifiers
2784 down to the element type of an array. */
2785
2786tree
2787c_build_qualified_type (tree type, int type_quals)
2788{
2789 if (type == error_mark_node)
2790 return type;
2617
2618/* Make a variant type in the proper way for C/C++, propagating qualifiers
2619 down to the element type of an array. */
2620
2621tree
2622c_build_qualified_type (tree type, int type_quals)
2623{
2624 if (type == error_mark_node)
2625 return type;
2791
2626
2792 if (TREE_CODE (type) == ARRAY_TYPE)
2627 if (TREE_CODE (type) == ARRAY_TYPE)
2793 return build_array_type (c_build_qualified_type (TREE_TYPE (type),
2794 type_quals),
2795 TYPE_DOMAIN (type));
2628 {
2629 tree t;
2630 tree element_type = c_build_qualified_type (TREE_TYPE (type),
2631 type_quals);
2796
2632
2633 /* See if we already have an identically qualified type. */
2634 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2635 {
2636 if (TYPE_QUALS (strip_array_types (t)) == type_quals
2637 && TYPE_NAME (t) == TYPE_NAME (type)
2638 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2639 && attribute_list_equal (TYPE_ATTRIBUTES (t),
2640 TYPE_ATTRIBUTES (type)))
2641 break;
2642 }
2643 if (!t)
2644 {
2645 t = build_variant_type_copy (type);
2646 TREE_TYPE (t) = element_type;
2647 }
2648 return t;
2649 }
2650
2797 /* A restrict-qualified pointer type must be a pointer to object or
2798 incomplete type. Note that the use of POINTER_TYPE_P also allows
2799 REFERENCE_TYPEs, which is appropriate for C++. */
2800 if ((type_quals & TYPE_QUAL_RESTRICT)
2801 && (!POINTER_TYPE_P (type)
2802 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2803 {
2651 /* A restrict-qualified pointer type must be a pointer to object or
2652 incomplete type. Note that the use of POINTER_TYPE_P also allows
2653 REFERENCE_TYPEs, which is appropriate for C++. */
2654 if ((type_quals & TYPE_QUAL_RESTRICT)
2655 && (!POINTER_TYPE_P (type)
2656 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2657 {
2804 error ("invalid use of `restrict'");
2658 error ("invalid use of %<restrict%>");
2805 type_quals &= ~TYPE_QUAL_RESTRICT;
2806 }
2807
2808 return build_qualified_type (type, type_quals);
2809}
2810
2811/* Apply the TYPE_QUALS to the new DECL. */
2812
2813void
2814c_apply_type_quals_to_decl (int type_quals, tree decl)
2815{
2816 tree type = TREE_TYPE (decl);
2659 type_quals &= ~TYPE_QUAL_RESTRICT;
2660 }
2661
2662 return build_qualified_type (type, type_quals);
2663}
2664
2665/* Apply the TYPE_QUALS to the new DECL. */
2666
2667void
2668c_apply_type_quals_to_decl (int type_quals, tree decl)
2669{
2670 tree type = TREE_TYPE (decl);
2817
2671
2818 if (type == error_mark_node)
2819 return;
2820
2821 if (((type_quals & TYPE_QUAL_CONST)
2822 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2823 /* An object declared 'const' is only readonly after it is
2824 initialized. We don't have any way of expressing this currently,
2825 so we need to be conservative and unset TREE_READONLY for types

--- 10 unchanged lines hidden (view full) ---

2836 {
2837 while (type && TREE_CODE (type) == ARRAY_TYPE)
2838 /* Allow 'restrict' on arrays of pointers.
2839 FIXME currently we just ignore it. */
2840 type = TREE_TYPE (type);
2841 if (!type
2842 || !POINTER_TYPE_P (type)
2843 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2672 if (type == error_mark_node)
2673 return;
2674
2675 if (((type_quals & TYPE_QUAL_CONST)
2676 || (type && TREE_CODE (type) == REFERENCE_TYPE))
2677 /* An object declared 'const' is only readonly after it is
2678 initialized. We don't have any way of expressing this currently,
2679 so we need to be conservative and unset TREE_READONLY for types

--- 10 unchanged lines hidden (view full) ---

2690 {
2691 while (type && TREE_CODE (type) == ARRAY_TYPE)
2692 /* Allow 'restrict' on arrays of pointers.
2693 FIXME currently we just ignore it. */
2694 type = TREE_TYPE (type);
2695 if (!type
2696 || !POINTER_TYPE_P (type)
2697 || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2844 error ("invalid use of `restrict'");
2698 error ("invalid use of %<restrict%>");
2845 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2846 /* Indicate we need to make a unique alias set for this pointer.
2847 We can't do it here because it might be pointing to an
2848 incomplete type. */
2849 DECL_POINTER_ALIAS_SET (decl) = -2;
2850 }
2851}
2852
2699 else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2700 /* Indicate we need to make a unique alias set for this pointer.
2701 We can't do it here because it might be pointing to an
2702 incomplete type. */
2703 DECL_POINTER_ALIAS_SET (decl) = -2;
2704 }
2705}
2706
2707/* Hash function for the problem of multiple type definitions in
2708 different files. This must hash all types that will compare
2709 equal via comptypes to the same value. In practice it hashes
2710 on some of the simple stuff and leaves the details to comptypes. */
2711
2712static hashval_t
2713c_type_hash (const void *p)
2714{
2715 int i = 0;
2716 int shift, size;
2717 tree t = (tree) p;
2718 tree t2;
2719 switch (TREE_CODE (t))
2720 {
2721 /* For pointers, hash on pointee type plus some swizzling. */
2722 case POINTER_TYPE:
2723 return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2724 /* Hash on number of elements and total size. */
2725 case ENUMERAL_TYPE:
2726 shift = 3;
2727 t2 = TYPE_VALUES (t);
2728 break;
2729 case RECORD_TYPE:
2730 shift = 0;
2731 t2 = TYPE_FIELDS (t);
2732 break;
2733 case QUAL_UNION_TYPE:
2734 shift = 1;
2735 t2 = TYPE_FIELDS (t);
2736 break;
2737 case UNION_TYPE:
2738 shift = 2;
2739 t2 = TYPE_FIELDS (t);
2740 break;
2741 default:
2742 gcc_unreachable ();
2743 }
2744 for (; t2; t2 = TREE_CHAIN (t2))
2745 i++;
2746 size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2747 return ((size << 24) | (i << shift));
2748}
2749
2750static GTY((param_is (union tree_node))) htab_t type_hash_table;
2751
2853/* Return the typed-based alias set for T, which may be an expression
2854 or a type. Return -1 if we don't do anything special. */
2855
2856HOST_WIDE_INT
2857c_common_get_alias_set (tree t)
2858{
2859 tree u;
2752/* Return the typed-based alias set for T, which may be an expression
2753 or a type. Return -1 if we don't do anything special. */
2754
2755HOST_WIDE_INT
2756c_common_get_alias_set (tree t)
2757{
2758 tree u;
2759 PTR *slot;
2860
2861 /* Permit type-punning when accessing a union, provided the access
2862 is directly through the union. For example, this code does not
2863 permit taking the address of a union member and then storing
2864 through it. Even the type-punning allowed here is a GCC
2865 extension, albeit a common and useful one; the C standard says
2866 that such accesses have implementation-defined behavior. */
2867 for (u = t;
2868 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2869 u = TREE_OPERAND (u, 0))
2870 if (TREE_CODE (u) == COMPONENT_REF
2871 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2872 return 0;
2873
2874 /* That's all the expressions we handle specially. */
2760
2761 /* Permit type-punning when accessing a union, provided the access
2762 is directly through the union. For example, this code does not
2763 permit taking the address of a union member and then storing
2764 through it. Even the type-punning allowed here is a GCC
2765 extension, albeit a common and useful one; the C standard says
2766 that such accesses have implementation-defined behavior. */
2767 for (u = t;
2768 TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2769 u = TREE_OPERAND (u, 0))
2770 if (TREE_CODE (u) == COMPONENT_REF
2771 && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2772 return 0;
2773
2774 /* That's all the expressions we handle specially. */
2875 if (! TYPE_P (t))
2775 if (!TYPE_P (t))
2876 return -1;
2877
2878 /* The C standard guarantees that any object may be accessed via an
2879 lvalue that has character type. */
2880 if (t == char_type_node
2881 || t == signed_char_type_node
2882 || t == unsigned_char_type_node)
2883 return 0;
2884
2885 /* If it has the may_alias attribute, it can alias anything. */
2886 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2887 return 0;
2888
2889 /* The C standard specifically allows aliasing between signed and
2890 unsigned variants of the same type. We treat the signed
2891 variant as canonical. */
2776 return -1;
2777
2778 /* The C standard guarantees that any object may be accessed via an
2779 lvalue that has character type. */
2780 if (t == char_type_node
2781 || t == signed_char_type_node
2782 || t == unsigned_char_type_node)
2783 return 0;
2784
2785 /* If it has the may_alias attribute, it can alias anything. */
2786 if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2787 return 0;
2788
2789 /* The C standard specifically allows aliasing between signed and
2790 unsigned variants of the same type. We treat the signed
2791 variant as canonical. */
2892 if (TREE_CODE (t) == INTEGER_TYPE && TREE_UNSIGNED (t))
2792 if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2893 {
2894 tree t1 = c_common_signed_type (t);
2895
2896 /* t1 == t can happen for boolean nodes which are always unsigned. */
2897 if (t1 != t)
2898 return get_alias_set (t1);
2899 }
2900 else if (POINTER_TYPE_P (t))

--- 7 unchanged lines hidden (view full) ---

2908
2909 Technically, this approach is actually more conservative that
2910 it needs to be. In particular, `const int *' and `int *'
2911 should be in different alias sets, according to the C and C++
2912 standard, since their types are not the same, and so,
2913 technically, an `int **' and `const int **' cannot point at
2914 the same thing.
2915
2793 {
2794 tree t1 = c_common_signed_type (t);
2795
2796 /* t1 == t can happen for boolean nodes which are always unsigned. */
2797 if (t1 != t)
2798 return get_alias_set (t1);
2799 }
2800 else if (POINTER_TYPE_P (t))

--- 7 unchanged lines hidden (view full) ---

2808
2809 Technically, this approach is actually more conservative that
2810 it needs to be. In particular, `const int *' and `int *'
2811 should be in different alias sets, according to the C and C++
2812 standard, since their types are not the same, and so,
2813 technically, an `int **' and `const int **' cannot point at
2814 the same thing.
2815
2916 But, the standard is wrong. In particular, this code is
2816 But, the standard is wrong. In particular, this code is
2917 legal C++:
2918
2817 legal C++:
2818
2919 int *ip;
2920 int **ipp = &ip;
2921 const int* const* cipp = &ipp;
2819 int *ip;
2820 int **ipp = &ip;
2821 const int* const* cipp = ipp;
2922
2822
2923 And, it doesn't make sense for that to be legal unless you
2823 And, it doesn't make sense for that to be legal unless you
2924 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2925 the pointed-to types. This issue has been reported to the
2926 C++ committee. */
2927 t1 = build_type_no_quals (t);
2928 if (t1 != t)
2929 return get_alias_set (t1);
2930 }
2931
2824 can dereference IPP and CIPP. So, we ignore cv-qualifiers on
2825 the pointed-to types. This issue has been reported to the
2826 C++ committee. */
2827 t1 = build_type_no_quals (t);
2828 if (t1 != t)
2829 return get_alias_set (t1);
2830 }
2831
2832 /* Handle the case of multiple type nodes referring to "the same" type,
2833 which occurs with IMA. These share an alias set. FIXME: Currently only
2834 C90 is handled. (In C99 type compatibility is not transitive, which
2835 complicates things mightily. The alias set splay trees can theoretically
2836 represent this, but insertion is tricky when you consider all the
2837 different orders things might arrive in.) */
2838
2839 if (c_language != clk_c || flag_isoc99)
2840 return -1;
2841
2842 /* Save time if there's only one input file. */
2843 if (num_in_fnames == 1)
2844 return -1;
2845
2846 /* Pointers need special handling if they point to any type that
2847 needs special handling (below). */
2848 if (TREE_CODE (t) == POINTER_TYPE)
2849 {
2850 tree t2;
2851 /* Find bottom type under any nested POINTERs. */
2852 for (t2 = TREE_TYPE (t);
2853 TREE_CODE (t2) == POINTER_TYPE;
2854 t2 = TREE_TYPE (t2))
2855 ;
2856 if (TREE_CODE (t2) != RECORD_TYPE
2857 && TREE_CODE (t2) != ENUMERAL_TYPE
2858 && TREE_CODE (t2) != QUAL_UNION_TYPE
2859 && TREE_CODE (t2) != UNION_TYPE)
2932 return -1;
2860 return -1;
2861 if (TYPE_SIZE (t2) == 0)
2862 return -1;
2863 }
2864 /* These are the only cases that need special handling. */
2865 if (TREE_CODE (t) != RECORD_TYPE
2866 && TREE_CODE (t) != ENUMERAL_TYPE
2867 && TREE_CODE (t) != QUAL_UNION_TYPE
2868 && TREE_CODE (t) != UNION_TYPE
2869 && TREE_CODE (t) != POINTER_TYPE)
2870 return -1;
2871 /* Undefined? */
2872 if (TYPE_SIZE (t) == 0)
2873 return -1;
2874
2875 /* Look up t in hash table. Only one of the compatible types within each
2876 alias set is recorded in the table. */
2877 if (!type_hash_table)
2878 type_hash_table = htab_create_ggc (1021, c_type_hash,
2879 (htab_eq) lang_hooks.types_compatible_p,
2880 NULL);
2881 slot = htab_find_slot (type_hash_table, t, INSERT);
2882 if (*slot != NULL)
2883 {
2884 TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2885 return TYPE_ALIAS_SET ((tree)*slot);
2886 }
2887 else
2888 /* Our caller will assign and record (in t) a new alias set; all we need
2889 to do is remember t in the hash table. */
2890 *slot = t;
2891
2892 return -1;
2933}
2934
2935/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2936 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2937 flag controls whether we should diagnose possibly ill-formed
2938 constructs or not. */
2893}
2894
2895/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2896 second parameter indicates which OPERATOR is being applied. The COMPLAIN
2897 flag controls whether we should diagnose possibly ill-formed
2898 constructs or not. */
2899
2939tree
2900tree
2940c_sizeof_or_alignof_type (tree type, enum tree_code op, int complain)
2901c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2941{
2942 const char *op_name;
2943 tree value = NULL;
2944 enum tree_code type_code = TREE_CODE (type);
2945
2902{
2903 const char *op_name;
2904 tree value = NULL;
2905 enum tree_code type_code = TREE_CODE (type);
2906
2946 my_friendly_assert (op == SIZEOF_EXPR || op == ALIGNOF_EXPR, 20020720);
2947 op_name = op == SIZEOF_EXPR ? "sizeof" : "__alignof__";
2907 op_name = is_sizeof ? "sizeof" : "__alignof__";
2948
2949 if (type_code == FUNCTION_TYPE)
2950 {
2908
2909 if (type_code == FUNCTION_TYPE)
2910 {
2951 if (op == SIZEOF_EXPR)
2911 if (is_sizeof)
2952 {
2953 if (complain && (pedantic || warn_pointer_arith))
2912 {
2913 if (complain && (pedantic || warn_pointer_arith))
2954 pedwarn ("invalid application of `sizeof' to a function type");
2914 pedwarn ("invalid application of %<sizeof%> to a function type");
2955 value = size_one_node;
2956 }
2957 else
2958 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2959 }
2960 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2961 {
2962 if (type_code == VOID_TYPE
2963 && complain && (pedantic || warn_pointer_arith))
2915 value = size_one_node;
2916 }
2917 else
2918 value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2919 }
2920 else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2921 {
2922 if (type_code == VOID_TYPE
2923 && complain && (pedantic || warn_pointer_arith))
2964 pedwarn ("invalid application of `%s' to a void type", op_name);
2924 pedwarn ("invalid application of %qs to a void type", op_name);
2965 value = size_one_node;
2966 }
2967 else if (!COMPLETE_TYPE_P (type))
2968 {
2969 if (complain)
2925 value = size_one_node;
2926 }
2927 else if (!COMPLETE_TYPE_P (type))
2928 {
2929 if (complain)
2970 error ("invalid application of `%s' to incomplete type `%T' ",
2930 error ("invalid application of %qs to incomplete type %qT ",
2971 op_name, type);
2972 value = size_zero_node;
2973 }
2974 else
2975 {
2931 op_name, type);
2932 value = size_zero_node;
2933 }
2934 else
2935 {
2976 if (op == SIZEOF_EXPR)
2936 if (is_sizeof)
2977 /* Convert in case a char is more than one unit. */
2978 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2979 size_int (TYPE_PRECISION (char_type_node)
2980 / BITS_PER_UNIT));
2981 else
2937 /* Convert in case a char is more than one unit. */
2938 value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2939 size_int (TYPE_PRECISION (char_type_node)
2940 / BITS_PER_UNIT));
2941 else
2982 value = size_int (TYPE_ALIGN (type) / BITS_PER_UNIT);
2942 value = size_int (TYPE_ALIGN_UNIT (type));
2983 }
2984
2985 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2986 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2987 never happen. However, this node should really have type
2988 `size_t', which is just a typedef for an ordinary integer type. */
2943 }
2944
2945 /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2946 TYPE_IS_SIZETYPE means that certain things (like overflow) will
2947 never happen. However, this node should really have type
2948 `size_t', which is just a typedef for an ordinary integer type. */
2989 value = fold (build1 (NOP_EXPR, size_type_node, value));
2990 my_friendly_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)), 20001021);
2949 value = fold_convert (size_type_node, value);
2950 gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2991
2992 return value;
2993}
2994
2995/* Implement the __alignof keyword: Return the minimum required
2996 alignment of EXPR, measured in bytes. For VAR_DECL's and
2997 FIELD_DECL's return DECL_ALIGN (which can be set from an
2998 "aligned" __attribute__ specification). */
2999
3000tree
3001c_alignof_expr (tree expr)
3002{
3003 tree t;
3004
3005 if (TREE_CODE (expr) == VAR_DECL)
2951
2952 return value;
2953}
2954
2955/* Implement the __alignof keyword: Return the minimum required
2956 alignment of EXPR, measured in bytes. For VAR_DECL's and
2957 FIELD_DECL's return DECL_ALIGN (which can be set from an
2958 "aligned" __attribute__ specification). */
2959
2960tree
2961c_alignof_expr (tree expr)
2962{
2963 tree t;
2964
2965 if (TREE_CODE (expr) == VAR_DECL)
3006 t = size_int (DECL_ALIGN (expr) / BITS_PER_UNIT);
2966 t = size_int (DECL_ALIGN_UNIT (expr));
3007
3008 else if (TREE_CODE (expr) == COMPONENT_REF
3009 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
3010 {
2967
2968 else if (TREE_CODE (expr) == COMPONENT_REF
2969 && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2970 {
3011 error ("`__alignof' applied to a bit-field");
2971 error ("%<__alignof%> applied to a bit-field");
3012 t = size_one_node;
3013 }
3014 else if (TREE_CODE (expr) == COMPONENT_REF
3015 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2972 t = size_one_node;
2973 }
2974 else if (TREE_CODE (expr) == COMPONENT_REF
2975 && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
3016 t = size_int (DECL_ALIGN (TREE_OPERAND (expr, 1)) / BITS_PER_UNIT);
2976 t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
3017
3018 else if (TREE_CODE (expr) == INDIRECT_REF)
3019 {
3020 tree t = TREE_OPERAND (expr, 0);
3021 tree best = t;
3022 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3023
2977
2978 else if (TREE_CODE (expr) == INDIRECT_REF)
2979 {
2980 tree t = TREE_OPERAND (expr, 0);
2981 tree best = t;
2982 int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2983
3024 while (TREE_CODE (t) == NOP_EXPR
2984 while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
3025 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
3026 {
3027 int thisalign;
3028
3029 t = TREE_OPERAND (t, 0);
3030 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
3031 if (thisalign > bestalign)
3032 best = t, bestalign = thisalign;
3033 }
3034 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
3035 }
3036 else
3037 return c_alignof (TREE_TYPE (expr));
3038
2985 && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2986 {
2987 int thisalign;
2988
2989 t = TREE_OPERAND (t, 0);
2990 thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2991 if (thisalign > bestalign)
2992 best = t, bestalign = thisalign;
2993 }
2994 return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2995 }
2996 else
2997 return c_alignof (TREE_TYPE (expr));
2998
3039 return fold (build1 (NOP_EXPR, size_type_node, t));
2999 return fold_convert (size_type_node, t);
3040}
3041
3042/* Handle C and C++ default attributes. */
3043
3044enum built_in_attribute
3045{
3046#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3047#define DEF_ATTR_INT(ENUM, VALUE) ENUM,

--- 6 unchanged lines hidden (view full) ---

3054#undef DEF_ATTR_TREE_LIST
3055 ATTR_LAST
3056};
3057
3058static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3059
3060static void c_init_attributes (void);
3061
3000}
3001
3002/* Handle C and C++ default attributes. */
3003
3004enum built_in_attribute
3005{
3006#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3007#define DEF_ATTR_INT(ENUM, VALUE) ENUM,

--- 6 unchanged lines hidden (view full) ---

3014#undef DEF_ATTR_TREE_LIST
3015 ATTR_LAST
3016};
3017
3018static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3019
3020static void c_init_attributes (void);
3021
3062/* Build tree nodes and builtin functions common to both C and C++ language
3063 frontends. */
3064
3065void
3066c_common_nodes_and_builtins (void)
3022enum c_builtin_type
3067{
3023{
3068 enum builtin_type
3069 {
3070#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3071#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3072#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3073#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3074#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3075#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3024#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3025#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3026#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3027#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3028#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3029#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3030#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3031#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3032#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3076#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3077#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3078#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3079#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3033#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3034#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3035#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3036#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3037#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3038#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3039 NAME,
3080#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3081#include "builtin-types.def"
3082#undef DEF_PRIMITIVE_TYPE
3083#undef DEF_FUNCTION_TYPE_0
3084#undef DEF_FUNCTION_TYPE_1
3085#undef DEF_FUNCTION_TYPE_2
3086#undef DEF_FUNCTION_TYPE_3
3087#undef DEF_FUNCTION_TYPE_4
3040#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3041#include "builtin-types.def"
3042#undef DEF_PRIMITIVE_TYPE
3043#undef DEF_FUNCTION_TYPE_0
3044#undef DEF_FUNCTION_TYPE_1
3045#undef DEF_FUNCTION_TYPE_2
3046#undef DEF_FUNCTION_TYPE_3
3047#undef DEF_FUNCTION_TYPE_4
3048#undef DEF_FUNCTION_TYPE_5
3049#undef DEF_FUNCTION_TYPE_6
3050#undef DEF_FUNCTION_TYPE_7
3088#undef DEF_FUNCTION_TYPE_VAR_0
3089#undef DEF_FUNCTION_TYPE_VAR_1
3090#undef DEF_FUNCTION_TYPE_VAR_2
3091#undef DEF_FUNCTION_TYPE_VAR_3
3051#undef DEF_FUNCTION_TYPE_VAR_0
3052#undef DEF_FUNCTION_TYPE_VAR_1
3053#undef DEF_FUNCTION_TYPE_VAR_2
3054#undef DEF_FUNCTION_TYPE_VAR_3
3055#undef DEF_FUNCTION_TYPE_VAR_4
3056#undef DEF_FUNCTION_TYPE_VAR_5
3092#undef DEF_POINTER_TYPE
3057#undef DEF_POINTER_TYPE
3093 BT_LAST
3094 };
3058 BT_LAST
3059};
3095
3060
3096 typedef enum builtin_type builtin_type;
3061typedef enum c_builtin_type builtin_type;
3097
3062
3098 tree builtin_types[(int) BT_LAST];
3063/* A temporary array for c_common_nodes_and_builtins. Used in
3064 communication with def_fn_type. */
3065static tree builtin_types[(int) BT_LAST + 1];
3066
3067/* A helper function for c_common_nodes_and_builtins. Build function type
3068 for DEF with return type RET and N arguments. If VAR is true, then the
3069 function should be variadic after those N arguments.
3070
3071 Takes special care not to ICE if any of the types involved are
3072 error_mark_node, which indicates that said type is not in fact available
3073 (see builtin_type_for_size). In which case the function type as a whole
3074 should be error_mark_node. */
3075
3076static void
3077def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3078{
3079 tree args = NULL, t;
3080 va_list list;
3081 int i;
3082
3083 va_start (list, n);
3084 for (i = 0; i < n; ++i)
3085 {
3086 builtin_type a = va_arg (list, builtin_type);
3087 t = builtin_types[a];
3088 if (t == error_mark_node)
3089 goto egress;
3090 args = tree_cons (NULL_TREE, t, args);
3091 }
3092 va_end (list);
3093
3094 args = nreverse (args);
3095 if (!var)
3096 args = chainon (args, void_list_node);
3097
3098 t = builtin_types[ret];
3099 if (t == error_mark_node)
3100 goto egress;
3101 t = build_function_type (t, args);
3102
3103 egress:
3104 builtin_types[def] = t;
3105}
3106
3107/* Build tree nodes and builtin functions common to both C and C++ language
3108 frontends. */
3109
3110void
3111c_common_nodes_and_builtins (void)
3112{
3099 int wchar_type_size;
3100 tree array_domain_type;
3101 tree va_list_ref_type_node;
3102 tree va_list_arg_type_node;
3103
3104 /* Define `int' and `char' first so that dbx will output them first. */
3105 record_builtin_type (RID_INT, NULL, integer_type_node);
3106 record_builtin_type (RID_CHAR, "char", char_type_node);

--- 24 unchanged lines hidden (view full) ---

3131 short_unsigned_type_node);
3132
3133 /* Define both `signed char' and `unsigned char'. */
3134 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3135 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3136
3137 /* These are types that c_common_type_for_size and
3138 c_common_type_for_mode use. */
3113 int wchar_type_size;
3114 tree array_domain_type;
3115 tree va_list_ref_type_node;
3116 tree va_list_arg_type_node;
3117
3118 /* Define `int' and `char' first so that dbx will output them first. */
3119 record_builtin_type (RID_INT, NULL, integer_type_node);
3120 record_builtin_type (RID_CHAR, "char", char_type_node);

--- 24 unchanged lines hidden (view full) ---

3145 short_unsigned_type_node);
3146
3147 /* Define both `signed char' and `unsigned char'. */
3148 record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3149 record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3150
3151 /* These are types that c_common_type_for_size and
3152 c_common_type_for_mode use. */
3139 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3140 intQI_type_node));
3141 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3142 intHI_type_node));
3143 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3144 intSI_type_node));
3145 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3146 intDI_type_node));
3153 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3154 intQI_type_node));
3155 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3156 intHI_type_node));
3157 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3158 intSI_type_node));
3159 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3160 intDI_type_node));
3147#if HOST_BITS_PER_WIDE_INT >= 64
3161#if HOST_BITS_PER_WIDE_INT >= 64
3148 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3149 get_identifier ("__int128_t"),
3150 intTI_type_node));
3162 if (targetm.scalar_mode_supported_p (TImode))
3163 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3164 get_identifier ("__int128_t"),
3165 intTI_type_node));
3151#endif
3166#endif
3152 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3153 unsigned_intQI_type_node));
3154 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3155 unsigned_intHI_type_node));
3156 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3157 unsigned_intSI_type_node));
3158 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3159 unsigned_intDI_type_node));
3167 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3168 unsigned_intQI_type_node));
3169 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3170 unsigned_intHI_type_node));
3171 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3172 unsigned_intSI_type_node));
3173 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3174 unsigned_intDI_type_node));
3160#if HOST_BITS_PER_WIDE_INT >= 64
3175#if HOST_BITS_PER_WIDE_INT >= 64
3161 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3162 get_identifier ("__uint128_t"),
3163 unsigned_intTI_type_node));
3176 if (targetm.scalar_mode_supported_p (TImode))
3177 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3178 get_identifier ("__uint128_t"),
3179 unsigned_intTI_type_node));
3164#endif
3165
3166 /* Create the widest literal types. */
3167 widest_integer_literal_type_node
3168 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3180#endif
3181
3182 /* Create the widest literal types. */
3183 widest_integer_literal_type_node
3184 = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3169 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3170 widest_integer_literal_type_node));
3185 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3186 widest_integer_literal_type_node));
3171
3172 widest_unsigned_literal_type_node
3173 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3187
3188 widest_unsigned_literal_type_node
3189 = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3174 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL, NULL_TREE,
3175 widest_unsigned_literal_type_node));
3190 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3191 widest_unsigned_literal_type_node));
3176
3177 /* `unsigned long' is the standard type for sizeof.
3178 Note that stddef.h uses `unsigned long',
3179 and this must agree, even if long and int are the same size. */
3180 size_type_node =
3181 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3182 signed_size_type_node = c_common_signed_type (size_type_node);
3183 set_sizetype (size_type_node);
3184
3192
3193 /* `unsigned long' is the standard type for sizeof.
3194 Note that stddef.h uses `unsigned long',
3195 and this must agree, even if long and int are the same size. */
3196 size_type_node =
3197 TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3198 signed_size_type_node = c_common_signed_type (size_type_node);
3199 set_sizetype (size_type_node);
3200
3201 pid_type_node =
3202 TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3203
3185 build_common_tree_nodes_2 (flag_short_double);
3186
3187 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3188 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3189 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3190
3204 build_common_tree_nodes_2 (flag_short_double);
3205
3206 record_builtin_type (RID_FLOAT, NULL, float_type_node);
3207 record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3208 record_builtin_type (RID_MAX, "long double", long_double_type_node);
3209
3191 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3192 get_identifier ("complex int"),
3193 complex_integer_type_node));
3194 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3195 get_identifier ("complex float"),
3196 complex_float_type_node));
3197 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3198 get_identifier ("complex double"),
3199 complex_double_type_node));
3200 (*lang_hooks.decls.pushdecl)
3201 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3202 complex_long_double_type_node));
3203
3204 /* Types which are common to the fortran compiler and libf2c. When
3205 changing these, you also need to be concerned with f/com.h. */
3206
3207 if (TYPE_PRECISION (float_type_node)
3208 == TYPE_PRECISION (long_integer_type_node))
3210 /* Only supported decimal floating point extension if the target
3211 actually supports underlying modes. */
3212 if (targetm.scalar_mode_supported_p (SDmode)
3213 && targetm.scalar_mode_supported_p (DDmode)
3214 && targetm.scalar_mode_supported_p (TDmode))
3209 {
3215 {
3210 g77_integer_type_node = long_integer_type_node;
3211 g77_uinteger_type_node = long_unsigned_type_node;
3216 record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3217 record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3218 record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3212 }
3219 }
3213 else if (TYPE_PRECISION (float_type_node)
3214 == TYPE_PRECISION (integer_type_node))
3215 {
3216 g77_integer_type_node = integer_type_node;
3217 g77_uinteger_type_node = unsigned_type_node;
3218 }
3219 else
3220 g77_integer_type_node = g77_uinteger_type_node = NULL_TREE;
3221
3220
3222 if (g77_integer_type_node != NULL_TREE)
3223 {
3224 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3225 get_identifier ("__g77_integer"),
3226 g77_integer_type_node));
3227 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3228 get_identifier ("__g77_uinteger"),
3229 g77_uinteger_type_node));
3230 }
3221 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3222 get_identifier ("complex int"),
3223 complex_integer_type_node));
3224 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3225 get_identifier ("complex float"),
3226 complex_float_type_node));
3227 lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3228 get_identifier ("complex double"),
3229 complex_double_type_node));
3230 lang_hooks.decls.pushdecl
3231 (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3232 complex_long_double_type_node));
3231
3233
3232 if (TYPE_PRECISION (float_type_node) * 2
3233 == TYPE_PRECISION (long_integer_type_node))
3234 {
3235 g77_longint_type_node = long_integer_type_node;
3236 g77_ulongint_type_node = long_unsigned_type_node;
3237 }
3238 else if (TYPE_PRECISION (float_type_node) * 2
3239 == TYPE_PRECISION (long_long_integer_type_node))
3240 {
3241 g77_longint_type_node = long_long_integer_type_node;
3242 g77_ulongint_type_node = long_long_unsigned_type_node;
3243 }
3244 else
3245 g77_longint_type_node = g77_ulongint_type_node = NULL_TREE;
3234 if (c_dialect_cxx ())
3235 /* For C++, make fileptr_type_node a distinct void * type until
3236 FILE type is defined. */
3237 fileptr_type_node = build_variant_type_copy (ptr_type_node);
3246
3238
3247 if (g77_longint_type_node != NULL_TREE)
3248 {
3249 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3250 get_identifier ("__g77_longint"),
3251 g77_longint_type_node));
3252 (*lang_hooks.decls.pushdecl) (build_decl (TYPE_DECL,
3253 get_identifier ("__g77_ulongint"),
3254 g77_ulongint_type_node));
3255 }
3256
3257 record_builtin_type (RID_VOID, NULL, void_type_node);
3258
3239 record_builtin_type (RID_VOID, NULL, void_type_node);
3240
3259 void_zero_node = build_int_2 (0, 0);
3241 /* This node must not be shared. */
3242 void_zero_node = make_node (INTEGER_CST);
3260 TREE_TYPE (void_zero_node) = void_type_node;
3261
3262 void_list_node = build_void_list_node ();
3263
3264 /* Make a type to be the domain of a few array types
3265 whose domains don't really matter.
3266 200 is small enough that it always fits in size_t
3267 and large enough that it can hold most function names for the

--- 16 unchanged lines hidden (view full) ---

3284 (char_type_node, TYPE_QUAL_CONST));
3285
3286 /* This is special for C++ so functions can be overloaded. */
3287 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3288 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3289 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3290 if (c_dialect_cxx ())
3291 {
3243 TREE_TYPE (void_zero_node) = void_type_node;
3244
3245 void_list_node = build_void_list_node ();
3246
3247 /* Make a type to be the domain of a few array types
3248 whose domains don't really matter.
3249 200 is small enough that it always fits in size_t
3250 and large enough that it can hold most function names for the

--- 16 unchanged lines hidden (view full) ---

3267 (char_type_node, TYPE_QUAL_CONST));
3268
3269 /* This is special for C++ so functions can be overloaded. */
3270 wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3271 wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3272 wchar_type_size = TYPE_PRECISION (wchar_type_node);
3273 if (c_dialect_cxx ())
3274 {
3292 if (TREE_UNSIGNED (wchar_type_node))
3275 if (TYPE_UNSIGNED (wchar_type_node))
3293 wchar_type_node = make_unsigned_type (wchar_type_size);
3294 else
3295 wchar_type_node = make_signed_type (wchar_type_size);
3296 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3297 }
3298 else
3299 {
3300 signed_wchar_type_node = c_common_signed_type (wchar_type_node);

--- 12 unchanged lines hidden (view full) ---

3313 uintmax_type_node =
3314 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3315
3316 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3317 ptrdiff_type_node
3318 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3319 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3320
3276 wchar_type_node = make_unsigned_type (wchar_type_size);
3277 else
3278 wchar_type_node = make_signed_type (wchar_type_size);
3279 record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3280 }
3281 else
3282 {
3283 signed_wchar_type_node = c_common_signed_type (wchar_type_node);

--- 12 unchanged lines hidden (view full) ---

3296 uintmax_type_node =
3297 TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3298
3299 default_function_type = build_function_type (integer_type_node, NULL_TREE);
3300 ptrdiff_type_node
3301 = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3302 unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3303
3321 (*lang_hooks.decls.pushdecl)
3304 lang_hooks.decls.pushdecl
3322 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3323 va_list_type_node));
3324
3305 (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3306 va_list_type_node));
3307
3325 (*lang_hooks.decls.pushdecl)
3326 (build_decl (TYPE_DECL, get_identifier ("__builtin_ptrdiff_t"),
3327 ptrdiff_type_node));
3328
3329 (*lang_hooks.decls.pushdecl)
3330 (build_decl (TYPE_DECL, get_identifier ("__builtin_size_t"),
3331 sizetype));
3332
3333 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3334 {
3335 va_list_arg_type_node = va_list_ref_type_node =
3336 build_pointer_type (TREE_TYPE (va_list_type_node));
3337 }
3338 else
3339 {
3340 va_list_arg_type_node = va_list_type_node;
3341 va_list_ref_type_node = build_reference_type (va_list_type_node);
3342 }
3343
3344#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3308 if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3309 {
3310 va_list_arg_type_node = va_list_ref_type_node =
3311 build_pointer_type (TREE_TYPE (va_list_type_node));
3312 }
3313 else
3314 {
3315 va_list_arg_type_node = va_list_type_node;
3316 va_list_ref_type_node = build_reference_type (va_list_type_node);
3317 }
3318
3319#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3345 builtin_types[(int) ENUM] = VALUE;
3346#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3347 builtin_types[(int) ENUM] \
3348 = build_function_type (builtin_types[(int) RETURN], \
3349 void_list_node);
3350#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3351 builtin_types[(int) ENUM] \
3352 = build_function_type (builtin_types[(int) RETURN], \
3353 tree_cons (NULL_TREE, \
3354 builtin_types[(int) ARG1], \
3355 void_list_node));
3356#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3357 builtin_types[(int) ENUM] \
3358 = build_function_type \
3359 (builtin_types[(int) RETURN], \
3360 tree_cons (NULL_TREE, \
3361 builtin_types[(int) ARG1], \
3362 tree_cons (NULL_TREE, \
3363 builtin_types[(int) ARG2], \
3364 void_list_node)));
3365#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3366 builtin_types[(int) ENUM] \
3367 = build_function_type \
3368 (builtin_types[(int) RETURN], \
3369 tree_cons (NULL_TREE, \
3370 builtin_types[(int) ARG1], \
3371 tree_cons (NULL_TREE, \
3372 builtin_types[(int) ARG2], \
3373 tree_cons (NULL_TREE, \
3374 builtin_types[(int) ARG3], \
3375 void_list_node))));
3376#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3377 builtin_types[(int) ENUM] \
3378 = build_function_type \
3379 (builtin_types[(int) RETURN], \
3380 tree_cons (NULL_TREE, \
3381 builtin_types[(int) ARG1], \
3382 tree_cons (NULL_TREE, \
3383 builtin_types[(int) ARG2], \
3384 tree_cons \
3385 (NULL_TREE, \
3386 builtin_types[(int) ARG3], \
3387 tree_cons (NULL_TREE, \
3388 builtin_types[(int) ARG4], \
3389 void_list_node)))));
3390#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3391 builtin_types[(int) ENUM] \
3392 = build_function_type (builtin_types[(int) RETURN], NULL_TREE);
3393#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3394 builtin_types[(int) ENUM] \
3395 = build_function_type (builtin_types[(int) RETURN], \
3396 tree_cons (NULL_TREE, \
3397 builtin_types[(int) ARG1], \
3398 NULL_TREE));
3320 builtin_types[ENUM] = VALUE;
3321#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3322 def_fn_type (ENUM, RETURN, 0, 0);
3323#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3324 def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3325#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3326 def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3327#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3328 def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3329#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3330 def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3331#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3332 def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3333#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3334 ARG6) \
3335 def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3336#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3337 ARG6, ARG7) \
3338 def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3339#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3340 def_fn_type (ENUM, RETURN, 1, 0);
3341#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3342 def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3343#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3344 def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3345#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3346 def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3347#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3348 def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3349#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3350 def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3351#define DEF_POINTER_TYPE(ENUM, TYPE) \
3352 builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3399
3353
3400#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3401 builtin_types[(int) ENUM] \
3402 = build_function_type \
3403 (builtin_types[(int) RETURN], \
3404 tree_cons (NULL_TREE, \
3405 builtin_types[(int) ARG1], \
3406 tree_cons (NULL_TREE, \
3407 builtin_types[(int) ARG2], \
3408 NULL_TREE)));
3409
3410#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3411 builtin_types[(int) ENUM] \
3412 = build_function_type \
3413 (builtin_types[(int) RETURN], \
3414 tree_cons (NULL_TREE, \
3415 builtin_types[(int) ARG1], \
3416 tree_cons (NULL_TREE, \
3417 builtin_types[(int) ARG2], \
3418 tree_cons (NULL_TREE, \
3419 builtin_types[(int) ARG3], \
3420 NULL_TREE))));
3421
3422#define DEF_POINTER_TYPE(ENUM, TYPE) \
3423 builtin_types[(int) ENUM] \
3424 = build_pointer_type (builtin_types[(int) TYPE]);
3425#include "builtin-types.def"
3354#include "builtin-types.def"
3355
3426#undef DEF_PRIMITIVE_TYPE
3427#undef DEF_FUNCTION_TYPE_1
3428#undef DEF_FUNCTION_TYPE_2
3429#undef DEF_FUNCTION_TYPE_3
3430#undef DEF_FUNCTION_TYPE_4
3356#undef DEF_PRIMITIVE_TYPE
3357#undef DEF_FUNCTION_TYPE_1
3358#undef DEF_FUNCTION_TYPE_2
3359#undef DEF_FUNCTION_TYPE_3
3360#undef DEF_FUNCTION_TYPE_4
3361#undef DEF_FUNCTION_TYPE_5
3362#undef DEF_FUNCTION_TYPE_6
3431#undef DEF_FUNCTION_TYPE_VAR_0
3432#undef DEF_FUNCTION_TYPE_VAR_1
3433#undef DEF_FUNCTION_TYPE_VAR_2
3434#undef DEF_FUNCTION_TYPE_VAR_3
3363#undef DEF_FUNCTION_TYPE_VAR_0
3364#undef DEF_FUNCTION_TYPE_VAR_1
3365#undef DEF_FUNCTION_TYPE_VAR_2
3366#undef DEF_FUNCTION_TYPE_VAR_3
3367#undef DEF_FUNCTION_TYPE_VAR_4
3368#undef DEF_FUNCTION_TYPE_VAR_5
3435#undef DEF_POINTER_TYPE
3369#undef DEF_POINTER_TYPE
3370 builtin_types[(int) BT_LAST] = NULL_TREE;
3436
3437 c_init_attributes ();
3438
3371
3372 c_init_attributes ();
3373
3439#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, \
3440 BOTH_P, FALLBACK_P, NONANSI_P, ATTRS, IMPLICIT) \
3441 if (NAME) \
3442 { \
3443 tree decl; \
3444 \
3445 if (strncmp (NAME, "__builtin_", strlen ("__builtin_")) != 0) \
3446 abort (); \
3447 \
3448 if (!BOTH_P) \
3449 decl = builtin_function (NAME, builtin_types[TYPE], ENUM, \
3450 CLASS, \
3451 (FALLBACK_P \
3452 ? (NAME + strlen ("__builtin_")) \
3453 : NULL), \
3454 built_in_attributes[(int) ATTRS]); \
3455 else \
3456 decl = builtin_function_2 (NAME, \
3457 NAME + strlen ("__builtin_"), \
3458 builtin_types[TYPE], \
3459 builtin_types[LIBTYPE], \
3460 ENUM, \
3461 CLASS, \
3462 FALLBACK_P, \
3463 NONANSI_P, \
3464 built_in_attributes[(int) ATTRS]); \
3465 \
3466 built_in_decls[(int) ENUM] = decl; \
3467 if (IMPLICIT) \
3468 implicit_built_in_decls[(int) ENUM] = decl; \
3469 }
3374#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3375 NONANSI_P, ATTRS, IMPLICIT, COND) \
3376 if (NAME && COND) \
3377 def_builtin_1 (ENUM, NAME, CLASS, \
3378 builtin_types[(int) TYPE], \
3379 builtin_types[(int) LIBTYPE], \
3380 BOTH_P, FALLBACK_P, NONANSI_P, \
3381 built_in_attributes[(int) ATTRS], IMPLICIT);
3470#include "builtins.def"
3471#undef DEF_BUILTIN
3472
3382#include "builtins.def"
3383#undef DEF_BUILTIN
3384
3473 (*targetm.init_builtins) ();
3385 build_common_builtin_nodes ();
3474
3386
3387 targetm.init_builtins ();
3388 if (flag_mudflap)
3389 mudflap_init ();
3390
3475 main_identifier_node = get_identifier ("main");
3391 main_identifier_node = get_identifier ("main");
3392
3393 /* Create the built-in __null node. It is important that this is
3394 not shared. */
3395 null_node = make_node (INTEGER_CST);
3396 TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3397
3398 /* Since builtin_types isn't gc'ed, don't export these nodes. */
3399 memset (builtin_types, 0, sizeof (builtin_types));
3476}
3477
3400}
3401
3402/* Look up the function in built_in_decls that corresponds to DECL
3403 and set ASMSPEC as its user assembler name. DECL must be a
3404 function decl that declares a builtin. */
3405
3406void
3407set_builtin_user_assembler_name (tree decl, const char *asmspec)
3408{
3409 tree builtin;
3410 gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3411 && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3412 && asmspec != 0);
3413
3414 builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3415 set_user_assembler_name (builtin, asmspec);
3416 if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3417 init_block_move_fn (asmspec);
3418 else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3419 init_block_clear_fn (asmspec);
3420}
3421
3422/* The number of named compound-literals generated thus far. */
3423static GTY(()) int compound_literal_number;
3424
3425/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal. */
3426
3427void
3428set_compound_literal_name (tree decl)
3429{
3430 char *name;
3431 ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3432 compound_literal_number);
3433 compound_literal_number++;
3434 DECL_NAME (decl) = get_identifier (name);
3435}
3436
3478tree
3479build_va_arg (tree expr, tree type)
3480{
3481 return build1 (VA_ARG_EXPR, type, expr);
3482}
3483
3484
3485/* Linked list of disabled built-in functions. */

--- 9 unchanged lines hidden (view full) ---

3495
3496/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3497 begins with "__builtin_", give an error. */
3498
3499void
3500disable_builtin_function (const char *name)
3501{
3502 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3437tree
3438build_va_arg (tree expr, tree type)
3439{
3440 return build1 (VA_ARG_EXPR, type, expr);
3441}
3442
3443
3444/* Linked list of disabled built-in functions. */

--- 9 unchanged lines hidden (view full) ---

3454
3455/* Disable a built-in function specified by -fno-builtin-NAME. If NAME
3456 begins with "__builtin_", give an error. */
3457
3458void
3459disable_builtin_function (const char *name)
3460{
3461 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3503 error ("cannot disable built-in function `%s'", name);
3462 error ("cannot disable built-in function %qs", name);
3504 else
3505 {
3463 else
3464 {
3506 disabled_builtin *new = xmalloc (sizeof (disabled_builtin));
3507 new->name = name;
3508 new->next = disabled_builtins;
3509 disabled_builtins = new;
3465 disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3466 new_disabled_builtin->name = name;
3467 new_disabled_builtin->next = disabled_builtins;
3468 disabled_builtins = new_disabled_builtin;
3510 }
3511}
3512
3513
3514/* Return true if the built-in function NAME has been disabled, false
3515 otherwise. */
3516
3517static bool

--- 4 unchanged lines hidden (view full) ---

3522 {
3523 if (strcmp (name, p->name) == 0)
3524 return true;
3525 }
3526 return false;
3527}
3528
3529
3469 }
3470}
3471
3472
3473/* Return true if the built-in function NAME has been disabled, false
3474 otherwise. */
3475
3476static bool

--- 4 unchanged lines hidden (view full) ---

3481 {
3482 if (strcmp (name, p->name) == 0)
3483 return true;
3484 }
3485 return false;
3486}
3487
3488
3530/* Possibly define a builtin function with one or two names. BUILTIN_NAME
3531 is an __builtin_-prefixed name; NAME is the ordinary name; one or both
3532 of these may be NULL (though both being NULL is useless).
3533 BUILTIN_TYPE is the type of the __builtin_-prefixed function;
3534 TYPE is the type of the function with the ordinary name. These
3535 may differ if the ordinary name is declared with a looser type to avoid
3536 conflicts with headers. FUNCTION_CODE and CLASS are as for
3537 builtin_function. If LIBRARY_NAME_P is nonzero, NAME is passed as
3538 the LIBRARY_NAME parameter to builtin_function when declaring BUILTIN_NAME.
3539 If NONANSI_P is nonzero, the name NAME is treated as a non-ANSI name;
3540 ATTRS is the tree list representing the builtin's function attributes.
3541 Returns the declaration of BUILTIN_NAME, if any, otherwise
3542 the declaration of NAME. Does not declare NAME if flag_no_builtin,
3543 or if NONANSI_P and flag_no_nonansi_builtin. */
3489/* Worker for DEF_BUILTIN.
3490 Possibly define a builtin function with one or two names.
3491 Does not declare a non-__builtin_ function if flag_no_builtin, or if
3492 nonansi_p and flag_no_nonansi_builtin. */
3544
3493
3545static tree
3546builtin_function_2 (const char *builtin_name, const char *name,
3547 tree builtin_type, tree type, int function_code,
3548 enum built_in_class class, int library_name_p,
3549 int nonansi_p, tree attrs)
3494static void
3495def_builtin_1 (enum built_in_function fncode,
3496 const char *name,
3497 enum built_in_class fnclass,
3498 tree fntype, tree libtype,
3499 bool both_p, bool fallback_p, bool nonansi_p,
3500 tree fnattrs, bool implicit_p)
3550{
3501{
3551 tree bdecl = NULL_TREE;
3552 tree decl = NULL_TREE;
3502 tree decl;
3503 const char *libname;
3553
3504
3554 if (builtin_name != 0)
3555 bdecl = builtin_function (builtin_name, builtin_type, function_code,
3556 class, library_name_p ? name : NULL, attrs);
3505 if (fntype == error_mark_node)
3506 return;
3557
3507
3558 if (name != 0 && !flag_no_builtin && !builtin_function_disabled_p (name)
3508 gcc_assert ((!both_p && !fallback_p)
3509 || !strncmp (name, "__builtin_",
3510 strlen ("__builtin_")));
3511
3512 libname = name + strlen ("__builtin_");
3513 decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3514 (fallback_p ? libname : NULL),
3515 fnattrs);
3516 if (both_p
3517 && !flag_no_builtin && !builtin_function_disabled_p (libname)
3559 && !(nonansi_p && flag_no_nonansi_builtin))
3518 && !(nonansi_p && flag_no_nonansi_builtin))
3560 decl = builtin_function (name, type, function_code, class, NULL, attrs);
3519 lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3520 NULL, fnattrs);
3561
3521
3562 return (bdecl != 0 ? bdecl : decl);
3522 built_in_decls[(int) fncode] = decl;
3523 if (implicit_p)
3524 implicit_built_in_decls[(int) fncode] = decl;
3563}
3564
3565/* Nonzero if the type T promotes to int. This is (nearly) the
3566 integral promotions defined in ISO C99 6.3.1.1/2. */
3567
3568bool
3569c_promoting_integer_type_p (tree t)
3570{

--- 27 unchanged lines hidden (view full) ---

3598int
3599self_promoting_args_p (tree parms)
3600{
3601 tree t;
3602 for (t = parms; t; t = TREE_CHAIN (t))
3603 {
3604 tree type = TREE_VALUE (t);
3605
3525}
3526
3527/* Nonzero if the type T promotes to int. This is (nearly) the
3528 integral promotions defined in ISO C99 6.3.1.1/2. */
3529
3530bool
3531c_promoting_integer_type_p (tree t)
3532{

--- 27 unchanged lines hidden (view full) ---

3560int
3561self_promoting_args_p (tree parms)
3562{
3563 tree t;
3564 for (t = parms; t; t = TREE_CHAIN (t))
3565 {
3566 tree type = TREE_VALUE (t);
3567
3568 if (type == error_mark_node)
3569 continue;
3570
3606 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3607 return 0;
3608
3609 if (type == 0)
3610 return 0;
3611
3612 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3613 return 0;

--- 20 unchanged lines hidden (view full) ---

3634tree
3635strip_pointer_operator (tree t)
3636{
3637 while (POINTER_TYPE_P (t))
3638 t = TREE_TYPE (t);
3639 return t;
3640}
3641
3571 if (TREE_CHAIN (t) == 0 && type != void_type_node)
3572 return 0;
3573
3574 if (type == 0)
3575 return 0;
3576
3577 if (TYPE_MAIN_VARIANT (type) == float_type_node)
3578 return 0;

--- 20 unchanged lines hidden (view full) ---

3599tree
3600strip_pointer_operator (tree t)
3601{
3602 while (POINTER_TYPE_P (t))
3603 t = TREE_TYPE (t);
3604 return t;
3605}
3606
3642static tree expand_unordered_cmp (tree, tree, enum tree_code, enum tree_code);
3643
3644/* Expand a call to an unordered comparison function such as
3645 __builtin_isgreater(). FUNCTION is the function's declaration and
3646 PARAMS a list of the values passed. For __builtin_isunordered(),
3647 UNORDERED_CODE is UNORDERED_EXPR and ORDERED_CODE is NOP_EXPR. In
3648 other cases, UNORDERED_CODE and ORDERED_CODE are comparison codes
3649 that give the opposite of the desired result. UNORDERED_CODE is
3650 used for modes that can hold NaNs and ORDERED_CODE is used for the
3651 rest. */
3652
3653static tree
3654expand_unordered_cmp (tree function, tree params,
3655 enum tree_code unordered_code,
3656 enum tree_code ordered_code)
3657{
3658 tree arg0, arg1, type;
3659 enum tree_code code0, code1;
3660
3661 /* Check that we have exactly two arguments. */
3662 if (params == 0 || TREE_CHAIN (params) == 0)
3663 {
3664 error ("too few arguments to function `%s'",
3665 IDENTIFIER_POINTER (DECL_NAME (function)));
3666 return error_mark_node;
3667 }
3668 else if (TREE_CHAIN (TREE_CHAIN (params)) != 0)
3669 {
3670 error ("too many arguments to function `%s'",
3671 IDENTIFIER_POINTER (DECL_NAME (function)));
3672 return error_mark_node;
3673 }
3674
3675 arg0 = TREE_VALUE (params);
3676 arg1 = TREE_VALUE (TREE_CHAIN (params));
3677
3678 code0 = TREE_CODE (TREE_TYPE (arg0));
3679 code1 = TREE_CODE (TREE_TYPE (arg1));
3680
3681 /* Make sure that the arguments have a common type of REAL. */
3682 type = 0;
3683 if ((code0 == INTEGER_TYPE || code0 == REAL_TYPE)
3684 && (code1 == INTEGER_TYPE || code1 == REAL_TYPE))
3685 type = common_type (TREE_TYPE (arg0), TREE_TYPE (arg1));
3686
3687 if (type == 0 || TREE_CODE (type) != REAL_TYPE)
3688 {
3689 error ("non-floating-point argument to function `%s'",
3690 IDENTIFIER_POINTER (DECL_NAME (function)));
3691 return error_mark_node;
3692 }
3693
3694 if (unordered_code == UNORDERED_EXPR)
3695 {
3696 if (MODE_HAS_NANS (TYPE_MODE (type)))
3697 return build_binary_op (unordered_code,
3698 convert (type, arg0),
3699 convert (type, arg1),
3700 0);
3701 else
3702 return integer_zero_node;
3703 }
3704
3705 return build_unary_op (TRUTH_NOT_EXPR,
3706 build_binary_op (MODE_HAS_NANS (TYPE_MODE (type))
3707 ? unordered_code
3708 : ordered_code,
3709 convert (type, arg0),
3710 convert (type, arg1),
3711 0),
3712 0);
3713}
3714
3715
3716/* Recognize certain built-in functions so we can make tree-codes
3717 other than CALL_EXPR. We do this when it enables fold-const.c
3718 to do something useful. */
3719/* ??? By rights this should go in builtins.c, but only C and C++
3720 implement build_{binary,unary}_op. Not exactly sure what bits
3721 of functionality are actually needed from those functions, or
3722 where the similar functionality exists in the other front ends. */
3723
3724tree
3725expand_tree_builtin (tree function, tree params, tree coerced_params)
3726{
3727 if (DECL_BUILT_IN_CLASS (function) != BUILT_IN_NORMAL)
3728 return NULL_TREE;
3729
3730 switch (DECL_FUNCTION_CODE (function))
3731 {
3732 case BUILT_IN_ABS:
3733 case BUILT_IN_LABS:
3734 case BUILT_IN_LLABS:
3735 case BUILT_IN_IMAXABS:
3736 case BUILT_IN_FABS:
3737 case BUILT_IN_FABSL:
3738 case BUILT_IN_FABSF:
3739 if (coerced_params == 0)
3740 return integer_zero_node;
3741 return build_unary_op (ABS_EXPR, TREE_VALUE (coerced_params), 0);
3742
3743 case BUILT_IN_CONJ:
3744 case BUILT_IN_CONJF:
3745 case BUILT_IN_CONJL:
3746 if (coerced_params == 0)
3747 return integer_zero_node;
3748 return build_unary_op (CONJ_EXPR, TREE_VALUE (coerced_params), 0);
3749
3750 case BUILT_IN_CREAL:
3751 case BUILT_IN_CREALF:
3752 case BUILT_IN_CREALL:
3753 if (coerced_params == 0)
3754 return integer_zero_node;
3755 return non_lvalue (build_unary_op (REALPART_EXPR,
3756 TREE_VALUE (coerced_params), 0));
3757
3758 case BUILT_IN_CIMAG:
3759 case BUILT_IN_CIMAGF:
3760 case BUILT_IN_CIMAGL:
3761 if (coerced_params == 0)
3762 return integer_zero_node;
3763 return non_lvalue (build_unary_op (IMAGPART_EXPR,
3764 TREE_VALUE (coerced_params), 0));
3765
3766 case BUILT_IN_ISGREATER:
3767 return expand_unordered_cmp (function, params, UNLE_EXPR, LE_EXPR);
3768
3769 case BUILT_IN_ISGREATEREQUAL:
3770 return expand_unordered_cmp (function, params, UNLT_EXPR, LT_EXPR);
3771
3772 case BUILT_IN_ISLESS:
3773 return expand_unordered_cmp (function, params, UNGE_EXPR, GE_EXPR);
3774
3775 case BUILT_IN_ISLESSEQUAL:
3776 return expand_unordered_cmp (function, params, UNGT_EXPR, GT_EXPR);
3777
3778 case BUILT_IN_ISLESSGREATER:
3779 return expand_unordered_cmp (function, params, UNEQ_EXPR, EQ_EXPR);
3780
3781 case BUILT_IN_ISUNORDERED:
3782 return expand_unordered_cmp (function, params, UNORDERED_EXPR, NOP_EXPR);
3783
3784 default:
3785 break;
3786 }
3787
3788 return NULL_TREE;
3789}
3790
3791/* Walk the statement tree, rooted at *tp. Apply FUNC to all the
3792 sub-trees of *TP in a pre-order traversal. FUNC is called with the
3793 DATA and the address of each sub-tree. If FUNC returns a non-NULL
3794 value, the traversal is aborted, and the value returned by FUNC is
3795 returned. If FUNC sets WALK_SUBTREES to zero, then the subtrees of
3796 the node being visited are not walked.
3797
3798 We don't need a without_duplicates variant of this one because the
3799 statement tree is a tree, not a graph. */
3800
3801tree
3802walk_stmt_tree (tree *tp, walk_tree_fn func, void *data)
3803{
3804 enum tree_code code;
3805 int walk_subtrees;
3806 tree result;
3807 int i, len;
3808
3809#define WALK_SUBTREE(NODE) \
3810 do \
3811 { \
3812 result = walk_stmt_tree (&(NODE), func, data); \
3813 if (result) \
3814 return result; \
3815 } \
3816 while (0)
3817
3818 /* Skip empty subtrees. */
3819 if (!*tp)
3820 return NULL_TREE;
3821
3822 /* Skip subtrees below non-statement nodes. */
3823 if (!STATEMENT_CODE_P (TREE_CODE (*tp)))
3824 return NULL_TREE;
3825
3826 /* Call the function. */
3827 walk_subtrees = 1;
3828 result = (*func) (tp, &walk_subtrees, data);
3829
3830 /* If we found something, return it. */
3831 if (result)
3832 return result;
3833
3834 /* FUNC may have modified the tree, recheck that we're looking at a
3835 statement node. */
3836 code = TREE_CODE (*tp);
3837 if (!STATEMENT_CODE_P (code))
3838 return NULL_TREE;
3839
3840 /* Visit the subtrees unless FUNC decided that there was nothing
3841 interesting below this point in the tree. */
3842 if (walk_subtrees)
3843 {
3844 /* Walk over all the sub-trees of this operand. Statement nodes
3845 never contain RTL, and we needn't worry about TARGET_EXPRs. */
3846 len = TREE_CODE_LENGTH (code);
3847
3848 /* Go through the subtrees. We need to do this in forward order so
3849 that the scope of a FOR_EXPR is handled properly. */
3850 for (i = 0; i < len; ++i)
3851 WALK_SUBTREE (TREE_OPERAND (*tp, i));
3852 }
3853
3854 /* Finally visit the chain. This can be tail-recursion optimized if
3855 we write it this way. */
3856 return walk_stmt_tree (&TREE_CHAIN (*tp), func, data);
3857
3858#undef WALK_SUBTREE
3859}
3860
3861/* Used to compare case labels. K1 and K2 are actually tree nodes
3862 representing case labels, or NULL_TREE for a `default' label.
3863 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3864 K2, and 0 if K1 and K2 are equal. */
3865
3866int
3867case_compare (splay_tree_key k1, splay_tree_key k2)
3868{

--- 8 unchanged lines hidden (view full) ---

3877}
3878
3879/* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3880 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3881 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3882 case label was declared using the usual C/C++ syntax, rather than
3883 the GNU case range extension. CASES is a tree containing all the
3884 case ranges processed so far; COND is the condition for the
3607/* Used to compare case labels. K1 and K2 are actually tree nodes
3608 representing case labels, or NULL_TREE for a `default' label.
3609 Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3610 K2, and 0 if K1 and K2 are equal. */
3611
3612int
3613case_compare (splay_tree_key k1, splay_tree_key k2)
3614{

--- 8 unchanged lines hidden (view full) ---

3623}
3624
3625/* Process a case label for the range LOW_VALUE ... HIGH_VALUE. If
3626 LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3627 actually a `default' label. If only HIGH_VALUE is NULL_TREE, then
3628 case label was declared using the usual C/C++ syntax, rather than
3629 the GNU case range extension. CASES is a tree containing all the
3630 case ranges processed so far; COND is the condition for the
3885 switch-statement itself. Returns the CASE_LABEL created, or
3886 ERROR_MARK_NODE if no CASE_LABEL is created. */
3631 switch-statement itself. Returns the CASE_LABEL_EXPR created, or
3632 ERROR_MARK_NODE if no CASE_LABEL_EXPR is created. */
3887
3888tree
3633
3634tree
3889c_add_case_label (splay_tree cases, tree cond, tree low_value,
3890 tree high_value)
3635c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3636 tree low_value, tree high_value)
3891{
3892 tree type;
3893 tree label;
3894 tree case_label;
3895 splay_tree_node node;
3896
3897 /* Create the LABEL_DECL itself. */
3637{
3638 tree type;
3639 tree label;
3640 tree case_label;
3641 splay_tree_node node;
3642
3643 /* Create the LABEL_DECL itself. */
3898 label = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
3899 DECL_CONTEXT (label) = current_function_decl;
3644 label = create_artificial_label ();
3900
3901 /* If there was an error processing the switch condition, bail now
3902 before we get more confused. */
3903 if (!cond || cond == error_mark_node)
3645
3646 /* If there was an error processing the switch condition, bail now
3647 before we get more confused. */
3648 if (!cond || cond == error_mark_node)
3904 {
3905 /* Add a label anyhow so that the back-end doesn't think that
3906 the beginning of the switch is unreachable. */
3907 if (!cases->root)
3908 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3909 return error_mark_node;
3910 }
3649 goto error_out;
3911
3912 if ((low_value && TREE_TYPE (low_value)
3913 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3914 || (high_value && TREE_TYPE (high_value)
3915 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3650
3651 if ((low_value && TREE_TYPE (low_value)
3652 && POINTER_TYPE_P (TREE_TYPE (low_value)))
3653 || (high_value && TREE_TYPE (high_value)
3654 && POINTER_TYPE_P (TREE_TYPE (high_value))))
3916 error ("pointers are not permitted as case values");
3655 {
3656 error ("pointers are not permitted as case values");
3657 goto error_out;
3658 }
3917
3918 /* Case ranges are a GNU extension. */
3919 if (high_value && pedantic)
3920 pedwarn ("range expressions in switch statements are non-standard");
3921
3922 type = TREE_TYPE (cond);
3923 if (low_value)
3924 {
3925 low_value = check_case_value (low_value);
3926 low_value = convert_and_check (type, low_value);
3659
3660 /* Case ranges are a GNU extension. */
3661 if (high_value && pedantic)
3662 pedwarn ("range expressions in switch statements are non-standard");
3663
3664 type = TREE_TYPE (cond);
3665 if (low_value)
3666 {
3667 low_value = check_case_value (low_value);
3668 low_value = convert_and_check (type, low_value);
3669 if (low_value == error_mark_node)
3670 goto error_out;
3927 }
3928 if (high_value)
3929 {
3930 high_value = check_case_value (high_value);
3931 high_value = convert_and_check (type, high_value);
3671 }
3672 if (high_value)
3673 {
3674 high_value = check_case_value (high_value);
3675 high_value = convert_and_check (type, high_value);
3676 if (high_value == error_mark_node)
3677 goto error_out;
3932 }
3933
3678 }
3679
3934 /* If an error has occurred, bail out now. */
3935 if (low_value == error_mark_node || high_value == error_mark_node)
3680 if (low_value && high_value)
3936 {
3681 {
3937 if (!cases->root)
3938 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3939 return error_mark_node;
3682 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3683 really a case range, even though it was written that way.
3684 Remove the HIGH_VALUE to simplify later processing. */
3685 if (tree_int_cst_equal (low_value, high_value))
3686 high_value = NULL_TREE;
3687 else if (!tree_int_cst_lt (low_value, high_value))
3688 warning (0, "empty range specified");
3940 }
3941
3689 }
3690
3942 /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3943 really a case range, even though it was written that way. Remove
3944 the HIGH_VALUE to simplify later processing. */
3945 if (tree_int_cst_equal (low_value, high_value))
3946 high_value = NULL_TREE;
3947 if (low_value && high_value
3948 && !tree_int_cst_lt (low_value, high_value))
3949 warning ("empty range specified");
3691 /* See if the case is in range of the type of the original testing
3692 expression. If both low_value and high_value are out of range,
3693 don't insert the case label and return NULL_TREE. */
3694 if (low_value
3695 && !check_case_bounds (type, orig_type,
3696 &low_value, high_value ? &high_value : NULL))
3697 return NULL_TREE;
3950
3951 /* Look up the LOW_VALUE in the table of case labels we already
3952 have. */
3953 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3954 /* If there was not an exact match, check for overlapping ranges.
3955 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3956 that's a `default' label and the only overlap is an exact match. */
3957 if (!node && (low_value || high_value))

--- 30 unchanged lines hidden (view full) ---

3988 && (tree_int_cst_compare ((tree) high_bound->key,
3989 high_value)
3990 <= 0))
3991 node = high_bound;
3992 }
3993 /* If there was an overlap, issue an error. */
3994 if (node)
3995 {
3698
3699 /* Look up the LOW_VALUE in the table of case labels we already
3700 have. */
3701 node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3702 /* If there was not an exact match, check for overlapping ranges.
3703 There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3704 that's a `default' label and the only overlap is an exact match. */
3705 if (!node && (low_value || high_value))

--- 30 unchanged lines hidden (view full) ---

3736 && (tree_int_cst_compare ((tree) high_bound->key,
3737 high_value)
3738 <= 0))
3739 node = high_bound;
3740 }
3741 /* If there was an overlap, issue an error. */
3742 if (node)
3743 {
3996 tree duplicate = CASE_LABEL_DECL ((tree) node->value);
3744 tree duplicate = CASE_LABEL ((tree) node->value);
3997
3998 if (high_value)
3999 {
4000 error ("duplicate (or overlapping) case value");
4001 error ("%Jthis is the first entry overlapping that value", duplicate);
4002 }
4003 else if (low_value)
4004 {
4005 error ("duplicate case value") ;
4006 error ("%Jpreviously used here", duplicate);
4007 }
4008 else
4009 {
4010 error ("multiple default labels in one switch");
4011 error ("%Jthis is the first default label", duplicate);
4012 }
3745
3746 if (high_value)
3747 {
3748 error ("duplicate (or overlapping) case value");
3749 error ("%Jthis is the first entry overlapping that value", duplicate);
3750 }
3751 else if (low_value)
3752 {
3753 error ("duplicate case value") ;
3754 error ("%Jpreviously used here", duplicate);
3755 }
3756 else
3757 {
3758 error ("multiple default labels in one switch");
3759 error ("%Jthis is the first default label", duplicate);
3760 }
4013 if (!cases->root)
4014 add_stmt (build_case_label (NULL_TREE, NULL_TREE, label));
3761 goto error_out;
4015 }
4016
4017 /* Add a CASE_LABEL to the statement-tree. */
4018 case_label = add_stmt (build_case_label (low_value, high_value, label));
4019 /* Register this case label in the splay tree. */
4020 splay_tree_insert (cases,
4021 (splay_tree_key) low_value,
4022 (splay_tree_value) case_label);
4023
4024 return case_label;
3762 }
3763
3764 /* Add a CASE_LABEL to the statement-tree. */
3765 case_label = add_stmt (build_case_label (low_value, high_value, label));
3766 /* Register this case label in the splay tree. */
3767 splay_tree_insert (cases,
3768 (splay_tree_key) low_value,
3769 (splay_tree_value) case_label);
3770
3771 return case_label;
3772
3773 error_out:
3774 /* Add a label so that the back-end doesn't think that the beginning of
3775 the switch is unreachable. Note that we do not add a case label, as
3776 that just leads to duplicates and thence to failure later on. */
3777 if (!cases->root)
3778 {
3779 tree t = create_artificial_label ();
3780 add_stmt (build_stmt (LABEL_EXPR, t));
3781 }
3782 return error_mark_node;
4025}
4026
3783}
3784
3785/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3786 Used to verify that case values match up with enumerator values. */
3787
3788static void
3789match_case_to_enum_1 (tree key, tree type, tree label)
3790{
3791 char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3792
3793 /* ??? Not working too hard to print the double-word value.
3794 Should perhaps be done with %lwd in the diagnostic routines? */
3795 if (TREE_INT_CST_HIGH (key) == 0)
3796 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3797 TREE_INT_CST_LOW (key));
3798 else if (!TYPE_UNSIGNED (type)
3799 && TREE_INT_CST_HIGH (key) == -1
3800 && TREE_INT_CST_LOW (key) != 0)
3801 snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3802 -TREE_INT_CST_LOW (key));
3803 else
3804 snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3805 TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3806
3807 if (TYPE_NAME (type) == 0)
3808 warning (0, "%Jcase value %qs not in enumerated type",
3809 CASE_LABEL (label), buf);
3810 else
3811 warning (0, "%Jcase value %qs not in enumerated type %qT",
3812 CASE_LABEL (label), buf, type);
3813}
3814
3815/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3816 Used to verify that case values match up with enumerator values. */
3817
3818static int
3819match_case_to_enum (splay_tree_node node, void *data)
3820{
3821 tree label = (tree) node->value;
3822 tree type = (tree) data;
3823
3824 /* Skip default case. */
3825 if (!CASE_LOW (label))
3826 return 0;
3827
3828 /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3829 when we did our enum->case scan. Reset our scratch bit after. */
3830 if (!CASE_LOW_SEEN (label))
3831 match_case_to_enum_1 (CASE_LOW (label), type, label);
3832 else
3833 CASE_LOW_SEEN (label) = 0;
3834
3835 /* If CASE_HIGH is non-null, we have a range. If CASE_HIGH_SEEN is
3836 not set, that means that CASE_HIGH did not appear when we did our
3837 enum->case scan. Reset our scratch bit after. */
3838 if (CASE_HIGH (label))
3839 {
3840 if (!CASE_HIGH_SEEN (label))
3841 match_case_to_enum_1 (CASE_HIGH (label), type, label);
3842 else
3843 CASE_HIGH_SEEN (label) = 0;
3844 }
3845
3846 return 0;
3847}
3848
3849/* Handle -Wswitch*. Called from the front end after parsing the
3850 switch construct. */
3851/* ??? Should probably be somewhere generic, since other languages
3852 besides C and C++ would want this. At the moment, however, C/C++
3853 are the only tree-ssa languages that support enumerations at all,
3854 so the point is moot. */
3855
3856void
3857c_do_switch_warnings (splay_tree cases, location_t switch_location,
3858 tree type, tree cond)
3859{
3860 splay_tree_node default_node;
3861 splay_tree_node node;
3862 tree chain;
3863
3864 if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3865 return;
3866
3867 default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3868 if (!default_node)
3869 warning (OPT_Wswitch_default, "%Hswitch missing default case",
3870 &switch_location);
3871
3872 /* From here on, we only care about about enumerated types. */
3873 if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
3874 return;
3875
3876 /* If the switch expression was an enumerated type, check that
3877 exactly all enumeration literals are covered by the cases.
3878 The check is made when -Wswitch was specified and there is no
3879 default case, or when -Wswitch-enum was specified. */
3880
3881 if (!warn_switch_enum
3882 && !(warn_switch && !default_node))
3883 return;
3884
3885 /* Clearing COND if it is not an integer constant simplifies
3886 the tests inside the loop below. */
3887 if (TREE_CODE (cond) != INTEGER_CST)
3888 cond = NULL_TREE;
3889
3890 /* The time complexity here is O(N*lg(N)) worst case, but for the
3891 common case of monotonically increasing enumerators, it is
3892 O(N), since the nature of the splay tree will keep the next
3893 element adjacent to the root at all times. */
3894
3895 for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3896 {
3897 tree value = TREE_VALUE (chain);
3898 node = splay_tree_lookup (cases, (splay_tree_key) value);
3899 if (node)
3900 {
3901 /* Mark the CASE_LOW part of the case entry as seen. */
3902 tree label = (tree) node->value;
3903 CASE_LOW_SEEN (label) = 1;
3904 continue;
3905 }
3906
3907 /* Even though there wasn't an exact match, there might be a
3908 case range which includes the enumator's value. */
3909 node = splay_tree_predecessor (cases, (splay_tree_key) value);
3910 if (node && CASE_HIGH ((tree) node->value))
3911 {
3912 tree label = (tree) node->value;
3913 int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
3914 if (cmp >= 0)
3915 {
3916 /* If we match the upper bound exactly, mark the CASE_HIGH
3917 part of the case entry as seen. */
3918 if (cmp == 0)
3919 CASE_HIGH_SEEN (label) = 1;
3920 continue;
3921 }
3922 }
3923
3924 /* We've now determined that this enumerated literal isn't
3925 handled by the case labels of the switch statement. */
3926
3927 /* If the switch expression is a constant, we only really care
3928 about whether that constant is handled by the switch. */
3929 if (cond && tree_int_cst_compare (cond, value))
3930 continue;
3931
3932 warning (0, "%Henumeration value %qE not handled in switch",
3933 &switch_location, TREE_PURPOSE (chain));
3934 }
3935
3936 /* Warn if there are case expressions that don't correspond to
3937 enumerators. This can occur since C and C++ don't enforce
3938 type-checking of assignments to enumeration variables.
3939
3940 The time complexity here is now always O(N) worst case, since
3941 we should have marked both the lower bound and upper bound of
3942 every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
3943 above. This scan also resets those fields. */
3944 splay_tree_foreach (cases, match_case_to_enum, type);
3945}
3946
4027/* Finish an expression taking the address of LABEL (an
4028 IDENTIFIER_NODE). Returns an expression for the address. */
4029
4030tree
4031finish_label_address_expr (tree label)
4032{
4033 tree result;
4034

--- 5 unchanged lines hidden (view full) ---

4040
4041 label = lookup_label (label);
4042 if (label == NULL_TREE)
4043 result = null_pointer_node;
4044 else
4045 {
4046 TREE_USED (label) = 1;
4047 result = build1 (ADDR_EXPR, ptr_type_node, label);
3947/* Finish an expression taking the address of LABEL (an
3948 IDENTIFIER_NODE). Returns an expression for the address. */
3949
3950tree
3951finish_label_address_expr (tree label)
3952{
3953 tree result;
3954

--- 5 unchanged lines hidden (view full) ---

3960
3961 label = lookup_label (label);
3962 if (label == NULL_TREE)
3963 result = null_pointer_node;
3964 else
3965 {
3966 TREE_USED (label) = 1;
3967 result = build1 (ADDR_EXPR, ptr_type_node, label);
4048 TREE_CONSTANT (result) = 1;
4049 /* The current function in not necessarily uninlinable.
4050 Computed gotos are incompatible with inlining, but the value
4051 here could be used only in a diagnostic, for example. */
4052 }
4053
4054 return result;
4055}
4056
4057/* Hook used by expand_expr to expand language-specific tree codes. */
3968 /* The current function in not necessarily uninlinable.
3969 Computed gotos are incompatible with inlining, but the value
3970 here could be used only in a diagnostic, for example. */
3971 }
3972
3973 return result;
3974}
3975
3976/* Hook used by expand_expr to expand language-specific tree codes. */
3977/* The only things that should go here are bits needed to expand
3978 constant initializers. Everything else should be handled by the
3979 gimplification routines. */
4058
4059rtx
3980
3981rtx
4060c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3982c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
4061 int modifier /* Actually enum_modifier. */,
4062 rtx *alt_rtl)
4063{
4064 switch (TREE_CODE (exp))
4065 {
3983 int modifier /* Actually enum_modifier. */,
3984 rtx *alt_rtl)
3985{
3986 switch (TREE_CODE (exp))
3987 {
4066 case STMT_EXPR:
4067 {
4068 tree rtl_expr;
4069 rtx result;
4070 bool preserve_result = false;
4071
4072 if (STMT_EXPR_WARN_UNUSED_RESULT (exp) && target == const0_rtx)
4073 {
4074 tree stmt = STMT_EXPR_STMT (exp);
4075 tree scope;
4076
4077 for (scope = COMPOUND_BODY (stmt);
4078 scope && TREE_CODE (scope) != SCOPE_STMT;
4079 scope = TREE_CHAIN (scope));
4080
4081 if (scope && SCOPE_STMT_BLOCK (scope))
4082 warning ("%Hignoring return value of `%D', "
4083 "declared with attribute warn_unused_result",
4084 &expr_wfl_stack->location,
4085 BLOCK_ABSTRACT_ORIGIN (SCOPE_STMT_BLOCK (scope)));
4086 else
4087 warning ("%Hignoring return value of function "
4088 "declared with attribute warn_unused_result",
4089 &expr_wfl_stack->location);
4090 }
4091
4092 /* Since expand_expr_stmt calls free_temp_slots after every
4093 expression statement, we must call push_temp_slots here.
4094 Otherwise, any temporaries in use now would be considered
4095 out-of-scope after the first EXPR_STMT from within the
4096 STMT_EXPR. */
4097 push_temp_slots ();
4098 rtl_expr = expand_start_stmt_expr (!STMT_EXPR_NO_SCOPE (exp));
4099
4100 /* If we want the result of this expression, find the last
4101 EXPR_STMT in the COMPOUND_STMT and mark it as addressable. */
4102 if (target != const0_rtx
4103 && TREE_CODE (STMT_EXPR_STMT (exp)) == COMPOUND_STMT
4104 && TREE_CODE (COMPOUND_BODY (STMT_EXPR_STMT (exp))) == SCOPE_STMT)
4105 {
4106 tree expr = COMPOUND_BODY (STMT_EXPR_STMT (exp));
4107 tree last = TREE_CHAIN (expr);
4108
4109 while (TREE_CHAIN (last))
4110 {
4111 expr = last;
4112 last = TREE_CHAIN (last);
4113 }
4114
4115 if (TREE_CODE (last) == SCOPE_STMT
4116 && TREE_CODE (expr) == EXPR_STMT)
4117 {
4118 /* Otherwise, note that we want the value from the last
4119 expression. */
4120 TREE_ADDRESSABLE (expr) = 1;
4121 preserve_result = true;
4122 }
4123 }
4124
4125 expand_stmt (STMT_EXPR_STMT (exp));
4126 expand_end_stmt_expr (rtl_expr);
4127
4128 result = expand_expr_real (rtl_expr, target, tmode, modifier, alt_rtl);
4129 if (preserve_result && GET_CODE (result) == MEM)
4130 {
4131 if (GET_MODE (result) != BLKmode)
4132 result = copy_to_reg (result);
4133 else
4134 preserve_temp_slots (result);
4135 }
4136
4137 /* If the statment-expression does not have a scope, then the
4138 new temporaries we created within it must live beyond the
4139 statement-expression. */
4140 if (STMT_EXPR_NO_SCOPE (exp))
4141 preserve_temp_slots (NULL_RTX);
4142
4143 pop_temp_slots ();
4144 return result;
4145 }
4146 break;
4147
4148 case COMPOUND_LITERAL_EXPR:
4149 {
4150 /* Initialize the anonymous variable declared in the compound
4151 literal, then return the variable. */
4152 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
4153 emit_local_var (decl);
4154 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
4155 }
4156
4157 default:
3988 case COMPOUND_LITERAL_EXPR:
3989 {
3990 /* Initialize the anonymous variable declared in the compound
3991 literal, then return the variable. */
3992 tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3993 emit_local_var (decl);
3994 return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3995 }
3996
3997 default:
4158 abort ();
3998 gcc_unreachable ();
4159 }
3999 }
4160
4161 abort ();
4162 return NULL;
4163}
4164
4000}
4001
4165/* Hook used by safe_from_p to handle language-specific tree codes. */
4166
4167int
4168c_safe_from_p (rtx target, tree exp)
4169{
4170 /* We can see statements here when processing the body of a
4171 statement-expression. For a declaration statement declaring a
4172 variable, look at the variable's initializer. */
4173 if (TREE_CODE (exp) == DECL_STMT)
4174 {
4175 tree decl = DECL_STMT_DECL (exp);
4176
4177 if (TREE_CODE (decl) == VAR_DECL
4178 && DECL_INITIAL (decl)
4179 && !safe_from_p (target, DECL_INITIAL (decl), /*top_p=*/0))
4180 return 0;
4181 }
4182
4183 /* For any statement, we must follow the statement-chain. */
4184 if (STATEMENT_CODE_P (TREE_CODE (exp)) && TREE_CHAIN (exp))
4185 return safe_from_p (target, TREE_CHAIN (exp), /*top_p=*/0);
4186
4187 /* Assume everything else is safe. */
4188 return 1;
4189}
4190
4191/* Hook used by unsafe_for_reeval to handle language-specific tree codes. */
4192
4193int
4194c_common_unsafe_for_reeval (tree exp)
4195{
4196 /* Statement expressions may not be reevaluated, likewise compound
4197 literals. */
4198 if (TREE_CODE (exp) == STMT_EXPR
4199 || TREE_CODE (exp) == COMPOUND_LITERAL_EXPR)
4200 return 2;
4201
4202 /* Walk all other expressions. */
4203 return -1;
4204}
4205
4206/* Hook used by staticp to handle language-specific tree codes. */
4207
4002/* Hook used by staticp to handle language-specific tree codes. */
4003
4208int
4004tree
4209c_staticp (tree exp)
4210{
4005c_staticp (tree exp)
4006{
4211 if (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4212 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp)))
4213 return 1;
4214 return 0;
4007 return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4008 && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4009 ? exp : NULL);
4215}
4216
4217
4218/* Given a boolean expression ARG, return a tree representing an increment
4219 or decrement (as indicated by CODE) of ARG. The front end must check for
4220 invalid cases (e.g., decrement in C++). */
4221tree
4222boolean_increment (enum tree_code code, tree arg)
4223{
4224 tree val;
4225 tree true_res = boolean_true_node;
4226
4227 arg = stabilize_reference (arg);
4228 switch (code)
4229 {
4230 case PREINCREMENT_EXPR:
4010}
4011
4012
4013/* Given a boolean expression ARG, return a tree representing an increment
4014 or decrement (as indicated by CODE) of ARG. The front end must check for
4015 invalid cases (e.g., decrement in C++). */
4016tree
4017boolean_increment (enum tree_code code, tree arg)
4018{
4019 tree val;
4020 tree true_res = boolean_true_node;
4021
4022 arg = stabilize_reference (arg);
4023 switch (code)
4024 {
4025 case PREINCREMENT_EXPR:
4231 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4026 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4232 break;
4233 case POSTINCREMENT_EXPR:
4027 break;
4028 case POSTINCREMENT_EXPR:
4234 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4029 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4235 arg = save_expr (arg);
4030 arg = save_expr (arg);
4236 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4237 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4031 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4032 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4238 break;
4239 case PREDECREMENT_EXPR:
4033 break;
4034 case PREDECREMENT_EXPR:
4240 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4035 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4036 invert_truthvalue (arg));
4241 break;
4242 case POSTDECREMENT_EXPR:
4037 break;
4038 case POSTDECREMENT_EXPR:
4243 val = build (MODIFY_EXPR, TREE_TYPE (arg), arg, invert_truthvalue (arg));
4039 val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4040 invert_truthvalue (arg));
4244 arg = save_expr (arg);
4041 arg = save_expr (arg);
4245 val = build (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4246 val = build (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4042 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4043 val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4247 break;
4248 default:
4044 break;
4045 default:
4249 abort ();
4046 gcc_unreachable ();
4250 }
4251 TREE_SIDE_EFFECTS (val) = 1;
4252 return val;
4253}
4254
4255/* Built-in macros for stddef.h, that require macros defined in this
4256 file. */
4257void
4258c_stddef_cpp_builtins(void)
4259{
4260 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4261 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4262 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4263 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4047 }
4048 TREE_SIDE_EFFECTS (val) = 1;
4049 return val;
4050}
4051
4052/* Built-in macros for stddef.h, that require macros defined in this
4053 file. */
4054void
4055c_stddef_cpp_builtins(void)
4056{
4057 builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4058 builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4059 builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4060 builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4061 builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4062 builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4264}
4265
4266static void
4267c_init_attributes (void)
4268{
4269 /* Fill in the built_in_attributes array. */
4063}
4064
4065static void
4066c_init_attributes (void)
4067{
4068 /* Fill in the built_in_attributes array. */
4270#define DEF_ATTR_NULL_TREE(ENUM) \
4069#define DEF_ATTR_NULL_TREE(ENUM) \
4271 built_in_attributes[(int) ENUM] = NULL_TREE;
4070 built_in_attributes[(int) ENUM] = NULL_TREE;
4272#define DEF_ATTR_INT(ENUM, VALUE) \
4273 built_in_attributes[(int) ENUM] = build_int_2 (VALUE, VALUE < 0 ? -1 : 0);
4071#define DEF_ATTR_INT(ENUM, VALUE) \
4072 built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4274#define DEF_ATTR_IDENT(ENUM, STRING) \
4275 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4276#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4277 built_in_attributes[(int) ENUM] \
4278 = tree_cons (built_in_attributes[(int) PURPOSE], \
4279 built_in_attributes[(int) VALUE], \
4280 built_in_attributes[(int) CHAIN]);
4281#include "builtin-attrs.def"

--- 4 unchanged lines hidden (view full) ---

4286}
4287
4288/* Attribute handlers common to C front ends. */
4289
4290/* Handle a "packed" attribute; arguments as in
4291 struct attribute_spec.handler. */
4292
4293static tree
4073#define DEF_ATTR_IDENT(ENUM, STRING) \
4074 built_in_attributes[(int) ENUM] = get_identifier (STRING);
4075#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4076 built_in_attributes[(int) ENUM] \
4077 = tree_cons (built_in_attributes[(int) PURPOSE], \
4078 built_in_attributes[(int) VALUE], \
4079 built_in_attributes[(int) CHAIN]);
4080#include "builtin-attrs.def"

--- 4 unchanged lines hidden (view full) ---

4085}
4086
4087/* Attribute handlers common to C front ends. */
4088
4089/* Handle a "packed" attribute; arguments as in
4090 struct attribute_spec.handler. */
4091
4092static tree
4294handle_packed_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4093handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4295 int flags, bool *no_add_attrs)
4296{
4297 if (TYPE_P (*node))
4298 {
4299 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4094 int flags, bool *no_add_attrs)
4095{
4096 if (TYPE_P (*node))
4097 {
4098 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4300 *node = build_type_copy (*node);
4099 *node = build_variant_type_copy (*node);
4301 TYPE_PACKED (*node) = 1;
4100 TYPE_PACKED (*node) = 1;
4302 if (TYPE_MAIN_VARIANT (*node) == *node)
4303 {
4304 /* If it is the main variant, then pack the other variants
4305 too. This happens in,
4306
4307 struct Foo {
4308 struct Foo const *ptr; // creates a variant w/o packed flag
4309 } __ attribute__((packed)); // packs it now.
4310 */
4311 tree probe;
4312
4313 for (probe = *node; probe; probe = TYPE_NEXT_VARIANT (probe))
4314 TYPE_PACKED (probe) = 1;
4315 }
4316
4317 }
4318 else if (TREE_CODE (*node) == FIELD_DECL)
4101 }
4102 else if (TREE_CODE (*node) == FIELD_DECL)
4319 DECL_PACKED (*node) = 1;
4103 {
4104 if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4105 warning (OPT_Wattributes,
4106 "%qE attribute ignored for field of type %qT",
4107 name, TREE_TYPE (*node));
4108 else
4109 DECL_PACKED (*node) = 1;
4110 }
4320 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4321 used for DECL_REGISTER. It wouldn't mean anything anyway.
4322 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4323 that changes what the typedef is typing. */
4324 else
4325 {
4111 /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4112 used for DECL_REGISTER. It wouldn't mean anything anyway.
4113 We can't set DECL_PACKED on the type of a TYPE_DECL, because
4114 that changes what the typedef is typing. */
4115 else
4116 {
4326 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4117 warning (OPT_Wattributes, "%qE attribute ignored", name);
4327 *no_add_attrs = true;
4328 }
4329
4330 return NULL_TREE;
4331}
4332
4333/* Handle a "nocommon" attribute; arguments as in
4334 struct attribute_spec.handler. */
4335
4336static tree
4337handle_nocommon_attribute (tree *node, tree name,
4118 *no_add_attrs = true;
4119 }
4120
4121 return NULL_TREE;
4122}
4123
4124/* Handle a "nocommon" attribute; arguments as in
4125 struct attribute_spec.handler. */
4126
4127static tree
4128handle_nocommon_attribute (tree *node, tree name,
4338 tree args ATTRIBUTE_UNUSED,
4339 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4129 tree ARG_UNUSED (args),
4130 int ARG_UNUSED (flags), bool *no_add_attrs)
4340{
4341 if (TREE_CODE (*node) == VAR_DECL)
4342 DECL_COMMON (*node) = 0;
4343 else
4344 {
4131{
4132 if (TREE_CODE (*node) == VAR_DECL)
4133 DECL_COMMON (*node) = 0;
4134 else
4135 {
4345 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4136 warning (OPT_Wattributes, "%qE attribute ignored", name);
4346 *no_add_attrs = true;
4347 }
4348
4349 return NULL_TREE;
4350}
4351
4352/* Handle a "common" attribute; arguments as in
4353 struct attribute_spec.handler. */
4354
4355static tree
4137 *no_add_attrs = true;
4138 }
4139
4140 return NULL_TREE;
4141}
4142
4143/* Handle a "common" attribute; arguments as in
4144 struct attribute_spec.handler. */
4145
4146static tree
4356handle_common_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4357 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4147handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4148 int ARG_UNUSED (flags), bool *no_add_attrs)
4358{
4359 if (TREE_CODE (*node) == VAR_DECL)
4360 DECL_COMMON (*node) = 1;
4361 else
4362 {
4149{
4150 if (TREE_CODE (*node) == VAR_DECL)
4151 DECL_COMMON (*node) = 1;
4152 else
4153 {
4363 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4154 warning (OPT_Wattributes, "%qE attribute ignored", name);
4364 *no_add_attrs = true;
4365 }
4366
4367 return NULL_TREE;
4368}
4369
4370/* Handle a "noreturn" attribute; arguments as in
4371 struct attribute_spec.handler. */
4372
4373static tree
4155 *no_add_attrs = true;
4156 }
4157
4158 return NULL_TREE;
4159}
4160
4161/* Handle a "noreturn" attribute; arguments as in
4162 struct attribute_spec.handler. */
4163
4164static tree
4374handle_noreturn_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4375 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4165handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4166 int ARG_UNUSED (flags), bool *no_add_attrs)
4376{
4377 tree type = TREE_TYPE (*node);
4378
4379 /* See FIXME comment in c_common_attribute_table. */
4380 if (TREE_CODE (*node) == FUNCTION_DECL)
4381 TREE_THIS_VOLATILE (*node) = 1;
4382 else if (TREE_CODE (type) == POINTER_TYPE
4383 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4384 TREE_TYPE (*node)
4385 = build_pointer_type
4386 (build_type_variant (TREE_TYPE (type),
4167{
4168 tree type = TREE_TYPE (*node);
4169
4170 /* See FIXME comment in c_common_attribute_table. */
4171 if (TREE_CODE (*node) == FUNCTION_DECL)
4172 TREE_THIS_VOLATILE (*node) = 1;
4173 else if (TREE_CODE (type) == POINTER_TYPE
4174 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4175 TREE_TYPE (*node)
4176 = build_pointer_type
4177 (build_type_variant (TREE_TYPE (type),
4387 TREE_READONLY (TREE_TYPE (type)), 1));
4178 TYPE_READONLY (TREE_TYPE (type)), 1));
4388 else
4389 {
4179 else
4180 {
4390 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4181 warning (OPT_Wattributes, "%qE attribute ignored", name);
4391 *no_add_attrs = true;
4392 }
4393
4394 return NULL_TREE;
4395}
4396
4397/* Handle a "noinline" attribute; arguments as in
4398 struct attribute_spec.handler. */
4399
4400static tree
4401handle_noinline_attribute (tree *node, tree name,
4182 *no_add_attrs = true;
4183 }
4184
4185 return NULL_TREE;
4186}
4187
4188/* Handle a "noinline" attribute; arguments as in
4189 struct attribute_spec.handler. */
4190
4191static tree
4192handle_noinline_attribute (tree *node, tree name,
4402 tree args ATTRIBUTE_UNUSED,
4403 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4193 tree ARG_UNUSED (args),
4194 int ARG_UNUSED (flags), bool *no_add_attrs)
4404{
4405 if (TREE_CODE (*node) == FUNCTION_DECL)
4406 DECL_UNINLINABLE (*node) = 1;
4407 else
4408 {
4195{
4196 if (TREE_CODE (*node) == FUNCTION_DECL)
4197 DECL_UNINLINABLE (*node) = 1;
4198 else
4199 {
4409 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4200 warning (OPT_Wattributes, "%qE attribute ignored", name);
4410 *no_add_attrs = true;
4411 }
4412
4413 return NULL_TREE;
4414}
4415
4416/* Handle a "always_inline" attribute; arguments as in
4417 struct attribute_spec.handler. */
4418
4419static tree
4420handle_always_inline_attribute (tree *node, tree name,
4201 *no_add_attrs = true;
4202 }
4203
4204 return NULL_TREE;
4205}
4206
4207/* Handle a "always_inline" attribute; arguments as in
4208 struct attribute_spec.handler. */
4209
4210static tree
4211handle_always_inline_attribute (tree *node, tree name,
4421 tree args ATTRIBUTE_UNUSED,
4422 int flags ATTRIBUTE_UNUSED,
4212 tree ARG_UNUSED (args),
4213 int ARG_UNUSED (flags),
4423 bool *no_add_attrs)
4424{
4425 if (TREE_CODE (*node) == FUNCTION_DECL)
4426 {
4427 /* Do nothing else, just set the attribute. We'll get at
4428 it later with lookup_attribute. */
4429 }
4430 else
4431 {
4214 bool *no_add_attrs)
4215{
4216 if (TREE_CODE (*node) == FUNCTION_DECL)
4217 {
4218 /* Do nothing else, just set the attribute. We'll get at
4219 it later with lookup_attribute. */
4220 }
4221 else
4222 {
4432 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4223 warning (OPT_Wattributes, "%qE attribute ignored", name);
4433 *no_add_attrs = true;
4434 }
4435
4436 return NULL_TREE;
4437}
4438
4224 *no_add_attrs = true;
4225 }
4226
4227 return NULL_TREE;
4228}
4229
4230/* Handle a "gnu_inline" attribute; arguments as in
4231 struct attribute_spec.handler. */
4232
4233static tree
4234handle_gnu_inline_attribute (tree *node, tree name,
4235 tree ARG_UNUSED (args),
4236 int ARG_UNUSED (flags),
4237 bool *no_add_attrs)
4238{
4239 if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4240 {
4241 /* Do nothing else, just set the attribute. We'll get at
4242 it later with lookup_attribute. */
4243 }
4244 else
4245 {
4246 warning (OPT_Wattributes, "%qE attribute ignored", name);
4247 *no_add_attrs = true;
4248 }
4249
4250 return NULL_TREE;
4251}
4252
4253/* Handle a "flatten" attribute; arguments as in
4254 struct attribute_spec.handler. */
4255
4256static tree
4257handle_flatten_attribute (tree *node, tree name,
4258 tree args ATTRIBUTE_UNUSED,
4259 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4260{
4261 if (TREE_CODE (*node) == FUNCTION_DECL)
4262 /* Do nothing else, just set the attribute. We'll get at
4263 it later with lookup_attribute. */
4264 ;
4265 else
4266 {
4267 warning (OPT_Wattributes, "%qE attribute ignored", name);
4268 *no_add_attrs = true;
4269 }
4270
4271 return NULL_TREE;
4272}
4273
4274
4439/* Handle a "used" attribute; arguments as in
4440 struct attribute_spec.handler. */
4441
4442static tree
4275/* Handle a "used" attribute; arguments as in
4276 struct attribute_spec.handler. */
4277
4278static tree
4443handle_used_attribute (tree *pnode, tree name, tree args ATTRIBUTE_UNUSED,
4444 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4279handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4280 int ARG_UNUSED (flags), bool *no_add_attrs)
4445{
4446 tree node = *pnode;
4447
4448 if (TREE_CODE (node) == FUNCTION_DECL
4449 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4450 {
4451 TREE_USED (node) = 1;
4281{
4282 tree node = *pnode;
4283
4284 if (TREE_CODE (node) == FUNCTION_DECL
4285 || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4286 {
4287 TREE_USED (node) = 1;
4288 DECL_PRESERVE_P (node) = 1;
4452 }
4453 else
4454 {
4289 }
4290 else
4291 {
4455 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4292 warning (OPT_Wattributes, "%qE attribute ignored", name);
4456 *no_add_attrs = true;
4457 }
4458
4459 return NULL_TREE;
4460}
4461
4462/* Handle a "unused" attribute; arguments as in
4463 struct attribute_spec.handler. */
4464
4465static tree
4293 *no_add_attrs = true;
4294 }
4295
4296 return NULL_TREE;
4297}
4298
4299/* Handle a "unused" attribute; arguments as in
4300 struct attribute_spec.handler. */
4301
4302static tree
4466handle_unused_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4467 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4303handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4304 int flags, bool *no_add_attrs)
4468{
4469 if (DECL_P (*node))
4470 {
4471 tree decl = *node;
4472
4473 if (TREE_CODE (decl) == PARM_DECL
4474 || TREE_CODE (decl) == VAR_DECL
4475 || TREE_CODE (decl) == FUNCTION_DECL
4476 || TREE_CODE (decl) == LABEL_DECL
4477 || TREE_CODE (decl) == TYPE_DECL)
4478 TREE_USED (decl) = 1;
4479 else
4480 {
4305{
4306 if (DECL_P (*node))
4307 {
4308 tree decl = *node;
4309
4310 if (TREE_CODE (decl) == PARM_DECL
4311 || TREE_CODE (decl) == VAR_DECL
4312 || TREE_CODE (decl) == FUNCTION_DECL
4313 || TREE_CODE (decl) == LABEL_DECL
4314 || TREE_CODE (decl) == TYPE_DECL)
4315 TREE_USED (decl) = 1;
4316 else
4317 {
4481 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4318 warning (OPT_Wattributes, "%qE attribute ignored", name);
4482 *no_add_attrs = true;
4483 }
4484 }
4485 else
4486 {
4487 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4319 *no_add_attrs = true;
4320 }
4321 }
4322 else
4323 {
4324 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4488 *node = build_type_copy (*node);
4325 *node = build_variant_type_copy (*node);
4489 TREE_USED (*node) = 1;
4490 }
4491
4492 return NULL_TREE;
4493}
4494
4326 TREE_USED (*node) = 1;
4327 }
4328
4329 return NULL_TREE;
4330}
4331
4332/* Handle a "externally_visible" attribute; arguments as in
4333 struct attribute_spec.handler. */
4334
4335static tree
4336handle_externally_visible_attribute (tree *pnode, tree name,
4337 tree ARG_UNUSED (args),
4338 int ARG_UNUSED (flags),
4339 bool *no_add_attrs)
4340{
4341 tree node = *pnode;
4342
4343 if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4344 {
4345 if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4346 && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4347 {
4348 warning (OPT_Wattributes,
4349 "%qE attribute have effect only on public objects", name);
4350 *no_add_attrs = true;
4351 }
4352 }
4353 else
4354 {
4355 warning (OPT_Wattributes, "%qE attribute ignored", name);
4356 *no_add_attrs = true;
4357 }
4358
4359 return NULL_TREE;
4360}
4361
4495/* Handle a "const" attribute; arguments as in
4496 struct attribute_spec.handler. */
4497
4498static tree
4362/* Handle a "const" attribute; arguments as in
4363 struct attribute_spec.handler. */
4364
4365static tree
4499handle_const_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4500 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4366handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4367 int ARG_UNUSED (flags), bool *no_add_attrs)
4501{
4502 tree type = TREE_TYPE (*node);
4503
4504 /* See FIXME comment on noreturn in c_common_attribute_table. */
4505 if (TREE_CODE (*node) == FUNCTION_DECL)
4506 TREE_READONLY (*node) = 1;
4507 else if (TREE_CODE (type) == POINTER_TYPE
4508 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4509 TREE_TYPE (*node)
4510 = build_pointer_type
4511 (build_type_variant (TREE_TYPE (type), 1,
4512 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4513 else
4514 {
4368{
4369 tree type = TREE_TYPE (*node);
4370
4371 /* See FIXME comment on noreturn in c_common_attribute_table. */
4372 if (TREE_CODE (*node) == FUNCTION_DECL)
4373 TREE_READONLY (*node) = 1;
4374 else if (TREE_CODE (type) == POINTER_TYPE
4375 && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4376 TREE_TYPE (*node)
4377 = build_pointer_type
4378 (build_type_variant (TREE_TYPE (type), 1,
4379 TREE_THIS_VOLATILE (TREE_TYPE (type))));
4380 else
4381 {
4515 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4382 warning (OPT_Wattributes, "%qE attribute ignored", name);
4516 *no_add_attrs = true;
4517 }
4518
4519 return NULL_TREE;
4520}
4521
4522/* Handle a "transparent_union" attribute; arguments as in
4523 struct attribute_spec.handler. */
4524
4525static tree
4526handle_transparent_union_attribute (tree *node, tree name,
4383 *no_add_attrs = true;
4384 }
4385
4386 return NULL_TREE;
4387}
4388
4389/* Handle a "transparent_union" attribute; arguments as in
4390 struct attribute_spec.handler. */
4391
4392static tree
4393handle_transparent_union_attribute (tree *node, tree name,
4527 tree args ATTRIBUTE_UNUSED, int flags,
4394 tree ARG_UNUSED (args), int flags,
4528 bool *no_add_attrs)
4529{
4395 bool *no_add_attrs)
4396{
4530 tree decl = NULL_TREE;
4531 tree *type = NULL;
4532 int is_type = 0;
4397 tree type = NULL;
4533
4398
4399 *no_add_attrs = true;
4400
4534 if (DECL_P (*node))
4535 {
4401 if (DECL_P (*node))
4402 {
4536 decl = *node;
4537 type = &TREE_TYPE (decl);
4538 is_type = TREE_CODE (*node) == TYPE_DECL;
4403 if (TREE_CODE (*node) != TYPE_DECL)
4404 goto ignored;
4405 node = &TREE_TYPE (*node);
4406 type = *node;
4539 }
4540 else if (TYPE_P (*node))
4407 }
4408 else if (TYPE_P (*node))
4541 type = node, is_type = 1;
4409 type = *node;
4410 else
4411 goto ignored;
4542
4412
4543 if (is_type
4544 && TREE_CODE (*type) == UNION_TYPE
4545 && (decl == 0
4546 || (TYPE_FIELDS (*type) != 0
4547 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))))
4413 if (TREE_CODE (type) == UNION_TYPE)
4548 {
4414 {
4415 /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4416 the code in finish_struct. */
4549 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4417 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4550 *type = build_type_copy (*type);
4551 TYPE_TRANSPARENT_UNION (*type) = 1;
4418 {
4419 if (TYPE_FIELDS (type) == NULL_TREE
4420 || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4421 goto ignored;
4422
4423 /* A type variant isn't good enough, since we don't a cast
4424 to such a type removed as a no-op. */
4425 *node = type = build_duplicate_type (type);
4426 }
4427
4428 TYPE_TRANSPARENT_UNION (type) = 1;
4429 return NULL_TREE;
4552 }
4430 }
4553 else if (decl != 0 && TREE_CODE (decl) == PARM_DECL
4554 && TREE_CODE (*type) == UNION_TYPE
4555 && TYPE_MODE (*type) == DECL_MODE (TYPE_FIELDS (*type)))
4556 DECL_TRANSPARENT_UNION (decl) = 1;
4557 else
4558 {
4559 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4560 *no_add_attrs = true;
4561 }
4562
4431
4432 ignored:
4433 warning (OPT_Wattributes, "%qE attribute ignored", name);
4563 return NULL_TREE;
4564}
4565
4566/* Handle a "constructor" attribute; arguments as in
4567 struct attribute_spec.handler. */
4568
4569static tree
4570handle_constructor_attribute (tree *node, tree name,
4434 return NULL_TREE;
4435}
4436
4437/* Handle a "constructor" attribute; arguments as in
4438 struct attribute_spec.handler. */
4439
4440static tree
4441handle_constructor_attribute (tree *node, tree name,
4571 tree args ATTRIBUTE_UNUSED,
4572 int flags ATTRIBUTE_UNUSED,
4442 tree ARG_UNUSED (args),
4443 int ARG_UNUSED (flags),
4573 bool *no_add_attrs)
4574{
4575 tree decl = *node;
4576 tree type = TREE_TYPE (decl);
4577
4578 if (TREE_CODE (decl) == FUNCTION_DECL
4579 && TREE_CODE (type) == FUNCTION_TYPE
4580 && decl_function_context (decl) == 0)
4581 {
4582 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4583 TREE_USED (decl) = 1;
4584 }
4585 else
4586 {
4444 bool *no_add_attrs)
4445{
4446 tree decl = *node;
4447 tree type = TREE_TYPE (decl);
4448
4449 if (TREE_CODE (decl) == FUNCTION_DECL
4450 && TREE_CODE (type) == FUNCTION_TYPE
4451 && decl_function_context (decl) == 0)
4452 {
4453 DECL_STATIC_CONSTRUCTOR (decl) = 1;
4454 TREE_USED (decl) = 1;
4455 }
4456 else
4457 {
4587 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4458 warning (OPT_Wattributes, "%qE attribute ignored", name);
4588 *no_add_attrs = true;
4589 }
4590
4591 return NULL_TREE;
4592}
4593
4594/* Handle a "destructor" attribute; arguments as in
4595 struct attribute_spec.handler. */
4596
4597static tree
4598handle_destructor_attribute (tree *node, tree name,
4459 *no_add_attrs = true;
4460 }
4461
4462 return NULL_TREE;
4463}
4464
4465/* Handle a "destructor" attribute; arguments as in
4466 struct attribute_spec.handler. */
4467
4468static tree
4469handle_destructor_attribute (tree *node, tree name,
4599 tree args ATTRIBUTE_UNUSED,
4600 int flags ATTRIBUTE_UNUSED,
4470 tree ARG_UNUSED (args),
4471 int ARG_UNUSED (flags),
4601 bool *no_add_attrs)
4602{
4603 tree decl = *node;
4604 tree type = TREE_TYPE (decl);
4605
4606 if (TREE_CODE (decl) == FUNCTION_DECL
4607 && TREE_CODE (type) == FUNCTION_TYPE
4608 && decl_function_context (decl) == 0)
4609 {
4610 DECL_STATIC_DESTRUCTOR (decl) = 1;
4611 TREE_USED (decl) = 1;
4612 }
4613 else
4614 {
4472 bool *no_add_attrs)
4473{
4474 tree decl = *node;
4475 tree type = TREE_TYPE (decl);
4476
4477 if (TREE_CODE (decl) == FUNCTION_DECL
4478 && TREE_CODE (type) == FUNCTION_TYPE
4479 && decl_function_context (decl) == 0)
4480 {
4481 DECL_STATIC_DESTRUCTOR (decl) = 1;
4482 TREE_USED (decl) = 1;
4483 }
4484 else
4485 {
4615 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4486 warning (OPT_Wattributes, "%qE attribute ignored", name);
4616 *no_add_attrs = true;
4617 }
4618
4619 return NULL_TREE;
4620}
4621
4622/* Handle a "mode" attribute; arguments as in
4623 struct attribute_spec.handler. */
4624
4625static tree
4487 *no_add_attrs = true;
4488 }
4489
4490 return NULL_TREE;
4491}
4492
4493/* Handle a "mode" attribute; arguments as in
4494 struct attribute_spec.handler. */
4495
4496static tree
4626handle_mode_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
4627 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4497handle_mode_attribute (tree *node, tree name, tree args,
4498 int ARG_UNUSED (flags), bool *no_add_attrs)
4628{
4629 tree type = *node;
4630
4631 *no_add_attrs = true;
4632
4633 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4499{
4500 tree type = *node;
4501
4502 *no_add_attrs = true;
4503
4504 if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4634 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4505 warning (OPT_Wattributes, "%qE attribute ignored", name);
4635 else
4636 {
4637 int j;
4638 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4639 int len = strlen (p);
4640 enum machine_mode mode = VOIDmode;
4641 tree typefm;
4506 else
4507 {
4508 int j;
4509 const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4510 int len = strlen (p);
4511 enum machine_mode mode = VOIDmode;
4512 tree typefm;
4642 tree ptr_type;
4513 bool valid_mode;
4643
4644 if (len > 4 && p[0] == '_' && p[1] == '_'
4645 && p[len - 1] == '_' && p[len - 2] == '_')
4646 {
4514
4515 if (len > 4 && p[0] == '_' && p[1] == '_'
4516 && p[len - 1] == '_' && p[len - 2] == '_')
4517 {
4647 char *newp = alloca (len - 1);
4518 char *newp = (char *) alloca (len - 1);
4648
4649 strcpy (newp, &p[2]);
4650 newp[len - 4] = '\0';
4651 p = newp;
4652 }
4653
4654 /* Change this type to have a type with the specified mode.
4655 First check for the special modes. */
4519
4520 strcpy (newp, &p[2]);
4521 newp[len - 4] = '\0';
4522 p = newp;
4523 }
4524
4525 /* Change this type to have a type with the specified mode.
4526 First check for the special modes. */
4656 if (! strcmp (p, "byte"))
4527 if (!strcmp (p, "byte"))
4657 mode = byte_mode;
4658 else if (!strcmp (p, "word"))
4659 mode = word_mode;
4528 mode = byte_mode;
4529 else if (!strcmp (p, "word"))
4530 mode = word_mode;
4660 else if (! strcmp (p, "pointer"))
4531 else if (!strcmp (p, "pointer"))
4661 mode = ptr_mode;
4662 else
4663 for (j = 0; j < NUM_MACHINE_MODES; j++)
4664 if (!strcmp (p, GET_MODE_NAME (j)))
4665 {
4666 mode = (enum machine_mode) j;
4667 break;
4668 }
4669
4670 if (mode == VOIDmode)
4532 mode = ptr_mode;
4533 else
4534 for (j = 0; j < NUM_MACHINE_MODES; j++)
4535 if (!strcmp (p, GET_MODE_NAME (j)))
4536 {
4537 mode = (enum machine_mode) j;
4538 break;
4539 }
4540
4541 if (mode == VOIDmode)
4671 error ("unknown machine mode `%s'", p);
4672 else if (0 == (typefm = (*lang_hooks.types.type_for_mode)
4673 (mode, TREE_UNSIGNED (type))))
4674 error ("no data type for mode `%s'", p);
4675 else if ((TREE_CODE (type) == POINTER_TYPE
4676 || TREE_CODE (type) == REFERENCE_TYPE)
4677 && !(*targetm.valid_pointer_mode) (mode))
4678 error ("invalid pointer mode `%s'", p);
4679 else
4680 {
4542 {
4681 /* If this is a vector, make sure we either have hardware
4682 support, or we can emulate it. */
4683 if (VECTOR_MODE_P (mode) && !vector_mode_valid_p (mode))
4543 error ("unknown machine mode %qs", p);
4544 return NULL_TREE;
4545 }
4546
4547 valid_mode = false;
4548 switch (GET_MODE_CLASS (mode))
4549 {
4550 case MODE_INT:
4551 case MODE_PARTIAL_INT:
4552 case MODE_FLOAT:
4553 case MODE_DECIMAL_FLOAT:
4554 valid_mode = targetm.scalar_mode_supported_p (mode);
4555 break;
4556
4557 case MODE_COMPLEX_INT:
4558 case MODE_COMPLEX_FLOAT:
4559 valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4560 break;
4561
4562 case MODE_VECTOR_INT:
4563 case MODE_VECTOR_FLOAT:
4564 warning (OPT_Wattributes, "specifying vector types with "
4565 "__attribute__ ((mode)) is deprecated");
4566 warning (OPT_Wattributes,
4567 "use __attribute__ ((vector_size)) instead");
4568 valid_mode = vector_mode_valid_p (mode);
4569 break;
4570
4571 default:
4572 break;
4573 }
4574 if (!valid_mode)
4575 {
4576 error ("unable to emulate %qs", p);
4577 return NULL_TREE;
4578 }
4579
4580 if (POINTER_TYPE_P (type))
4581 {
4582 tree (*fn)(tree, enum machine_mode, bool);
4583
4584 if (!targetm.valid_pointer_mode (mode))
4684 {
4585 {
4685 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
4586 error ("invalid pointer mode %qs", p);
4686 return NULL_TREE;
4687 }
4688
4689 if (TREE_CODE (type) == POINTER_TYPE)
4587 return NULL_TREE;
4588 }
4589
4590 if (TREE_CODE (type) == POINTER_TYPE)
4591 fn = build_pointer_type_for_mode;
4592 else
4593 fn = build_reference_type_for_mode;
4594 typefm = fn (TREE_TYPE (type), mode, false);
4595 }
4596 else
4597 typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4598
4599 if (typefm == NULL_TREE)
4600 {
4601 error ("no data type for mode %qs", p);
4602 return NULL_TREE;
4603 }
4604 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4605 {
4606 /* For enumeral types, copy the precision from the integer
4607 type returned above. If not an INTEGER_TYPE, we can't use
4608 this mode for this type. */
4609 if (TREE_CODE (typefm) != INTEGER_TYPE)
4690 {
4610 {
4691 ptr_type = build_pointer_type_for_mode (TREE_TYPE (type),
4692 mode);
4693 *node = ptr_type;
4611 error ("cannot use mode %qs for enumeral types", p);
4612 return NULL_TREE;
4694 }
4613 }
4695 else if (TREE_CODE (type) == REFERENCE_TYPE)
4696 {
4697 ptr_type = build_reference_type_for_mode (TREE_TYPE (type),
4698 mode);
4699 *node = ptr_type;
4700 }
4701 else if (TREE_CODE (type) == ENUMERAL_TYPE)
4702 {
4703 /* For enumeral types, copy the precision from the integer
4704 type returned above. If not an INTEGER_TYPE, we can't use
4705 this mode for this type. */
4706 if (TREE_CODE (typefm) != INTEGER_TYPE)
4707 {
4708 error ("cannot use mode %qs for enumeral types", p);
4709 return NULL_TREE;
4710 }
4711
4614
4712 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4713 type = build_type_copy (type);
4714
4715 /* We cannot use layout_type here, because that will attempt
4716 to re-layout all variants, corrupting our original. */
4615 if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4616 {
4717 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4617 TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4718 TYPE_MIN_VALUE (type) = TYPE_MIN_VALUE (typefm);
4719 TYPE_MAX_VALUE (type) = TYPE_MAX_VALUE (typefm);
4720 TYPE_SIZE (type) = TYPE_SIZE (typefm);
4721 TYPE_SIZE_UNIT (type) = TYPE_SIZE_UNIT (typefm);
4722 TYPE_MODE (type) = TYPE_MODE (typefm);
4723 if (!TYPE_USER_ALIGN (type))
4724 TYPE_ALIGN (type) = TYPE_ALIGN (typefm);
4725
4726 *node = type;
4618 typefm = type;
4727 }
4619 }
4728 else if (VECTOR_MODE_P (mode)
4729 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4730 : TREE_CODE (type) != TREE_CODE (typefm))
4731
4620 else
4732 {
4621 {
4733 error ("mode `%s' applied to inappropriate type", p);
4734 return NULL_TREE;
4622 /* We cannot build a type variant, as there's code that assumes
4623 that TYPE_MAIN_VARIANT has the same mode. This includes the
4624 debug generators. Instead, create a subrange type. This
4625 results in all of the enumeral values being emitted only once
4626 in the original, and the subtype gets them by reference. */
4627 if (TYPE_UNSIGNED (type))
4628 typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4629 else
4630 typefm = make_signed_type (TYPE_PRECISION (typefm));
4631 TREE_TYPE (typefm) = type;
4735 }
4632 }
4736 else
4737 *node = typefm;
4738
4739 /* No need to layout the type here. The caller should do this. */
4740 }
4633 }
4634 else if (VECTOR_MODE_P (mode)
4635 ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4636 : TREE_CODE (type) != TREE_CODE (typefm))
4637 {
4638 error ("mode %qs applied to inappropriate type", p);
4639 return NULL_TREE;
4640 }
4641
4642 *node = typefm;
4741 }
4742
4743 return NULL_TREE;
4744}
4745
4746/* Handle a "section" attribute; arguments as in
4747 struct attribute_spec.handler. */
4748
4749static tree
4643 }
4644
4645 return NULL_TREE;
4646}
4647
4648/* Handle a "section" attribute; arguments as in
4649 struct attribute_spec.handler. */
4650
4651static tree
4750handle_section_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4751 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4652handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4653 int ARG_UNUSED (flags), bool *no_add_attrs)
4752{
4753 tree decl = *node;
4754
4755 if (targetm.have_named_sections)
4756 {
4654{
4655 tree decl = *node;
4656
4657 if (targetm.have_named_sections)
4658 {
4659 user_defined_section_attribute = true;
4660
4757 if ((TREE_CODE (decl) == FUNCTION_DECL
4758 || TREE_CODE (decl) == VAR_DECL)
4759 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4760 {
4761 if (TREE_CODE (decl) == VAR_DECL
4762 && current_function_decl != NULL_TREE
4661 if ((TREE_CODE (decl) == FUNCTION_DECL
4662 || TREE_CODE (decl) == VAR_DECL)
4663 && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4664 {
4665 if (TREE_CODE (decl) == VAR_DECL
4666 && current_function_decl != NULL_TREE
4763 && ! TREE_STATIC (decl))
4667 && !TREE_STATIC (decl))
4764 {
4765 error ("%Jsection attribute cannot be specified for "
4668 {
4669 error ("%Jsection attribute cannot be specified for "
4766 "local variables", decl);
4670 "local variables", decl);
4767 *no_add_attrs = true;
4768 }
4769
4770 /* The decl may have already been given a section attribute
4771 from a previous declaration. Ensure they match. */
4772 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4773 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4774 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4775 {
4671 *no_add_attrs = true;
4672 }
4673
4674 /* The decl may have already been given a section attribute
4675 from a previous declaration. Ensure they match. */
4676 else if (DECL_SECTION_NAME (decl) != NULL_TREE
4677 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4678 TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4679 {
4776 error ("%Jsection of '%D' conflicts with previous declaration",
4777 *node, *node);
4680 error ("section of %q+D conflicts with previous declaration",
4681 *node);
4778 *no_add_attrs = true;
4779 }
4780 else
4781 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4782 }
4783 else
4784 {
4682 *no_add_attrs = true;
4683 }
4684 else
4685 DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4686 }
4687 else
4688 {
4785 error ("%Jsection attribute not allowed for '%D'", *node, *node);
4689 error ("section attribute not allowed for %q+D", *node);
4786 *no_add_attrs = true;
4787 }
4788 }
4789 else
4790 {
4791 error ("%Jsection attributes are not supported for this target", *node);
4792 *no_add_attrs = true;
4793 }
4794
4795 return NULL_TREE;
4796}
4797
4798/* Handle a "aligned" attribute; arguments as in
4799 struct attribute_spec.handler. */
4800
4801static tree
4690 *no_add_attrs = true;
4691 }
4692 }
4693 else
4694 {
4695 error ("%Jsection attributes are not supported for this target", *node);
4696 *no_add_attrs = true;
4697 }
4698
4699 return NULL_TREE;
4700}
4701
4702/* Handle a "aligned" attribute; arguments as in
4703 struct attribute_spec.handler. */
4704
4705static tree
4802handle_aligned_attribute (tree *node, tree name ATTRIBUTE_UNUSED, tree args,
4706handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4803 int flags, bool *no_add_attrs)
4804{
4805 tree decl = NULL_TREE;
4806 tree *type = NULL;
4807 int is_type = 0;
4808 tree align_expr = (args ? TREE_VALUE (args)
4809 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4810 int i;
4811
4812 if (DECL_P (*node))
4813 {
4814 decl = *node;
4815 type = &TREE_TYPE (decl);
4816 is_type = TREE_CODE (*node) == TYPE_DECL;
4817 }
4818 else if (TYPE_P (*node))
4819 type = node, is_type = 1;
4820
4707 int flags, bool *no_add_attrs)
4708{
4709 tree decl = NULL_TREE;
4710 tree *type = NULL;
4711 int is_type = 0;
4712 tree align_expr = (args ? TREE_VALUE (args)
4713 : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4714 int i;
4715
4716 if (DECL_P (*node))
4717 {
4718 decl = *node;
4719 type = &TREE_TYPE (decl);
4720 is_type = TREE_CODE (*node) == TYPE_DECL;
4721 }
4722 else if (TYPE_P (*node))
4723 type = node, is_type = 1;
4724
4821 /* Strip any NOPs of any kind. */
4822 while (TREE_CODE (align_expr) == NOP_EXPR
4823 || TREE_CODE (align_expr) == CONVERT_EXPR
4824 || TREE_CODE (align_expr) == NON_LVALUE_EXPR)
4825 align_expr = TREE_OPERAND (align_expr, 0);
4826
4827 if (TREE_CODE (align_expr) != INTEGER_CST)
4828 {
4829 error ("requested alignment is not a constant");
4830 *no_add_attrs = true;
4831 }
4832 else if ((i = tree_log2 (align_expr)) == -1)
4833 {
4834 error ("requested alignment is not a power of 2");

--- 7 unchanged lines hidden (view full) ---

4842 else if (is_type)
4843 {
4844 /* If we have a TYPE_DECL, then copy the type, so that we
4845 don't accidentally modify a builtin type. See pushdecl. */
4846 if (decl && TREE_TYPE (decl) != error_mark_node
4847 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4848 {
4849 tree tt = TREE_TYPE (decl);
4725 if (TREE_CODE (align_expr) != INTEGER_CST)
4726 {
4727 error ("requested alignment is not a constant");
4728 *no_add_attrs = true;
4729 }
4730 else if ((i = tree_log2 (align_expr)) == -1)
4731 {
4732 error ("requested alignment is not a power of 2");

--- 7 unchanged lines hidden (view full) ---

4740 else if (is_type)
4741 {
4742 /* If we have a TYPE_DECL, then copy the type, so that we
4743 don't accidentally modify a builtin type. See pushdecl. */
4744 if (decl && TREE_TYPE (decl) != error_mark_node
4745 && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4746 {
4747 tree tt = TREE_TYPE (decl);
4850 *type = build_type_copy (*type);
4748 *type = build_variant_type_copy (*type);
4851 DECL_ORIGINAL_TYPE (decl) = tt;
4852 TYPE_NAME (*type) = decl;
4853 TREE_USED (*type) = TREE_USED (decl);
4854 TREE_TYPE (decl) = *type;
4855 }
4856 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4749 DECL_ORIGINAL_TYPE (decl) = tt;
4750 TYPE_NAME (*type) = decl;
4751 TREE_USED (*type) = TREE_USED (decl);
4752 TREE_TYPE (decl) = *type;
4753 }
4754 else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4857 *type = build_type_copy (*type);
4755 *type = build_variant_type_copy (*type);
4858
4859 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4860 TYPE_USER_ALIGN (*type) = 1;
4861 }
4862 else if (TREE_CODE (decl) != VAR_DECL
4863 && TREE_CODE (decl) != FIELD_DECL)
4864 {
4756
4757 TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4758 TYPE_USER_ALIGN (*type) = 1;
4759 }
4760 else if (TREE_CODE (decl) != VAR_DECL
4761 && TREE_CODE (decl) != FIELD_DECL)
4762 {
4865 error ("%Jalignment may not be specified for '%D'", decl, decl);
4763 error ("alignment may not be specified for %q+D", decl);
4866 *no_add_attrs = true;
4867 }
4868 else
4869 {
4870 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4871 DECL_USER_ALIGN (decl) = 1;
4872 }
4873
4874 return NULL_TREE;
4875}
4876
4877/* Handle a "weak" attribute; arguments as in
4878 struct attribute_spec.handler. */
4879
4880static tree
4764 *no_add_attrs = true;
4765 }
4766 else
4767 {
4768 DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4769 DECL_USER_ALIGN (decl) = 1;
4770 }
4771
4772 return NULL_TREE;
4773}
4774
4775/* Handle a "weak" attribute; arguments as in
4776 struct attribute_spec.handler. */
4777
4778static tree
4881handle_weak_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
4882 tree args ATTRIBUTE_UNUSED,
4883 int flags ATTRIBUTE_UNUSED,
4884 bool *no_add_attrs ATTRIBUTE_UNUSED)
4779handle_weak_attribute (tree *node, tree name,
4780 tree ARG_UNUSED (args),
4781 int ARG_UNUSED (flags),
4782 bool * ARG_UNUSED (no_add_attrs))
4885{
4783{
4886 declare_weak (*node);
4784 if (TREE_CODE (*node) == FUNCTION_DECL
4785 || TREE_CODE (*node) == VAR_DECL)
4786 declare_weak (*node);
4787 else
4788 warning (OPT_Wattributes, "%qE attribute ignored", name);
4789
4887
4888 return NULL_TREE;
4889}
4890
4891/* Handle an "alias" attribute; arguments as in
4892 struct attribute_spec.handler. */
4893
4894static tree
4895handle_alias_attribute (tree *node, tree name, tree args,
4790
4791 return NULL_TREE;
4792}
4793
4794/* Handle an "alias" attribute; arguments as in
4795 struct attribute_spec.handler. */
4796
4797static tree
4798handle_alias_attribute (tree *node, tree name, tree args,
4896 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4799 int ARG_UNUSED (flags), bool *no_add_attrs)
4897{
4898 tree decl = *node;
4899
4900 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4800{
4801 tree decl = *node;
4802
4803 if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4901 || (TREE_CODE (decl) != FUNCTION_DECL && ! DECL_EXTERNAL (decl)))
4804 || (TREE_CODE (decl) != FUNCTION_DECL
4805 && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4806 /* A static variable declaration is always a tentative definition,
4807 but the alias is a non-tentative definition which overrides. */
4808 || (TREE_CODE (decl) != FUNCTION_DECL
4809 && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4902 {
4810 {
4903 error ("%J'%D' defined both normally and as an alias", decl, decl);
4811 error ("%q+D defined both normally and as an alias", decl);
4904 *no_add_attrs = true;
4905 }
4812 *no_add_attrs = true;
4813 }
4906 else if (decl_function_context (decl) == 0)
4814
4815 /* Note that the very first time we process a nested declaration,
4816 decl_function_context will not be set. Indeed, *would* never
4817 be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4818 we do below. After such frobbery, pushdecl would set the context.
4819 In any case, this is never what we want. */
4820 else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4907 {
4908 tree id;
4909
4910 id = TREE_VALUE (args);
4911 if (TREE_CODE (id) != STRING_CST)
4912 {
4821 {
4822 tree id;
4823
4824 id = TREE_VALUE (args);
4825 if (TREE_CODE (id) != STRING_CST)
4826 {
4913 error ("alias arg not a string");
4827 error ("alias argument not a string");
4914 *no_add_attrs = true;
4915 return NULL_TREE;
4916 }
4917 id = get_identifier (TREE_STRING_POINTER (id));
4918 /* This counts as a use of the object pointed to. */
4919 TREE_USED (id) = 1;
4920
4921 if (TREE_CODE (decl) == FUNCTION_DECL)
4922 DECL_INITIAL (decl) = error_mark_node;
4923 else
4828 *no_add_attrs = true;
4829 return NULL_TREE;
4830 }
4831 id = get_identifier (TREE_STRING_POINTER (id));
4832 /* This counts as a use of the object pointed to. */
4833 TREE_USED (id) = 1;
4834
4835 if (TREE_CODE (decl) == FUNCTION_DECL)
4836 DECL_INITIAL (decl) = error_mark_node;
4837 else
4924 DECL_EXTERNAL (decl) = 0;
4838 {
4839 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4840 DECL_EXTERNAL (decl) = 1;
4841 else
4842 DECL_EXTERNAL (decl) = 0;
4843 TREE_STATIC (decl) = 1;
4844 }
4925 }
4926 else
4927 {
4845 }
4846 else
4847 {
4928 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4848 warning (OPT_Wattributes, "%qE attribute ignored", name);
4929 *no_add_attrs = true;
4930 }
4931
4932 return NULL_TREE;
4933}
4934
4849 *no_add_attrs = true;
4850 }
4851
4852 return NULL_TREE;
4853}
4854
4855/* Handle a "weakref" attribute; arguments as in struct
4856 attribute_spec.handler. */
4857
4858static tree
4859handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4860 int flags, bool *no_add_attrs)
4861{
4862 tree attr = NULL_TREE;
4863
4864 /* We must ignore the attribute when it is associated with
4865 local-scoped decls, since attribute alias is ignored and many
4866 such symbols do not even have a DECL_WEAK field. */
4867 if (decl_function_context (*node) || current_function_decl)
4868 {
4869 warning (OPT_Wattributes, "%qE attribute ignored", name);
4870 *no_add_attrs = true;
4871 return NULL_TREE;
4872 }
4873
4874 /* The idea here is that `weakref("name")' mutates into `weakref,
4875 alias("name")', and weakref without arguments, in turn,
4876 implicitly adds weak. */
4877
4878 if (args)
4879 {
4880 attr = tree_cons (get_identifier ("alias"), args, attr);
4881 attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
4882
4883 *no_add_attrs = true;
4884
4885 decl_attributes (node, attr, flags);
4886 }
4887 else
4888 {
4889 if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
4890 error ("%Jweakref attribute must appear before alias attribute",
4891 *node);
4892
4893 /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
4894 and that isn't supported; and because it wants to add it to
4895 the list of weak decls, which isn't helpful. */
4896 DECL_WEAK (*node) = 1;
4897 }
4898
4899 return NULL_TREE;
4900}
4901
4935/* Handle an "visibility" attribute; arguments as in
4936 struct attribute_spec.handler. */
4937
4938static tree
4939handle_visibility_attribute (tree *node, tree name, tree args,
4902/* Handle an "visibility" attribute; arguments as in
4903 struct attribute_spec.handler. */
4904
4905static tree
4906handle_visibility_attribute (tree *node, tree name, tree args,
4940 int flags ATTRIBUTE_UNUSED,
4941 bool *no_add_attrs)
4907 int ARG_UNUSED (flags),
4908 bool *ARG_UNUSED (no_add_attrs))
4942{
4943 tree decl = *node;
4944 tree id = TREE_VALUE (args);
4909{
4910 tree decl = *node;
4911 tree id = TREE_VALUE (args);
4912 enum symbol_visibility vis;
4945
4913
4946 *no_add_attrs = true;
4947
4948 if (decl_function_context (decl) != 0 || ! TREE_PUBLIC (decl))
4914 if (TYPE_P (*node))
4949 {
4915 {
4950 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4916 if (TREE_CODE (*node) == ENUMERAL_TYPE)
4917 /* OK */;
4918 else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4919 {
4920 warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
4921 name);
4922 return NULL_TREE;
4923 }
4924 else if (TYPE_FIELDS (*node))
4925 {
4926 error ("%qE attribute ignored because %qT is already defined",
4927 name, *node);
4928 return NULL_TREE;
4929 }
4930 }
4931 else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4932 {
4933 warning (OPT_Wattributes, "%qE attribute ignored", name);
4951 return NULL_TREE;
4952 }
4953
4954 if (TREE_CODE (id) != STRING_CST)
4955 {
4934 return NULL_TREE;
4935 }
4936
4937 if (TREE_CODE (id) != STRING_CST)
4938 {
4956 error ("visibility arg not a string");
4939 error ("visibility argument not a string");
4957 return NULL_TREE;
4958 }
4959
4940 return NULL_TREE;
4941 }
4942
4943 /* If this is a type, set the visibility on the type decl. */
4944 if (TYPE_P (decl))
4945 {
4946 decl = TYPE_NAME (decl);
4947 if (!decl)
4948 return NULL_TREE;
4949 if (TREE_CODE (decl) == IDENTIFIER_NODE)
4950 {
4951 warning (OPT_Wattributes, "%qE attribute ignored on types",
4952 name);
4953 return NULL_TREE;
4954 }
4955 }
4956
4960 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4957 if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4961 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
4958 vis = VISIBILITY_DEFAULT;
4962 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4959 else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4963 DECL_VISIBILITY (decl) = VISIBILITY_INTERNAL;
4960 vis = VISIBILITY_INTERNAL;
4964 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4961 else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4965 DECL_VISIBILITY (decl) = VISIBILITY_HIDDEN;
4962 vis = VISIBILITY_HIDDEN;
4966 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4963 else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4967 DECL_VISIBILITY (decl) = VISIBILITY_PROTECTED;
4964 vis = VISIBILITY_PROTECTED;
4968 else
4965 else
4969 error ("visibility arg must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4966 {
4967 error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4968 vis = VISIBILITY_DEFAULT;
4969 }
4970
4970
4971 if (DECL_VISIBILITY_SPECIFIED (decl)
4972 && vis != DECL_VISIBILITY (decl)
4973 && lookup_attribute ("visibility", (TYPE_P (*node)
4974 ? TYPE_ATTRIBUTES (*node)
4975 : DECL_ATTRIBUTES (decl))))
4976 error ("%qD redeclared with different visibility", decl);
4977
4978 DECL_VISIBILITY (decl) = vis;
4979 DECL_VISIBILITY_SPECIFIED (decl) = 1;
4980
4981 /* Go ahead and attach the attribute to the node as well. This is needed
4982 so we can determine whether we have VISIBILITY_DEFAULT because the
4983 visibility was not specified, or because it was explicitly overridden
4984 from the containing scope. */
4985
4971 return NULL_TREE;
4972}
4973
4986 return NULL_TREE;
4987}
4988
4989/* Determine the ELF symbol visibility for DECL, which is either a
4990 variable or a function. It is an error to use this function if a
4991 definition of DECL is not available in this translation unit.
4992 Returns true if the final visibility has been determined by this
4993 function; false if the caller is free to make additional
4994 modifications. */
4995
4996bool
4997c_determine_visibility (tree decl)
4998{
4999 gcc_assert (TREE_CODE (decl) == VAR_DECL
5000 || TREE_CODE (decl) == FUNCTION_DECL);
5001
5002 /* If the user explicitly specified the visibility with an
5003 attribute, honor that. DECL_VISIBILITY will have been set during
5004 the processing of the attribute. We check for an explicit
5005 attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5006 to distinguish the use of an attribute from the use of a "#pragma
5007 GCC visibility push(...)"; in the latter case we still want other
5008 considerations to be able to overrule the #pragma. */
5009 if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5010 return true;
5011
5012 /* Anything that is exported must have default visibility. */
5013 if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5014 && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5015 {
5016 DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5017 DECL_VISIBILITY_SPECIFIED (decl) = 1;
5018 return true;
5019 }
5020
5021 /* Set default visibility to whatever the user supplied with
5022 visibility_specified depending on #pragma GCC visibility. */
5023 if (!DECL_VISIBILITY_SPECIFIED (decl))
5024 {
5025 DECL_VISIBILITY (decl) = default_visibility;
5026 DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5027 }
5028 return false;
5029}
5030
4974/* Handle an "tls_model" attribute; arguments as in
4975 struct attribute_spec.handler. */
4976
4977static tree
4978handle_tls_model_attribute (tree *node, tree name, tree args,
5031/* Handle an "tls_model" attribute; arguments as in
5032 struct attribute_spec.handler. */
5033
5034static tree
5035handle_tls_model_attribute (tree *node, tree name, tree args,
4979 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5036 int ARG_UNUSED (flags), bool *no_add_attrs)
4980{
5037{
5038 tree id;
4981 tree decl = *node;
5039 tree decl = *node;
5040 enum tls_model kind;
4982
5041
4983 if (! DECL_THREAD_LOCAL (decl))
5042 *no_add_attrs = true;
5043
5044 if (!DECL_THREAD_LOCAL_P (decl))
4984 {
5045 {
4985 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
4986 *no_add_attrs = true;
5046 warning (OPT_Wattributes, "%qE attribute ignored", name);
5047 return NULL_TREE;
4987 }
5048 }
4988 else
4989 {
4990 tree id;
4991
5049
4992 id = TREE_VALUE (args);
4993 if (TREE_CODE (id) != STRING_CST)
4994 {
4995 error ("tls_model arg not a string");
4996 *no_add_attrs = true;
4997 return NULL_TREE;
4998 }
4999 if (strcmp (TREE_STRING_POINTER (id), "local-exec")
5000 && strcmp (TREE_STRING_POINTER (id), "initial-exec")
5001 && strcmp (TREE_STRING_POINTER (id), "local-dynamic")
5002 && strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5003 {
5004 error ("tls_model arg must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5005 *no_add_attrs = true;
5006 return NULL_TREE;
5007 }
5050 kind = DECL_TLS_MODEL (decl);
5051 id = TREE_VALUE (args);
5052 if (TREE_CODE (id) != STRING_CST)
5053 {
5054 error ("tls_model argument not a string");
5055 return NULL_TREE;
5008 }
5009
5056 }
5057
5058 if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5059 kind = TLS_MODEL_LOCAL_EXEC;
5060 else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5061 kind = TLS_MODEL_INITIAL_EXEC;
5062 else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5063 kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5064 else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5065 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5066 else
5067 error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5068
5069 DECL_TLS_MODEL (decl) = kind;
5010 return NULL_TREE;
5011}
5012
5013/* Handle a "no_instrument_function" attribute; arguments as in
5014 struct attribute_spec.handler. */
5015
5016static tree
5017handle_no_instrument_function_attribute (tree *node, tree name,
5070 return NULL_TREE;
5071}
5072
5073/* Handle a "no_instrument_function" attribute; arguments as in
5074 struct attribute_spec.handler. */
5075
5076static tree
5077handle_no_instrument_function_attribute (tree *node, tree name,
5018 tree args ATTRIBUTE_UNUSED,
5019 int flags ATTRIBUTE_UNUSED,
5078 tree ARG_UNUSED (args),
5079 int ARG_UNUSED (flags),
5020 bool *no_add_attrs)
5021{
5022 tree decl = *node;
5023
5024 if (TREE_CODE (decl) != FUNCTION_DECL)
5025 {
5080 bool *no_add_attrs)
5081{
5082 tree decl = *node;
5083
5084 if (TREE_CODE (decl) != FUNCTION_DECL)
5085 {
5026 error ("%J'%E' attribute applies only to functions", decl, name);
5086 error ("%J%qE attribute applies only to functions", decl, name);
5027 *no_add_attrs = true;
5028 }
5029 else if (DECL_INITIAL (decl))
5030 {
5087 *no_add_attrs = true;
5088 }
5089 else if (DECL_INITIAL (decl))
5090 {
5031 error ("%Jcan't set '%E' attribute after definition", decl, name);
5091 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5032 *no_add_attrs = true;
5033 }
5034 else
5035 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5036
5037 return NULL_TREE;
5038}
5039
5040/* Handle a "malloc" attribute; arguments as in
5041 struct attribute_spec.handler. */
5042
5043static tree
5092 *no_add_attrs = true;
5093 }
5094 else
5095 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5096
5097 return NULL_TREE;
5098}
5099
5100/* Handle a "malloc" attribute; arguments as in
5101 struct attribute_spec.handler. */
5102
5103static tree
5044handle_malloc_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5045 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5104handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5105 int ARG_UNUSED (flags), bool *no_add_attrs)
5046{
5106{
5047 if (TREE_CODE (*node) == FUNCTION_DECL)
5107 if (TREE_CODE (*node) == FUNCTION_DECL
5108 && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5048 DECL_IS_MALLOC (*node) = 1;
5109 DECL_IS_MALLOC (*node) = 1;
5049 /* ??? TODO: Support types. */
5050 else
5051 {
5110 else
5111 {
5052 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5112 warning (OPT_Wattributes, "%qE attribute ignored", name);
5053 *no_add_attrs = true;
5054 }
5055
5056 return NULL_TREE;
5057}
5058
5113 *no_add_attrs = true;
5114 }
5115
5116 return NULL_TREE;
5117}
5118
5119/* Handle a "returns_twice" attribute; arguments as in
5120 struct attribute_spec.handler. */
5121
5122static tree
5123handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5124 int ARG_UNUSED (flags), bool *no_add_attrs)
5125{
5126 if (TREE_CODE (*node) == FUNCTION_DECL)
5127 DECL_IS_RETURNS_TWICE (*node) = 1;
5128 else
5129 {
5130 warning (OPT_Wattributes, "%qE attribute ignored", name);
5131 *no_add_attrs = true;
5132 }
5133
5134 return NULL_TREE;
5135}
5136
5059/* Handle a "no_limit_stack" attribute; arguments as in
5060 struct attribute_spec.handler. */
5061
5062static tree
5063handle_no_limit_stack_attribute (tree *node, tree name,
5137/* Handle a "no_limit_stack" attribute; arguments as in
5138 struct attribute_spec.handler. */
5139
5140static tree
5141handle_no_limit_stack_attribute (tree *node, tree name,
5064 tree args ATTRIBUTE_UNUSED,
5065 int flags ATTRIBUTE_UNUSED,
5142 tree ARG_UNUSED (args),
5143 int ARG_UNUSED (flags),
5066 bool *no_add_attrs)
5067{
5068 tree decl = *node;
5069
5070 if (TREE_CODE (decl) != FUNCTION_DECL)
5071 {
5144 bool *no_add_attrs)
5145{
5146 tree decl = *node;
5147
5148 if (TREE_CODE (decl) != FUNCTION_DECL)
5149 {
5072 error ("%J'%E' attribute applies only to functions", decl, name);
5150 error ("%J%qE attribute applies only to functions", decl, name);
5073 *no_add_attrs = true;
5074 }
5075 else if (DECL_INITIAL (decl))
5076 {
5151 *no_add_attrs = true;
5152 }
5153 else if (DECL_INITIAL (decl))
5154 {
5077 error ("%Jcan't set '%E' attribute after definition", decl, name);
5155 error ("%Jcan%'t set %qE attribute after definition", decl, name);
5078 *no_add_attrs = true;
5079 }
5080 else
5081 DECL_NO_LIMIT_STACK (decl) = 1;
5082
5083 return NULL_TREE;
5084}
5085
5086/* Handle a "pure" attribute; arguments as in
5087 struct attribute_spec.handler. */
5088
5089static tree
5156 *no_add_attrs = true;
5157 }
5158 else
5159 DECL_NO_LIMIT_STACK (decl) = 1;
5160
5161 return NULL_TREE;
5162}
5163
5164/* Handle a "pure" attribute; arguments as in
5165 struct attribute_spec.handler. */
5166
5167static tree
5090handle_pure_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5091 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5168handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5169 int ARG_UNUSED (flags), bool *no_add_attrs)
5092{
5093 if (TREE_CODE (*node) == FUNCTION_DECL)
5094 DECL_IS_PURE (*node) = 1;
5095 /* ??? TODO: Support types. */
5096 else
5097 {
5170{
5171 if (TREE_CODE (*node) == FUNCTION_DECL)
5172 DECL_IS_PURE (*node) = 1;
5173 /* ??? TODO: Support types. */
5174 else
5175 {
5098 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5176 warning (OPT_Wattributes, "%qE attribute ignored", name);
5099 *no_add_attrs = true;
5100 }
5101
5102 return NULL_TREE;
5103}
5104
5177 *no_add_attrs = true;
5178 }
5179
5180 return NULL_TREE;
5181}
5182
5183/* Handle a "no vops" attribute; arguments as in
5184 struct attribute_spec.handler. */
5185
5186static tree
5187handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5188 tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5189 bool *ARG_UNUSED (no_add_attrs))
5190{
5191 gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5192 DECL_IS_NOVOPS (*node) = 1;
5193 return NULL_TREE;
5194}
5195
5105/* Handle a "deprecated" attribute; arguments as in
5106 struct attribute_spec.handler. */
5107
5108static tree
5109handle_deprecated_attribute (tree *node, tree name,
5196/* Handle a "deprecated" attribute; arguments as in
5197 struct attribute_spec.handler. */
5198
5199static tree
5200handle_deprecated_attribute (tree *node, tree name,
5110 tree args ATTRIBUTE_UNUSED, int flags,
5201 tree ARG_UNUSED (args), int flags,
5111 bool *no_add_attrs)
5112{
5113 tree type = NULL_TREE;
5114 int warn = 0;
5202 bool *no_add_attrs)
5203{
5204 tree type = NULL_TREE;
5205 int warn = 0;
5115 const char *what = NULL;
5206 tree what = NULL_TREE;
5116
5117 if (DECL_P (*node))
5118 {
5119 tree decl = *node;
5120 type = TREE_TYPE (decl);
5121
5122 if (TREE_CODE (decl) == TYPE_DECL
5123 || TREE_CODE (decl) == PARM_DECL
5124 || TREE_CODE (decl) == VAR_DECL
5125 || TREE_CODE (decl) == FUNCTION_DECL
5126 || TREE_CODE (decl) == FIELD_DECL)
5127 TREE_DEPRECATED (decl) = 1;
5128 else
5129 warn = 1;
5130 }
5131 else if (TYPE_P (*node))
5132 {
5133 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5207
5208 if (DECL_P (*node))
5209 {
5210 tree decl = *node;
5211 type = TREE_TYPE (decl);
5212
5213 if (TREE_CODE (decl) == TYPE_DECL
5214 || TREE_CODE (decl) == PARM_DECL
5215 || TREE_CODE (decl) == VAR_DECL
5216 || TREE_CODE (decl) == FUNCTION_DECL
5217 || TREE_CODE (decl) == FIELD_DECL)
5218 TREE_DEPRECATED (decl) = 1;
5219 else
5220 warn = 1;
5221 }
5222 else if (TYPE_P (*node))
5223 {
5224 if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5134 *node = build_type_copy (*node);
5225 *node = build_variant_type_copy (*node);
5135 TREE_DEPRECATED (*node) = 1;
5136 type = *node;
5137 }
5138 else
5139 warn = 1;
5140
5141 if (warn)
5142 {
5143 *no_add_attrs = true;
5144 if (type && TYPE_NAME (type))
5145 {
5146 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5226 TREE_DEPRECATED (*node) = 1;
5227 type = *node;
5228 }
5229 else
5230 warn = 1;
5231
5232 if (warn)
5233 {
5234 *no_add_attrs = true;
5235 if (type && TYPE_NAME (type))
5236 {
5237 if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5147 what = IDENTIFIER_POINTER (TYPE_NAME (*node));
5238 what = TYPE_NAME (*node);
5148 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5149 && DECL_NAME (TYPE_NAME (type)))
5239 else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5240 && DECL_NAME (TYPE_NAME (type)))
5150 what = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (type)));
5241 what = DECL_NAME (TYPE_NAME (type));
5151 }
5152 if (what)
5242 }
5243 if (what)
5153 warning ("`%s' attribute ignored for `%s'",
5154 IDENTIFIER_POINTER (name), what);
5244 warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5155 else
5245 else
5156 warning ("`%s' attribute ignored",
5157 IDENTIFIER_POINTER (name));
5246 warning (OPT_Wattributes, "%qE attribute ignored", name);
5158 }
5159
5160 return NULL_TREE;
5161}
5162
5247 }
5248
5249 return NULL_TREE;
5250}
5251
5163/* Keep a list of vector type nodes we created in handle_vector_size_attribute,
5164 to prevent us from duplicating type nodes unnecessarily.
5165 The normal mechanism to prevent duplicates is to use type_hash_canon, but
5166 since we want to distinguish types that are essentially identical (except
5167 for their debug representation), we use a local list here. */
5168static GTY(()) tree vector_type_node_list = 0;
5169
5170/* Handle a "vector_size" attribute; arguments as in
5171 struct attribute_spec.handler. */
5172
5173static tree
5174handle_vector_size_attribute (tree *node, tree name, tree args,
5252/* Handle a "vector_size" attribute; arguments as in
5253 struct attribute_spec.handler. */
5254
5255static tree
5256handle_vector_size_attribute (tree *node, tree name, tree args,
5175 int flags ATTRIBUTE_UNUSED,
5257 int ARG_UNUSED (flags),
5176 bool *no_add_attrs)
5177{
5178 unsigned HOST_WIDE_INT vecsize, nunits;
5258 bool *no_add_attrs)
5259{
5260 unsigned HOST_WIDE_INT vecsize, nunits;
5179 enum machine_mode mode, orig_mode, new_mode;
5180 tree type = *node, new_type = NULL_TREE;
5181 tree type_list_node;
5261 enum machine_mode orig_mode;
5262 tree type = *node, new_type, size;
5182
5183 *no_add_attrs = true;
5184
5263
5264 *no_add_attrs = true;
5265
5185 if (! host_integerp (TREE_VALUE (args), 1))
5266 size = TREE_VALUE (args);
5267
5268 if (!host_integerp (size, 1))
5186 {
5269 {
5187 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5270 warning (OPT_Wattributes, "%qE attribute ignored", name);
5188 return NULL_TREE;
5189 }
5190
5191 /* Get the vector size (in bytes). */
5271 return NULL_TREE;
5272 }
5273
5274 /* Get the vector size (in bytes). */
5192 vecsize = tree_low_cst (TREE_VALUE (args), 1);
5275 vecsize = tree_low_cst (size, 1);
5193
5194 /* We need to provide for vector pointers, vector arrays, and
5195 functions returning vectors. For example:
5196
5197 __attribute__((vector_size(16))) short *foo;
5198
5199 In this case, the mode is SI, but the type being modified is
5200 HI, so we need to look further. */
5201
5202 while (POINTER_TYPE_P (type)
5203 || TREE_CODE (type) == FUNCTION_TYPE
5204 || TREE_CODE (type) == METHOD_TYPE
5205 || TREE_CODE (type) == ARRAY_TYPE)
5206 type = TREE_TYPE (type);
5207
5208 /* Get the mode of the type being modified. */
5209 orig_mode = TYPE_MODE (type);
5210
5211 if (TREE_CODE (type) == RECORD_TYPE
5276
5277 /* We need to provide for vector pointers, vector arrays, and
5278 functions returning vectors. For example:
5279
5280 __attribute__((vector_size(16))) short *foo;
5281
5282 In this case, the mode is SI, but the type being modified is
5283 HI, so we need to look further. */
5284
5285 while (POINTER_TYPE_P (type)
5286 || TREE_CODE (type) == FUNCTION_TYPE
5287 || TREE_CODE (type) == METHOD_TYPE
5288 || TREE_CODE (type) == ARRAY_TYPE)
5289 type = TREE_TYPE (type);
5290
5291 /* Get the mode of the type being modified. */
5292 orig_mode = TYPE_MODE (type);
5293
5294 if (TREE_CODE (type) == RECORD_TYPE
5212 || (GET_MODE_CLASS (orig_mode) != MODE_FLOAT
5295 || TREE_CODE (type) == UNION_TYPE
5296 || TREE_CODE (type) == VECTOR_TYPE
5297 || (!SCALAR_FLOAT_MODE_P (orig_mode)
5213 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5298 && GET_MODE_CLASS (orig_mode) != MODE_INT)
5214 || ! host_integerp (TYPE_SIZE_UNIT (type), 1))
5299 || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5215 {
5300 {
5216 error ("invalid vector type for attribute `%s'",
5217 IDENTIFIER_POINTER (name));
5301 error ("invalid vector type for attribute %qE", name);
5218 return NULL_TREE;
5219 }
5220
5302 return NULL_TREE;
5303 }
5304
5221 /* Calculate how many units fit in the vector. */
5222 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5223
5224 /* Find a suitably sized vector. */
5225 new_mode = VOIDmode;
5226 for (mode = GET_CLASS_NARROWEST_MODE (GET_MODE_CLASS (orig_mode) == MODE_INT
5227 ? MODE_VECTOR_INT
5228 : MODE_VECTOR_FLOAT);
5229 mode != VOIDmode;
5230 mode = GET_MODE_WIDER_MODE (mode))
5231 if (vecsize == GET_MODE_SIZE (mode)
5232 && nunits == (unsigned HOST_WIDE_INT) GET_MODE_NUNITS (mode))
5233 {
5234 new_mode = mode;
5235 break;
5236 }
5237
5238 if (new_mode == VOIDmode)
5305 if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5239 {
5306 {
5240 error ("no vector mode with the size and type specified could be found");
5241 return NULL_TREE;
5307 error ("vector size not an integral multiple of component size");
5308 return NULL;
5242 }
5243
5309 }
5310
5244 for (type_list_node = vector_type_node_list; type_list_node;
5245 type_list_node = TREE_CHAIN (type_list_node))
5311 if (vecsize == 0)
5246 {
5312 {
5247 tree other_type = TREE_VALUE (type_list_node);
5248 tree record = TYPE_DEBUG_REPRESENTATION_TYPE (other_type);
5249 tree fields = TYPE_FIELDS (record);
5250 tree field_type = TREE_TYPE (fields);
5251 tree array_type = TREE_TYPE (field_type);
5252 if (TREE_CODE (fields) != FIELD_DECL
5253 || TREE_CODE (field_type) != ARRAY_TYPE)
5254 abort ();
5255
5256 if (TYPE_MODE (other_type) == mode && type == array_type)
5257 {
5258 new_type = other_type;
5259 break;
5260 }
5313 error ("zero vector size");
5314 return NULL;
5261 }
5262
5315 }
5316
5263 if (new_type == NULL_TREE)
5317 /* Calculate how many units fit in the vector. */
5318 nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5319 if (nunits & (nunits - 1))
5264 {
5320 {
5265 tree index, array, rt, list_node;
5266
5267 new_type = (*lang_hooks.types.type_for_mode) (new_mode,
5268 TREE_UNSIGNED (type));
5269
5270 if (!new_type)
5271 {
5272 error ("no vector mode with the size and type specified could be found");
5273 return NULL_TREE;
5274 }
5275
5276 new_type = build_type_copy (new_type);
5277
5278 /* If this is a vector, make sure we either have hardware
5279 support, or we can emulate it. */
5280 if ((GET_MODE_CLASS (mode) == MODE_VECTOR_INT
5281 || GET_MODE_CLASS (mode) == MODE_VECTOR_FLOAT)
5282 && !vector_mode_valid_p (mode))
5283 {
5284 error ("unable to emulate '%s'", GET_MODE_NAME (mode));
5285 return NULL_TREE;
5286 }
5287
5288 /* Set the debug information here, because this is the only
5289 place where we know the underlying type for a vector made
5290 with vector_size. For debugging purposes we pretend a vector
5291 is an array within a structure. */
5292 index = build_int_2 (TYPE_VECTOR_SUBPARTS (new_type) - 1, 0);
5293 array = build_array_type (type, build_index_type (index));
5294 rt = make_node (RECORD_TYPE);
5295
5296 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
5297 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
5298 layout_type (rt);
5299 TYPE_DEBUG_REPRESENTATION_TYPE (new_type) = rt;
5300
5301 list_node = build_tree_list (NULL, new_type);
5302 TREE_CHAIN (list_node) = vector_type_node_list;
5303 vector_type_node_list = list_node;
5321 error ("number of components of the vector not a power of two");
5322 return NULL_TREE;
5304 }
5305
5323 }
5324
5325 new_type = build_vector_type (type, nunits);
5326
5306 /* Build back pointers if needed. */
5307 *node = reconstruct_complex_type (*node, new_type);
5308
5309 return NULL_TREE;
5310}
5311
5312/* Handle the "nonnull" attribute. */
5313static tree
5327 /* Build back pointers if needed. */
5328 *node = reconstruct_complex_type (*node, new_type);
5329
5330 return NULL_TREE;
5331}
5332
5333/* Handle the "nonnull" attribute. */
5334static tree
5314handle_nonnull_attribute (tree *node, tree name ATTRIBUTE_UNUSED,
5315 tree args, int flags ATTRIBUTE_UNUSED,
5335handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5336 tree args, int ARG_UNUSED (flags),
5316 bool *no_add_attrs)
5317{
5318 tree type = *node;
5319 unsigned HOST_WIDE_INT attr_arg_num;
5320
5321 /* If no arguments are specified, all pointer arguments should be
5322 non-null. Verify a full prototype is given so that the arguments
5323 will have the correct types when we actually check them later. */
5337 bool *no_add_attrs)
5338{
5339 tree type = *node;
5340 unsigned HOST_WIDE_INT attr_arg_num;
5341
5342 /* If no arguments are specified, all pointer arguments should be
5343 non-null. Verify a full prototype is given so that the arguments
5344 will have the correct types when we actually check them later. */
5324 if (! args)
5345 if (!args)
5325 {
5346 {
5326 if (! TYPE_ARG_TYPES (type))
5347 if (!TYPE_ARG_TYPES (type))
5327 {
5328 error ("nonnull attribute without arguments on a non-prototype");
5348 {
5349 error ("nonnull attribute without arguments on a non-prototype");
5329 *no_add_attrs = true;
5350 *no_add_attrs = true;
5330 }
5331 return NULL_TREE;
5332 }
5333
5334 /* Argument list specified. Verify that each argument number references
5335 a pointer argument. */
5336 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5337 {
5338 tree argument;
5351 }
5352 return NULL_TREE;
5353 }
5354
5355 /* Argument list specified. Verify that each argument number references
5356 a pointer argument. */
5357 for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5358 {
5359 tree argument;
5339 unsigned HOST_WIDE_INT arg_num, ck_num;
5360 unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5340
5361
5341 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5362 if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5342 {
5363 {
5343 error ("nonnull argument has invalid operand number (arg %lu)",
5364 error ("nonnull argument has invalid operand number (argument %lu)",
5344 (unsigned long) attr_arg_num);
5345 *no_add_attrs = true;
5346 return NULL_TREE;
5347 }
5348
5349 argument = TYPE_ARG_TYPES (type);
5350 if (argument)
5351 {
5352 for (ck_num = 1; ; ck_num++)
5353 {
5365 (unsigned long) attr_arg_num);
5366 *no_add_attrs = true;
5367 return NULL_TREE;
5368 }
5369
5370 argument = TYPE_ARG_TYPES (type);
5371 if (argument)
5372 {
5373 for (ck_num = 1; ; ck_num++)
5374 {
5354 if (! argument || ck_num == arg_num)
5375 if (!argument || ck_num == arg_num)
5355 break;
5356 argument = TREE_CHAIN (argument);
5357 }
5358
5376 break;
5377 argument = TREE_CHAIN (argument);
5378 }
5379
5359 if (! argument
5380 if (!argument
5360 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5361 {
5381 || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5382 {
5362 error ("nonnull argument with out-of-range operand number (arg %lu, operand %lu)",
5383 error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5363 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5364 *no_add_attrs = true;
5365 return NULL_TREE;
5366 }
5367
5384 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5385 *no_add_attrs = true;
5386 return NULL_TREE;
5387 }
5388
5368 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5389 if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5369 {
5390 {
5370 error ("nonnull argument references non-pointer operand (arg %lu, operand %lu)",
5391 error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5371 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5372 *no_add_attrs = true;
5373 return NULL_TREE;
5374 }
5375 }
5376 }
5377
5378 return NULL_TREE;

--- 7 unchanged lines hidden (view full) ---

5386{
5387 tree a, args, param;
5388 int param_num;
5389
5390 for (a = attrs; a; a = TREE_CHAIN (a))
5391 {
5392 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5393 {
5392 (unsigned long) attr_arg_num, (unsigned long) arg_num);
5393 *no_add_attrs = true;
5394 return NULL_TREE;
5395 }
5396 }
5397 }
5398
5399 return NULL_TREE;

--- 7 unchanged lines hidden (view full) ---

5407{
5408 tree a, args, param;
5409 int param_num;
5410
5411 for (a = attrs; a; a = TREE_CHAIN (a))
5412 {
5413 if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5414 {
5394 args = TREE_VALUE (a);
5415 args = TREE_VALUE (a);
5395
5416
5396 /* Walk the argument list. If we encounter an argument number we
5397 should check for non-null, do it. If the attribute has no args,
5398 then every pointer argument is checked (in which case the check
5417 /* Walk the argument list. If we encounter an argument number we
5418 should check for non-null, do it. If the attribute has no args,
5419 then every pointer argument is checked (in which case the check
5399 for pointer type is done in check_nonnull_arg). */
5420 for pointer type is done in check_nonnull_arg). */
5400 for (param = params, param_num = 1; ;
5401 param_num++, param = TREE_CHAIN (param))
5402 {
5403 if (! param)
5421 for (param = params, param_num = 1; ;
5422 param_num++, param = TREE_CHAIN (param))
5423 {
5424 if (!param)
5404 break;
5425 break;
5405 if (! args || nonnull_check_p (args, param_num))
5426 if (!args || nonnull_check_p (args, param_num))
5406 check_function_arguments_recurse (check_nonnull_arg, NULL,
5407 TREE_VALUE (param),
5408 param_num);
5427 check_function_arguments_recurse (check_nonnull_arg, NULL,
5428 TREE_VALUE (param),
5429 param_num);
5409 }
5430 }
5410 }
5411 }
5412}
5413
5431 }
5432 }
5433}
5434
5435/* Check that the Nth argument of a function call (counting backwards
5436 from the end) is a (pointer)0. */
5437
5438static void
5439check_function_sentinel (tree attrs, tree params, tree typelist)
5440{
5441 tree attr = lookup_attribute ("sentinel", attrs);
5442
5443 if (attr)
5444 {
5445 /* Skip over the named arguments. */
5446 while (typelist && params)
5447 {
5448 typelist = TREE_CHAIN (typelist);
5449 params = TREE_CHAIN (params);
5450 }
5451
5452 if (typelist || !params)
5453 warning (OPT_Wformat,
5454 "not enough variable arguments to fit a sentinel");
5455 else
5456 {
5457 tree sentinel, end;
5458 unsigned pos = 0;
5459
5460 if (TREE_VALUE (attr))
5461 {
5462 tree p = TREE_VALUE (TREE_VALUE (attr));
5463 pos = TREE_INT_CST_LOW (p);
5464 }
5465
5466 sentinel = end = params;
5467
5468 /* Advance `end' ahead of `sentinel' by `pos' positions. */
5469 while (pos > 0 && TREE_CHAIN (end))
5470 {
5471 pos--;
5472 end = TREE_CHAIN (end);
5473 }
5474 if (pos > 0)
5475 {
5476 warning (OPT_Wformat,
5477 "not enough variable arguments to fit a sentinel");
5478 return;
5479 }
5480
5481 /* Now advance both until we find the last parameter. */
5482 while (TREE_CHAIN (end))
5483 {
5484 end = TREE_CHAIN (end);
5485 sentinel = TREE_CHAIN (sentinel);
5486 }
5487
5488 /* Validate the sentinel. */
5489 if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5490 || !integer_zerop (TREE_VALUE (sentinel)))
5491 /* Although __null (in C++) is only an integer we allow it
5492 nevertheless, as we are guaranteed that it's exactly
5493 as wide as a pointer, and we don't want to force
5494 users to cast the NULL they have written there.
5495 We warn with -Wstrict-null-sentinel, though. */
5496 && (warn_strict_null_sentinel
5497 || null_node != TREE_VALUE (sentinel)))
5498 warning (OPT_Wformat, "missing sentinel in function call");
5499 }
5500 }
5501}
5502
5414/* Helper for check_function_nonnull; given a list of operands which
5415 must be non-null in ARGS, determine if operand PARAM_NUM should be
5416 checked. */
5417
5418static bool
5419nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5420{
5503/* Helper for check_function_nonnull; given a list of operands which
5504 must be non-null in ARGS, determine if operand PARAM_NUM should be
5505 checked. */
5506
5507static bool
5508nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5509{
5421 unsigned HOST_WIDE_INT arg_num;
5510 unsigned HOST_WIDE_INT arg_num = 0;
5422
5423 for (; args; args = TREE_CHAIN (args))
5424 {
5511
5512 for (; args; args = TREE_CHAIN (args))
5513 {
5425 if (! get_nonnull_operand (TREE_VALUE (args), &arg_num))
5426 abort ();
5514 bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5427
5515
5516 gcc_assert (found);
5517
5428 if (arg_num == param_num)
5429 return true;
5430 }
5431 return false;
5432}
5433
5434/* Check that the function argument PARAM (which is operand number
5435 PARAM_NUM) is non-null. This is called by check_function_nonnull
5436 via check_function_arguments_recurse. */
5437
5438static void
5518 if (arg_num == param_num)
5519 return true;
5520 }
5521 return false;
5522}
5523
5524/* Check that the function argument PARAM (which is operand number
5525 PARAM_NUM) is non-null. This is called by check_function_nonnull
5526 via check_function_arguments_recurse. */
5527
5528static void
5439check_nonnull_arg (void *ctx ATTRIBUTE_UNUSED, tree param,
5529check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5440 unsigned HOST_WIDE_INT param_num)
5441{
5442 /* Just skip checking the argument if it's not a pointer. This can
5443 happen if the "nonnull" attribute was given without an operand
5444 list (which means to check every pointer argument). */
5445
5446 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5447 return;
5448
5449 if (integer_zerop (param))
5530 unsigned HOST_WIDE_INT param_num)
5531{
5532 /* Just skip checking the argument if it's not a pointer. This can
5533 happen if the "nonnull" attribute was given without an operand
5534 list (which means to check every pointer argument). */
5535
5536 if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5537 return;
5538
5539 if (integer_zerop (param))
5450 warning ("null argument where non-null required (arg %lu)",
5451 (unsigned long) param_num);
5540 warning (OPT_Wnonnull, "null argument where non-null required "
5541 "(argument %lu)", (unsigned long) param_num);
5452}
5453
5454/* Helper for nonnull attribute handling; fetch the operand number
5455 from the attribute argument list. */
5456
5457static bool
5458get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5459{
5542}
5543
5544/* Helper for nonnull attribute handling; fetch the operand number
5545 from the attribute argument list. */
5546
5547static bool
5548get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5549{
5460 /* Strip any conversions from the arg number and verify they
5461 are constants. */
5462 while (TREE_CODE (arg_num_expr) == NOP_EXPR
5463 || TREE_CODE (arg_num_expr) == CONVERT_EXPR
5464 || TREE_CODE (arg_num_expr) == NON_LVALUE_EXPR)
5465 arg_num_expr = TREE_OPERAND (arg_num_expr, 0);
5466
5550 /* Verify the arg number is a constant. */
5467 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5468 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5469 return false;
5470
5471 *valp = TREE_INT_CST_LOW (arg_num_expr);
5472 return true;
5473}
5474
5475/* Handle a "nothrow" attribute; arguments as in
5476 struct attribute_spec.handler. */
5477
5478static tree
5551 if (TREE_CODE (arg_num_expr) != INTEGER_CST
5552 || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5553 return false;
5554
5555 *valp = TREE_INT_CST_LOW (arg_num_expr);
5556 return true;
5557}
5558
5559/* Handle a "nothrow" attribute; arguments as in
5560 struct attribute_spec.handler. */
5561
5562static tree
5479handle_nothrow_attribute (tree *node, tree name, tree args ATTRIBUTE_UNUSED,
5480 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5563handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5564 int ARG_UNUSED (flags), bool *no_add_attrs)
5481{
5482 if (TREE_CODE (*node) == FUNCTION_DECL)
5483 TREE_NOTHROW (*node) = 1;
5484 /* ??? TODO: Support types. */
5485 else
5486 {
5565{
5566 if (TREE_CODE (*node) == FUNCTION_DECL)
5567 TREE_NOTHROW (*node) = 1;
5568 /* ??? TODO: Support types. */
5569 else
5570 {
5487 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5571 warning (OPT_Wattributes, "%qE attribute ignored", name);
5488 *no_add_attrs = true;
5489 }
5490
5491 return NULL_TREE;
5492}
5493
5494/* Handle a "cleanup" attribute; arguments as in
5495 struct attribute_spec.handler. */
5496
5497static tree
5498handle_cleanup_attribute (tree *node, tree name, tree args,
5572 *no_add_attrs = true;
5573 }
5574
5575 return NULL_TREE;
5576}
5577
5578/* Handle a "cleanup" attribute; arguments as in
5579 struct attribute_spec.handler. */
5580
5581static tree
5582handle_cleanup_attribute (tree *node, tree name, tree args,
5499 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5583 int ARG_UNUSED (flags), bool *no_add_attrs)
5500{
5501 tree decl = *node;
5502 tree cleanup_id, cleanup_decl;
5503
5504 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5505 for global destructors in C++. This requires infrastructure that
5506 we don't have generically at the moment. It's also not a feature
5507 we'd be missing too much, since we do have attribute constructor. */
5508 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5509 {
5584{
5585 tree decl = *node;
5586 tree cleanup_id, cleanup_decl;
5587
5588 /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5589 for global destructors in C++. This requires infrastructure that
5590 we don't have generically at the moment. It's also not a feature
5591 we'd be missing too much, since we do have attribute constructor. */
5592 if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5593 {
5510 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5594 warning (OPT_Wattributes, "%qE attribute ignored", name);
5511 *no_add_attrs = true;
5512 return NULL_TREE;
5513 }
5514
5515 /* Verify that the argument is a function in scope. */
5516 /* ??? We could support pointers to functions here as well, if
5517 that was considered desirable. */
5518 cleanup_id = TREE_VALUE (args);
5519 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5520 {
5595 *no_add_attrs = true;
5596 return NULL_TREE;
5597 }
5598
5599 /* Verify that the argument is a function in scope. */
5600 /* ??? We could support pointers to functions here as well, if
5601 that was considered desirable. */
5602 cleanup_id = TREE_VALUE (args);
5603 if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5604 {
5521 error ("cleanup arg not an identifier");
5605 error ("cleanup argument not an identifier");
5522 *no_add_attrs = true;
5523 return NULL_TREE;
5524 }
5525 cleanup_decl = lookup_name (cleanup_id);
5526 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5527 {
5606 *no_add_attrs = true;
5607 return NULL_TREE;
5608 }
5609 cleanup_decl = lookup_name (cleanup_id);
5610 if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5611 {
5528 error ("cleanup arg not a function");
5612 error ("cleanup argument not a function");
5529 *no_add_attrs = true;
5530 return NULL_TREE;
5531 }
5532
5533 /* That the function has proper type is checked with the
5534 eventual call to build_function_call. */
5535
5536 return NULL_TREE;
5537}
5538
5539/* Handle a "warn_unused_result" attribute. No special handling. */
5540
5541static tree
5542handle_warn_unused_result_attribute (tree *node, tree name,
5613 *no_add_attrs = true;
5614 return NULL_TREE;
5615 }
5616
5617 /* That the function has proper type is checked with the
5618 eventual call to build_function_call. */
5619
5620 return NULL_TREE;
5621}
5622
5623/* Handle a "warn_unused_result" attribute. No special handling. */
5624
5625static tree
5626handle_warn_unused_result_attribute (tree *node, tree name,
5543 tree args ATTRIBUTE_UNUSED,
5544 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
5627 tree ARG_UNUSED (args),
5628 int ARG_UNUSED (flags), bool *no_add_attrs)
5545{
5546 /* Ignore the attribute for functions not returning any value. */
5547 if (VOID_TYPE_P (TREE_TYPE (*node)))
5548 {
5629{
5630 /* Ignore the attribute for functions not returning any value. */
5631 if (VOID_TYPE_P (TREE_TYPE (*node)))
5632 {
5549 warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
5633 warning (OPT_Wattributes, "%qE attribute ignored", name);
5550 *no_add_attrs = true;
5551 }
5552
5553 return NULL_TREE;
5554}
5634 *no_add_attrs = true;
5635 }
5636
5637 return NULL_TREE;
5638}
5639
5640/* Handle a "sentinel" attribute. */
5641
5642static tree
5643handle_sentinel_attribute (tree *node, tree name, tree args,
5644 int ARG_UNUSED (flags), bool *no_add_attrs)
5645{
5646 tree params = TYPE_ARG_TYPES (*node);
5647
5648 if (!params)
5649 {
5650 warning (OPT_Wattributes,
5651 "%qE attribute requires prototypes with named arguments", name);
5652 *no_add_attrs = true;
5653 }
5654 else
5655 {
5656 while (TREE_CHAIN (params))
5657 params = TREE_CHAIN (params);
5658
5659 if (VOID_TYPE_P (TREE_VALUE (params)))
5660 {
5661 warning (OPT_Wattributes,
5662 "%qE attribute only applies to variadic functions", name);
5663 *no_add_attrs = true;
5664 }
5665 }
5666
5667 if (args)
5668 {
5669 tree position = TREE_VALUE (args);
5670
5671 if (TREE_CODE (position) != INTEGER_CST)
5672 {
5673 warning (0, "requested position is not an integer constant");
5674 *no_add_attrs = true;
5675 }
5676 else
5677 {
5678 if (tree_int_cst_lt (position, integer_zero_node))
5679 {
5680 warning (0, "requested position is less than zero");
5681 *no_add_attrs = true;
5682 }
5683 }
5684 }
5685
5686 return NULL_TREE;
5687}
5555
5556/* Check for valid arguments being passed to a function. */
5557void
5688
5689/* Check for valid arguments being passed to a function. */
5690void
5558check_function_arguments (tree attrs, tree params)
5691check_function_arguments (tree attrs, tree params, tree typelist)
5559{
5560 /* Check for null being passed in a pointer argument that must be
5561 non-null. We also need to do this if format checking is enabled. */
5562
5563 if (warn_nonnull)
5564 check_function_nonnull (attrs, params);
5565
5566 /* Check for errors in format strings. */
5567
5692{
5693 /* Check for null being passed in a pointer argument that must be
5694 non-null. We also need to do this if format checking is enabled. */
5695
5696 if (warn_nonnull)
5697 check_function_nonnull (attrs, params);
5698
5699 /* Check for errors in format strings. */
5700
5701 if (warn_format || warn_missing_format_attribute)
5702 check_function_format (attrs, params);
5703
5568 if (warn_format)
5704 if (warn_format)
5569 check_function_format (NULL, attrs, params);
5705 check_function_sentinel (attrs, params, typelist);
5570}
5571
5572/* Generic argument checking recursion routine. PARAM is the argument to
5573 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5574 once the argument is resolved. CTX is context for the callback. */
5575void
5576check_function_arguments_recurse (void (*callback)
5577 (void *, tree, unsigned HOST_WIDE_INT),
5578 void *ctx, tree param,
5579 unsigned HOST_WIDE_INT param_num)
5580{
5706}
5707
5708/* Generic argument checking recursion routine. PARAM is the argument to
5709 be checked. PARAM_NUM is the number of the argument. CALLBACK is invoked
5710 once the argument is resolved. CTX is context for the callback. */
5711void
5712check_function_arguments_recurse (void (*callback)
5713 (void *, tree, unsigned HOST_WIDE_INT),
5714 void *ctx, tree param,
5715 unsigned HOST_WIDE_INT param_num)
5716{
5581 if (TREE_CODE (param) == NOP_EXPR)
5717 if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
5718 && (TYPE_PRECISION (TREE_TYPE (param))
5719 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
5582 {
5583 /* Strip coercion. */
5584 check_function_arguments_recurse (callback, ctx,
5720 {
5721 /* Strip coercion. */
5722 check_function_arguments_recurse (callback, ctx,
5585 TREE_OPERAND (param, 0), param_num);
5723 TREE_OPERAND (param, 0), param_num);
5586 return;
5587 }
5588
5589 if (TREE_CODE (param) == CALL_EXPR)
5590 {
5591 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5592 tree attrs;
5593 bool found_format_arg = false;

--- 10 unchanged lines hidden (view full) ---

5604 tree inner_args;
5605 tree format_num_expr;
5606 int format_num;
5607 int i;
5608
5609 /* Extract the argument number, which was previously checked
5610 to be valid. */
5611 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5724 return;
5725 }
5726
5727 if (TREE_CODE (param) == CALL_EXPR)
5728 {
5729 tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5730 tree attrs;
5731 bool found_format_arg = false;

--- 10 unchanged lines hidden (view full) ---

5742 tree inner_args;
5743 tree format_num_expr;
5744 int format_num;
5745 int i;
5746
5747 /* Extract the argument number, which was previously checked
5748 to be valid. */
5749 format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5612 while (TREE_CODE (format_num_expr) == NOP_EXPR
5613 || TREE_CODE (format_num_expr) == CONVERT_EXPR
5614 || TREE_CODE (format_num_expr) == NON_LVALUE_EXPR)
5615 format_num_expr = TREE_OPERAND (format_num_expr, 0);
5616
5750
5617 if (TREE_CODE (format_num_expr) != INTEGER_CST
5618 || TREE_INT_CST_HIGH (format_num_expr) != 0)
5619 abort ();
5751 gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5752 && !TREE_INT_CST_HIGH (format_num_expr));
5620
5621 format_num = TREE_INT_CST_LOW (format_num_expr);
5622
5623 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5624 inner_args != 0;
5625 inner_args = TREE_CHAIN (inner_args), i++)
5626 if (i == format_num)
5627 {

--- 11 unchanged lines hidden (view full) ---

5639 if (found_format_arg)
5640 return;
5641 }
5642
5643 if (TREE_CODE (param) == COND_EXPR)
5644 {
5645 /* Check both halves of the conditional expression. */
5646 check_function_arguments_recurse (callback, ctx,
5753
5754 format_num = TREE_INT_CST_LOW (format_num_expr);
5755
5756 for (inner_args = TREE_OPERAND (param, 1), i = 1;
5757 inner_args != 0;
5758 inner_args = TREE_CHAIN (inner_args), i++)
5759 if (i == format_num)
5760 {

--- 11 unchanged lines hidden (view full) ---

5772 if (found_format_arg)
5773 return;
5774 }
5775
5776 if (TREE_CODE (param) == COND_EXPR)
5777 {
5778 /* Check both halves of the conditional expression. */
5779 check_function_arguments_recurse (callback, ctx,
5647 TREE_OPERAND (param, 1), param_num);
5780 TREE_OPERAND (param, 1), param_num);
5648 check_function_arguments_recurse (callback, ctx,
5781 check_function_arguments_recurse (callback, ctx,
5649 TREE_OPERAND (param, 2), param_num);
5782 TREE_OPERAND (param, 2), param_num);
5650 return;
5651 }
5652
5653 (*callback) (ctx, param, param_num);
5654}
5655
5656/* Function to help qsort sort FIELD_DECLs by name order. */
5657
5658int
5659field_decl_cmp (const void *x_p, const void *y_p)
5660{
5783 return;
5784 }
5785
5786 (*callback) (ctx, param, param_num);
5787}
5788
5789/* Function to help qsort sort FIELD_DECLs by name order. */
5790
5791int
5792field_decl_cmp (const void *x_p, const void *y_p)
5793{
5661 const tree *const x = x_p;
5662 const tree *const y = y_p;
5794 const tree *const x = (const tree *const) x_p;
5795 const tree *const y = (const tree *const) y_p;
5796
5663 if (DECL_NAME (*x) == DECL_NAME (*y))
5664 /* A nontype is "greater" than a type. */
5665 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5666 if (DECL_NAME (*x) == NULL_TREE)
5667 return -1;
5668 if (DECL_NAME (*y) == NULL_TREE)
5669 return 1;
5670 if (DECL_NAME (*x) < DECL_NAME (*y))

--- 7 unchanged lines hidden (view full) ---

5678} resort_data;
5679
5680/* This routine compares two fields like field_decl_cmp but using the
5681pointer operator in resort_data. */
5682
5683static int
5684resort_field_decl_cmp (const void *x_p, const void *y_p)
5685{
5797 if (DECL_NAME (*x) == DECL_NAME (*y))
5798 /* A nontype is "greater" than a type. */
5799 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5800 if (DECL_NAME (*x) == NULL_TREE)
5801 return -1;
5802 if (DECL_NAME (*y) == NULL_TREE)
5803 return 1;
5804 if (DECL_NAME (*x) < DECL_NAME (*y))

--- 7 unchanged lines hidden (view full) ---

5812} resort_data;
5813
5814/* This routine compares two fields like field_decl_cmp but using the
5815pointer operator in resort_data. */
5816
5817static int
5818resort_field_decl_cmp (const void *x_p, const void *y_p)
5819{
5686 const tree *const x = x_p;
5687 const tree *const y = y_p;
5820 const tree *const x = (const tree *const) x_p;
5821 const tree *const y = (const tree *const) y_p;
5688
5689 if (DECL_NAME (*x) == DECL_NAME (*y))
5690 /* A nontype is "greater" than a type. */
5691 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5692 if (DECL_NAME (*x) == NULL_TREE)
5693 return -1;
5694 if (DECL_NAME (*y) == NULL_TREE)
5695 return 1;

--- 7 unchanged lines hidden (view full) ---

5703 }
5704 return 1;
5705}
5706
5707/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5708
5709void
5710resort_sorted_fields (void *obj,
5822
5823 if (DECL_NAME (*x) == DECL_NAME (*y))
5824 /* A nontype is "greater" than a type. */
5825 return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5826 if (DECL_NAME (*x) == NULL_TREE)
5827 return -1;
5828 if (DECL_NAME (*y) == NULL_TREE)
5829 return 1;

--- 7 unchanged lines hidden (view full) ---

5837 }
5838 return 1;
5839}
5840
5841/* Resort DECL_SORTED_FIELDS because pointers have been reordered. */
5842
5843void
5844resort_sorted_fields (void *obj,
5711 void *orig_obj ATTRIBUTE_UNUSED ,
5712 gt_pointer_operator new_value,
5713 void *cookie)
5845 void * ARG_UNUSED (orig_obj),
5846 gt_pointer_operator new_value,
5847 void *cookie)
5714{
5848{
5715 struct sorted_fields_type *sf = obj;
5849 struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5716 resort_data.new_value = new_value;
5717 resort_data.cookie = cookie;
5718 qsort (&sf->elts[0], sf->len, sizeof (tree),
5850 resort_data.new_value = new_value;
5851 resort_data.cookie = cookie;
5852 qsort (&sf->elts[0], sf->len, sizeof (tree),
5719 resort_field_decl_cmp);
5853 resort_field_decl_cmp);
5720}
5721
5854}
5855
5722/* Used by estimate_num_insns. Estimate number of instructions seen
5723 by given statement. */
5724static tree
5725c_estimate_num_insns_1 (tree *tp, int *walk_subtrees, void *data)
5856/* Subroutine of c_parse_error.
5857 Return the result of concatenating LHS and RHS. RHS is really
5858 a string literal, its first character is indicated by RHS_START and
5859 RHS_SIZE is its length (including the terminating NUL character).
5860
5861 The caller is responsible for deleting the returned pointer. */
5862
5863static char *
5864catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5726{
5865{
5727 int *count = data;
5728 tree x = *tp;
5866 const int lhs_size = strlen (lhs);
5867 char *result = XNEWVEC (char, lhs_size + rhs_size);
5868 strncpy (result, lhs, lhs_size);
5869 strncpy (result + lhs_size, rhs_start, rhs_size);
5870 return result;
5871}
5729
5872
5730 if (TYPE_P (x) || DECL_P (x))
5873/* Issue the error given by GMSGID, indicating that it occurred before
5874 TOKEN, which had the associated VALUE. */
5875
5876void
5877c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
5878{
5879#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5880
5881 char *message = NULL;
5882
5883 if (token == CPP_EOF)
5884 message = catenate_messages (gmsgid, " at end of input");
5885 else if (token == CPP_CHAR || token == CPP_WCHAR)
5731 {
5886 {
5732 *walk_subtrees = 0;
5733 return NULL;
5887 unsigned int val = TREE_INT_CST_LOW (value);
5888 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5889 if (val <= UCHAR_MAX && ISGRAPH (val))
5890 message = catenate_messages (gmsgid, " before %s'%c'");
5891 else
5892 message = catenate_messages (gmsgid, " before %s'\\x%x'");
5893
5894 error (message, ell, val);
5895 free (message);
5896 message = NULL;
5734 }
5897 }
5735 /* Assume that constants and references counts nothing. These should
5736 be majorized by amount of operations among them we count later
5737 and are common target of CSE and similar optimizations. */
5738 if (TREE_CODE_CLASS (TREE_CODE (x)) == 'c'
5739 || TREE_CODE_CLASS (TREE_CODE (x)) == 'r')
5740 return NULL;
5741 switch (TREE_CODE (x))
5742 {
5743 /* Recognize assignments of large structures and constructors of
5744 big arrays. */
5745 case MODIFY_EXPR:
5746 case CONSTRUCTOR:
5747 {
5748 HOST_WIDE_INT size;
5898 else if (token == CPP_STRING || token == CPP_WSTRING)
5899 message = catenate_messages (gmsgid, " before string constant");
5900 else if (token == CPP_NUMBER)
5901 message = catenate_messages (gmsgid, " before numeric constant");
5902 else if (token == CPP_NAME)
5903 {
5904 message = catenate_messages (gmsgid, " before %qE");
5905 error (message, value);
5906 free (message);
5907 message = NULL;
5908 }
5909 else if (token == CPP_PRAGMA)
5910 message = catenate_messages (gmsgid, " before %<#pragma%>");
5911 else if (token == CPP_PRAGMA_EOL)
5912 message = catenate_messages (gmsgid, " before end of line");
5913 else if (token < N_TTYPES)
5914 {
5915 message = catenate_messages (gmsgid, " before %qs token");
5916 error (message, cpp_type2name (token));
5917 free (message);
5918 message = NULL;
5919 }
5920 else
5921 error (gmsgid);
5749
5922
5750 size = int_size_in_bytes (TREE_TYPE (x));
5923 if (message)
5924 {
5925 error (message);
5926 free (message);
5927 }
5928#undef catenate_messages
5929}
5751
5930
5752 if (size < 0 || size > MOVE_MAX_PIECES * MOVE_RATIO)
5753 *count += 10;
5754 else
5755 *count += ((size + MOVE_MAX_PIECES - 1) / MOVE_MAX_PIECES);
5756 }
5931/* Walk a gimplified function and warn for functions whose return value is
5932 ignored and attribute((warn_unused_result)) is set. This is done before
5933 inlining, so we don't have to worry about that. */
5934
5935void
5936c_warn_unused_result (tree *top_p)
5937{
5938 tree t = *top_p;
5939 tree_stmt_iterator i;
5940 tree fdecl, ftype;
5941
5942 switch (TREE_CODE (t))
5943 {
5944 case STATEMENT_LIST:
5945 for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5946 c_warn_unused_result (tsi_stmt_ptr (i));
5757 break;
5947 break;
5758 case CALL_EXPR:
5759 {
5760 tree decl = get_callee_fndecl (x);
5761
5948
5762 if (decl && DECL_BUILT_IN (decl))
5763 switch (DECL_FUNCTION_CODE (decl))
5764 {
5765 case BUILT_IN_CONSTANT_P:
5766 *walk_subtrees = 0;
5767 return NULL_TREE;
5768 case BUILT_IN_EXPECT:
5769 return NULL_TREE;
5770 default:
5771 break;
5772 }
5773 *count += 10;
5774 break;
5775 }
5776 /* Few special cases of expensive operations. This is usefull
5777 to avoid inlining on functions having too many of these. */
5778 case TRUNC_DIV_EXPR:
5779 case CEIL_DIV_EXPR:
5780 case FLOOR_DIV_EXPR:
5781 case ROUND_DIV_EXPR:
5782 case TRUNC_MOD_EXPR:
5783 case CEIL_MOD_EXPR:
5784 case FLOOR_MOD_EXPR:
5785 case ROUND_MOD_EXPR:
5786 case RDIV_EXPR:
5787 *count += 10;
5949 case COND_EXPR:
5950 c_warn_unused_result (&COND_EXPR_THEN (t));
5951 c_warn_unused_result (&COND_EXPR_ELSE (t));
5788 break;
5952 break;
5789 /* Various containers that will produce no code themselves. */
5790 case INIT_EXPR:
5791 case TARGET_EXPR:
5792 case BIND_EXPR:
5953 case BIND_EXPR:
5793 case BLOCK:
5794 case TREE_LIST:
5795 case TREE_VEC:
5796 case IDENTIFIER_NODE:
5797 case PLACEHOLDER_EXPR:
5798 case WITH_CLEANUP_EXPR:
5799 case CLEANUP_POINT_EXPR:
5800 case NOP_EXPR:
5801 case VIEW_CONVERT_EXPR:
5802 case SAVE_EXPR:
5803 case UNSAVE_EXPR:
5804 case COMPLEX_EXPR:
5805 case REALPART_EXPR:
5806 case IMAGPART_EXPR:
5807 case TRY_CATCH_EXPR:
5954 c_warn_unused_result (&BIND_EXPR_BODY (t));
5955 break;
5808 case TRY_FINALLY_EXPR:
5956 case TRY_FINALLY_EXPR:
5809 case LABEL_EXPR:
5810 case EXIT_EXPR:
5811 case LABELED_BLOCK_EXPR:
5812 case EXIT_BLOCK_EXPR:
5813 case EXPR_WITH_FILE_LOCATION:
5957 case TRY_CATCH_EXPR:
5958 c_warn_unused_result (&TREE_OPERAND (t, 0));
5959 c_warn_unused_result (&TREE_OPERAND (t, 1));
5960 break;
5961 case CATCH_EXPR:
5962 c_warn_unused_result (&CATCH_BODY (t));
5963 break;
5964 case EH_FILTER_EXPR:
5965 c_warn_unused_result (&EH_FILTER_FAILURE (t));
5966 break;
5814
5967
5815 case EXPR_STMT:
5816 case COMPOUND_STMT:
5817 case RETURN_STMT:
5818 case LABEL_STMT:
5819 case SCOPE_STMT:
5820 case FILE_STMT:
5821 case CASE_LABEL:
5822 case STMT_EXPR:
5823 case CLEANUP_STMT:
5968 case CALL_EXPR:
5969 if (TREE_USED (t))
5970 break;
5824
5971
5825 case SIZEOF_EXPR:
5826 case ARROW_EXPR:
5827 case ALIGNOF_EXPR:
5972 /* This is a naked call, as opposed to a CALL_EXPR nested inside
5973 a MODIFY_EXPR. All calls whose value is ignored should be
5974 represented like this. Look for the attribute. */
5975 fdecl = get_callee_fndecl (t);
5976 if (fdecl)
5977 ftype = TREE_TYPE (fdecl);
5978 else
5979 {
5980 ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5981 /* Look past pointer-to-function to the function type itself. */
5982 ftype = TREE_TYPE (ftype);
5983 }
5984
5985 if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5986 {
5987 if (fdecl)
5988 warning (0, "%Hignoring return value of %qD, "
5989 "declared with attribute warn_unused_result",
5990 EXPR_LOCUS (t), fdecl);
5991 else
5992 warning (0, "%Hignoring return value of function "
5993 "declared with attribute warn_unused_result",
5994 EXPR_LOCUS (t));
5995 }
5828 break;
5996 break;
5829 case DECL_STMT:
5830 /* Do not account static initializers. */
5831 if (TREE_STATIC (TREE_OPERAND (x, 0)))
5832 *walk_subtrees = 0;
5997
5998 default:
5999 /* Not a container, not a call, or a call whose value is used. */
5833 break;
6000 break;
6001 }
6002}
6003
6004/* Convert a character from the host to the target execution character
6005 set. cpplib handles this, mostly. */
6006
6007HOST_WIDE_INT
6008c_common_to_target_charset (HOST_WIDE_INT c)
6009{
6010 /* Character constants in GCC proper are sign-extended under -fsigned-char,
6011 zero-extended under -fno-signed-char. cpplib insists that characters
6012 and character constants are always unsigned. Hence we must convert
6013 back and forth. */
6014 cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6015
6016 uc = cpp_host_to_exec_charset (parse_in, uc);
6017
6018 if (flag_signed_char)
6019 return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6020 >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6021 else
6022 return uc;
6023}
6024
6025/* Build the result of __builtin_offsetof. EXPR is a nested sequence of
6026 component references, with STOP_REF, or alternatively an INDIRECT_REF of
6027 NULL, at the bottom; much like the traditional rendering of offsetof as a
6028 macro. Returns the folded and properly cast result. */
6029
6030static tree
6031fold_offsetof_1 (tree expr, tree stop_ref)
6032{
6033 enum tree_code code = PLUS_EXPR;
6034 tree base, off, t;
6035
6036 if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6037 return size_zero_node;
6038
6039 switch (TREE_CODE (expr))
6040 {
6041 case ERROR_MARK:
6042 return expr;
6043
6044 case VAR_DECL:
6045 error ("cannot apply %<offsetof%> to static data member %qD", expr);
6046 return error_mark_node;
6047
6048 case CALL_EXPR:
6049 error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6050 return error_mark_node;
6051
6052 case INTEGER_CST:
6053 gcc_assert (integer_zerop (expr));
6054 return size_zero_node;
6055
6056 case NOP_EXPR:
6057 case INDIRECT_REF:
6058 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6059 gcc_assert (base == error_mark_node || base == size_zero_node);
6060 return base;
6061
6062 case COMPONENT_REF:
6063 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6064 if (base == error_mark_node)
6065 return base;
6066
6067 t = TREE_OPERAND (expr, 1);
6068 if (DECL_C_BIT_FIELD (t))
6069 {
6070 error ("attempt to take address of bit-field structure "
6071 "member %qD", t);
6072 return error_mark_node;
6073 }
6074 off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6075 size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6076 / BITS_PER_UNIT));
6077 break;
6078
6079 case ARRAY_REF:
6080 base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6081 if (base == error_mark_node)
6082 return base;
6083
6084 t = TREE_OPERAND (expr, 1);
6085 if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6086 {
6087 code = MINUS_EXPR;
6088 t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6089 }
6090 t = convert (sizetype, t);
6091 off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6092 break;
6093
6094 case COMPOUND_EXPR:
6095 /* Handle static members of volatile structs. */
6096 t = TREE_OPERAND (expr, 1);
6097 gcc_assert (TREE_CODE (t) == VAR_DECL);
6098 return fold_offsetof_1 (t, stop_ref);
6099
5834 default:
6100 default:
5835 (*count)++;
6101 gcc_unreachable ();
5836 }
6102 }
5837 return NULL;
6103
6104 return size_binop (code, base, off);
5838}
5839
6105}
6106
5840/* Estimate number of instructions that will be created by expanding the body. */
6107tree
6108fold_offsetof (tree expr, tree stop_ref)
6109{
6110 /* Convert back from the internal sizetype to size_t. */
6111 return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6112}
6113
6114/* Print an error message for an invalid lvalue. USE says
6115 how the lvalue is being used and so selects the error message. */
6116
6117void
6118lvalue_error (enum lvalue_use use)
6119{
6120 switch (use)
6121 {
6122 case lv_assign:
6123 error ("lvalue required as left operand of assignment");
6124 break;
6125 case lv_increment:
6126 error ("lvalue required as increment operand");
6127 break;
6128 case lv_decrement:
6129 error ("lvalue required as decrement operand");
6130 break;
6131 case lv_addressof:
6132 error ("lvalue required as unary %<&%> operand");
6133 break;
6134 case lv_asm:
6135 error ("lvalue required in asm statement");
6136 break;
6137 default:
6138 gcc_unreachable ();
6139 }
6140}
6141
6142/* *PTYPE is an incomplete array. Complete it with a domain based on
6143 INITIAL_VALUE. If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6144 is true. Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6145 2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty. */
6146
5841int
6147int
5842c_estimate_num_insns (tree decl)
6148complete_array_type (tree *ptype, tree initial_value, bool do_default)
5843{
6149{
5844 int num = 0;
5845 walk_tree_without_duplicates (&DECL_SAVED_TREE (decl), c_estimate_num_insns_1, &num);
5846 return num;
6150 tree maxindex, type, main_type, elt, unqual_elt;
6151 int failure = 0, quals;
6152
6153 maxindex = size_zero_node;
6154 if (initial_value)
6155 {
6156 if (TREE_CODE (initial_value) == STRING_CST)
6157 {
6158 int eltsize
6159 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6160 maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6161 }
6162 else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6163 {
6164 VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6165
6166 if (VEC_empty (constructor_elt, v))
6167 {
6168 if (pedantic)
6169 failure = 3;
6170 maxindex = integer_minus_one_node;
6171 }
6172 else
6173 {
6174 tree curindex;
6175 unsigned HOST_WIDE_INT cnt;
6176 constructor_elt *ce;
6177
6178 if (VEC_index (constructor_elt, v, 0)->index)
6179 maxindex = fold_convert (sizetype,
6180 VEC_index (constructor_elt,
6181 v, 0)->index);
6182 curindex = maxindex;
6183
6184 for (cnt = 1;
6185 VEC_iterate (constructor_elt, v, cnt, ce);
6186 cnt++)
6187 {
6188 if (ce->index)
6189 curindex = fold_convert (sizetype, ce->index);
6190 else
6191 curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6192
6193 if (tree_int_cst_lt (maxindex, curindex))
6194 maxindex = curindex;
6195 }
6196 }
6197 }
6198 else
6199 {
6200 /* Make an error message unless that happened already. */
6201 if (initial_value != error_mark_node)
6202 failure = 1;
6203 }
6204 }
6205 else
6206 {
6207 failure = 2;
6208 if (!do_default)
6209 return failure;
6210 }
6211
6212 type = *ptype;
6213 elt = TREE_TYPE (type);
6214 quals = TYPE_QUALS (strip_array_types (elt));
6215 if (quals == 0)
6216 unqual_elt = elt;
6217 else
6218 unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6219
6220 /* Using build_distinct_type_copy and modifying things afterward instead
6221 of using build_array_type to create a new type preserves all of the
6222 TYPE_LANG_FLAG_? bits that the front end may have set. */
6223 main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6224 TREE_TYPE (main_type) = unqual_elt;
6225 TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6226 layout_type (main_type);
6227
6228 if (quals == 0)
6229 type = main_type;
6230 else
6231 type = c_build_qualified_type (main_type, quals);
6232
6233 *ptype = type;
6234 return failure;
5847}
5848
6235}
6236
5849/* Used by c_decl_uninit to find where expressions like x = x + 1; */
6237
6238/* Used to help initialize the builtin-types.def table. When a type of
6239 the correct size doesn't exist, use error_mark_node instead of NULL.
6240 The later results in segfaults even when a decl using the type doesn't
6241 get invoked. */
5850
6242
6243tree
6244builtin_type_for_size (int size, bool unsignedp)
6245{
6246 tree type = lang_hooks.types.type_for_size (size, unsignedp);
6247 return type ? type : error_mark_node;
6248}
6249
6250/* A helper function for resolve_overloaded_builtin in resolving the
6251 overloaded __sync_ builtins. Returns a positive power of 2 if the
6252 first operand of PARAMS is a pointer to a supported data type.
6253 Returns 0 if an error is encountered. */
6254
6255static int
6256sync_resolve_size (tree function, tree params)
6257{
6258 tree type;
6259 int size;
6260
6261 if (params == NULL)
6262 {
6263 error ("too few arguments to function %qE", function);
6264 return 0;
6265 }
6266
6267 type = TREE_TYPE (TREE_VALUE (params));
6268 if (TREE_CODE (type) != POINTER_TYPE)
6269 goto incompatible;
6270
6271 type = TREE_TYPE (type);
6272 if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6273 goto incompatible;
6274
6275 size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6276 if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6277 return size;
6278
6279 incompatible:
6280 error ("incompatible type for argument %d of %qE", 1, function);
6281 return 0;
6282}
6283
6284/* A helper function for resolve_overloaded_builtin. Adds casts to
6285 PARAMS to make arguments match up with those of FUNCTION. Drops
6286 the variadic arguments at the end. Returns false if some error
6287 was encountered; true on success. */
6288
6289static bool
6290sync_resolve_params (tree orig_function, tree function, tree params)
6291{
6292 tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6293 tree ptype;
6294 int number;
6295
6296 /* We've declared the implementation functions to use "volatile void *"
6297 as the pointer parameter, so we shouldn't get any complaints from the
6298 call to check_function_arguments what ever type the user used. */
6299 arg_types = TREE_CHAIN (arg_types);
6300 ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6301 number = 2;
6302
6303 /* For the rest of the values, we need to cast these to FTYPE, so that we
6304 don't get warnings for passing pointer types, etc. */
6305 while (arg_types != void_list_node)
6306 {
6307 tree val;
6308
6309 params = TREE_CHAIN (params);
6310 if (params == NULL)
6311 {
6312 error ("too few arguments to function %qE", orig_function);
6313 return false;
6314 }
6315
6316 /* ??? Ideally for the first conversion we'd use convert_for_assignment
6317 so that we get warnings for anything that doesn't match the pointer
6318 type. This isn't portable across the C and C++ front ends atm. */
6319 val = TREE_VALUE (params);
6320 val = convert (ptype, val);
6321 val = convert (TREE_VALUE (arg_types), val);
6322 TREE_VALUE (params) = val;
6323
6324 arg_types = TREE_CHAIN (arg_types);
6325 number++;
6326 }
6327
6328 /* The definition of these primitives is variadic, with the remaining
6329 being "an optional list of variables protected by the memory barrier".
6330 No clue what that's supposed to mean, precisely, but we consider all
6331 call-clobbered variables to be protected so we're safe. */
6332 TREE_CHAIN (params) = NULL;
6333
6334 return true;
6335}
6336
6337/* A helper function for resolve_overloaded_builtin. Adds a cast to
6338 RESULT to make it match the type of the first pointer argument in
6339 PARAMS. */
6340
5851static tree
6341static tree
5852c_decl_uninit_1 (tree *t, int *walk_sub_trees, void *x)
6342sync_resolve_return (tree params, tree result)
5853{
6343{
5854 /* If x = EXP(&x)EXP, then do not warn about the use of x. */
5855 if (TREE_CODE (*t) == ADDR_EXPR && TREE_OPERAND (*t, 0) == x)
6344 tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6345 ptype = TYPE_MAIN_VARIANT (ptype);
6346 return convert (ptype, result);
6347}
6348
6349/* Some builtin functions are placeholders for other expressions. This
6350 function should be called immediately after parsing the call expression
6351 before surrounding code has committed to the type of the expression.
6352
6353 FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6354 PARAMS is the argument list for the call. The return value is non-null
6355 when expansion is complete, and null if normal processing should
6356 continue. */
6357
6358tree
6359resolve_overloaded_builtin (tree function, tree params)
6360{
6361 enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6362 switch (DECL_BUILT_IN_CLASS (function))
5856 {
6363 {
5857 *walk_sub_trees = 0;
6364 case BUILT_IN_NORMAL:
6365 break;
6366 case BUILT_IN_MD:
6367 if (targetm.resolve_overloaded_builtin)
6368 return targetm.resolve_overloaded_builtin (function, params);
6369 else
6370 return NULL_TREE;
6371 default:
5858 return NULL_TREE;
5859 }
6372 return NULL_TREE;
6373 }
5860 if (*t == x)
5861 return *t;
5862 return NULL_TREE;
5863}
5864
6374
5865/* Find out if a variable is uninitialized based on DECL_INITIAL. */
6375 /* Handle BUILT_IN_NORMAL here. */
6376 switch (orig_code)
6377 {
6378 case BUILT_IN_FETCH_AND_ADD_N:
6379 case BUILT_IN_FETCH_AND_SUB_N:
6380 case BUILT_IN_FETCH_AND_OR_N:
6381 case BUILT_IN_FETCH_AND_AND_N:
6382 case BUILT_IN_FETCH_AND_XOR_N:
6383 case BUILT_IN_FETCH_AND_NAND_N:
6384 case BUILT_IN_ADD_AND_FETCH_N:
6385 case BUILT_IN_SUB_AND_FETCH_N:
6386 case BUILT_IN_OR_AND_FETCH_N:
6387 case BUILT_IN_AND_AND_FETCH_N:
6388 case BUILT_IN_XOR_AND_FETCH_N:
6389 case BUILT_IN_NAND_AND_FETCH_N:
6390 case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6391 case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6392 case BUILT_IN_LOCK_TEST_AND_SET_N:
6393 case BUILT_IN_LOCK_RELEASE_N:
6394 {
6395 int n = sync_resolve_size (function, params);
6396 tree new_function, result;
5866
6397
6398 if (n == 0)
6399 return error_mark_node;
6400
6401 new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6402 if (!sync_resolve_params (function, new_function, params))
6403 return error_mark_node;
6404
6405 result = build_function_call (new_function, params);
6406 if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6407 && orig_code != BUILT_IN_LOCK_RELEASE_N)
6408 result = sync_resolve_return (params, result);
6409
6410 return result;
6411 }
6412
6413 default:
6414 return NULL_TREE;
6415 }
6416}
6417
6418/* Ignoring their sign, return true if two scalar types are the same. */
5867bool
6419bool
5868c_decl_uninit (tree t)
6420same_scalar_type_ignoring_signedness (tree t1, tree t2)
5869{
6421{
5870 /* int x = x; is GCC extension to turn off this warning, only if warn_init_self is zero. */
5871 if (DECL_INITIAL (t) == t)
5872 return warn_init_self ? true : false;
6422 enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
5873
6423
5874 /* Walk the trees looking for the variable itself. */
5875 if (walk_tree_without_duplicates (&DECL_INITIAL (t), c_decl_uninit_1, t))
5876 return true;
5877 return false;
6424 gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6425 && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6426
6427 /* Equality works here because c_common_signed_type uses
6428 TYPE_MAIN_VARIANT. */
6429 return lang_hooks.types.signed_type (t1)
6430 == lang_hooks.types.signed_type (t2);
5878}
5879
6431}
6432
5880/* Issue the error given by MSGID, indicating that it occurred before
5881 TOKEN, which had the associated VALUE. */
6433/* Check for missing format attributes on function pointers. LTYPE is
6434 the new type or left-hand side type. RTYPE is the old type or
6435 right-hand side type. Returns TRUE if LTYPE is missing the desired
6436 attribute. */
5882
6437
5883void
5884c_parse_error (const char *msgid, enum cpp_ttype token, tree value)
6438bool
6439check_missing_format_attribute (tree ltype, tree rtype)
5885{
6440{
5886 const char *string = _(msgid);
6441 tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6442 tree ra;
5887
6443
5888 if (token == CPP_EOF)
5889 error ("%s at end of input", string);
5890 else if (token == CPP_CHAR || token == CPP_WCHAR)
6444 for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6445 if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6446 break;
6447 if (ra)
5891 {
6448 {
5892 unsigned int val = TREE_INT_CST_LOW (value);
5893 const char *const ell = (token == CPP_CHAR) ? "" : "L";
5894 if (val <= UCHAR_MAX && ISGRAPH (val))
5895 error ("%s before %s'%c'", string, ell, val);
5896 else
5897 error ("%s before %s'\\x%x'", string, ell, val);
6449 tree la;
6450 for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6451 if (is_attribute_p ("format", TREE_PURPOSE (la)))
6452 break;
6453 return !la;
5898 }
6454 }
5899 else if (token == CPP_STRING
5900 || token == CPP_WSTRING)
5901 error ("%s before string constant", string);
5902 else if (token == CPP_NUMBER)
5903 error ("%s before numeric constant", string);
5904 else if (token == CPP_NAME)
5905 error ("%s before \"%s\"", string, IDENTIFIER_POINTER (value));
5906 else if (token < N_TTYPES)
5907 error ("%s before '%s' token", string, cpp_type2name (token));
5908 else
6455 else
5909 error ("%s", string);
6456 return false;
5910}
5911
6457}
6458
6459/* Subscripting with type char is likely to lose on a machine where
6460 chars are signed. So warn on any machine, but optionally. Don't
6461 warn for unsigned char since that type is safe. Don't warn for
6462 signed char because anyone who uses that must have done so
6463 deliberately. Furthermore, we reduce the false positive load by
6464 warning only for non-constant value of type char. */
6465
6466void
6467warn_array_subscript_with_type_char (tree index)
6468{
6469 if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6470 && TREE_CODE (index) != INTEGER_CST)
6471 warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6472}
6473
6474
5912#include "gt-c-common.h"
6475#include "gt-c-common.h"