OSDN Git Service

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