OSDN Git Service

59dd295d3d62f0c3fb3bc18a4c6ae5f22631afc9
[pf3gnuchains/gcc-fork.git] / gcc / c-common.c
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, 2005, 2006, 2007, 2008, 2009, 2010
4    Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
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"
29 #include "output.h"
30 #include "c-pragma.h"
31 #include "rtl.h"
32 #include "ggc.h"
33 #include "expr.h" /* For vector_mode_valid_p */
34 #include "c-common.h"
35 #include "tm_p.h"
36 #include "obstack.h"
37 #include "cpplib.h"
38 #include "target.h"
39 #include "langhooks.h"
40 #include "tree-inline.h"
41 #include "c-tree.h"
42 #include "toplev.h"
43 #include "diagnostic.h"
44 #include "tree-iterator.h"
45 #include "hashtab.h"
46 #include "tree-mudflap.h"
47 #include "opts.h"
48 #include "real.h"
49 #include "cgraph.h"
50 #include "target-def.h"
51 #include "fixed-value.h"
52 #include "libfuncs.h"
53
54 cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
55
56 /* The following symbols are subsumed in the c_global_trees array, and
57    listed here individually for documentation purposes.
58
59    INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
60
61         tree short_integer_type_node;
62         tree long_integer_type_node;
63         tree long_long_integer_type_node;
64
65         tree short_unsigned_type_node;
66         tree long_unsigned_type_node;
67         tree long_long_unsigned_type_node;
68
69         tree truthvalue_type_node;
70         tree truthvalue_false_node;
71         tree truthvalue_true_node;
72
73         tree ptrdiff_type_node;
74
75         tree unsigned_char_type_node;
76         tree signed_char_type_node;
77         tree wchar_type_node;
78
79         tree char16_type_node;
80         tree char32_type_node;
81
82         tree float_type_node;
83         tree double_type_node;
84         tree long_double_type_node;
85
86         tree complex_integer_type_node;
87         tree complex_float_type_node;
88         tree complex_double_type_node;
89         tree complex_long_double_type_node;
90
91         tree dfloat32_type_node;
92         tree dfloat64_type_node;
93         tree_dfloat128_type_node;
94
95         tree intQI_type_node;
96         tree intHI_type_node;
97         tree intSI_type_node;
98         tree intDI_type_node;
99         tree intTI_type_node;
100
101         tree unsigned_intQI_type_node;
102         tree unsigned_intHI_type_node;
103         tree unsigned_intSI_type_node;
104         tree unsigned_intDI_type_node;
105         tree unsigned_intTI_type_node;
106
107         tree widest_integer_literal_type_node;
108         tree widest_unsigned_literal_type_node;
109
110    Nodes for types `void *' and `const void *'.
111
112         tree ptr_type_node, const_ptr_type_node;
113
114    Nodes for types `char *' and `const char *'.
115
116         tree string_type_node, const_string_type_node;
117
118    Type `char[SOMENUMBER]'.
119    Used when an array of char is needed and the size is irrelevant.
120
121         tree char_array_type_node;
122
123    Type `int[SOMENUMBER]' or something like it.
124    Used when an array of int needed and the size is irrelevant.
125
126         tree int_array_type_node;
127
128    Type `wchar_t[SOMENUMBER]' or something like it.
129    Used when a wide string literal is created.
130
131         tree wchar_array_type_node;
132
133    Type `char16_t[SOMENUMBER]' or something like it.
134    Used when a UTF-16 string literal is created.
135
136         tree char16_array_type_node;
137
138    Type `char32_t[SOMENUMBER]' or something like it.
139    Used when a UTF-32 string literal is created.
140
141         tree char32_array_type_node;
142
143    Type `int ()' -- used for implicit declaration of functions.
144
145         tree default_function_type;
146
147    A VOID_TYPE node, packaged in a TREE_LIST.
148
149         tree void_list_node;
150
151   The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
152   and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
153   VAR_DECLS, but C++ does.)
154
155         tree function_name_decl_node;
156         tree pretty_function_name_decl_node;
157         tree c99_function_name_decl_node;
158
159   Stack of nested function name VAR_DECLs.
160
161         tree saved_function_name_decls;
162
163 */
164
165 tree c_global_trees[CTI_MAX];
166 \f
167 /* Switches common to the C front ends.  */
168
169 /* Nonzero if preprocessing only.  */
170
171 int flag_preprocess_only;
172
173 /* Nonzero means don't output line number information.  */
174
175 char flag_no_line_commands;
176
177 /* Nonzero causes -E output not to be done, but directives such as
178    #define that have side effects are still obeyed.  */
179
180 char flag_no_output;
181
182 /* Nonzero means dump macros in some fashion.  */
183
184 char flag_dump_macros;
185
186 /* Nonzero means pass #include lines through to the output.  */
187
188 char flag_dump_includes;
189
190 /* Nonzero means process PCH files while preprocessing.  */
191
192 bool flag_pch_preprocess;
193
194 /* The file name to which we should write a precompiled header, or
195    NULL if no header will be written in this compile.  */
196
197 const char *pch_file;
198
199 /* Nonzero if an ISO standard was selected.  It rejects macros in the
200    user's namespace.  */
201 int flag_iso;
202
203 /* Nonzero if -undef was given.  It suppresses target built-in macros
204    and assertions.  */
205 int flag_undef;
206
207 /* Nonzero means don't recognize the non-ANSI builtin functions.  */
208
209 int flag_no_builtin;
210
211 /* Nonzero means don't recognize the non-ANSI builtin functions.
212    -ansi sets this.  */
213
214 int flag_no_nonansi_builtin;
215
216 /* Nonzero means give `double' the same size as `float'.  */
217
218 int flag_short_double;
219
220 /* Nonzero means give `wchar_t' the same size as `short'.  */
221
222 int flag_short_wchar;
223
224 /* Nonzero means allow implicit conversions between vectors with
225    differing numbers of subparts and/or differing element types.  */
226 int flag_lax_vector_conversions;
227
228 /* Nonzero means allow Microsoft extensions without warnings or errors.  */
229 int flag_ms_extensions;
230
231 /* Nonzero means don't recognize the keyword `asm'.  */
232
233 int flag_no_asm;
234
235 /* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
236
237 int flag_signed_bitfields = 1;
238
239 /* Warn about #pragma directives that are not recognized.  */
240
241 int warn_unknown_pragmas; /* Tri state variable.  */
242
243 /* Warn about format/argument anomalies in calls to formatted I/O functions
244    (*printf, *scanf, strftime, strfmon, etc.).  */
245
246 int warn_format;
247
248 /* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
249    with GCC this doesn't matter as __null is guaranteed to have the right
250    size.  */
251
252 int warn_strict_null_sentinel;
253
254 /* Zero means that faster, ...NonNil variants of objc_msgSend...
255    calls will be used in ObjC; passing nil receivers to such calls
256    will most likely result in crashes.  */
257 int flag_nil_receivers = 1;
258
259 /* Nonzero means that code generation will be altered to support
260    "zero-link" execution.  This currently affects ObjC only, but may
261    affect other languages in the future.  */
262 int flag_zero_link = 0;
263
264 /* Nonzero means emit an '__OBJC, __image_info' for the current translation
265    unit.  It will inform the ObjC runtime that class definition(s) herein
266    contained are to replace one(s) previously loaded.  */
267 int flag_replace_objc_classes = 0;
268
269 /* C/ObjC language option variables.  */
270
271
272 /* Nonzero means allow type mismatches in conditional expressions;
273    just make their values `void'.  */
274
275 int flag_cond_mismatch;
276
277 /* Nonzero means enable C89 Amendment 1 features.  */
278
279 int flag_isoc94;
280
281 /* Nonzero means use the ISO C99 (or C1X) dialect of C.  */
282
283 int flag_isoc99;
284
285 /* Nonzero means use the ISO C1X dialect of C.  */
286
287 int flag_isoc1x;
288
289 /* Nonzero means that we have builtin functions, and main is an int.  */
290
291 int flag_hosted = 1;
292
293
294 /* ObjC language option variables.  */
295
296
297 /* Open and close the file for outputting class declarations, if
298    requested (ObjC).  */
299
300 int flag_gen_declaration;
301
302 /* Tells the compiler that this is a special run.  Do not perform any
303    compiling, instead we are to test some platform dependent features
304    and output a C header file with appropriate definitions.  */
305
306 int print_struct_values;
307
308 /* Tells the compiler what is the constant string class for ObjC.  */
309
310 const char *constant_string_class_name;
311
312
313 /* C++ language option variables.  */
314
315
316 /* Nonzero means don't recognize any extension keywords.  */
317
318 int flag_no_gnu_keywords;
319
320 /* Nonzero means do emit exported implementations of functions even if
321    they can be inlined.  */
322
323 int flag_implement_inlines = 1;
324
325 /* Nonzero means that implicit instantiations will be emitted if needed.  */
326
327 int flag_implicit_templates = 1;
328
329 /* Nonzero means that implicit instantiations of inline templates will be
330    emitted if needed, even if instantiations of non-inline templates
331    aren't.  */
332
333 int flag_implicit_inline_templates = 1;
334
335 /* Nonzero means generate separate instantiation control files and
336    juggle them at link time.  */
337
338 int flag_use_repository;
339
340 /* Nonzero if we want to issue diagnostics that the standard says are not
341    required.  */
342
343 int flag_optional_diags = 1;
344
345 /* Nonzero means we should attempt to elide constructors when possible.  */
346
347 int flag_elide_constructors = 1;
348
349 /* Nonzero means that member functions defined in class scope are
350    inline by default.  */
351
352 int flag_default_inline = 1;
353
354 /* Controls whether compiler generates 'type descriptor' that give
355    run-time type information.  */
356
357 int flag_rtti = 1;
358
359 /* Nonzero if we want to conserve space in the .o files.  We do this
360    by putting uninitialized data and runtime initialized data into
361    .common instead of .data at the expense of not flagging multiple
362    definitions.  */
363
364 int flag_conserve_space;
365
366 /* Nonzero if we want to obey access control semantics.  */
367
368 int flag_access_control = 1;
369
370 /* Nonzero if we want to check the return value of new and avoid calling
371    constructors if it is a null pointer.  */
372
373 int flag_check_new;
374
375 /* The C++ dialect being used. C++98 is the default.  */
376
377 enum cxx_dialect cxx_dialect = cxx98;
378
379 /* Nonzero if we want the new ISO rules for pushing a new scope for `for'
380    initialization variables.
381    0: Old rules, set by -fno-for-scope.
382    2: New ISO rules, set by -ffor-scope.
383    1: Try to implement new ISO rules, but with backup compatibility
384    (and warnings).  This is the default, for now.  */
385
386 int flag_new_for_scope = 1;
387
388 /* Nonzero if we want to emit defined symbols with common-like linkage as
389    weak symbols where possible, in order to conform to C++ semantics.
390    Otherwise, emit them as local symbols.  */
391
392 int flag_weak = 1;
393
394 /* 0 means we want the preprocessor to not emit line directives for
395    the current working directory.  1 means we want it to do it.  -1
396    means we should decide depending on whether debugging information
397    is being emitted or not.  */
398
399 int flag_working_directory = -1;
400
401 /* Nonzero to use __cxa_atexit, rather than atexit, to register
402    destructors for local statics and global objects.  '2' means it has been
403    set nonzero as a default, not by a command-line flag.  */
404
405 int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
406
407 /* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
408    code.  '2' means it has not been set explicitly on the command line.  */
409
410 int flag_use_cxa_get_exception_ptr = 2;
411
412 /* Nonzero means to implement standard semantics for exception
413    specifications, calling unexpected if an exception is thrown that
414    doesn't match the specification.  Zero means to treat them as
415    assertions and optimize accordingly, but not check them.  */
416
417 int flag_enforce_eh_specs = 1;
418
419 /* Nonzero means to generate thread-safe code for initializing local
420    statics.  */
421
422 int flag_threadsafe_statics = 1;
423
424 /* Nonzero if we want to pretty-print template specializations as the
425    template signature followed by the arguments.  */
426
427 int flag_pretty_templates = 1;
428
429 /* Maximum template instantiation depth.  This limit exists to limit the
430    time it takes to notice infinite template instantiations; the default
431    value of 1024 is likely to be in the next C++ standard.  */
432
433 int max_tinst_depth = 1024;
434
435
436
437 /* The elements of `ridpointers' are identifier nodes for the reserved
438    type names and storage classes.  It is indexed by a RID_... value.  */
439 tree *ridpointers;
440
441 tree (*make_fname_decl) (location_t, tree, int);
442
443 /* Nonzero means don't warn about problems that occur when the code is
444    executed.  */
445 int c_inhibit_evaluation_warnings;
446
447 /* Whether lexing has been completed, so subsequent preprocessor
448    errors should use the compiler's input_location.  */
449 bool done_lexing = false;
450
451 /* Information about how a function name is generated.  */
452 struct fname_var_t
453 {
454   tree *const decl;     /* pointer to the VAR_DECL.  */
455   const unsigned rid;   /* RID number for the identifier.  */
456   const int pretty;     /* How pretty is it? */
457 };
458
459 /* The three ways of getting then name of the current function.  */
460
461 const struct fname_var_t fname_vars[] =
462 {
463   /* C99 compliant __func__, must be first.  */
464   {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
465   /* GCC __FUNCTION__ compliant.  */
466   {&function_name_decl_node, RID_FUNCTION_NAME, 0},
467   /* GCC __PRETTY_FUNCTION__ compliant.  */
468   {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
469   {NULL, 0, 0},
470 };
471
472 static tree c_fully_fold_internal (tree expr, bool, bool *, bool *);
473 static tree check_case_value (tree);
474 static bool check_case_bounds (tree, tree, tree *, tree *);
475
476 static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
477 static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
478 static tree handle_common_attribute (tree *, tree, tree, int, bool *);
479 static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
480 static tree handle_hot_attribute (tree *, tree, tree, int, bool *);
481 static tree handle_cold_attribute (tree *, tree, tree, int, bool *);
482 static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
483 static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
484 static tree handle_always_inline_attribute (tree *, tree, tree, int,
485                                             bool *);
486 static tree handle_gnu_inline_attribute (tree *, tree, tree, int, bool *);
487 static tree handle_artificial_attribute (tree *, tree, tree, int, bool *);
488 static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
489 static tree handle_error_attribute (tree *, tree, tree, int, bool *);
490 static tree handle_used_attribute (tree *, tree, tree, int, bool *);
491 static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
492 static tree handle_externally_visible_attribute (tree *, tree, tree, int,
493                                                  bool *);
494 static tree handle_const_attribute (tree *, tree, tree, int, bool *);
495 static tree handle_transparent_union_attribute (tree *, tree, tree,
496                                                 int, bool *);
497 static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
498 static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
499 static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
500 static tree handle_section_attribute (tree *, tree, tree, int, bool *);
501 static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
502 static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
503 static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
504 static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
505 static tree handle_visibility_attribute (tree *, tree, tree, int,
506                                          bool *);
507 static tree handle_tls_model_attribute (tree *, tree, tree, int,
508                                         bool *);
509 static tree handle_no_instrument_function_attribute (tree *, tree,
510                                                      tree, int, bool *);
511 static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
512 static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
513 static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
514                                              bool *);
515 static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
516 static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
517 static tree handle_deprecated_attribute (tree *, tree, tree, int,
518                                          bool *);
519 static tree handle_vector_size_attribute (tree *, tree, tree, int,
520                                           bool *);
521 static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
522 static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
523 static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
524 static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
525                                                  bool *);
526 static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
527 static tree handle_type_generic_attribute (tree *, tree, tree, int, bool *);
528 static tree handle_alloc_size_attribute (tree *, tree, tree, int, bool *);
529 static tree handle_target_attribute (tree *, tree, tree, int, bool *);
530 static tree handle_optimize_attribute (tree *, tree, tree, int, bool *);
531 static tree handle_fnspec_attribute (tree *, tree, tree, int, bool *);
532
533 static void check_function_nonnull (tree, int, tree *);
534 static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
535 static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
536 static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
537 static int resort_field_decl_cmp (const void *, const void *);
538
539 /* Reserved words.  The third field is a mask: keywords are disabled
540    if they match the mask.
541
542    Masks for languages:
543    C --std=c89: D_C99 | D_CXXONLY | D_OBJC | D_CXX_OBJC
544    C --std=c99: D_CXXONLY | D_OBJC
545    ObjC is like C except that D_OBJC and D_CXX_OBJC are not set
546    C++ --std=c98: D_CONLY | D_CXXOX | D_OBJC
547    C++ --std=c0x: D_CONLY | D_OBJC
548    ObjC++ is like C++ except that D_OBJC is not set
549
550    If -fno-asm is used, D_ASM is added to the mask.  If
551    -fno-gnu-keywords is used, D_EXT is added.  If -fno-asm and C in
552    C89 mode, D_EXT89 is added for both -fno-asm and -fno-gnu-keywords.
553    In C with -Wc++-compat, we warn if D_CXXWARN is set.  */
554
555 const struct c_common_resword c_common_reswords[] =
556 {
557   { "_Bool",            RID_BOOL,      D_CONLY },
558   { "_Complex",         RID_COMPLEX,    0 },
559   { "_Imaginary",       RID_IMAGINARY, D_CONLY },
560   { "_Decimal32",       RID_DFLOAT32,  D_CONLY | D_EXT },
561   { "_Decimal64",       RID_DFLOAT64,  D_CONLY | D_EXT },
562   { "_Decimal128",      RID_DFLOAT128, D_CONLY | D_EXT },
563   { "_Fract",           RID_FRACT,     D_CONLY | D_EXT },
564   { "_Accum",           RID_ACCUM,     D_CONLY | D_EXT },
565   { "_Sat",             RID_SAT,       D_CONLY | D_EXT },
566   { "_Static_assert",   RID_STATIC_ASSERT, D_CONLY },
567   { "__FUNCTION__",     RID_FUNCTION_NAME, 0 },
568   { "__PRETTY_FUNCTION__", RID_PRETTY_FUNCTION_NAME, 0 },
569   { "__alignof",        RID_ALIGNOF,    0 },
570   { "__alignof__",      RID_ALIGNOF,    0 },
571   { "__asm",            RID_ASM,        0 },
572   { "__asm__",          RID_ASM,        0 },
573   { "__attribute",      RID_ATTRIBUTE,  0 },
574   { "__attribute__",    RID_ATTRIBUTE,  0 },
575   { "__builtin_choose_expr", RID_CHOOSE_EXPR, D_CONLY },
576   { "__builtin_offsetof", RID_OFFSETOF, 0 },
577   { "__builtin_types_compatible_p", RID_TYPES_COMPATIBLE_P, D_CONLY },
578   { "__builtin_va_arg", RID_VA_ARG,     0 },
579   { "__complex",        RID_COMPLEX,    0 },
580   { "__complex__",      RID_COMPLEX,    0 },
581   { "__const",          RID_CONST,      0 },
582   { "__const__",        RID_CONST,      0 },
583   { "__decltype",       RID_DECLTYPE,   D_CXXONLY },
584   { "__extension__",    RID_EXTENSION,  0 },
585   { "__func__",         RID_C99_FUNCTION_NAME, 0 },
586   { "__has_nothrow_assign", RID_HAS_NOTHROW_ASSIGN, D_CXXONLY },
587   { "__has_nothrow_constructor", RID_HAS_NOTHROW_CONSTRUCTOR, D_CXXONLY },
588   { "__has_nothrow_copy", RID_HAS_NOTHROW_COPY, D_CXXONLY },
589   { "__has_trivial_assign", RID_HAS_TRIVIAL_ASSIGN, D_CXXONLY },
590   { "__has_trivial_constructor", RID_HAS_TRIVIAL_CONSTRUCTOR, D_CXXONLY },
591   { "__has_trivial_copy", RID_HAS_TRIVIAL_COPY, D_CXXONLY },
592   { "__has_trivial_destructor", RID_HAS_TRIVIAL_DESTRUCTOR, D_CXXONLY },
593   { "__has_virtual_destructor", RID_HAS_VIRTUAL_DESTRUCTOR, D_CXXONLY },
594   { "__is_abstract",    RID_IS_ABSTRACT, D_CXXONLY },
595   { "__is_base_of",     RID_IS_BASE_OF, D_CXXONLY },
596   { "__is_class",       RID_IS_CLASS,   D_CXXONLY },
597   { "__is_convertible_to", RID_IS_CONVERTIBLE_TO, D_CXXONLY },
598   { "__is_empty",       RID_IS_EMPTY,   D_CXXONLY },
599   { "__is_enum",        RID_IS_ENUM,    D_CXXONLY },
600   { "__is_pod",         RID_IS_POD,     D_CXXONLY },
601   { "__is_polymorphic", RID_IS_POLYMORPHIC, D_CXXONLY },
602   { "__is_standard_layout", RID_IS_STD_LAYOUT, D_CXXONLY },
603   { "__is_trivial",     RID_IS_TRIVIAL, D_CXXONLY },
604   { "__is_union",       RID_IS_UNION,   D_CXXONLY },
605   { "__imag",           RID_IMAGPART,   0 },
606   { "__imag__",         RID_IMAGPART,   0 },
607   { "__inline",         RID_INLINE,     0 },
608   { "__inline__",       RID_INLINE,     0 },
609   { "__label__",        RID_LABEL,      0 },
610   { "__null",           RID_NULL,       0 },
611   { "__real",           RID_REALPART,   0 },
612   { "__real__",         RID_REALPART,   0 },
613   { "__restrict",       RID_RESTRICT,   0 },
614   { "__restrict__",     RID_RESTRICT,   0 },
615   { "__signed",         RID_SIGNED,     0 },
616   { "__signed__",       RID_SIGNED,     0 },
617   { "__thread",         RID_THREAD,     0 },
618   { "__typeof",         RID_TYPEOF,     0 },
619   { "__typeof__",       RID_TYPEOF,     0 },
620   { "__volatile",       RID_VOLATILE,   0 },
621   { "__volatile__",     RID_VOLATILE,   0 },
622   { "alignof",          RID_ALIGNOF,    D_CXXONLY | D_CXX0X | D_CXXWARN },
623   { "asm",              RID_ASM,        D_ASM },
624   { "auto",             RID_AUTO,       0 },
625   { "bool",             RID_BOOL,       D_CXXONLY | D_CXXWARN },
626   { "break",            RID_BREAK,      0 },
627   { "case",             RID_CASE,       0 },
628   { "catch",            RID_CATCH,      D_CXX_OBJC | D_CXXWARN },
629   { "char",             RID_CHAR,       0 },
630   { "char16_t",         RID_CHAR16,     D_CXXONLY | D_CXX0X | D_CXXWARN },
631   { "char32_t",         RID_CHAR32,     D_CXXONLY | D_CXX0X | D_CXXWARN },
632   { "class",            RID_CLASS,      D_CXX_OBJC | D_CXXWARN },
633   { "const",            RID_CONST,      0 },
634   { "constexpr",        RID_CONSTEXPR,  D_CXXONLY | D_CXX0X | D_CXXWARN },
635   { "const_cast",       RID_CONSTCAST,  D_CXXONLY | D_CXXWARN },
636   { "continue",         RID_CONTINUE,   0 },
637   { "decltype",         RID_DECLTYPE,   D_CXXONLY | D_CXX0X | D_CXXWARN },
638   { "default",          RID_DEFAULT,    0 },
639   { "delete",           RID_DELETE,     D_CXXONLY | D_CXXWARN },
640   { "do",               RID_DO,         0 },
641   { "double",           RID_DOUBLE,     0 },
642   { "dynamic_cast",     RID_DYNCAST,    D_CXXONLY | D_CXXWARN },
643   { "else",             RID_ELSE,       0 },
644   { "enum",             RID_ENUM,       0 },
645   { "explicit",         RID_EXPLICIT,   D_CXXONLY | D_CXXWARN },
646   { "export",           RID_EXPORT,     D_CXXONLY | D_CXXWARN },
647   { "extern",           RID_EXTERN,     0 },
648   { "false",            RID_FALSE,      D_CXXONLY | D_CXXWARN },
649   { "float",            RID_FLOAT,      0 },
650   { "for",              RID_FOR,        0 },
651   { "friend",           RID_FRIEND,     D_CXXONLY | D_CXXWARN },
652   { "goto",             RID_GOTO,       0 },
653   { "if",               RID_IF,         0 },
654   { "inline",           RID_INLINE,     D_EXT89 },
655   { "int",              RID_INT,        0 },
656   { "long",             RID_LONG,       0 },
657   { "mutable",          RID_MUTABLE,    D_CXXONLY | D_CXXWARN },
658   { "namespace",        RID_NAMESPACE,  D_CXXONLY | D_CXXWARN },
659   { "new",              RID_NEW,        D_CXXONLY | D_CXXWARN },
660   { "nullptr",          RID_NULLPTR,    D_CXXONLY | D_CXX0X | D_CXXWARN },
661   { "operator",         RID_OPERATOR,   D_CXXONLY | D_CXXWARN },
662   { "private",          RID_PRIVATE,    D_CXX_OBJC | D_CXXWARN },
663   { "protected",        RID_PROTECTED,  D_CXX_OBJC | D_CXXWARN },
664   { "public",           RID_PUBLIC,     D_CXX_OBJC | D_CXXWARN },
665   { "register",         RID_REGISTER,   0 },
666   { "reinterpret_cast", RID_REINTCAST,  D_CXXONLY | D_CXXWARN },
667   { "restrict",         RID_RESTRICT,   D_CONLY | D_C99 },
668   { "return",           RID_RETURN,     0 },
669   { "short",            RID_SHORT,      0 },
670   { "signed",           RID_SIGNED,     0 },
671   { "sizeof",           RID_SIZEOF,     0 },
672   { "static",           RID_STATIC,     0 },
673   { "static_assert",    RID_STATIC_ASSERT, D_CXXONLY | D_CXX0X | D_CXXWARN },
674   { "static_cast",      RID_STATCAST,   D_CXXONLY | D_CXXWARN },
675   { "struct",           RID_STRUCT,     0 },
676   { "switch",           RID_SWITCH,     0 },
677   { "template",         RID_TEMPLATE,   D_CXXONLY | D_CXXWARN },
678   { "this",             RID_THIS,       D_CXXONLY | D_CXXWARN },
679   { "throw",            RID_THROW,      D_CXX_OBJC | D_CXXWARN },
680   { "true",             RID_TRUE,       D_CXXONLY | D_CXXWARN },
681   { "try",              RID_TRY,        D_CXX_OBJC | D_CXXWARN },
682   { "typedef",          RID_TYPEDEF,    0 },
683   { "typename",         RID_TYPENAME,   D_CXXONLY | D_CXXWARN },
684   { "typeid",           RID_TYPEID,     D_CXXONLY | D_CXXWARN },
685   { "typeof",           RID_TYPEOF,     D_ASM | D_EXT },
686   { "union",            RID_UNION,      0 },
687   { "unsigned",         RID_UNSIGNED,   0 },
688   { "using",            RID_USING,      D_CXXONLY | D_CXXWARN },
689   { "virtual",          RID_VIRTUAL,    D_CXXONLY | D_CXXWARN },
690   { "void",             RID_VOID,       0 },
691   { "volatile",         RID_VOLATILE,   0 },
692   { "wchar_t",          RID_WCHAR,      D_CXXONLY },
693   { "while",            RID_WHILE,      0 },
694   /* These Objective-C keywords are recognized only immediately after
695      an '@'.  */
696   { "compatibility_alias", RID_AT_ALIAS,        D_OBJC },
697   { "defs",             RID_AT_DEFS,            D_OBJC },
698   { "encode",           RID_AT_ENCODE,          D_OBJC },
699   { "end",              RID_AT_END,             D_OBJC },
700   { "implementation",   RID_AT_IMPLEMENTATION,  D_OBJC },
701   { "interface",        RID_AT_INTERFACE,       D_OBJC },
702   { "protocol",         RID_AT_PROTOCOL,        D_OBJC },
703   { "selector",         RID_AT_SELECTOR,        D_OBJC },
704   { "finally",          RID_AT_FINALLY,         D_OBJC },
705   { "synchronized",     RID_AT_SYNCHRONIZED,    D_OBJC },
706   /* These are recognized only in protocol-qualifier context
707      (see above) */
708   { "bycopy",           RID_BYCOPY,             D_OBJC },
709   { "byref",            RID_BYREF,              D_OBJC },
710   { "in",               RID_IN,                 D_OBJC },
711   { "inout",            RID_INOUT,              D_OBJC },
712   { "oneway",           RID_ONEWAY,             D_OBJC },
713   { "out",              RID_OUT,                D_OBJC },
714
715 #ifdef TARGET_ADDR_SPACE_KEYWORDS
716   /* Any address space keywords recognized by the target.  */
717   TARGET_ADDR_SPACE_KEYWORDS,
718 #endif
719 };
720
721 const unsigned int num_c_common_reswords =
722   sizeof c_common_reswords / sizeof (struct c_common_resword);
723
724 /* Table of machine-independent attributes common to all C-like languages.  */
725 const struct attribute_spec c_common_attribute_table[] =
726 {
727   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
728   { "packed",                 0, 0, false, false, false,
729                               handle_packed_attribute },
730   { "nocommon",               0, 0, true,  false, false,
731                               handle_nocommon_attribute },
732   { "common",                 0, 0, true,  false, false,
733                               handle_common_attribute },
734   /* FIXME: logically, noreturn attributes should be listed as
735      "false, true, true" and apply to function types.  But implementing this
736      would require all the places in the compiler that use TREE_THIS_VOLATILE
737      on a decl to identify non-returning functions to be located and fixed
738      to check the function type instead.  */
739   { "noreturn",               0, 0, true,  false, false,
740                               handle_noreturn_attribute },
741   { "volatile",               0, 0, true,  false, false,
742                               handle_noreturn_attribute },
743   { "noinline",               0, 0, true,  false, false,
744                               handle_noinline_attribute },
745   { "noclone",                0, 0, true,  false, false,
746                               handle_noclone_attribute },
747   { "always_inline",          0, 0, true,  false, false,
748                               handle_always_inline_attribute },
749   { "gnu_inline",             0, 0, true,  false, false,
750                               handle_gnu_inline_attribute },
751   { "artificial",             0, 0, true,  false, false,
752                               handle_artificial_attribute },
753   { "flatten",                0, 0, true,  false, false,
754                               handle_flatten_attribute },
755   { "used",                   0, 0, true,  false, false,
756                               handle_used_attribute },
757   { "unused",                 0, 0, false, false, false,
758                               handle_unused_attribute },
759   { "externally_visible",     0, 0, true,  false, false,
760                               handle_externally_visible_attribute },
761   /* The same comments as for noreturn attributes apply to const ones.  */
762   { "const",                  0, 0, true,  false, false,
763                               handle_const_attribute },
764   { "transparent_union",      0, 0, false, false, false,
765                               handle_transparent_union_attribute },
766   { "constructor",            0, 1, true,  false, false,
767                               handle_constructor_attribute },
768   { "destructor",             0, 1, true,  false, false,
769                               handle_destructor_attribute },
770   { "mode",                   1, 1, false,  true, false,
771                               handle_mode_attribute },
772   { "section",                1, 1, true,  false, false,
773                               handle_section_attribute },
774   { "aligned",                0, 1, false, false, false,
775                               handle_aligned_attribute },
776   { "weak",                   0, 0, true,  false, false,
777                               handle_weak_attribute },
778   { "alias",                  1, 1, true,  false, false,
779                               handle_alias_attribute },
780   { "weakref",                0, 1, true,  false, false,
781                               handle_weakref_attribute },
782   { "no_instrument_function", 0, 0, true,  false, false,
783                               handle_no_instrument_function_attribute },
784   { "malloc",                 0, 0, true,  false, false,
785                               handle_malloc_attribute },
786   { "returns_twice",          0, 0, true,  false, false,
787                               handle_returns_twice_attribute },
788   { "no_stack_limit",         0, 0, true,  false, false,
789                               handle_no_limit_stack_attribute },
790   { "pure",                   0, 0, true,  false, false,
791                               handle_pure_attribute },
792   /* For internal use (marking of builtins) only.  The name contains space
793      to prevent its usage in source code.  */
794   { "no vops",                0, 0, true,  false, false,
795                               handle_novops_attribute },
796   { "deprecated",             0, 1, false, false, false,
797                               handle_deprecated_attribute },
798   { "vector_size",            1, 1, false, true, false,
799                               handle_vector_size_attribute },
800   { "visibility",             1, 1, false, false, false,
801                               handle_visibility_attribute },
802   { "tls_model",              1, 1, true,  false, false,
803                               handle_tls_model_attribute },
804   { "nonnull",                0, -1, false, true, true,
805                               handle_nonnull_attribute },
806   { "nothrow",                0, 0, true,  false, false,
807                               handle_nothrow_attribute },
808   { "may_alias",              0, 0, false, true, false, NULL },
809   { "cleanup",                1, 1, true, false, false,
810                               handle_cleanup_attribute },
811   { "warn_unused_result",     0, 0, false, true, true,
812                               handle_warn_unused_result_attribute },
813   { "sentinel",               0, 1, false, true, true,
814                               handle_sentinel_attribute },
815   /* For internal use (marking of builtins) only.  The name contains space
816      to prevent its usage in source code.  */
817   { "type generic",           0, 0, false, true, true,
818                               handle_type_generic_attribute },
819   { "alloc_size",             1, 2, false, true, true,
820                               handle_alloc_size_attribute },
821   { "cold",                   0, 0, true,  false, false,
822                               handle_cold_attribute },
823   { "hot",                    0, 0, true,  false, false,
824                               handle_hot_attribute },
825   { "warning",                1, 1, true,  false, false,
826                               handle_error_attribute },
827   { "error",                  1, 1, true,  false, false,
828                               handle_error_attribute },
829   { "target",                 1, -1, true, false, false,
830                               handle_target_attribute },
831   { "optimize",               1, -1, true, false, false,
832                               handle_optimize_attribute },
833   /* For internal use (marking of builtins and runtime functions) only.
834      The name contains space to prevent its usage in source code.  */
835   { "fn spec",                1, 1, false, true, true,
836                               handle_fnspec_attribute },
837   { NULL,                     0, 0, false, false, false, NULL }
838 };
839
840 /* Give the specifications for the format attributes, used by C and all
841    descendants.  */
842
843 const struct attribute_spec c_common_format_attribute_table[] =
844 {
845   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
846   { "format",                 3, 3, false, true,  true,
847                               handle_format_attribute },
848   { "format_arg",             1, 1, false, true,  true,
849                               handle_format_arg_attribute },
850   { NULL,                     0, 0, false, false, false, NULL }
851 };
852
853 /* Return identifier for address space AS.  */
854 const char *
855 c_addr_space_name (addr_space_t as)
856 {
857   unsigned int i;
858
859   for (i = 0; i < num_c_common_reswords; i++)
860     if (c_common_reswords[i].rid == RID_FIRST_ADDR_SPACE + as)
861       return c_common_reswords[i].word;
862
863   gcc_unreachable ();
864 }
865
866 /* Push current bindings for the function name VAR_DECLS.  */
867
868 void
869 start_fname_decls (void)
870 {
871   unsigned ix;
872   tree saved = NULL_TREE;
873
874   for (ix = 0; fname_vars[ix].decl; ix++)
875     {
876       tree decl = *fname_vars[ix].decl;
877
878       if (decl)
879         {
880           saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
881           *fname_vars[ix].decl = NULL_TREE;
882         }
883     }
884   if (saved || saved_function_name_decls)
885     /* Normally they'll have been NULL, so only push if we've got a
886        stack, or they are non-NULL.  */
887     saved_function_name_decls = tree_cons (saved, NULL_TREE,
888                                            saved_function_name_decls);
889 }
890
891 /* Finish up the current bindings, adding them into the current function's
892    statement tree.  This must be done _before_ finish_stmt_tree is called.
893    If there is no current function, we must be at file scope and no statements
894    are involved. Pop the previous bindings.  */
895
896 void
897 finish_fname_decls (void)
898 {
899   unsigned ix;
900   tree stmts = NULL_TREE;
901   tree stack = saved_function_name_decls;
902
903   for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
904     append_to_statement_list (TREE_VALUE (stack), &stmts);
905
906   if (stmts)
907     {
908       tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
909
910       if (TREE_CODE (*bodyp) == BIND_EXPR)
911         bodyp = &BIND_EXPR_BODY (*bodyp);
912
913       append_to_statement_list_force (*bodyp, &stmts);
914       *bodyp = stmts;
915     }
916
917   for (ix = 0; fname_vars[ix].decl; ix++)
918     *fname_vars[ix].decl = NULL_TREE;
919
920   if (stack)
921     {
922       /* We had saved values, restore them.  */
923       tree saved;
924
925       for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
926         {
927           tree decl = TREE_PURPOSE (saved);
928           unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
929
930           *fname_vars[ix].decl = decl;
931         }
932       stack = TREE_CHAIN (stack);
933     }
934   saved_function_name_decls = stack;
935 }
936
937 /* Return the text name of the current function, suitably prettified
938    by PRETTY_P.  Return string must be freed by caller.  */
939
940 const char *
941 fname_as_string (int pretty_p)
942 {
943   const char *name = "top level";
944   char *namep;
945   int vrb = 2, len;
946   cpp_string cstr = { 0, 0 }, strname;
947
948   if (!pretty_p)
949     {
950       name = "";
951       vrb = 0;
952     }
953
954   if (current_function_decl)
955     name = lang_hooks.decl_printable_name (current_function_decl, vrb);
956
957   len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
958
959   namep = XNEWVEC (char, len);
960   snprintf (namep, len, "\"%s\"", name);
961   strname.text = (unsigned char *) namep;
962   strname.len = len - 1;
963
964   if (cpp_interpret_string (parse_in, &strname, 1, &cstr, CPP_STRING))
965     {
966       XDELETEVEC (namep);
967       return (const char *) cstr.text;
968     }
969
970   return namep;
971 }
972
973 /* Return the VAR_DECL for a const char array naming the current
974    function. If the VAR_DECL has not yet been created, create it
975    now. RID indicates how it should be formatted and IDENTIFIER_NODE
976    ID is its name (unfortunately C and C++ hold the RID values of
977    keywords in different places, so we can't derive RID from ID in
978    this language independent code. LOC is the location of the
979    function.  */
980
981 tree
982 fname_decl (location_t loc, unsigned int rid, tree id)
983 {
984   unsigned ix;
985   tree decl = NULL_TREE;
986
987   for (ix = 0; fname_vars[ix].decl; ix++)
988     if (fname_vars[ix].rid == rid)
989       break;
990
991   decl = *fname_vars[ix].decl;
992   if (!decl)
993     {
994       /* If a tree is built here, it would normally have the lineno of
995          the current statement.  Later this tree will be moved to the
996          beginning of the function and this line number will be wrong.
997          To avoid this problem set the lineno to 0 here; that prevents
998          it from appearing in the RTL.  */
999       tree stmts;
1000       location_t saved_location = input_location;
1001       input_location = UNKNOWN_LOCATION;
1002
1003       stmts = push_stmt_list ();
1004       decl = (*make_fname_decl) (loc, id, fname_vars[ix].pretty);
1005       stmts = pop_stmt_list (stmts);
1006       if (!IS_EMPTY_STMT (stmts))
1007         saved_function_name_decls
1008           = tree_cons (decl, stmts, saved_function_name_decls);
1009       *fname_vars[ix].decl = decl;
1010       input_location = saved_location;
1011     }
1012   if (!ix && !current_function_decl)
1013     pedwarn (loc, 0, "%qD is not defined outside of function scope", decl);
1014
1015   return decl;
1016 }
1017
1018 /* Given a STRING_CST, give it a suitable array-of-chars data type.  */
1019
1020 tree
1021 fix_string_type (tree value)
1022 {
1023   int length = TREE_STRING_LENGTH (value);
1024   int nchars;
1025   tree e_type, i_type, a_type;
1026
1027   /* Compute the number of elements, for the array type.  */
1028   if (TREE_TYPE (value) == char_array_type_node || !TREE_TYPE (value))
1029     {
1030       nchars = length;
1031       e_type = char_type_node;
1032     }
1033   else if (TREE_TYPE (value) == char16_array_type_node)
1034     {
1035       nchars = length / (TYPE_PRECISION (char16_type_node) / BITS_PER_UNIT);
1036       e_type = char16_type_node;
1037     }
1038   else if (TREE_TYPE (value) == char32_array_type_node)
1039     {
1040       nchars = length / (TYPE_PRECISION (char32_type_node) / BITS_PER_UNIT);
1041       e_type = char32_type_node;
1042     }
1043   else
1044     {
1045       nchars = length / (TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT);
1046       e_type = wchar_type_node;
1047     }
1048
1049   /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
1050      limit in C++98 Annex B is very large (65536) and is not normative,
1051      so we do not diagnose it (warn_overlength_strings is forced off
1052      in c_common_post_options).  */
1053   if (warn_overlength_strings)
1054     {
1055       const int nchars_max = flag_isoc99 ? 4095 : 509;
1056       const int relevant_std = flag_isoc99 ? 99 : 90;
1057       if (nchars - 1 > nchars_max)
1058         /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
1059            separate the %d from the 'C'.  'ISO' should not be
1060            translated, but it may be moved after 'C%d' in languages
1061            where modifiers follow nouns.  */
1062         pedwarn (input_location, OPT_Woverlength_strings,
1063                  "string length %qd is greater than the length %qd "
1064                  "ISO C%d compilers are required to support",
1065                  nchars - 1, nchars_max, relevant_std);
1066     }
1067
1068   /* Create the array type for the string constant.  The ISO C++
1069      standard says that a string literal has type `const char[N]' or
1070      `const wchar_t[N]'.  We use the same logic when invoked as a C
1071      front-end with -Wwrite-strings.
1072      ??? We should change the type of an expression depending on the
1073      state of a warning flag.  We should just be warning -- see how
1074      this is handled in the C++ front-end for the deprecated implicit
1075      conversion from string literals to `char*' or `wchar_t*'.
1076
1077      The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
1078      array type being the unqualified version of that type.
1079      Therefore, if we are constructing an array of const char, we must
1080      construct the matching unqualified array type first.  The C front
1081      end does not require this, but it does no harm, so we do it
1082      unconditionally.  */
1083   i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
1084   a_type = build_array_type (e_type, i_type);
1085   if (c_dialect_cxx() || warn_write_strings)
1086     a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
1087
1088   TREE_TYPE (value) = a_type;
1089   TREE_CONSTANT (value) = 1;
1090   TREE_READONLY (value) = 1;
1091   TREE_STATIC (value) = 1;
1092   return value;
1093 }
1094 \f
1095 /* Fully fold EXPR, an expression that was not folded (beyond integer
1096    constant expressions and null pointer constants) when being built
1097    up.  If IN_INIT, this is in a static initializer and certain
1098    changes are made to the folding done.  Clear *MAYBE_CONST if
1099    MAYBE_CONST is not NULL and EXPR is definitely not a constant
1100    expression because it contains an evaluated operator (in C99) or an
1101    operator outside of sizeof returning an integer constant (in C90)
1102    not permitted in constant expressions, or because it contains an
1103    evaluated arithmetic overflow.  (*MAYBE_CONST should typically be
1104    set to true by callers before calling this function.)  Return the
1105    folded expression.  Function arguments have already been folded
1106    before calling this function, as have the contents of SAVE_EXPR,
1107    TARGET_EXPR, BIND_EXPR, VA_ARG_EXPR, OBJ_TYPE_REF and
1108    C_MAYBE_CONST_EXPR.  */
1109
1110 tree
1111 c_fully_fold (tree expr, bool in_init, bool *maybe_const)
1112 {
1113   tree ret;
1114   tree eptype = NULL_TREE;
1115   bool dummy = true;
1116   bool maybe_const_itself = true;
1117   location_t loc = EXPR_LOCATION (expr);
1118
1119   /* This function is not relevant to C++ because C++ folds while
1120      parsing, and may need changes to be correct for C++ when C++
1121      stops folding while parsing.  */
1122   if (c_dialect_cxx ())
1123     gcc_unreachable ();
1124
1125   if (!maybe_const)
1126     maybe_const = &dummy;
1127   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
1128     {
1129       eptype = TREE_TYPE (expr);
1130       expr = TREE_OPERAND (expr, 0);
1131     }
1132   ret = c_fully_fold_internal (expr, in_init, maybe_const,
1133                                &maybe_const_itself);
1134   if (eptype)
1135     ret = fold_convert_loc (loc, eptype, ret);
1136   *maybe_const &= maybe_const_itself;
1137   return ret;
1138 }
1139
1140 /* Internal helper for c_fully_fold.  EXPR and IN_INIT are as for
1141    c_fully_fold.  *MAYBE_CONST_OPERANDS is cleared because of operands
1142    not permitted, while *MAYBE_CONST_ITSELF is cleared because of
1143    arithmetic overflow (for C90, *MAYBE_CONST_OPERANDS is carried from
1144    both evaluated and unevaluated subexpressions while
1145    *MAYBE_CONST_ITSELF is carried from only evaluated
1146    subexpressions).  */
1147
1148 static tree
1149 c_fully_fold_internal (tree expr, bool in_init, bool *maybe_const_operands,
1150                        bool *maybe_const_itself)
1151 {
1152   tree ret = expr;
1153   enum tree_code code = TREE_CODE (expr);
1154   enum tree_code_class kind = TREE_CODE_CLASS (code);
1155   location_t loc = EXPR_LOCATION (expr);
1156   tree op0, op1, op2, op3;
1157   tree orig_op0, orig_op1, orig_op2;
1158   bool op0_const = true, op1_const = true, op2_const = true;
1159   bool op0_const_self = true, op1_const_self = true, op2_const_self = true;
1160   bool nowarning = TREE_NO_WARNING (expr);
1161   int unused_p;
1162
1163   /* This function is not relevant to C++ because C++ folds while
1164      parsing, and may need changes to be correct for C++ when C++
1165      stops folding while parsing.  */
1166   if (c_dialect_cxx ())
1167     gcc_unreachable ();
1168
1169   /* Constants, declarations, statements, errors, SAVE_EXPRs and
1170      anything else not counted as an expression cannot usefully be
1171      folded further at this point.  */
1172   if (!IS_EXPR_CODE_CLASS (kind)
1173       || kind == tcc_statement
1174       || code == SAVE_EXPR)
1175     return expr;
1176
1177   /* Operands of variable-length expressions (function calls) have
1178      already been folded, as have __builtin_* function calls, and such
1179      expressions cannot occur in constant expressions.  */
1180   if (kind == tcc_vl_exp)
1181     {
1182       *maybe_const_operands = false;
1183       ret = fold (expr);
1184       goto out;
1185     }
1186
1187   if (code == C_MAYBE_CONST_EXPR)
1188     {
1189       tree pre = C_MAYBE_CONST_EXPR_PRE (expr);
1190       tree inner = C_MAYBE_CONST_EXPR_EXPR (expr);
1191       if (C_MAYBE_CONST_EXPR_NON_CONST (expr))
1192         *maybe_const_operands = false;
1193       if (C_MAYBE_CONST_EXPR_INT_OPERANDS (expr))
1194         *maybe_const_itself = false;
1195       if (pre && !in_init)
1196         ret = build2 (COMPOUND_EXPR, TREE_TYPE (expr), pre, inner);
1197       else
1198         ret = inner;
1199       goto out;
1200     }
1201
1202   /* Assignment, increment, decrement, function call and comma
1203      operators, and statement expressions, cannot occur in constant
1204      expressions if evaluated / outside of sizeof.  (Function calls
1205      were handled above, though VA_ARG_EXPR is treated like a function
1206      call here, and statement expressions are handled through
1207      C_MAYBE_CONST_EXPR to avoid folding inside them.)  */
1208   switch (code)
1209     {
1210     case MODIFY_EXPR:
1211     case PREDECREMENT_EXPR:
1212     case PREINCREMENT_EXPR:
1213     case POSTDECREMENT_EXPR:
1214     case POSTINCREMENT_EXPR:
1215     case COMPOUND_EXPR:
1216       *maybe_const_operands = false;
1217       break;
1218
1219     case VA_ARG_EXPR:
1220     case TARGET_EXPR:
1221     case BIND_EXPR:
1222     case OBJ_TYPE_REF:
1223       *maybe_const_operands = false;
1224       ret = fold (expr);
1225       goto out;
1226
1227     default:
1228       break;
1229     }
1230
1231   /* Fold individual tree codes as appropriate.  */
1232   switch (code)
1233     {
1234     case COMPOUND_LITERAL_EXPR:
1235       /* Any non-constancy will have been marked in a containing
1236          C_MAYBE_CONST_EXPR; there is no more folding to do here.  */
1237       goto out;
1238
1239     case COMPONENT_REF:
1240       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1241       op1 = TREE_OPERAND (expr, 1);
1242       op2 = TREE_OPERAND (expr, 2);
1243       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1244                                    maybe_const_itself);
1245       STRIP_TYPE_NOPS (op0);
1246       if (op0 != orig_op0)
1247         ret = build3 (COMPONENT_REF, TREE_TYPE (expr), op0, op1, op2);
1248       if (ret != expr)
1249         {
1250           TREE_READONLY (ret) = TREE_READONLY (expr);
1251           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1252         }
1253       goto out;
1254
1255     case ARRAY_REF:
1256       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1257       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1258       op2 = TREE_OPERAND (expr, 2);
1259       op3 = TREE_OPERAND (expr, 3);
1260       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1261                                    maybe_const_itself);
1262       STRIP_TYPE_NOPS (op0);
1263       op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1264                                    maybe_const_itself);
1265       STRIP_TYPE_NOPS (op1);
1266       op1 = decl_constant_value_for_optimization (op1);
1267       if (op0 != orig_op0 || op1 != orig_op1)
1268         ret = build4 (ARRAY_REF, TREE_TYPE (expr), op0, op1, op2, op3);
1269       if (ret != expr)
1270         {
1271           TREE_READONLY (ret) = TREE_READONLY (expr);
1272           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1273           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1274         }
1275       ret = fold (ret);
1276       goto out;
1277
1278     case COMPOUND_EXPR:
1279     case MODIFY_EXPR:
1280     case PREDECREMENT_EXPR:
1281     case PREINCREMENT_EXPR:
1282     case POSTDECREMENT_EXPR:
1283     case POSTINCREMENT_EXPR:
1284     case PLUS_EXPR:
1285     case MINUS_EXPR:
1286     case MULT_EXPR:
1287     case POINTER_PLUS_EXPR:
1288     case TRUNC_DIV_EXPR:
1289     case CEIL_DIV_EXPR:
1290     case FLOOR_DIV_EXPR:
1291     case TRUNC_MOD_EXPR:
1292     case RDIV_EXPR:
1293     case EXACT_DIV_EXPR:
1294     case LSHIFT_EXPR:
1295     case RSHIFT_EXPR:
1296     case BIT_IOR_EXPR:
1297     case BIT_XOR_EXPR:
1298     case BIT_AND_EXPR:
1299     case LT_EXPR:
1300     case LE_EXPR:
1301     case GT_EXPR:
1302     case GE_EXPR:
1303     case EQ_EXPR:
1304     case NE_EXPR:
1305     case COMPLEX_EXPR:
1306     case TRUTH_AND_EXPR:
1307     case TRUTH_OR_EXPR:
1308     case TRUTH_XOR_EXPR:
1309     case UNORDERED_EXPR:
1310     case ORDERED_EXPR:
1311     case UNLT_EXPR:
1312     case UNLE_EXPR:
1313     case UNGT_EXPR:
1314     case UNGE_EXPR:
1315     case UNEQ_EXPR:
1316       /* Binary operations evaluating both arguments (increment and
1317          decrement are binary internally in GCC).  */
1318       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1319       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1320       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1321                                    maybe_const_itself);
1322       STRIP_TYPE_NOPS (op0);
1323       if (code != MODIFY_EXPR
1324           && code != PREDECREMENT_EXPR
1325           && code != PREINCREMENT_EXPR
1326           && code != POSTDECREMENT_EXPR
1327           && code != POSTINCREMENT_EXPR)
1328         op0 = decl_constant_value_for_optimization (op0);
1329       /* The RHS of a MODIFY_EXPR was fully folded when building that
1330          expression for the sake of conversion warnings.  */
1331       if (code != MODIFY_EXPR)
1332         op1 = c_fully_fold_internal (op1, in_init, maybe_const_operands,
1333                                      maybe_const_itself);
1334       STRIP_TYPE_NOPS (op1);
1335       op1 = decl_constant_value_for_optimization (op1);
1336       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1337         ret = in_init
1338           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1339           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1340       else
1341         ret = fold (expr);
1342       if (TREE_OVERFLOW_P (ret)
1343           && !TREE_OVERFLOW_P (op0)
1344           && !TREE_OVERFLOW_P (op1))
1345         overflow_warning (EXPR_LOCATION (expr), ret);
1346       goto out;
1347
1348     case INDIRECT_REF:
1349     case FIX_TRUNC_EXPR:
1350     case FLOAT_EXPR:
1351     CASE_CONVERT:
1352     case NON_LVALUE_EXPR:
1353     case NEGATE_EXPR:
1354     case BIT_NOT_EXPR:
1355     case TRUTH_NOT_EXPR:
1356     case ADDR_EXPR:
1357     case CONJ_EXPR:
1358     case REALPART_EXPR:
1359     case IMAGPART_EXPR:
1360       /* Unary operations.  */
1361       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1362       op0 = c_fully_fold_internal (op0, in_init, maybe_const_operands,
1363                                    maybe_const_itself);
1364       STRIP_TYPE_NOPS (op0);
1365       if (code != ADDR_EXPR && code != REALPART_EXPR && code != IMAGPART_EXPR)
1366         op0 = decl_constant_value_for_optimization (op0);
1367       if (op0 != orig_op0 || in_init)
1368         ret = in_init
1369           ? fold_build1_initializer_loc (loc, code, TREE_TYPE (expr), op0)
1370           : fold_build1_loc (loc, code, TREE_TYPE (expr), op0);
1371       else
1372         ret = fold (expr);
1373       if (code == INDIRECT_REF
1374           && ret != expr
1375           && TREE_CODE (ret) == INDIRECT_REF)
1376         {
1377           TREE_READONLY (ret) = TREE_READONLY (expr);
1378           TREE_SIDE_EFFECTS (ret) = TREE_SIDE_EFFECTS (expr);
1379           TREE_THIS_VOLATILE (ret) = TREE_THIS_VOLATILE (expr);
1380         }
1381       switch (code)
1382         {
1383         case FIX_TRUNC_EXPR:
1384         case FLOAT_EXPR:
1385         CASE_CONVERT:
1386           /* Don't warn about explicit conversions.  We will already
1387              have warned about suspect implicit conversions.  */
1388           break;
1389
1390         default:
1391           if (TREE_OVERFLOW_P (ret) && !TREE_OVERFLOW_P (op0))
1392             overflow_warning (EXPR_LOCATION (expr), ret);
1393           break;
1394         }
1395       goto out;
1396
1397     case TRUTH_ANDIF_EXPR:
1398     case TRUTH_ORIF_EXPR:
1399       /* Binary operations not necessarily evaluating both
1400          arguments.  */
1401       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1402       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1403       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1404       STRIP_TYPE_NOPS (op0);
1405
1406       unused_p = (op0 == (code == TRUTH_ANDIF_EXPR
1407                           ? truthvalue_false_node
1408                           : truthvalue_true_node));
1409       c_inhibit_evaluation_warnings += unused_p;
1410       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1411       STRIP_TYPE_NOPS (op1);
1412       c_inhibit_evaluation_warnings -= unused_p;
1413
1414       if (op0 != orig_op0 || op1 != orig_op1 || in_init)
1415         ret = in_init
1416           ? fold_build2_initializer_loc (loc, code, TREE_TYPE (expr), op0, op1)
1417           : fold_build2_loc (loc, code, TREE_TYPE (expr), op0, op1);
1418       else
1419         ret = fold (expr);
1420       *maybe_const_operands &= op0_const;
1421       *maybe_const_itself &= op0_const_self;
1422       if (!(flag_isoc99
1423             && op0_const
1424             && op0_const_self
1425             && (code == TRUTH_ANDIF_EXPR
1426                 ? op0 == truthvalue_false_node
1427                 : op0 == truthvalue_true_node)))
1428         *maybe_const_operands &= op1_const;
1429       if (!(op0_const
1430             && op0_const_self
1431             && (code == TRUTH_ANDIF_EXPR
1432                 ? op0 == truthvalue_false_node
1433                 : op0 == truthvalue_true_node)))
1434         *maybe_const_itself &= op1_const_self;
1435       goto out;
1436
1437     case COND_EXPR:
1438       orig_op0 = op0 = TREE_OPERAND (expr, 0);
1439       orig_op1 = op1 = TREE_OPERAND (expr, 1);
1440       orig_op2 = op2 = TREE_OPERAND (expr, 2);
1441       op0 = c_fully_fold_internal (op0, in_init, &op0_const, &op0_const_self);
1442
1443       STRIP_TYPE_NOPS (op0);
1444       c_inhibit_evaluation_warnings += (op0 == truthvalue_false_node);
1445       op1 = c_fully_fold_internal (op1, in_init, &op1_const, &op1_const_self);
1446       STRIP_TYPE_NOPS (op1);
1447       c_inhibit_evaluation_warnings -= (op0 == truthvalue_false_node);
1448
1449       c_inhibit_evaluation_warnings += (op0 == truthvalue_true_node);
1450       op2 = c_fully_fold_internal (op2, in_init, &op2_const, &op2_const_self);
1451       STRIP_TYPE_NOPS (op2);
1452       c_inhibit_evaluation_warnings -= (op0 == truthvalue_true_node);
1453
1454       if (op0 != orig_op0 || op1 != orig_op1 || op2 != orig_op2)
1455         ret = fold_build3_loc (loc, code, TREE_TYPE (expr), op0, op1, op2);
1456       else
1457         ret = fold (expr);
1458       *maybe_const_operands &= op0_const;
1459       *maybe_const_itself &= op0_const_self;
1460       if (!(flag_isoc99
1461             && op0_const
1462             && op0_const_self
1463             && op0 == truthvalue_false_node))
1464         *maybe_const_operands &= op1_const;
1465       if (!(op0_const
1466             && op0_const_self
1467             && op0 == truthvalue_false_node))
1468         *maybe_const_itself &= op1_const_self;
1469       if (!(flag_isoc99
1470             && op0_const
1471             && op0_const_self
1472             && op0 == truthvalue_true_node))
1473         *maybe_const_operands &= op2_const;
1474       if (!(op0_const
1475             && op0_const_self
1476             && op0 == truthvalue_true_node))
1477         *maybe_const_itself &= op2_const_self;
1478       goto out;
1479
1480     case EXCESS_PRECISION_EXPR:
1481       /* Each case where an operand with excess precision may be
1482          encountered must remove the EXCESS_PRECISION_EXPR around
1483          inner operands and possibly put one around the whole
1484          expression or possibly convert to the semantic type (which
1485          c_fully_fold does); we cannot tell at this stage which is
1486          appropriate in any particular case.  */
1487       gcc_unreachable ();
1488
1489     default:
1490       /* Various codes may appear through folding built-in functions
1491          and their arguments.  */
1492       goto out;
1493     }
1494
1495  out:
1496   /* Some folding may introduce NON_LVALUE_EXPRs; all lvalue checks
1497      have been done by this point, so remove them again.  */
1498   nowarning |= TREE_NO_WARNING (ret);
1499   STRIP_TYPE_NOPS (ret);
1500   if (nowarning && !TREE_NO_WARNING (ret))
1501     {
1502       if (!CAN_HAVE_LOCATION_P (ret))
1503         ret = build1 (NOP_EXPR, TREE_TYPE (ret), ret);
1504       TREE_NO_WARNING (ret) = 1;
1505     }
1506   if (ret != expr)
1507     protected_set_expr_location (ret, loc);
1508   return ret;
1509 }
1510
1511 /* If not optimizing, EXP is not a VAR_DECL, or EXP has array type,
1512    return EXP.  Otherwise, return either EXP or its known constant
1513    value (if it has one), but return EXP if EXP has mode BLKmode.  ???
1514    Is the BLKmode test appropriate?  */
1515
1516 tree
1517 decl_constant_value_for_optimization (tree exp)
1518 {
1519   tree ret;
1520
1521   /* This function is only used by C, for c_fully_fold and other
1522      optimization, and may not be correct for C++.  */
1523   if (c_dialect_cxx ())
1524     gcc_unreachable ();
1525
1526   if (!optimize
1527       || TREE_CODE (exp) != VAR_DECL
1528       || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
1529       || DECL_MODE (exp) == BLKmode)
1530     return exp;
1531
1532   ret = decl_constant_value (exp);
1533   /* Avoid unwanted tree sharing between the initializer and current
1534      function's body where the tree can be modified e.g. by the
1535      gimplifier.  */
1536   if (ret != exp && TREE_STATIC (exp))
1537     ret = unshare_expr (ret);
1538   return ret;
1539 }
1540
1541 /* Print a warning if a constant expression had overflow in folding.
1542    Invoke this function on every expression that the language
1543    requires to be a constant expression.
1544    Note the ANSI C standard says it is erroneous for a
1545    constant expression to overflow.  */
1546
1547 void
1548 constant_expression_warning (tree value)
1549 {
1550   if (warn_overflow && pedantic
1551       && (TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1552           || TREE_CODE (value) == FIXED_CST
1553           || TREE_CODE (value) == VECTOR_CST
1554           || TREE_CODE (value) == COMPLEX_CST)
1555       && TREE_OVERFLOW (value))
1556     pedwarn (input_location, OPT_Woverflow, "overflow in constant expression");
1557 }
1558
1559 /* The same as above but print an unconditional error.  */
1560 void
1561 constant_expression_error (tree value)
1562 {
1563   if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
1564        || TREE_CODE (value) == FIXED_CST
1565        || TREE_CODE (value) == VECTOR_CST
1566        || TREE_CODE (value) == COMPLEX_CST)
1567       && TREE_OVERFLOW (value))
1568     error ("overflow in constant expression");
1569 }
1570
1571 /* Print a warning if an expression had overflow in folding and its
1572    operands hadn't.
1573
1574    Invoke this function on every expression that
1575    (1) appears in the source code, and
1576    (2) is a constant expression that overflowed, and
1577    (3) is not already checked by convert_and_check;
1578    however, do not invoke this function on operands of explicit casts
1579    or when the expression is the result of an operator and any operand
1580    already overflowed.  */
1581
1582 void
1583 overflow_warning (location_t loc, tree value)
1584 {
1585   if (c_inhibit_evaluation_warnings != 0)
1586     return;
1587
1588   switch (TREE_CODE (value))
1589     {
1590     case INTEGER_CST:
1591       warning_at (loc, OPT_Woverflow, "integer overflow in expression");
1592       break;
1593
1594     case REAL_CST:
1595       warning_at (loc, OPT_Woverflow,
1596                   "floating point overflow in expression");
1597       break;
1598
1599     case FIXED_CST:
1600       warning_at (loc, OPT_Woverflow, "fixed-point overflow in expression");
1601       break;
1602
1603     case VECTOR_CST:
1604       warning_at (loc, OPT_Woverflow, "vector overflow in expression");
1605       break;
1606
1607     case COMPLEX_CST:
1608       if (TREE_CODE (TREE_REALPART (value)) == INTEGER_CST)
1609         warning_at (loc, OPT_Woverflow,
1610                     "complex integer overflow in expression");
1611       else if (TREE_CODE (TREE_REALPART (value)) == REAL_CST)
1612         warning_at (loc, OPT_Woverflow,
1613                     "complex floating point overflow in expression");
1614       break;
1615
1616     default:
1617       break;
1618     }
1619 }
1620
1621 /* Warn about uses of logical || / && operator in a context where it
1622    is likely that the bitwise equivalent was intended by the
1623    programmer.  We have seen an expression in which CODE is a binary
1624    operator used to combine expressions OP_LEFT and OP_RIGHT, which before folding
1625    had CODE_LEFT and CODE_RIGHT, into an expression of type TYPE.  */
1626 void
1627 warn_logical_operator (location_t location, enum tree_code code, tree type,
1628                        enum tree_code code_left, tree op_left,
1629                        enum tree_code ARG_UNUSED (code_right), tree op_right)
1630 {
1631   int or_op = (code == TRUTH_ORIF_EXPR || code == TRUTH_OR_EXPR);
1632   int in0_p, in1_p, in_p;
1633   tree low0, low1, low, high0, high1, high, lhs, rhs, tem;
1634   bool strict_overflow_p = false;
1635
1636   if (code != TRUTH_ANDIF_EXPR
1637       && code != TRUTH_AND_EXPR
1638       && code != TRUTH_ORIF_EXPR
1639       && code != TRUTH_OR_EXPR)
1640     return;
1641
1642   /* Warn if &&/|| are being used in a context where it is
1643      likely that the bitwise equivalent was intended by the
1644      programmer. That is, an expression such as op && MASK
1645      where op should not be any boolean expression, nor a
1646      constant, and mask seems to be a non-boolean integer constant.  */
1647   if (!truth_value_p (code_left)
1648       && INTEGRAL_TYPE_P (TREE_TYPE (op_left))
1649       && !CONSTANT_CLASS_P (op_left)
1650       && !TREE_NO_WARNING (op_left)
1651       && TREE_CODE (op_right) == INTEGER_CST
1652       && !integer_zerop (op_right)
1653       && !integer_onep (op_right))
1654     {
1655       if (or_op)
1656         warning_at (location, OPT_Wlogical_op, "logical %<or%>"
1657                     " applied to non-boolean constant");
1658       else
1659         warning_at (location, OPT_Wlogical_op, "logical %<and%>"
1660                     " applied to non-boolean constant");
1661       TREE_NO_WARNING (op_left) = true;
1662       return;
1663     }
1664
1665   /* We do not warn for constants because they are typical of macro
1666      expansions that test for features.  */
1667   if (CONSTANT_CLASS_P (op_left) || CONSTANT_CLASS_P (op_right))
1668     return;
1669
1670   /* This warning only makes sense with logical operands.  */
1671   if (!(truth_value_p (TREE_CODE (op_left))
1672         || INTEGRAL_TYPE_P (TREE_TYPE (op_left)))
1673       || !(truth_value_p (TREE_CODE (op_right))
1674            || INTEGRAL_TYPE_P (TREE_TYPE (op_right))))
1675     return;
1676
1677   lhs = make_range (op_left, &in0_p, &low0, &high0, &strict_overflow_p);
1678   rhs = make_range (op_right, &in1_p, &low1, &high1, &strict_overflow_p);
1679
1680   if (lhs && TREE_CODE (lhs) == C_MAYBE_CONST_EXPR)
1681     lhs = C_MAYBE_CONST_EXPR_EXPR (lhs);
1682
1683   if (rhs && TREE_CODE (rhs) == C_MAYBE_CONST_EXPR)
1684     rhs = C_MAYBE_CONST_EXPR_EXPR (rhs);
1685
1686   /* If this is an OR operation, invert both sides; we will invert
1687      again at the end.  */
1688   if (or_op)
1689     in0_p = !in0_p, in1_p = !in1_p;
1690
1691   /* If both expressions are the same, if we can merge the ranges, and we
1692      can build the range test, return it or it inverted.  */
1693   if (lhs && rhs && operand_equal_p (lhs, rhs, 0)
1694       && merge_ranges (&in_p, &low, &high, in0_p, low0, high0,
1695                        in1_p, low1, high1)
1696       && 0 != (tem = build_range_check (UNKNOWN_LOCATION,
1697                                         type, lhs, in_p, low, high)))
1698     {
1699       if (TREE_CODE (tem) != INTEGER_CST)
1700         return;
1701
1702       if (or_op)
1703         warning_at (location, OPT_Wlogical_op,
1704                     "logical %<or%> "
1705                     "of collectively exhaustive tests is always true");
1706       else
1707         warning_at (location, OPT_Wlogical_op,
1708                     "logical %<and%> "
1709                     "of mutually exclusive tests is always false");
1710     }
1711 }
1712
1713
1714 /* Print a warning about casts that might indicate violation
1715    of strict aliasing rules if -Wstrict-aliasing is used and
1716    strict aliasing mode is in effect. OTYPE is the original
1717    TREE_TYPE of EXPR, and TYPE the type we're casting to. */
1718
1719 bool
1720 strict_aliasing_warning (tree otype, tree type, tree expr)
1721 {
1722   /* Strip pointer conversion chains and get to the correct original type.  */
1723   STRIP_NOPS (expr);
1724   otype = TREE_TYPE (expr);
1725
1726   if (!(flag_strict_aliasing
1727         && POINTER_TYPE_P (type)
1728         && POINTER_TYPE_P (otype)
1729         && !VOID_TYPE_P (TREE_TYPE (type)))
1730       /* If the type we are casting to is a ref-all pointer
1731          dereferencing it is always valid.  */
1732       || TYPE_REF_CAN_ALIAS_ALL (type))
1733     return false;
1734
1735   if ((warn_strict_aliasing > 1) && TREE_CODE (expr) == ADDR_EXPR
1736       && (DECL_P (TREE_OPERAND (expr, 0))
1737           || handled_component_p (TREE_OPERAND (expr, 0))))
1738     {
1739       /* Casting the address of an object to non void pointer. Warn
1740          if the cast breaks type based aliasing.  */
1741       if (!COMPLETE_TYPE_P (TREE_TYPE (type)) && warn_strict_aliasing == 2)
1742         {
1743           warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
1744                    "might break strict-aliasing rules");
1745           return true;
1746         }
1747       else
1748         {
1749           /* warn_strict_aliasing >= 3.   This includes the default (3).
1750              Only warn if the cast is dereferenced immediately.  */
1751           alias_set_type set1 =
1752             get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1753           alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1754
1755           if (set1 != set2 && set2 != 0
1756               && (set1 == 0 || !alias_sets_conflict_p (set1, set2)))
1757             {
1758               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1759                        "pointer will break strict-aliasing rules");
1760               return true;
1761             }
1762           else if (warn_strict_aliasing == 2
1763                    && !alias_sets_must_conflict_p (set1, set2))
1764             {
1765               warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1766                        "pointer might break strict-aliasing rules");
1767               return true;
1768             }
1769         }
1770     }
1771   else
1772     if ((warn_strict_aliasing == 1) && !VOID_TYPE_P (TREE_TYPE (otype)))
1773       {
1774         /* At this level, warn for any conversions, even if an address is
1775            not taken in the same statement.  This will likely produce many
1776            false positives, but could be useful to pinpoint problems that
1777            are not revealed at higher levels.  */
1778         alias_set_type set1 = get_alias_set (TREE_TYPE (otype));
1779         alias_set_type set2 = get_alias_set (TREE_TYPE (type));
1780         if (!COMPLETE_TYPE_P (type)
1781             || !alias_sets_must_conflict_p (set1, set2))
1782           {
1783             warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1784                      "pointer might break strict-aliasing rules");
1785             return true;
1786           }
1787       }
1788
1789   return false;
1790 }
1791
1792 /* Warn for unlikely, improbable, or stupid DECL declarations
1793    of `main'.  */
1794
1795 void
1796 check_main_parameter_types (tree decl)
1797 {
1798   tree args;
1799   int argct = 0;
1800
1801   for (args = TYPE_ARG_TYPES (TREE_TYPE (decl)); args;
1802       args = TREE_CHAIN (args))
1803    {
1804      tree type = args ? TREE_VALUE (args) : 0;
1805
1806      if (type == void_type_node || type == error_mark_node )
1807        break;
1808
1809      ++argct;
1810      switch (argct)
1811        {
1812        case 1:
1813          if (TYPE_MAIN_VARIANT (type) != integer_type_node)
1814            pedwarn (input_location, OPT_Wmain, "first argument of %q+D should be %<int%>",
1815                     decl);
1816          break;
1817
1818        case 2:
1819          if (TREE_CODE (type) != POINTER_TYPE
1820              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1821              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1822                  != char_type_node))
1823            pedwarn (input_location, OPT_Wmain, "second argument of %q+D should be %<char **%>",
1824                     decl);
1825          break;
1826
1827        case 3:
1828          if (TREE_CODE (type) != POINTER_TYPE
1829              || TREE_CODE (TREE_TYPE (type)) != POINTER_TYPE
1830              || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (type)))
1831                  != char_type_node))
1832            pedwarn (input_location, OPT_Wmain, "third argument of %q+D should probably be "
1833                     "%<char **%>", decl);
1834          break;
1835        }
1836    }
1837
1838   /* It is intentional that this message does not mention the third
1839     argument because it's only mentioned in an appendix of the
1840     standard.  */
1841   if (argct > 0 && (argct < 2 || argct > 3))
1842     pedwarn (input_location, OPT_Wmain, "%q+D takes only zero or two arguments", decl);
1843 }
1844
1845 /* True if pointers to distinct types T1 and T2 can be converted to
1846    each other without an explicit cast.  Only returns true for opaque
1847    vector types.  */
1848 bool
1849 vector_targets_convertible_p (const_tree t1, const_tree t2)
1850 {
1851   if (TREE_CODE (t1) == VECTOR_TYPE && TREE_CODE (t2) == VECTOR_TYPE
1852       && (TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1853       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1854     return true;
1855
1856   return false;
1857 }
1858
1859 /* True if vector types T1 and T2 can be converted to each other
1860    without an explicit cast.  If EMIT_LAX_NOTE is true, and T1 and T2
1861    can only be converted with -flax-vector-conversions yet that is not
1862    in effect, emit a note telling the user about that option if such
1863    a note has not previously been emitted.  */
1864 bool
1865 vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note)
1866 {
1867   static bool emitted_lax_note = false;
1868   bool convertible_lax;
1869
1870   if ((TYPE_VECTOR_OPAQUE (t1) || TYPE_VECTOR_OPAQUE (t2))
1871       && tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2)))
1872     return true;
1873
1874   convertible_lax =
1875     (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1876      && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1877          TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1878      && (INTEGRAL_TYPE_P (TREE_TYPE (t1))
1879          == INTEGRAL_TYPE_P (TREE_TYPE (t2))));
1880
1881   if (!convertible_lax || flag_lax_vector_conversions)
1882     return convertible_lax;
1883
1884   if (TYPE_VECTOR_SUBPARTS (t1) == TYPE_VECTOR_SUBPARTS (t2)
1885       && lang_hooks.types_compatible_p (TREE_TYPE (t1), TREE_TYPE (t2)))
1886     return true;
1887
1888   if (emit_lax_note && !emitted_lax_note)
1889     {
1890       emitted_lax_note = true;
1891       inform (input_location, "use -flax-vector-conversions to permit "
1892               "conversions between vectors with differing "
1893               "element types or numbers of subparts");
1894     }
1895
1896   return false;
1897 }
1898
1899 /* This is a helper function of build_binary_op.
1900
1901    For certain operations if both args were extended from the same
1902    smaller type, do the arithmetic in that type and then extend.
1903
1904    BITWISE indicates a bitwise operation.
1905    For them, this optimization is safe only if
1906    both args are zero-extended or both are sign-extended.
1907    Otherwise, we might change the result.
1908    Eg, (short)-1 | (unsigned short)-1 is (int)-1
1909    but calculated in (unsigned short) it would be (unsigned short)-1.
1910 */
1911 tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise)
1912 {
1913   int unsigned0, unsigned1;
1914   tree arg0, arg1;
1915   int uns;
1916   tree type;
1917
1918   /* Cast OP0 and OP1 to RESULT_TYPE.  Doing so prevents
1919      excessive narrowing when we call get_narrower below.  For
1920      example, suppose that OP0 is of unsigned int extended
1921      from signed char and that RESULT_TYPE is long long int.
1922      If we explicitly cast OP0 to RESULT_TYPE, OP0 would look
1923      like
1924
1925      (long long int) (unsigned int) signed_char
1926
1927      which get_narrower would narrow down to
1928
1929      (unsigned int) signed char
1930
1931      If we do not cast OP0 first, get_narrower would return
1932      signed_char, which is inconsistent with the case of the
1933      explicit cast.  */
1934   op0 = convert (result_type, op0);
1935   op1 = convert (result_type, op1);
1936
1937   arg0 = get_narrower (op0, &unsigned0);
1938   arg1 = get_narrower (op1, &unsigned1);
1939
1940   /* UNS is 1 if the operation to be done is an unsigned one.  */
1941   uns = TYPE_UNSIGNED (result_type);
1942
1943   /* Handle the case that OP0 (or OP1) does not *contain* a conversion
1944      but it *requires* conversion to FINAL_TYPE.  */
1945
1946   if ((TYPE_PRECISION (TREE_TYPE (op0))
1947        == TYPE_PRECISION (TREE_TYPE (arg0)))
1948       && TREE_TYPE (op0) != result_type)
1949     unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
1950   if ((TYPE_PRECISION (TREE_TYPE (op1))
1951        == TYPE_PRECISION (TREE_TYPE (arg1)))
1952       && TREE_TYPE (op1) != result_type)
1953     unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
1954
1955   /* Now UNSIGNED0 is 1 if ARG0 zero-extends to FINAL_TYPE.  */
1956
1957   /* For bitwise operations, signedness of nominal type
1958      does not matter.  Consider only how operands were extended.  */
1959   if (bitwise)
1960     uns = unsigned0;
1961
1962   /* Note that in all three cases below we refrain from optimizing
1963      an unsigned operation on sign-extended args.
1964      That would not be valid.  */
1965
1966   /* Both args variable: if both extended in same way
1967      from same width, do it in that width.
1968      Do it unsigned if args were zero-extended.  */
1969   if ((TYPE_PRECISION (TREE_TYPE (arg0))
1970        < TYPE_PRECISION (result_type))
1971       && (TYPE_PRECISION (TREE_TYPE (arg1))
1972           == TYPE_PRECISION (TREE_TYPE (arg0)))
1973       && unsigned0 == unsigned1
1974       && (unsigned0 || !uns))
1975     return c_common_signed_or_unsigned_type
1976       (unsigned0, common_type (TREE_TYPE (arg0), TREE_TYPE (arg1)));
1977
1978   else if (TREE_CODE (arg0) == INTEGER_CST
1979            && (unsigned1 || !uns)
1980            && (TYPE_PRECISION (TREE_TYPE (arg1))
1981                < TYPE_PRECISION (result_type))
1982            && (type
1983                = c_common_signed_or_unsigned_type (unsigned1,
1984                                                    TREE_TYPE (arg1)))
1985            && !POINTER_TYPE_P (type)
1986            && int_fits_type_p (arg0, type))
1987     return type;
1988
1989   else if (TREE_CODE (arg1) == INTEGER_CST
1990            && (unsigned0 || !uns)
1991            && (TYPE_PRECISION (TREE_TYPE (arg0))
1992                < TYPE_PRECISION (result_type))
1993            && (type
1994                = c_common_signed_or_unsigned_type (unsigned0,
1995                                                    TREE_TYPE (arg0)))
1996            && !POINTER_TYPE_P (type)
1997            && int_fits_type_p (arg1, type))
1998     return type;
1999
2000   return result_type;
2001 }
2002
2003 /* Warns if the conversion of EXPR to TYPE may alter a value.
2004    This is a helper function for warnings_for_convert_and_check.  */
2005
2006 static void
2007 conversion_warning (tree type, tree expr)
2008 {
2009   bool give_warning = false;
2010
2011   int i;
2012   const int expr_num_operands = TREE_OPERAND_LENGTH (expr);
2013   tree expr_type = TREE_TYPE (expr);
2014
2015   if (!warn_conversion && !warn_sign_conversion)
2016     return;
2017
2018   /* If any operand is artificial, then this expression was generated
2019      by the compiler and we do not warn.  */
2020   for (i = 0; i < expr_num_operands; i++)
2021     {
2022       tree op = TREE_OPERAND (expr, i);
2023       if (op && DECL_P (op) && DECL_ARTIFICIAL (op))
2024         return;
2025     }
2026
2027   switch (TREE_CODE (expr))
2028     {
2029     case EQ_EXPR:
2030     case NE_EXPR:
2031     case LE_EXPR:
2032     case GE_EXPR:
2033     case LT_EXPR:
2034     case GT_EXPR:
2035     case TRUTH_ANDIF_EXPR:
2036     case TRUTH_ORIF_EXPR:
2037     case TRUTH_AND_EXPR:
2038     case TRUTH_OR_EXPR:
2039     case TRUTH_XOR_EXPR:
2040     case TRUTH_NOT_EXPR:
2041       /* Conversion from boolean to a signed:1 bit-field (which only
2042          can hold the values 0 and -1) doesn't lose information - but
2043          it does change the value.  */
2044       if (TYPE_PRECISION (type) == 1 && !TYPE_UNSIGNED (type))
2045         warning (OPT_Wconversion,
2046                  "conversion to %qT from boolean expression", type);
2047       return;
2048
2049     case REAL_CST:
2050     case INTEGER_CST:
2051
2052       /* Warn for real constant that is not an exact integer converted
2053          to integer type.  */
2054       if (TREE_CODE (expr_type) == REAL_TYPE
2055           && TREE_CODE (type) == INTEGER_TYPE)
2056         {
2057           if (!real_isinteger (TREE_REAL_CST_PTR (expr), TYPE_MODE (expr_type)))
2058             give_warning = true;
2059         }
2060       /* Warn for an integer constant that does not fit into integer type.  */
2061       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2062                && TREE_CODE (type) == INTEGER_TYPE
2063                && !int_fits_type_p (expr, type))
2064         {
2065           if (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)
2066               && tree_int_cst_sgn (expr) < 0)
2067             warning (OPT_Wsign_conversion,
2068                      "negative integer implicitly converted to unsigned type");
2069           else if (!TYPE_UNSIGNED (type) && TYPE_UNSIGNED (expr_type))
2070             warning (OPT_Wsign_conversion,  "conversion of unsigned constant "
2071                      "value to negative integer");
2072           else
2073             give_warning = true;
2074         }
2075       else if (TREE_CODE (type) == REAL_TYPE)
2076         {
2077           /* Warn for an integer constant that does not fit into real type.  */
2078           if (TREE_CODE (expr_type) == INTEGER_TYPE)
2079             {
2080               REAL_VALUE_TYPE a = real_value_from_int_cst (0, expr);
2081               if (!exact_real_truncate (TYPE_MODE (type), &a))
2082                 give_warning = true;
2083             }
2084           /* Warn for a real constant that does not fit into a smaller
2085              real type.  */
2086           else if (TREE_CODE (expr_type) == REAL_TYPE
2087                    && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2088             {
2089               REAL_VALUE_TYPE a = TREE_REAL_CST (expr);
2090               if (!exact_real_truncate (TYPE_MODE (type), &a))
2091                 give_warning = true;
2092             }
2093         }
2094
2095       if (give_warning)
2096         warning (OPT_Wconversion,
2097                  "conversion to %qT alters %qT constant value",
2098                  type, expr_type);
2099
2100       return;
2101
2102     case COND_EXPR:
2103       {
2104         /* In case of COND_EXPR, if both operands are constants or
2105            COND_EXPR, then we do not care about the type of COND_EXPR,
2106            only about the conversion of each operand.  */
2107         tree op1 = TREE_OPERAND (expr, 1);
2108         tree op2 = TREE_OPERAND (expr, 2);
2109
2110         if ((TREE_CODE (op1) == REAL_CST || TREE_CODE (op1) == INTEGER_CST
2111              || TREE_CODE (op1) == COND_EXPR)
2112             && (TREE_CODE (op2) == REAL_CST || TREE_CODE (op2) == INTEGER_CST
2113                 || TREE_CODE (op2) == COND_EXPR))
2114           {
2115             conversion_warning (type, op1);
2116             conversion_warning (type, op2);
2117             return;
2118           }
2119         /* Fall through.  */
2120       }
2121
2122     default: /* 'expr' is not a constant.  */
2123
2124       /* Warn for real types converted to integer types.  */
2125       if (TREE_CODE (expr_type) == REAL_TYPE
2126           && TREE_CODE (type) == INTEGER_TYPE)
2127         give_warning = true;
2128
2129       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2130                && TREE_CODE (type) == INTEGER_TYPE)
2131         {
2132           /* Don't warn about unsigned char y = 0xff, x = (int) y;  */
2133           expr = get_unwidened (expr, 0);
2134           expr_type = TREE_TYPE (expr);
2135
2136           /* Don't warn for short y; short x = ((int)y & 0xff);  */
2137           if (TREE_CODE (expr) == BIT_AND_EXPR
2138                 || TREE_CODE (expr) == BIT_IOR_EXPR
2139               || TREE_CODE (expr) == BIT_XOR_EXPR)
2140             {
2141               /* If both args were extended from a shortest type,
2142                  use that type if that is safe.  */
2143               expr_type = shorten_binary_op (expr_type,
2144                                              TREE_OPERAND (expr, 0),
2145                                              TREE_OPERAND (expr, 1),
2146                                              /* bitwise */1);
2147
2148               if (TREE_CODE (expr) == BIT_AND_EXPR)
2149                 {
2150                   tree op0 = TREE_OPERAND (expr, 0);
2151                   tree op1 = TREE_OPERAND (expr, 1);
2152                   bool unsigned0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2153                   bool unsigned1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2154
2155                   /* If one of the operands is a non-negative constant
2156                      that fits in the target type, then the type of the
2157                      other operand does not matter. */
2158                   if ((TREE_CODE (op0) == INTEGER_CST
2159                        && int_fits_type_p (op0, c_common_signed_type (type))
2160                        && int_fits_type_p (op0, c_common_unsigned_type (type)))
2161                       || (TREE_CODE (op1) == INTEGER_CST
2162                           && int_fits_type_p (op1, c_common_signed_type (type))
2163                           && int_fits_type_p (op1,
2164                                               c_common_unsigned_type (type))))
2165                     return;
2166                   /* If constant is unsigned and fits in the target
2167                      type, then the result will also fit.  */
2168                   else if ((TREE_CODE (op0) == INTEGER_CST
2169                             && unsigned0
2170                             && int_fits_type_p (op0, type))
2171                            || (TREE_CODE (op1) == INTEGER_CST
2172                                && unsigned1
2173                                && int_fits_type_p (op1, type)))
2174                     return;
2175                 }
2176             }
2177           /* Warn for integer types converted to smaller integer types.  */
2178           if (TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2179             give_warning = true;
2180
2181           /* When they are the same width but different signedness,
2182              then the value may change.  */
2183           else if ((TYPE_PRECISION (type) == TYPE_PRECISION (expr_type)
2184                     && TYPE_UNSIGNED (expr_type) != TYPE_UNSIGNED (type))
2185                    /* Even when converted to a bigger type, if the type is
2186                       unsigned but expr is signed, then negative values
2187                       will be changed.  */
2188                    || (TYPE_UNSIGNED (type) && !TYPE_UNSIGNED (expr_type)))
2189             warning (OPT_Wsign_conversion, "conversion to %qT from %qT "
2190                      "may change the sign of the result",
2191                      type, expr_type);
2192         }
2193
2194       /* Warn for integer types converted to real types if and only if
2195          all the range of values of the integer type cannot be
2196          represented by the real type.  */
2197       else if (TREE_CODE (expr_type) == INTEGER_TYPE
2198                && TREE_CODE (type) == REAL_TYPE)
2199         {
2200           tree type_low_bound, type_high_bound;
2201           REAL_VALUE_TYPE real_low_bound, real_high_bound;
2202
2203           /* Don't warn about char y = 0xff; float x = (int) y;  */
2204           expr = get_unwidened (expr, 0);
2205           expr_type = TREE_TYPE (expr);
2206
2207           type_low_bound = TYPE_MIN_VALUE (expr_type);
2208           type_high_bound = TYPE_MAX_VALUE (expr_type);
2209           real_low_bound = real_value_from_int_cst (0, type_low_bound);
2210           real_high_bound = real_value_from_int_cst (0, type_high_bound);
2211
2212           if (!exact_real_truncate (TYPE_MODE (type), &real_low_bound)
2213               || !exact_real_truncate (TYPE_MODE (type), &real_high_bound))
2214             give_warning = true;
2215         }
2216
2217       /* Warn for real types converted to smaller real types.  */
2218       else if (TREE_CODE (expr_type) == REAL_TYPE
2219                && TREE_CODE (type) == REAL_TYPE
2220                && TYPE_PRECISION (type) < TYPE_PRECISION (expr_type))
2221         give_warning = true;
2222
2223
2224       if (give_warning)
2225         warning (OPT_Wconversion,
2226                  "conversion to %qT from %qT may alter its value",
2227                  type, expr_type);
2228     }
2229 }
2230
2231 /* Produce warnings after a conversion. RESULT is the result of
2232    converting EXPR to TYPE.  This is a helper function for
2233    convert_and_check and cp_convert_and_check.  */
2234
2235 void
2236 warnings_for_convert_and_check (tree type, tree expr, tree result)
2237 {
2238   if (TREE_CODE (expr) == INTEGER_CST
2239       && (TREE_CODE (type) == INTEGER_TYPE
2240           || TREE_CODE (type) == ENUMERAL_TYPE)
2241       && !int_fits_type_p (expr, type))
2242     {
2243       /* Do not diagnose overflow in a constant expression merely
2244          because a conversion overflowed.  */
2245       if (TREE_OVERFLOW (result))
2246         TREE_OVERFLOW (result) = TREE_OVERFLOW (expr);
2247
2248       if (TYPE_UNSIGNED (type))
2249         {
2250           /* This detects cases like converting -129 or 256 to
2251              unsigned char.  */
2252           if (!int_fits_type_p (expr, c_common_signed_type (type)))
2253             warning (OPT_Woverflow,
2254                      "large integer implicitly truncated to unsigned type");
2255           else
2256             conversion_warning (type, expr);
2257         }
2258       else if (!int_fits_type_p (expr, c_common_unsigned_type (type)))
2259         warning (OPT_Woverflow,
2260                  "overflow in implicit constant conversion");
2261       /* No warning for converting 0x80000000 to int.  */
2262       else if (pedantic
2263                && (TREE_CODE (TREE_TYPE (expr)) != INTEGER_TYPE
2264                    || TYPE_PRECISION (TREE_TYPE (expr))
2265                    != TYPE_PRECISION (type)))
2266         warning (OPT_Woverflow,
2267                  "overflow in implicit constant conversion");
2268
2269       else
2270         conversion_warning (type, expr);
2271     }
2272   else if ((TREE_CODE (result) == INTEGER_CST
2273             || TREE_CODE (result) == FIXED_CST) && TREE_OVERFLOW (result))
2274     warning (OPT_Woverflow,
2275              "overflow in implicit constant conversion");
2276   else
2277     conversion_warning (type, expr);
2278 }
2279
2280
2281 /* Convert EXPR to TYPE, warning about conversion problems with constants.
2282    Invoke this function on every expression that is converted implicitly,
2283    i.e. because of language rules and not because of an explicit cast.  */
2284
2285 tree
2286 convert_and_check (tree type, tree expr)
2287 {
2288   tree result;
2289   tree expr_for_warning;
2290
2291   /* Convert from a value with possible excess precision rather than
2292      via the semantic type, but do not warn about values not fitting
2293      exactly in the semantic type.  */
2294   if (TREE_CODE (expr) == EXCESS_PRECISION_EXPR)
2295     {
2296       tree orig_type = TREE_TYPE (expr);
2297       expr = TREE_OPERAND (expr, 0);
2298       expr_for_warning = convert (orig_type, expr);
2299       if (orig_type == type)
2300         return expr_for_warning;
2301     }
2302   else
2303     expr_for_warning = expr;
2304
2305   if (TREE_TYPE (expr) == type)
2306     return expr;
2307
2308   result = convert (type, expr);
2309
2310   if (c_inhibit_evaluation_warnings == 0
2311       && !TREE_OVERFLOW_P (expr)
2312       && result != error_mark_node)
2313     warnings_for_convert_and_check (type, expr_for_warning, result);
2314
2315   return result;
2316 }
2317 \f
2318 /* A node in a list that describes references to variables (EXPR), which are
2319    either read accesses if WRITER is zero, or write accesses, in which case
2320    WRITER is the parent of EXPR.  */
2321 struct tlist
2322 {
2323   struct tlist *next;
2324   tree expr, writer;
2325 };
2326
2327 /* Used to implement a cache the results of a call to verify_tree.  We only
2328    use this for SAVE_EXPRs.  */
2329 struct tlist_cache
2330 {
2331   struct tlist_cache *next;
2332   struct tlist *cache_before_sp;
2333   struct tlist *cache_after_sp;
2334   tree expr;
2335 };
2336
2337 /* Obstack to use when allocating tlist structures, and corresponding
2338    firstobj.  */
2339 static struct obstack tlist_obstack;
2340 static char *tlist_firstobj = 0;
2341
2342 /* Keep track of the identifiers we've warned about, so we can avoid duplicate
2343    warnings.  */
2344 static struct tlist *warned_ids;
2345 /* SAVE_EXPRs need special treatment.  We process them only once and then
2346    cache the results.  */
2347 static struct tlist_cache *save_expr_cache;
2348
2349 static void add_tlist (struct tlist **, struct tlist *, tree, int);
2350 static void merge_tlist (struct tlist **, struct tlist *, int);
2351 static void verify_tree (tree, struct tlist **, struct tlist **, tree);
2352 static int warning_candidate_p (tree);
2353 static bool candidate_equal_p (const_tree, const_tree);
2354 static void warn_for_collisions (struct tlist *);
2355 static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
2356 static struct tlist *new_tlist (struct tlist *, tree, tree);
2357
2358 /* Create a new struct tlist and fill in its fields.  */
2359 static struct tlist *
2360 new_tlist (struct tlist *next, tree t, tree writer)
2361 {
2362   struct tlist *l;
2363   l = XOBNEW (&tlist_obstack, struct tlist);
2364   l->next = next;
2365   l->expr = t;
2366   l->writer = writer;
2367   return l;
2368 }
2369
2370 /* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
2371    is nonnull, we ignore any node we find which has a writer equal to it.  */
2372
2373 static void
2374 add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
2375 {
2376   while (add)
2377     {
2378       struct tlist *next = add->next;
2379       if (!copy)
2380         add->next = *to;
2381       if (!exclude_writer || !candidate_equal_p (add->writer, exclude_writer))
2382         *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
2383       add = next;
2384     }
2385 }
2386
2387 /* Merge the nodes of ADD into TO.  This merging process is done so that for
2388    each variable that already exists in TO, no new node is added; however if
2389    there is a write access recorded in ADD, and an occurrence on TO is only
2390    a read access, then the occurrence in TO will be modified to record the
2391    write.  */
2392
2393 static void
2394 merge_tlist (struct tlist **to, struct tlist *add, int copy)
2395 {
2396   struct tlist **end = to;
2397
2398   while (*end)
2399     end = &(*end)->next;
2400
2401   while (add)
2402     {
2403       int found = 0;
2404       struct tlist *tmp2;
2405       struct tlist *next = add->next;
2406
2407       for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
2408         if (candidate_equal_p (tmp2->expr, add->expr))
2409           {
2410             found = 1;
2411             if (!tmp2->writer)
2412               tmp2->writer = add->writer;
2413           }
2414       if (!found)
2415         {
2416           *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
2417           end = &(*end)->next;
2418           *end = 0;
2419         }
2420       add = next;
2421     }
2422 }
2423
2424 /* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
2425    references in list LIST conflict with it, excluding reads if ONLY writers
2426    is nonzero.  */
2427
2428 static void
2429 warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
2430                        int only_writes)
2431 {
2432   struct tlist *tmp;
2433
2434   /* Avoid duplicate warnings.  */
2435   for (tmp = warned_ids; tmp; tmp = tmp->next)
2436     if (candidate_equal_p (tmp->expr, written))
2437       return;
2438
2439   while (list)
2440     {
2441       if (candidate_equal_p (list->expr, written)
2442           && !candidate_equal_p (list->writer, writer)
2443           && (!only_writes || list->writer))
2444         {
2445           warned_ids = new_tlist (warned_ids, written, NULL_TREE);
2446           warning_at (EXPR_HAS_LOCATION (writer)
2447                       ? EXPR_LOCATION (writer) : input_location,
2448                       OPT_Wsequence_point, "operation on %qE may be undefined",
2449                       list->expr);
2450         }
2451       list = list->next;
2452     }
2453 }
2454
2455 /* Given a list LIST of references to variables, find whether any of these
2456    can cause conflicts due to missing sequence points.  */
2457
2458 static void
2459 warn_for_collisions (struct tlist *list)
2460 {
2461   struct tlist *tmp;
2462
2463   for (tmp = list; tmp; tmp = tmp->next)
2464     {
2465       if (tmp->writer)
2466         warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
2467     }
2468 }
2469
2470 /* Return nonzero if X is a tree that can be verified by the sequence point
2471    warnings.  */
2472 static int
2473 warning_candidate_p (tree x)
2474 {
2475   /* !VOID_TYPE_P (TREE_TYPE (x)) is workaround for cp/tree.c
2476      (lvalue_p) crash on TRY/CATCH. */
2477   return !(DECL_P (x) && DECL_ARTIFICIAL (x))
2478     && TREE_TYPE (x) && !VOID_TYPE_P (TREE_TYPE (x)) && lvalue_p (x);
2479 }
2480
2481 /* Return nonzero if X and Y appear to be the same candidate (or NULL) */
2482 static bool
2483 candidate_equal_p (const_tree x, const_tree y)
2484 {
2485   return (x == y) || (x && y && operand_equal_p (x, y, 0));
2486 }
2487
2488 /* Walk the tree X, and record accesses to variables.  If X is written by the
2489    parent tree, WRITER is the parent.
2490    We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
2491    expression or its only operand forces a sequence point, then everything up
2492    to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
2493    in PNO_SP.
2494    Once we return, we will have emitted warnings if any subexpression before
2495    such a sequence point could be undefined.  On a higher level, however, the
2496    sequence point may not be relevant, and we'll merge the two lists.
2497
2498    Example: (b++, a) + b;
2499    The call that processes the COMPOUND_EXPR will store the increment of B
2500    in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
2501    processes the PLUS_EXPR will need to merge the two lists so that
2502    eventually, all accesses end up on the same list (and we'll warn about the
2503    unordered subexpressions b++ and b.
2504
2505    A note on merging.  If we modify the former example so that our expression
2506    becomes
2507      (b++, b) + a
2508    care must be taken not simply to add all three expressions into the final
2509    PNO_SP list.  The function merge_tlist takes care of that by merging the
2510    before-SP list of the COMPOUND_EXPR into its after-SP list in a special
2511    way, so that no more than one access to B is recorded.  */
2512
2513 static void
2514 verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
2515              tree writer)
2516 {
2517   struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
2518   enum tree_code code;
2519   enum tree_code_class cl;
2520
2521   /* X may be NULL if it is the operand of an empty statement expression
2522      ({ }).  */
2523   if (x == NULL)
2524     return;
2525
2526  restart:
2527   code = TREE_CODE (x);
2528   cl = TREE_CODE_CLASS (code);
2529
2530   if (warning_candidate_p (x))
2531     *pno_sp = new_tlist (*pno_sp, x, writer);
2532
2533   switch (code)
2534     {
2535     case CONSTRUCTOR:
2536       return;
2537
2538     case COMPOUND_EXPR:
2539     case TRUTH_ANDIF_EXPR:
2540     case TRUTH_ORIF_EXPR:
2541       tmp_before = tmp_nosp = tmp_list3 = 0;
2542       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2543       warn_for_collisions (tmp_nosp);
2544       merge_tlist (pbefore_sp, tmp_before, 0);
2545       merge_tlist (pbefore_sp, tmp_nosp, 0);
2546       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
2547       merge_tlist (pbefore_sp, tmp_list3, 0);
2548       return;
2549
2550     case COND_EXPR:
2551       tmp_before = tmp_list2 = 0;
2552       verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
2553       warn_for_collisions (tmp_list2);
2554       merge_tlist (pbefore_sp, tmp_before, 0);
2555       merge_tlist (pbefore_sp, tmp_list2, 1);
2556
2557       tmp_list3 = tmp_nosp = 0;
2558       verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
2559       warn_for_collisions (tmp_nosp);
2560       merge_tlist (pbefore_sp, tmp_list3, 0);
2561
2562       tmp_list3 = tmp_list2 = 0;
2563       verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
2564       warn_for_collisions (tmp_list2);
2565       merge_tlist (pbefore_sp, tmp_list3, 0);
2566       /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
2567          two first, to avoid warning for (a ? b++ : b++).  */
2568       merge_tlist (&tmp_nosp, tmp_list2, 0);
2569       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2570       return;
2571
2572     case PREDECREMENT_EXPR:
2573     case PREINCREMENT_EXPR:
2574     case POSTDECREMENT_EXPR:
2575     case POSTINCREMENT_EXPR:
2576       verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
2577       return;
2578
2579     case MODIFY_EXPR:
2580       tmp_before = tmp_nosp = tmp_list3 = 0;
2581       verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
2582       verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
2583       /* Expressions inside the LHS are not ordered wrt. the sequence points
2584          in the RHS.  Example:
2585            *a = (a++, 2)
2586          Despite the fact that the modification of "a" is in the before_sp
2587          list (tmp_before), it conflicts with the use of "a" in the LHS.
2588          We can handle this by adding the contents of tmp_list3
2589          to those of tmp_before, and redoing the collision warnings for that
2590          list.  */
2591       add_tlist (&tmp_before, tmp_list3, x, 1);
2592       warn_for_collisions (tmp_before);
2593       /* Exclude the LHS itself here; we first have to merge it into the
2594          tmp_nosp list.  This is done to avoid warning for "a = a"; if we
2595          didn't exclude the LHS, we'd get it twice, once as a read and once
2596          as a write.  */
2597       add_tlist (pno_sp, tmp_list3, x, 0);
2598       warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
2599
2600       merge_tlist (pbefore_sp, tmp_before, 0);
2601       if (warning_candidate_p (TREE_OPERAND (x, 0)))
2602         merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
2603       add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
2604       return;
2605
2606     case CALL_EXPR:
2607       /* We need to warn about conflicts among arguments and conflicts between
2608          args and the function address.  Side effects of the function address,
2609          however, are not ordered by the sequence point of the call.  */
2610       {
2611         call_expr_arg_iterator iter;
2612         tree arg;
2613         tmp_before = tmp_nosp = 0;
2614         verify_tree (CALL_EXPR_FN (x), &tmp_before, &tmp_nosp, NULL_TREE);
2615         FOR_EACH_CALL_EXPR_ARG (arg, iter, x)
2616           {
2617             tmp_list2 = tmp_list3 = 0;
2618             verify_tree (arg, &tmp_list2, &tmp_list3, NULL_TREE);
2619             merge_tlist (&tmp_list3, tmp_list2, 0);
2620             add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
2621           }
2622         add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
2623         warn_for_collisions (tmp_before);
2624         add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
2625         return;
2626       }
2627
2628     case TREE_LIST:
2629       /* Scan all the list, e.g. indices of multi dimensional array.  */
2630       while (x)
2631         {
2632           tmp_before = tmp_nosp = 0;
2633           verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
2634           merge_tlist (&tmp_nosp, tmp_before, 0);
2635           add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2636           x = TREE_CHAIN (x);
2637         }
2638       return;
2639
2640     case SAVE_EXPR:
2641       {
2642         struct tlist_cache *t;
2643         for (t = save_expr_cache; t; t = t->next)
2644           if (candidate_equal_p (t->expr, x))
2645             break;
2646
2647         if (!t)
2648           {
2649             t = XOBNEW (&tlist_obstack, struct tlist_cache);
2650             t->next = save_expr_cache;
2651             t->expr = x;
2652             save_expr_cache = t;
2653
2654             tmp_before = tmp_nosp = 0;
2655             verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
2656             warn_for_collisions (tmp_nosp);
2657
2658             tmp_list3 = 0;
2659             while (tmp_nosp)
2660               {
2661                 struct tlist *t = tmp_nosp;
2662                 tmp_nosp = t->next;
2663                 merge_tlist (&tmp_list3, t, 0);
2664               }
2665             t->cache_before_sp = tmp_before;
2666             t->cache_after_sp = tmp_list3;
2667           }
2668         merge_tlist (pbefore_sp, t->cache_before_sp, 1);
2669         add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
2670         return;
2671       }
2672
2673     case ADDR_EXPR:
2674       x = TREE_OPERAND (x, 0);
2675       if (DECL_P (x))
2676         return;
2677       writer = 0;
2678       goto restart;
2679
2680     default:
2681       /* For other expressions, simply recurse on their operands.
2682          Manual tail recursion for unary expressions.
2683          Other non-expressions need not be processed.  */
2684       if (cl == tcc_unary)
2685         {
2686           x = TREE_OPERAND (x, 0);
2687           writer = 0;
2688           goto restart;
2689         }
2690       else if (IS_EXPR_CODE_CLASS (cl))
2691         {
2692           int lp;
2693           int max = TREE_OPERAND_LENGTH (x);
2694           for (lp = 0; lp < max; lp++)
2695             {
2696               tmp_before = tmp_nosp = 0;
2697               verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
2698               merge_tlist (&tmp_nosp, tmp_before, 0);
2699               add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
2700             }
2701         }
2702       return;
2703     }
2704 }
2705
2706 /* Try to warn for undefined behavior in EXPR due to missing sequence
2707    points.  */
2708
2709 void
2710 verify_sequence_points (tree expr)
2711 {
2712   struct tlist *before_sp = 0, *after_sp = 0;
2713
2714   warned_ids = 0;
2715   save_expr_cache = 0;
2716   if (tlist_firstobj == 0)
2717     {
2718       gcc_obstack_init (&tlist_obstack);
2719       tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
2720     }
2721
2722   verify_tree (expr, &before_sp, &after_sp, 0);
2723   warn_for_collisions (after_sp);
2724   obstack_free (&tlist_obstack, tlist_firstobj);
2725 }
2726 \f
2727 /* Validate the expression after `case' and apply default promotions.  */
2728
2729 static tree
2730 check_case_value (tree value)
2731 {
2732   if (value == NULL_TREE)
2733     return value;
2734
2735   /* ??? Can we ever get nops here for a valid case value?  We
2736      shouldn't for C.  */
2737   STRIP_TYPE_NOPS (value);
2738   /* In C++, the following is allowed:
2739
2740        const int i = 3;
2741        switch (...) { case i: ... }
2742
2743      So, we try to reduce the VALUE to a constant that way.  */
2744   if (c_dialect_cxx ())
2745     {
2746       value = decl_constant_value (value);
2747       STRIP_TYPE_NOPS (value);
2748       value = fold (value);
2749     }
2750
2751   if (TREE_CODE (value) == INTEGER_CST)
2752     /* Promote char or short to int.  */
2753     value = perform_integral_promotions (value);
2754   else if (value != error_mark_node)
2755     {
2756       error ("case label does not reduce to an integer constant");
2757       value = error_mark_node;
2758     }
2759
2760   constant_expression_warning (value);
2761
2762   return value;
2763 }
2764 \f
2765 /* See if the case values LOW and HIGH are in the range of the original
2766    type (i.e. before the default conversion to int) of the switch testing
2767    expression.
2768    TYPE is the promoted type of the testing expression, and ORIG_TYPE is
2769    the type before promoting it.  CASE_LOW_P is a pointer to the lower
2770    bound of the case label, and CASE_HIGH_P is the upper bound or NULL
2771    if the case is not a case range.
2772    The caller has to make sure that we are not called with NULL for
2773    CASE_LOW_P (i.e. the default case).
2774    Returns true if the case label is in range of ORIG_TYPE (saturated or
2775    untouched) or false if the label is out of range.  */
2776
2777 static bool
2778 check_case_bounds (tree type, tree orig_type,
2779                    tree *case_low_p, tree *case_high_p)
2780 {
2781   tree min_value, max_value;
2782   tree case_low = *case_low_p;
2783   tree case_high = case_high_p ? *case_high_p : case_low;
2784
2785   /* If there was a problem with the original type, do nothing.  */
2786   if (orig_type == error_mark_node)
2787     return true;
2788
2789   min_value = TYPE_MIN_VALUE (orig_type);
2790   max_value = TYPE_MAX_VALUE (orig_type);
2791
2792   /* Case label is less than minimum for type.  */
2793   if (tree_int_cst_compare (case_low, min_value) < 0
2794       && tree_int_cst_compare (case_high, min_value) < 0)
2795     {
2796       warning (0, "case label value is less than minimum value for type");
2797       return false;
2798     }
2799
2800   /* Case value is greater than maximum for type.  */
2801   if (tree_int_cst_compare (case_low, max_value) > 0
2802       && tree_int_cst_compare (case_high, max_value) > 0)
2803     {
2804       warning (0, "case label value exceeds maximum value for type");
2805       return false;
2806     }
2807
2808   /* Saturate lower case label value to minimum.  */
2809   if (tree_int_cst_compare (case_high, min_value) >= 0
2810       && tree_int_cst_compare (case_low, min_value) < 0)
2811     {
2812       warning (0, "lower value in case label range"
2813                " less than minimum value for type");
2814       case_low = min_value;
2815     }
2816
2817   /* Saturate upper case label value to maximum.  */
2818   if (tree_int_cst_compare (case_low, max_value) <= 0
2819       && tree_int_cst_compare (case_high, max_value) > 0)
2820     {
2821       warning (0, "upper value in case label range"
2822                " exceeds maximum value for type");
2823       case_high = max_value;
2824     }
2825
2826   if (*case_low_p != case_low)
2827     *case_low_p = convert (type, case_low);
2828   if (case_high_p && *case_high_p != case_high)
2829     *case_high_p = convert (type, case_high);
2830
2831   return true;
2832 }
2833 \f
2834 /* Return an integer type with BITS bits of precision,
2835    that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
2836
2837 tree
2838 c_common_type_for_size (unsigned int bits, int unsignedp)
2839 {
2840   if (bits == TYPE_PRECISION (integer_type_node))
2841     return unsignedp ? unsigned_type_node : integer_type_node;
2842
2843   if (bits == TYPE_PRECISION (signed_char_type_node))
2844     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2845
2846   if (bits == TYPE_PRECISION (short_integer_type_node))
2847     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2848
2849   if (bits == TYPE_PRECISION (long_integer_type_node))
2850     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2851
2852   if (bits == TYPE_PRECISION (long_long_integer_type_node))
2853     return (unsignedp ? long_long_unsigned_type_node
2854             : long_long_integer_type_node);
2855
2856   if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
2857     return (unsignedp ? widest_unsigned_literal_type_node
2858             : widest_integer_literal_type_node);
2859
2860   if (bits <= TYPE_PRECISION (intQI_type_node))
2861     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2862
2863   if (bits <= TYPE_PRECISION (intHI_type_node))
2864     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2865
2866   if (bits <= TYPE_PRECISION (intSI_type_node))
2867     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2868
2869   if (bits <= TYPE_PRECISION (intDI_type_node))
2870     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2871
2872   return 0;
2873 }
2874
2875 /* Return a fixed-point type that has at least IBIT ibits and FBIT fbits
2876    that is unsigned if UNSIGNEDP is nonzero, otherwise signed;
2877    and saturating if SATP is nonzero, otherwise not saturating.  */
2878
2879 tree
2880 c_common_fixed_point_type_for_size (unsigned int ibit, unsigned int fbit,
2881                                     int unsignedp, int satp)
2882 {
2883   enum machine_mode mode;
2884   if (ibit == 0)
2885     mode = unsignedp ? UQQmode : QQmode;
2886   else
2887     mode = unsignedp ? UHAmode : HAmode;
2888
2889   for (; mode != VOIDmode; mode = GET_MODE_WIDER_MODE (mode))
2890     if (GET_MODE_IBIT (mode) >= ibit && GET_MODE_FBIT (mode) >= fbit)
2891       break;
2892
2893   if (mode == VOIDmode || !targetm.scalar_mode_supported_p (mode))
2894     {
2895       sorry ("GCC cannot support operators with integer types and "
2896              "fixed-point types that have too many integral and "
2897              "fractional bits together");
2898       return 0;
2899     }
2900
2901   return c_common_type_for_mode (mode, satp);
2902 }
2903
2904 /* Used for communication between c_common_type_for_mode and
2905    c_register_builtin_type.  */
2906 static GTY(()) tree registered_builtin_types;
2907
2908 /* Return a data type that has machine mode MODE.
2909    If the mode is an integer,
2910    then UNSIGNEDP selects between signed and unsigned types.
2911    If the mode is a fixed-point mode,
2912    then UNSIGNEDP selects between saturating and nonsaturating types.  */
2913
2914 tree
2915 c_common_type_for_mode (enum machine_mode mode, int unsignedp)
2916 {
2917   tree t;
2918
2919   if (mode == TYPE_MODE (integer_type_node))
2920     return unsignedp ? unsigned_type_node : integer_type_node;
2921
2922   if (mode == TYPE_MODE (signed_char_type_node))
2923     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2924
2925   if (mode == TYPE_MODE (short_integer_type_node))
2926     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2927
2928   if (mode == TYPE_MODE (long_integer_type_node))
2929     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2930
2931   if (mode == TYPE_MODE (long_long_integer_type_node))
2932     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
2933
2934   if (mode == TYPE_MODE (widest_integer_literal_type_node))
2935     return unsignedp ? widest_unsigned_literal_type_node
2936                      : widest_integer_literal_type_node;
2937
2938   if (mode == QImode)
2939     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2940
2941   if (mode == HImode)
2942     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2943
2944   if (mode == SImode)
2945     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2946
2947   if (mode == DImode)
2948     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2949
2950 #if HOST_BITS_PER_WIDE_INT >= 64
2951   if (mode == TYPE_MODE (intTI_type_node))
2952     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2953 #endif
2954
2955   if (mode == TYPE_MODE (float_type_node))
2956     return float_type_node;
2957
2958   if (mode == TYPE_MODE (double_type_node))
2959     return double_type_node;
2960
2961   if (mode == TYPE_MODE (long_double_type_node))
2962     return long_double_type_node;
2963
2964   if (mode == TYPE_MODE (void_type_node))
2965     return void_type_node;
2966
2967   if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
2968     return (unsignedp
2969             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2970             : make_signed_type (GET_MODE_PRECISION (mode)));
2971
2972   if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
2973     return (unsignedp
2974             ? make_unsigned_type (GET_MODE_PRECISION (mode))
2975             : make_signed_type (GET_MODE_PRECISION (mode)));
2976
2977   if (COMPLEX_MODE_P (mode))
2978     {
2979       enum machine_mode inner_mode;
2980       tree inner_type;
2981
2982       if (mode == TYPE_MODE (complex_float_type_node))
2983         return complex_float_type_node;
2984       if (mode == TYPE_MODE (complex_double_type_node))
2985         return complex_double_type_node;
2986       if (mode == TYPE_MODE (complex_long_double_type_node))
2987         return complex_long_double_type_node;
2988
2989       if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
2990         return complex_integer_type_node;
2991
2992       inner_mode = GET_MODE_INNER (mode);
2993       inner_type = c_common_type_for_mode (inner_mode, unsignedp);
2994       if (inner_type != NULL_TREE)
2995         return build_complex_type (inner_type);
2996     }
2997   else if (VECTOR_MODE_P (mode))
2998     {
2999       enum machine_mode inner_mode = GET_MODE_INNER (mode);
3000       tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
3001       if (inner_type != NULL_TREE)
3002         return build_vector_type_for_mode (inner_type, mode);
3003     }
3004
3005   if (mode == TYPE_MODE (dfloat32_type_node))
3006     return dfloat32_type_node;
3007   if (mode == TYPE_MODE (dfloat64_type_node))
3008     return dfloat64_type_node;
3009   if (mode == TYPE_MODE (dfloat128_type_node))
3010     return dfloat128_type_node;
3011
3012   if (ALL_SCALAR_FIXED_POINT_MODE_P (mode))
3013     {
3014       if (mode == TYPE_MODE (short_fract_type_node))
3015         return unsignedp ? sat_short_fract_type_node : short_fract_type_node;
3016       if (mode == TYPE_MODE (fract_type_node))
3017         return unsignedp ? sat_fract_type_node : fract_type_node;
3018       if (mode == TYPE_MODE (long_fract_type_node))
3019         return unsignedp ? sat_long_fract_type_node : long_fract_type_node;
3020       if (mode == TYPE_MODE (long_long_fract_type_node))
3021         return unsignedp ? sat_long_long_fract_type_node
3022                          : long_long_fract_type_node;
3023
3024       if (mode == TYPE_MODE (unsigned_short_fract_type_node))
3025         return unsignedp ? sat_unsigned_short_fract_type_node
3026                          : unsigned_short_fract_type_node;
3027       if (mode == TYPE_MODE (unsigned_fract_type_node))
3028         return unsignedp ? sat_unsigned_fract_type_node
3029                          : unsigned_fract_type_node;
3030       if (mode == TYPE_MODE (unsigned_long_fract_type_node))
3031         return unsignedp ? sat_unsigned_long_fract_type_node
3032                          : unsigned_long_fract_type_node;
3033       if (mode == TYPE_MODE (unsigned_long_long_fract_type_node))
3034         return unsignedp ? sat_unsigned_long_long_fract_type_node
3035                          : unsigned_long_long_fract_type_node;
3036
3037       if (mode == TYPE_MODE (short_accum_type_node))
3038         return unsignedp ? sat_short_accum_type_node : short_accum_type_node;
3039       if (mode == TYPE_MODE (accum_type_node))
3040         return unsignedp ? sat_accum_type_node : accum_type_node;
3041       if (mode == TYPE_MODE (long_accum_type_node))
3042         return unsignedp ? sat_long_accum_type_node : long_accum_type_node;
3043       if (mode == TYPE_MODE (long_long_accum_type_node))
3044         return unsignedp ? sat_long_long_accum_type_node
3045                          : long_long_accum_type_node;
3046
3047       if (mode == TYPE_MODE (unsigned_short_accum_type_node))
3048         return unsignedp ? sat_unsigned_short_accum_type_node
3049                          : unsigned_short_accum_type_node;
3050       if (mode == TYPE_MODE (unsigned_accum_type_node))
3051         return unsignedp ? sat_unsigned_accum_type_node
3052                          : unsigned_accum_type_node;
3053       if (mode == TYPE_MODE (unsigned_long_accum_type_node))
3054         return unsignedp ? sat_unsigned_long_accum_type_node
3055                          : unsigned_long_accum_type_node;
3056       if (mode == TYPE_MODE (unsigned_long_long_accum_type_node))
3057         return unsignedp ? sat_unsigned_long_long_accum_type_node
3058                          : unsigned_long_long_accum_type_node;
3059
3060       if (mode == QQmode)
3061         return unsignedp ? sat_qq_type_node : qq_type_node;
3062       if (mode == HQmode)
3063         return unsignedp ? sat_hq_type_node : hq_type_node;
3064       if (mode == SQmode)
3065         return unsignedp ? sat_sq_type_node : sq_type_node;
3066       if (mode == DQmode)
3067         return unsignedp ? sat_dq_type_node : dq_type_node;
3068       if (mode == TQmode)
3069         return unsignedp ? sat_tq_type_node : tq_type_node;
3070
3071       if (mode == UQQmode)
3072         return unsignedp ? sat_uqq_type_node : uqq_type_node;
3073       if (mode == UHQmode)
3074         return unsignedp ? sat_uhq_type_node : uhq_type_node;
3075       if (mode == USQmode)
3076         return unsignedp ? sat_usq_type_node : usq_type_node;
3077       if (mode == UDQmode)
3078         return unsignedp ? sat_udq_type_node : udq_type_node;
3079       if (mode == UTQmode)
3080         return unsignedp ? sat_utq_type_node : utq_type_node;
3081
3082       if (mode == HAmode)
3083         return unsignedp ? sat_ha_type_node : ha_type_node;
3084       if (mode == SAmode)
3085         return unsignedp ? sat_sa_type_node : sa_type_node;
3086       if (mode == DAmode)
3087         return unsignedp ? sat_da_type_node : da_type_node;
3088       if (mode == TAmode)
3089         return unsignedp ? sat_ta_type_node : ta_type_node;
3090
3091       if (mode == UHAmode)
3092         return unsignedp ? sat_uha_type_node : uha_type_node;
3093       if (mode == USAmode)
3094         return unsignedp ? sat_usa_type_node : usa_type_node;
3095       if (mode == UDAmode)
3096         return unsignedp ? sat_uda_type_node : uda_type_node;
3097       if (mode == UTAmode)
3098         return unsignedp ? sat_uta_type_node : uta_type_node;
3099     }
3100
3101   for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
3102     if (TYPE_MODE (TREE_VALUE (t)) == mode)
3103       return TREE_VALUE (t);
3104
3105   return 0;
3106 }
3107
3108 tree
3109 c_common_unsigned_type (tree type)
3110 {
3111   return c_common_signed_or_unsigned_type (1, type);
3112 }
3113
3114 /* Return a signed type the same as TYPE in other respects.  */
3115
3116 tree
3117 c_common_signed_type (tree type)
3118 {
3119   return c_common_signed_or_unsigned_type (0, type);
3120 }
3121
3122 /* Return a type the same as TYPE except unsigned or
3123    signed according to UNSIGNEDP.  */
3124
3125 tree
3126 c_common_signed_or_unsigned_type (int unsignedp, tree type)
3127 {
3128   tree type1;
3129
3130   /* This block of code emulates the behavior of the old
3131      c_common_unsigned_type. In particular, it returns
3132      long_unsigned_type_node if passed a long, even when a int would
3133      have the same size. This is necessary for warnings to work
3134      correctly in archs where sizeof(int) == sizeof(long) */
3135
3136   type1 = TYPE_MAIN_VARIANT (type);
3137   if (type1 == signed_char_type_node || type1 == char_type_node || type1 == unsigned_char_type_node)
3138     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3139   if (type1 == integer_type_node || type1 == unsigned_type_node)
3140     return unsignedp ? unsigned_type_node : integer_type_node;
3141   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
3142     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3143   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
3144     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3145   if (type1 == long_long_integer_type_node || type1 == long_long_unsigned_type_node)
3146     return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
3147   if (type1 == widest_integer_literal_type_node || type1 == widest_unsigned_literal_type_node)
3148     return unsignedp ? widest_unsigned_literal_type_node : widest_integer_literal_type_node;
3149 #if HOST_BITS_PER_WIDE_INT >= 64
3150   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
3151     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3152 #endif
3153   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
3154     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3155   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
3156     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3157   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
3158     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3159   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
3160     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3161
3162 #define C_COMMON_FIXED_TYPES(NAME)          \
3163   if (type1 == short_ ## NAME ## _type_node \
3164       || type1 == unsigned_short_ ## NAME ## _type_node) \
3165     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
3166                      : short_ ## NAME ## _type_node; \
3167   if (type1 == NAME ## _type_node \
3168       || type1 == unsigned_ ## NAME ## _type_node) \
3169     return unsignedp ? unsigned_ ## NAME ## _type_node \
3170                      : NAME ## _type_node; \
3171   if (type1 == long_ ## NAME ## _type_node \
3172       || type1 == unsigned_long_ ## NAME ## _type_node) \
3173     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
3174                      : long_ ## NAME ## _type_node; \
3175   if (type1 == long_long_ ## NAME ## _type_node \
3176       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
3177     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
3178                      : long_long_ ## NAME ## _type_node;
3179
3180 #define C_COMMON_FIXED_MODE_TYPES(NAME) \
3181   if (type1 == NAME ## _type_node \
3182       || type1 == u ## NAME ## _type_node) \
3183     return unsignedp ? u ## NAME ## _type_node \
3184                      : NAME ## _type_node;
3185
3186 #define C_COMMON_FIXED_TYPES_SAT(NAME) \
3187   if (type1 == sat_ ## short_ ## NAME ## _type_node \
3188       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
3189     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
3190                      : sat_ ## short_ ## NAME ## _type_node; \
3191   if (type1 == sat_ ## NAME ## _type_node \
3192       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
3193     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
3194                      : sat_ ## NAME ## _type_node; \
3195   if (type1 == sat_ ## long_ ## NAME ## _type_node \
3196       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
3197     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
3198                      : sat_ ## long_ ## NAME ## _type_node; \
3199   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
3200       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
3201     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
3202                      : sat_ ## long_long_ ## NAME ## _type_node;
3203
3204 #define C_COMMON_FIXED_MODE_TYPES_SAT(NAME)     \
3205   if (type1 == sat_ ## NAME ## _type_node \
3206       || type1 == sat_ ## u ## NAME ## _type_node) \
3207     return unsignedp ? sat_ ## u ## NAME ## _type_node \
3208                      : sat_ ## NAME ## _type_node;
3209
3210   C_COMMON_FIXED_TYPES (fract);
3211   C_COMMON_FIXED_TYPES_SAT (fract);
3212   C_COMMON_FIXED_TYPES (accum);
3213   C_COMMON_FIXED_TYPES_SAT (accum);
3214
3215   C_COMMON_FIXED_MODE_TYPES (qq);
3216   C_COMMON_FIXED_MODE_TYPES (hq);
3217   C_COMMON_FIXED_MODE_TYPES (sq);
3218   C_COMMON_FIXED_MODE_TYPES (dq);
3219   C_COMMON_FIXED_MODE_TYPES (tq);
3220   C_COMMON_FIXED_MODE_TYPES_SAT (qq);
3221   C_COMMON_FIXED_MODE_TYPES_SAT (hq);
3222   C_COMMON_FIXED_MODE_TYPES_SAT (sq);
3223   C_COMMON_FIXED_MODE_TYPES_SAT (dq);
3224   C_COMMON_FIXED_MODE_TYPES_SAT (tq);
3225   C_COMMON_FIXED_MODE_TYPES (ha);
3226   C_COMMON_FIXED_MODE_TYPES (sa);
3227   C_COMMON_FIXED_MODE_TYPES (da);
3228   C_COMMON_FIXED_MODE_TYPES (ta);
3229   C_COMMON_FIXED_MODE_TYPES_SAT (ha);
3230   C_COMMON_FIXED_MODE_TYPES_SAT (sa);
3231   C_COMMON_FIXED_MODE_TYPES_SAT (da);
3232   C_COMMON_FIXED_MODE_TYPES_SAT (ta);
3233
3234   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
3235      the precision; they have precision set to match their range, but
3236      may use a wider mode to match an ABI.  If we change modes, we may
3237      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
3238      the precision as well, so as to yield correct results for
3239      bit-field types.  C++ does not have these separate bit-field
3240      types, and producing a signed or unsigned variant of an
3241      ENUMERAL_TYPE may cause other problems as well.  */
3242
3243   if (!INTEGRAL_TYPE_P (type)
3244       || TYPE_UNSIGNED (type) == unsignedp)
3245     return type;
3246
3247 #define TYPE_OK(node)                                                       \
3248   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
3249    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
3250   if (TYPE_OK (signed_char_type_node))
3251     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3252   if (TYPE_OK (integer_type_node))
3253     return unsignedp ? unsigned_type_node : integer_type_node;
3254   if (TYPE_OK (short_integer_type_node))
3255     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3256   if (TYPE_OK (long_integer_type_node))
3257     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3258   if (TYPE_OK (long_long_integer_type_node))
3259     return (unsignedp ? long_long_unsigned_type_node
3260             : long_long_integer_type_node);
3261   if (TYPE_OK (widest_integer_literal_type_node))
3262     return (unsignedp ? widest_unsigned_literal_type_node
3263             : widest_integer_literal_type_node);
3264
3265 #if HOST_BITS_PER_WIDE_INT >= 64
3266   if (TYPE_OK (intTI_type_node))
3267     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
3268 #endif
3269   if (TYPE_OK (intDI_type_node))
3270     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
3271   if (TYPE_OK (intSI_type_node))
3272     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
3273   if (TYPE_OK (intHI_type_node))
3274     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
3275   if (TYPE_OK (intQI_type_node))
3276     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
3277 #undef TYPE_OK
3278
3279   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
3280 }
3281
3282 /* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
3283
3284 tree
3285 c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
3286 {
3287   /* Extended integer types of the same width as a standard type have
3288      lesser rank, so those of the same width as int promote to int or
3289      unsigned int and are valid for printf formats expecting int or
3290      unsigned int.  To avoid such special cases, avoid creating
3291      extended integer types for bit-fields if a standard integer type
3292      is available.  */
3293   if (width == TYPE_PRECISION (integer_type_node))
3294     return unsignedp ? unsigned_type_node : integer_type_node;
3295   if (width == TYPE_PRECISION (signed_char_type_node))
3296     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
3297   if (width == TYPE_PRECISION (short_integer_type_node))
3298     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
3299   if (width == TYPE_PRECISION (long_integer_type_node))
3300     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
3301   if (width == TYPE_PRECISION (long_long_integer_type_node))
3302     return (unsignedp ? long_long_unsigned_type_node
3303             : long_long_integer_type_node);
3304   return build_nonstandard_integer_type (width, unsignedp);
3305 }
3306
3307 /* The C version of the register_builtin_type langhook.  */
3308
3309 void
3310 c_register_builtin_type (tree type, const char* name)
3311 {
3312   tree decl;
3313
3314   decl = build_decl (UNKNOWN_LOCATION,
3315                      TYPE_DECL, get_identifier (name), type);
3316   DECL_ARTIFICIAL (decl) = 1;
3317   if (!TYPE_NAME (type))
3318     TYPE_NAME (type) = decl;
3319   pushdecl (decl);
3320
3321   registered_builtin_types = tree_cons (0, type, registered_builtin_types);
3322 }
3323 \f
3324 /* Print an error message for invalid operands to arith operation
3325    CODE with TYPE0 for operand 0, and TYPE1 for operand 1.
3326    LOCATION is the location of the message.  */
3327
3328 void
3329 binary_op_error (location_t location, enum tree_code code,
3330                  tree type0, tree type1)
3331 {
3332   const char *opname;
3333
3334   switch (code)
3335     {
3336     case PLUS_EXPR:
3337       opname = "+"; break;
3338     case MINUS_EXPR:
3339       opname = "-"; break;
3340     case MULT_EXPR:
3341       opname = "*"; break;
3342     case MAX_EXPR:
3343       opname = "max"; break;
3344     case MIN_EXPR:
3345       opname = "min"; break;
3346     case EQ_EXPR:
3347       opname = "=="; break;
3348     case NE_EXPR:
3349       opname = "!="; break;
3350     case LE_EXPR:
3351       opname = "<="; break;
3352     case GE_EXPR:
3353       opname = ">="; break;
3354     case LT_EXPR:
3355       opname = "<"; break;
3356     case GT_EXPR:
3357       opname = ">"; break;
3358     case LSHIFT_EXPR:
3359       opname = "<<"; break;
3360     case RSHIFT_EXPR:
3361       opname = ">>"; break;
3362     case TRUNC_MOD_EXPR:
3363     case FLOOR_MOD_EXPR:
3364       opname = "%"; break;
3365     case TRUNC_DIV_EXPR:
3366     case FLOOR_DIV_EXPR:
3367       opname = "/"; break;
3368     case BIT_AND_EXPR:
3369       opname = "&"; break;
3370     case BIT_IOR_EXPR:
3371       opname = "|"; break;
3372     case TRUTH_ANDIF_EXPR:
3373       opname = "&&"; break;
3374     case TRUTH_ORIF_EXPR:
3375       opname = "||"; break;
3376     case BIT_XOR_EXPR:
3377       opname = "^"; break;
3378     default:
3379       gcc_unreachable ();
3380     }
3381   error_at (location,
3382             "invalid operands to binary %s (have %qT and %qT)", opname,
3383             type0, type1);
3384 }
3385 \f
3386 /* Subroutine of build_binary_op, used for comparison operations.
3387    See if the operands have both been converted from subword integer types
3388    and, if so, perhaps change them both back to their original type.
3389    This function is also responsible for converting the two operands
3390    to the proper common type for comparison.
3391
3392    The arguments of this function are all pointers to local variables
3393    of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
3394    RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
3395
3396    If this function returns nonzero, it means that the comparison has
3397    a constant value.  What this function returns is an expression for
3398    that value.  */
3399
3400 tree
3401 shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
3402                  enum tree_code *rescode_ptr)
3403 {
3404   tree type;
3405   tree op0 = *op0_ptr;
3406   tree op1 = *op1_ptr;
3407   int unsignedp0, unsignedp1;
3408   int real1, real2;
3409   tree primop0, primop1;
3410   enum tree_code code = *rescode_ptr;
3411
3412   /* Throw away any conversions to wider types
3413      already present in the operands.  */
3414
3415   primop0 = get_narrower (op0, &unsignedp0);
3416   primop1 = get_narrower (op1, &unsignedp1);
3417
3418   /* Handle the case that OP0 does not *contain* a conversion
3419      but it *requires* conversion to FINAL_TYPE.  */
3420
3421   if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
3422     unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
3423   if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
3424     unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
3425
3426   /* If one of the operands must be floated, we cannot optimize.  */
3427   real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
3428   real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
3429
3430   /* If first arg is constant, swap the args (changing operation
3431      so value is preserved), for canonicalization.  Don't do this if
3432      the second arg is 0.  */
3433
3434   if (TREE_CONSTANT (primop0)
3435       && !integer_zerop (primop1) && !real_zerop (primop1)
3436       && !fixed_zerop (primop1))
3437     {
3438       tree tem = primop0;
3439       int temi = unsignedp0;
3440       primop0 = primop1;
3441       primop1 = tem;
3442       tem = op0;
3443       op0 = op1;
3444       op1 = tem;
3445       *op0_ptr = op0;
3446       *op1_ptr = op1;
3447       unsignedp0 = unsignedp1;
3448       unsignedp1 = temi;
3449       temi = real1;
3450       real1 = real2;
3451       real2 = temi;
3452
3453       switch (code)
3454         {
3455         case LT_EXPR:
3456           code = GT_EXPR;
3457           break;
3458         case GT_EXPR:
3459           code = LT_EXPR;
3460           break;
3461         case LE_EXPR:
3462           code = GE_EXPR;
3463           break;
3464         case GE_EXPR:
3465           code = LE_EXPR;
3466           break;
3467         default:
3468           break;
3469         }
3470       *rescode_ptr = code;
3471     }
3472
3473   /* If comparing an integer against a constant more bits wide,
3474      maybe we can deduce a value of 1 or 0 independent of the data.
3475      Or else truncate the constant now
3476      rather than extend the variable at run time.
3477
3478      This is only interesting if the constant is the wider arg.
3479      Also, it is not safe if the constant is unsigned and the
3480      variable arg is signed, since in this case the variable
3481      would be sign-extended and then regarded as unsigned.
3482      Our technique fails in this case because the lowest/highest
3483      possible unsigned results don't follow naturally from the
3484      lowest/highest possible values of the variable operand.
3485      For just EQ_EXPR and NE_EXPR there is another technique that
3486      could be used: see if the constant can be faithfully represented
3487      in the other operand's type, by truncating it and reextending it
3488      and see if that preserves the constant's value.  */
3489
3490   if (!real1 && !real2
3491       && TREE_CODE (TREE_TYPE (primop0)) != FIXED_POINT_TYPE
3492       && TREE_CODE (primop1) == INTEGER_CST
3493       && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
3494     {
3495       int min_gt, max_gt, min_lt, max_lt;
3496       tree maxval, minval;
3497       /* 1 if comparison is nominally unsigned.  */
3498       int unsignedp = TYPE_UNSIGNED (*restype_ptr);
3499       tree val;
3500
3501       type = c_common_signed_or_unsigned_type (unsignedp0,
3502                                                TREE_TYPE (primop0));
3503
3504       maxval = TYPE_MAX_VALUE (type);
3505       minval = TYPE_MIN_VALUE (type);
3506
3507       if (unsignedp && !unsignedp0)
3508         *restype_ptr = c_common_signed_type (*restype_ptr);
3509
3510       if (TREE_TYPE (primop1) != *restype_ptr)
3511         {
3512           /* Convert primop1 to target type, but do not introduce
3513              additional overflow.  We know primop1 is an int_cst.  */
3514           primop1 = force_fit_type_double (*restype_ptr,
3515                                            TREE_INT_CST_LOW (primop1),
3516                                            TREE_INT_CST_HIGH (primop1), 0,
3517                                            TREE_OVERFLOW (primop1));
3518         }
3519       if (type != *restype_ptr)
3520         {
3521           minval = convert (*restype_ptr, minval);
3522           maxval = convert (*restype_ptr, maxval);
3523         }
3524
3525       if (unsignedp && unsignedp0)
3526         {
3527           min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
3528           max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
3529           min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
3530           max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
3531         }
3532       else
3533         {
3534           min_gt = INT_CST_LT (primop1, minval);
3535           max_gt = INT_CST_LT (primop1, maxval);
3536           min_lt = INT_CST_LT (minval, primop1);
3537           max_lt = INT_CST_LT (maxval, primop1);
3538         }
3539
3540       val = 0;
3541       /* This used to be a switch, but Genix compiler can't handle that.  */
3542       if (code == NE_EXPR)
3543         {
3544           if (max_lt || min_gt)
3545             val = truthvalue_true_node;
3546         }
3547       else if (code == EQ_EXPR)
3548         {
3549           if (max_lt || min_gt)
3550             val = truthvalue_false_node;
3551         }
3552       else if (code == LT_EXPR)
3553         {
3554           if (max_lt)
3555             val = truthvalue_true_node;
3556           if (!min_lt)
3557             val = truthvalue_false_node;
3558         }
3559       else if (code == GT_EXPR)
3560         {
3561           if (min_gt)
3562             val = truthvalue_true_node;
3563           if (!max_gt)
3564             val = truthvalue_false_node;
3565         }
3566       else if (code == LE_EXPR)
3567         {
3568           if (!max_gt)
3569             val = truthvalue_true_node;
3570           if (min_gt)
3571             val = truthvalue_false_node;
3572         }
3573       else if (code == GE_EXPR)
3574         {
3575           if (!min_lt)
3576             val = truthvalue_true_node;
3577           if (max_lt)
3578             val = truthvalue_false_node;
3579         }
3580
3581       /* If primop0 was sign-extended and unsigned comparison specd,
3582          we did a signed comparison above using the signed type bounds.
3583          But the comparison we output must be unsigned.
3584
3585          Also, for inequalities, VAL is no good; but if the signed
3586          comparison had *any* fixed result, it follows that the
3587          unsigned comparison just tests the sign in reverse
3588          (positive values are LE, negative ones GE).
3589          So we can generate an unsigned comparison
3590          against an extreme value of the signed type.  */
3591
3592       if (unsignedp && !unsignedp0)
3593         {
3594           if (val != 0)
3595             switch (code)
3596               {
3597               case LT_EXPR:
3598               case GE_EXPR:
3599                 primop1 = TYPE_MIN_VALUE (type);
3600                 val = 0;
3601                 break;
3602
3603               case LE_EXPR:
3604               case GT_EXPR:
3605                 primop1 = TYPE_MAX_VALUE (type);
3606                 val = 0;
3607                 break;
3608
3609               default:
3610                 break;
3611               }
3612           type = c_common_unsigned_type (type);
3613         }
3614
3615       if (TREE_CODE (primop0) != INTEGER_CST)
3616         {
3617           if (val == truthvalue_false_node)
3618             warning (OPT_Wtype_limits, "comparison is always false due to limited range of data type");
3619           if (val == truthvalue_true_node)
3620             warning (OPT_Wtype_limits, "comparison is always true due to limited range of data type");
3621         }
3622
3623       if (val != 0)
3624         {
3625           /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3626           if (TREE_SIDE_EFFECTS (primop0))
3627             return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
3628           return val;
3629         }
3630
3631       /* Value is not predetermined, but do the comparison
3632          in the type of the operand that is not constant.
3633          TYPE is already properly set.  */
3634     }
3635
3636   /* If either arg is decimal float and the other is float, find the
3637      proper common type to use for comparison.  */
3638   else if (real1 && real2
3639            && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
3640                || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
3641     type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3642
3643   else if (real1 && real2
3644            && (TYPE_PRECISION (TREE_TYPE (primop0))
3645                == TYPE_PRECISION (TREE_TYPE (primop1))))
3646     type = TREE_TYPE (primop0);
3647
3648   /* If args' natural types are both narrower than nominal type
3649      and both extend in the same manner, compare them
3650      in the type of the wider arg.
3651      Otherwise must actually extend both to the nominal
3652      common type lest different ways of extending
3653      alter the result.
3654      (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
3655
3656   else if (unsignedp0 == unsignedp1 && real1 == real2
3657            && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
3658            && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
3659     {
3660       type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
3661       type = c_common_signed_or_unsigned_type (unsignedp0
3662                                                || TYPE_UNSIGNED (*restype_ptr),
3663                                                type);
3664       /* Make sure shorter operand is extended the right way
3665          to match the longer operand.  */
3666       primop0
3667         = convert (c_common_signed_or_unsigned_type (unsignedp0,
3668                                                      TREE_TYPE (primop0)),
3669                    primop0);
3670       primop1
3671         = convert (c_common_signed_or_unsigned_type (unsignedp1,
3672                                                      TREE_TYPE (primop1)),
3673                    primop1);
3674     }
3675   else
3676     {
3677       /* Here we must do the comparison on the nominal type
3678          using the args exactly as we received them.  */
3679       type = *restype_ptr;
3680       primop0 = op0;
3681       primop1 = op1;
3682
3683       if (!real1 && !real2 && integer_zerop (primop1)
3684           && TYPE_UNSIGNED (*restype_ptr))
3685         {
3686           tree value = 0;
3687           switch (code)
3688             {
3689             case GE_EXPR:
3690               /* All unsigned values are >= 0, so we warn.  However,
3691                  if OP0 is a constant that is >= 0, the signedness of
3692                  the comparison isn't an issue, so suppress the
3693                  warning.  */
3694               if (warn_type_limits && !in_system_header
3695                   && !(TREE_CODE (primop0) == INTEGER_CST
3696                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3697                                                    primop0))))
3698                 warning (OPT_Wtype_limits,
3699                          "comparison of unsigned expression >= 0 is always true");
3700               value = truthvalue_true_node;
3701               break;
3702
3703             case LT_EXPR:
3704               if (warn_type_limits && !in_system_header
3705                   && !(TREE_CODE (primop0) == INTEGER_CST
3706                        && !TREE_OVERFLOW (convert (c_common_signed_type (type),
3707                                                    primop0))))
3708                 warning (OPT_Wtype_limits,
3709                          "comparison of unsigned expression < 0 is always false");
3710               value = truthvalue_false_node;
3711               break;
3712
3713             default:
3714               break;
3715             }
3716
3717           if (value != 0)
3718             {
3719               /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
3720               if (TREE_SIDE_EFFECTS (primop0))
3721                 return build2 (COMPOUND_EXPR, TREE_TYPE (value),
3722                                primop0, value);
3723               return value;
3724             }
3725         }
3726     }
3727
3728   *op0_ptr = convert (type, primop0);
3729   *op1_ptr = convert (type, primop1);
3730
3731   *restype_ptr = truthvalue_type_node;
3732
3733   return 0;
3734 }
3735 \f
3736 /* Return a tree for the sum or difference (RESULTCODE says which)
3737    of pointer PTROP and integer INTOP.  */
3738
3739 tree
3740 pointer_int_sum (location_t loc, enum tree_code resultcode,
3741                  tree ptrop, tree intop)
3742 {
3743   tree size_exp, ret;
3744
3745   /* The result is a pointer of the same type that is being added.  */
3746   tree result_type = TREE_TYPE (ptrop);
3747
3748   if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
3749     {
3750       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3751                "pointer of type %<void *%> used in arithmetic");
3752       size_exp = integer_one_node;
3753     }
3754   else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
3755     {
3756       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3757                "pointer to a function used in arithmetic");
3758       size_exp = integer_one_node;
3759     }
3760   else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
3761     {
3762       pedwarn (loc, pedantic ? OPT_pedantic : OPT_Wpointer_arith,
3763                "pointer to member function used in arithmetic");
3764       size_exp = integer_one_node;
3765     }
3766   else
3767     size_exp = size_in_bytes (TREE_TYPE (result_type));
3768
3769   /* We are manipulating pointer values, so we don't need to warn
3770      about relying on undefined signed overflow.  We disable the
3771      warning here because we use integer types so fold won't know that
3772      they are really pointers.  */
3773   fold_defer_overflow_warnings ();
3774
3775   /* If what we are about to multiply by the size of the elements
3776      contains a constant term, apply distributive law
3777      and multiply that constant term separately.
3778      This helps produce common subexpressions.  */
3779   if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
3780       && !TREE_CONSTANT (intop)
3781       && TREE_CONSTANT (TREE_OPERAND (intop, 1))
3782       && TREE_CONSTANT (size_exp)
3783       /* If the constant comes from pointer subtraction,
3784          skip this optimization--it would cause an error.  */
3785       && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
3786       /* If the constant is unsigned, and smaller than the pointer size,
3787          then we must skip this optimization.  This is because it could cause
3788          an overflow error if the constant is negative but INTOP is not.  */
3789       && (!TYPE_UNSIGNED (TREE_TYPE (intop))
3790           || (TYPE_PRECISION (TREE_TYPE (intop))
3791               == TYPE_PRECISION (TREE_TYPE (ptrop)))))
3792     {
3793       enum tree_code subcode = resultcode;
3794       tree int_type = TREE_TYPE (intop);
3795       if (TREE_CODE (intop) == MINUS_EXPR)
3796         subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
3797       /* Convert both subexpression types to the type of intop,
3798          because weird cases involving pointer arithmetic
3799          can result in a sum or difference with different type args.  */
3800       ptrop = build_binary_op (EXPR_LOCATION (TREE_OPERAND (intop, 1)),
3801                                subcode, ptrop,
3802                                convert (int_type, TREE_OPERAND (intop, 1)), 1);
3803       intop = convert (int_type, TREE_OPERAND (intop, 0));
3804     }
3805
3806   /* Convert the integer argument to a type the same size as sizetype
3807      so the multiply won't overflow spuriously.  */
3808   if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
3809       || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
3810     intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
3811                                              TYPE_UNSIGNED (sizetype)), intop);
3812
3813   /* Replace the integer argument with a suitable product by the object size.
3814      Do this multiplication as signed, then convert to the appropriate type
3815      for the pointer operation and disregard an overflow that occured only
3816      because of the sign-extension change in the latter conversion.  */
3817   {
3818     tree t = build_binary_op (loc,
3819                               MULT_EXPR, intop,
3820                               convert (TREE_TYPE (intop), size_exp), 1);
3821     intop = convert (sizetype, t);
3822     if (TREE_OVERFLOW_P (intop) && !TREE_OVERFLOW (t))
3823       intop = build_int_cst_wide (TREE_TYPE (intop), TREE_INT_CST_LOW (intop),
3824                                   TREE_INT_CST_HIGH (intop));
3825   }
3826
3827   /* Create the sum or difference.  */
3828   if (resultcode == MINUS_EXPR)
3829     intop = fold_build1_loc (loc, NEGATE_EXPR, sizetype, intop);
3830
3831   ret = fold_build2_loc (loc, POINTER_PLUS_EXPR, result_type, ptrop, intop);
3832
3833   fold_undefer_and_ignore_overflow_warnings ();
3834
3835   return ret;
3836 }
3837 \f
3838 /* Wrap a C_MAYBE_CONST_EXPR around an expression that is fully folded
3839    and if NON_CONST is known not to be permitted in an evaluated part
3840    of a constant expression.  */
3841
3842 tree
3843 c_wrap_maybe_const (tree expr, bool non_const)
3844 {
3845   bool nowarning = TREE_NO_WARNING (expr);
3846   location_t loc = EXPR_LOCATION (expr);
3847
3848   /* This should never be called for C++.  */
3849   if (c_dialect_cxx ())
3850     gcc_unreachable ();
3851
3852   /* The result of folding may have a NOP_EXPR to set TREE_NO_WARNING.  */
3853   STRIP_TYPE_NOPS (expr);
3854   expr = build2 (C_MAYBE_CONST_EXPR, TREE_TYPE (expr), NULL, expr);
3855   C_MAYBE_CONST_EXPR_NON_CONST (expr) = non_const;
3856   if (nowarning)
3857     TREE_NO_WARNING (expr) = 1;
3858   protected_set_expr_location (expr, loc);
3859
3860   return expr;
3861 }
3862
3863 /* Wrap a SAVE_EXPR around EXPR, if appropriate.  Like save_expr, but
3864    for C folds the inside expression and wraps a C_MAYBE_CONST_EXPR
3865    around the SAVE_EXPR if needed so that c_fully_fold does not need
3866    to look inside SAVE_EXPRs.  */
3867
3868 tree
3869 c_save_expr (tree expr)
3870 {
3871   bool maybe_const = true;
3872   if (c_dialect_cxx ())
3873     return save_expr (expr);
3874   expr = c_fully_fold (expr, false, &maybe_const);
3875   expr = save_expr (expr);
3876   if (!maybe_const)
3877     expr = c_wrap_maybe_const (expr, true);
3878   return expr;
3879 }
3880
3881 /* Return whether EXPR is a declaration whose address can never be
3882    NULL.  */
3883
3884 bool
3885 decl_with_nonnull_addr_p (const_tree expr)
3886 {
3887   return (DECL_P (expr)
3888           && (TREE_CODE (expr) == PARM_DECL
3889               || TREE_CODE (expr) == LABEL_DECL
3890               || !DECL_WEAK (expr)));
3891 }
3892
3893 /* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
3894    or for an `if' or `while' statement or ?..: exp.  It should already
3895    have been validated to be of suitable type; otherwise, a bad
3896    diagnostic may result.
3897
3898    The EXPR is located at LOCATION.
3899
3900    This preparation consists of taking the ordinary
3901    representation of an expression expr and producing a valid tree
3902    boolean expression describing whether expr is nonzero.  We could
3903    simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
3904    but we optimize comparisons, &&, ||, and !.
3905
3906    The resulting type should always be `truthvalue_type_node'.  */
3907
3908 tree
3909 c_common_truthvalue_conversion (location_t location, tree expr)
3910 {
3911   switch (TREE_CODE (expr))
3912     {
3913     case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
3914     case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
3915     case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
3916     case ORDERED_EXPR: case UNORDERED_EXPR:
3917       if (TREE_TYPE (expr) == truthvalue_type_node)
3918         return expr;
3919       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3920                      TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
3921       goto ret;
3922
3923     case TRUTH_ANDIF_EXPR:
3924     case TRUTH_ORIF_EXPR:
3925     case TRUTH_AND_EXPR:
3926     case TRUTH_OR_EXPR:
3927     case TRUTH_XOR_EXPR:
3928       if (TREE_TYPE (expr) == truthvalue_type_node)
3929         return expr;
3930       expr = build2 (TREE_CODE (expr), truthvalue_type_node,
3931                      c_common_truthvalue_conversion (location,
3932                                                      TREE_OPERAND (expr, 0)),
3933                      c_common_truthvalue_conversion (location,
3934                                                      TREE_OPERAND (expr, 1)));
3935       goto ret;
3936
3937     case TRUTH_NOT_EXPR:
3938       if (TREE_TYPE (expr) == truthvalue_type_node)
3939         return expr;
3940       expr = build1 (TREE_CODE (expr), truthvalue_type_node,
3941                      c_common_truthvalue_conversion (location,
3942                                                      TREE_OPERAND (expr, 0)));
3943       goto ret;
3944
3945     case ERROR_MARK:
3946       return expr;
3947
3948     case INTEGER_CST:
3949       return integer_zerop (expr) ? truthvalue_false_node
3950                                   : truthvalue_true_node;
3951
3952     case REAL_CST:
3953       return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
3954              ? truthvalue_true_node
3955              : truthvalue_false_node;
3956
3957     case FIXED_CST:
3958       return fixed_compare (NE_EXPR, &TREE_FIXED_CST (expr),
3959                             &FCONST0 (TYPE_MODE (TREE_TYPE (expr))))
3960              ? truthvalue_true_node
3961              : truthvalue_false_node;
3962
3963     case FUNCTION_DECL:
3964       expr = build_unary_op (location, ADDR_EXPR, expr, 0);
3965       /* Fall through.  */
3966
3967     case ADDR_EXPR:
3968       {
3969         tree inner = TREE_OPERAND (expr, 0);
3970         if (decl_with_nonnull_addr_p (inner))
3971           {
3972             /* Common Ada/Pascal programmer's mistake.  */
3973             warning_at (location,
3974                         OPT_Waddress,
3975                         "the address of %qD will always evaluate as %<true%>",
3976                         inner);
3977             return truthvalue_true_node;
3978           }
3979
3980         /* If we still have a decl, it is possible for its address to
3981            be NULL, so we cannot optimize.  */
3982         if (DECL_P (inner))
3983           {
3984             gcc_assert (DECL_WEAK (inner));
3985             break;
3986           }
3987
3988         if (TREE_SIDE_EFFECTS (inner))
3989           {
3990             expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
3991                            inner, truthvalue_true_node);
3992             goto ret;
3993           }
3994         else
3995           return truthvalue_true_node;
3996       }
3997
3998     case COMPLEX_EXPR:
3999       expr = build_binary_op (EXPR_LOCATION (expr),
4000                               (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
4001                                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
4002                 c_common_truthvalue_conversion (location,
4003                                                 TREE_OPERAND (expr, 0)),
4004                 c_common_truthvalue_conversion (location,
4005                                                 TREE_OPERAND (expr, 1)),
4006                               0);
4007       goto ret;
4008
4009     case NEGATE_EXPR:
4010     case ABS_EXPR:
4011     case FLOAT_EXPR:
4012     case EXCESS_PRECISION_EXPR:
4013       /* These don't change whether an object is nonzero or zero.  */
4014       return c_common_truthvalue_conversion (location, TREE_OPERAND (expr, 0));
4015
4016     case LROTATE_EXPR:
4017     case RROTATE_EXPR:
4018       /* These don't change whether an object is zero or nonzero, but
4019          we can't ignore them if their second arg has side-effects.  */
4020       if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
4021         {
4022           expr = build2 (COMPOUND_EXPR, truthvalue_type_node,
4023                          TREE_OPERAND (expr, 1),