OSDN Git Service

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