OSDN Git Service

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