OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gcc-4.2.2/] [gcc/] [c-common.c] - Blame information for rev 820

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 38 julius
/* 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, 2007 Free Software Foundation, Inc.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
You should have received a copy of the GNU General Public License
18
along with GCC; see the file COPYING3.  If not see
19
<http://www.gnu.org/licenses/>.  */
20
 
21
#include "config.h"
22
#include "system.h"
23
#include "coretypes.h"
24
#include "tm.h"
25
#include "intl.h"
26
#include "tree.h"
27
#include "flags.h"
28
#include "output.h"
29
#include "c-pragma.h"
30
#include "rtl.h"
31
#include "ggc.h"
32
#include "varray.h"
33
#include "expr.h"
34
#include "c-common.h"
35
#include "diagnostic.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 "tree-iterator.h"
45
#include "hashtab.h"
46
#include "tree-mudflap.h"
47
#include "opts.h"
48
#include "real.h"
49
#include "cgraph.h"
50
 
51
cpp_reader *parse_in;           /* Declared in c-pragma.h.  */
52
 
53
/* We let tm.h override the types used here, to handle trivial differences
54
   such as the choice of unsigned int or long unsigned int for size_t.
55
   When machines start needing nontrivial differences in the size type,
56
   it would be best to do something here to figure out automatically
57
   from other information what type to use.  */
58
 
59
#ifndef SIZE_TYPE
60
#define SIZE_TYPE "long unsigned int"
61
#endif
62
 
63
#ifndef PID_TYPE
64
#define PID_TYPE "int"
65
#endif
66
 
67
#ifndef WCHAR_TYPE
68
#define WCHAR_TYPE "int"
69
#endif
70
 
71
/* WCHAR_TYPE gets overridden by -fshort-wchar.  */
72
#define MODIFIED_WCHAR_TYPE \
73
        (flag_short_wchar ? "short unsigned int" : WCHAR_TYPE)
74
 
75
#ifndef PTRDIFF_TYPE
76
#define PTRDIFF_TYPE "long int"
77
#endif
78
 
79
#ifndef WINT_TYPE
80
#define WINT_TYPE "unsigned int"
81
#endif
82
 
83
#ifndef INTMAX_TYPE
84
#define INTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)     \
85
                     ? "int"                                    \
86
                     : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
87
                        ? "long int"                            \
88
                        : "long long int"))
89
#endif
90
 
91
#ifndef UINTMAX_TYPE
92
#define UINTMAX_TYPE ((INT_TYPE_SIZE == LONG_LONG_TYPE_SIZE)    \
93
                     ? "unsigned int"                           \
94
                     : ((LONG_TYPE_SIZE == LONG_LONG_TYPE_SIZE) \
95
                        ? "long unsigned int"                   \
96
                        : "long long unsigned int"))
97
#endif
98
 
99
/* The following symbols are subsumed in the c_global_trees array, and
100
   listed here individually for documentation purposes.
101
 
102
   INTEGER_TYPE and REAL_TYPE nodes for the standard data types.
103
 
104
        tree short_integer_type_node;
105
        tree long_integer_type_node;
106
        tree long_long_integer_type_node;
107
 
108
        tree short_unsigned_type_node;
109
        tree long_unsigned_type_node;
110
        tree long_long_unsigned_type_node;
111
 
112
        tree truthvalue_type_node;
113
        tree truthvalue_false_node;
114
        tree truthvalue_true_node;
115
 
116
        tree ptrdiff_type_node;
117
 
118
        tree unsigned_char_type_node;
119
        tree signed_char_type_node;
120
        tree wchar_type_node;
121
        tree signed_wchar_type_node;
122
        tree unsigned_wchar_type_node;
123
 
124
        tree float_type_node;
125
        tree double_type_node;
126
        tree long_double_type_node;
127
 
128
        tree complex_integer_type_node;
129
        tree complex_float_type_node;
130
        tree complex_double_type_node;
131
        tree complex_long_double_type_node;
132
 
133
        tree dfloat32_type_node;
134
        tree dfloat64_type_node;
135
        tree_dfloat128_type_node;
136
 
137
        tree intQI_type_node;
138
        tree intHI_type_node;
139
        tree intSI_type_node;
140
        tree intDI_type_node;
141
        tree intTI_type_node;
142
 
143
        tree unsigned_intQI_type_node;
144
        tree unsigned_intHI_type_node;
145
        tree unsigned_intSI_type_node;
146
        tree unsigned_intDI_type_node;
147
        tree unsigned_intTI_type_node;
148
 
149
        tree widest_integer_literal_type_node;
150
        tree widest_unsigned_literal_type_node;
151
 
152
   Nodes for types `void *' and `const void *'.
153
 
154
        tree ptr_type_node, const_ptr_type_node;
155
 
156
   Nodes for types `char *' and `const char *'.
157
 
158
        tree string_type_node, const_string_type_node;
159
 
160
   Type `char[SOMENUMBER]'.
161
   Used when an array of char is needed and the size is irrelevant.
162
 
163
        tree char_array_type_node;
164
 
165
   Type `int[SOMENUMBER]' or something like it.
166
   Used when an array of int needed and the size is irrelevant.
167
 
168
        tree int_array_type_node;
169
 
170
   Type `wchar_t[SOMENUMBER]' or something like it.
171
   Used when a wide string literal is created.
172
 
173
        tree wchar_array_type_node;
174
 
175
   Type `int ()' -- used for implicit declaration of functions.
176
 
177
        tree default_function_type;
178
 
179
   A VOID_TYPE node, packaged in a TREE_LIST.
180
 
181
        tree void_list_node;
182
 
183
  The lazily created VAR_DECLs for __FUNCTION__, __PRETTY_FUNCTION__,
184
  and __func__. (C doesn't generate __FUNCTION__ and__PRETTY_FUNCTION__
185
  VAR_DECLS, but C++ does.)
186
 
187
        tree function_name_decl_node;
188
        tree pretty_function_name_decl_node;
189
        tree c99_function_name_decl_node;
190
 
191
  Stack of nested function name VAR_DECLs.
192
 
193
        tree saved_function_name_decls;
194
 
195
*/
196
 
197
tree c_global_trees[CTI_MAX];
198
 
199
/* Switches common to the C front ends.  */
200
 
201
/* Nonzero if prepreprocessing only.  */
202
 
203
int flag_preprocess_only;
204
 
205
/* Nonzero means don't output line number information.  */
206
 
207
char flag_no_line_commands;
208
 
209
/* Nonzero causes -E output not to be done, but directives such as
210
   #define that have side effects are still obeyed.  */
211
 
212
char flag_no_output;
213
 
214
/* Nonzero means dump macros in some fashion.  */
215
 
216
char flag_dump_macros;
217
 
218
/* Nonzero means pass #include lines through to the output.  */
219
 
220
char flag_dump_includes;
221
 
222
/* Nonzero means process PCH files while preprocessing.  */
223
 
224
bool flag_pch_preprocess;
225
 
226
/* The file name to which we should write a precompiled header, or
227
   NULL if no header will be written in this compile.  */
228
 
229
const char *pch_file;
230
 
231
/* Nonzero if an ISO standard was selected.  It rejects macros in the
232
   user's namespace.  */
233
int flag_iso;
234
 
235
/* Nonzero if -undef was given.  It suppresses target built-in macros
236
   and assertions.  */
237
int flag_undef;
238
 
239
/* Nonzero means don't recognize the non-ANSI builtin functions.  */
240
 
241
int flag_no_builtin;
242
 
243
/* Nonzero means don't recognize the non-ANSI builtin functions.
244
   -ansi sets this.  */
245
 
246
int flag_no_nonansi_builtin;
247
 
248
/* Nonzero means give `double' the same size as `float'.  */
249
 
250
int flag_short_double;
251
 
252
/* Nonzero means give `wchar_t' the same size as `short'.  */
253
 
254
int flag_short_wchar;
255
 
256
/* Nonzero means allow Microsoft extensions without warnings or errors.  */
257
int flag_ms_extensions;
258
 
259
/* Nonzero means don't recognize the keyword `asm'.  */
260
 
261
int flag_no_asm;
262
 
263
/* Nonzero means to treat bitfields as signed unless they say `unsigned'.  */
264
 
265
int flag_signed_bitfields = 1;
266
 
267
/* Warn about #pragma directives that are not recognized.  */
268
 
269
int warn_unknown_pragmas; /* Tri state variable.  */
270
 
271
/* Warn about format/argument anomalies in calls to formatted I/O functions
272
   (*printf, *scanf, strftime, strfmon, etc.).  */
273
 
274
int warn_format;
275
 
276
/* Warn about using __null (as NULL in C++) as sentinel.  For code compiled
277
   with GCC this doesn't matter as __null is guaranteed to have the right
278
   size.  */
279
 
280
int warn_strict_null_sentinel;
281
 
282
/* Zero means that faster, ...NonNil variants of objc_msgSend...
283
   calls will be used in ObjC; passing nil receivers to such calls
284
   will most likely result in crashes.  */
285
int flag_nil_receivers = 1;
286
 
287
/* Nonzero means that code generation will be altered to support
288
   "zero-link" execution.  This currently affects ObjC only, but may
289
   affect other languages in the future.  */
290
int flag_zero_link = 0;
291
 
292
/* Nonzero means emit an '__OBJC, __image_info' for the current translation
293
   unit.  It will inform the ObjC runtime that class definition(s) herein
294
   contained are to replace one(s) previously loaded.  */
295
int flag_replace_objc_classes = 0;
296
 
297
/* C/ObjC language option variables.  */
298
 
299
 
300
/* Nonzero means allow type mismatches in conditional expressions;
301
   just make their values `void'.  */
302
 
303
int flag_cond_mismatch;
304
 
305
/* Nonzero means enable C89 Amendment 1 features.  */
306
 
307
int flag_isoc94;
308
 
309
/* Nonzero means use the ISO C99 dialect of C.  */
310
 
311
int flag_isoc99;
312
 
313
/* Nonzero means that we have builtin functions, and main is an int.  */
314
 
315
int flag_hosted = 1;
316
 
317
/* Warn if main is suspicious.  */
318
 
319
int warn_main;
320
 
321
 
322
/* ObjC language option variables.  */
323
 
324
 
325
/* Open and close the file for outputting class declarations, if
326
   requested (ObjC).  */
327
 
328
int flag_gen_declaration;
329
 
330
/* Tells the compiler that this is a special run.  Do not perform any
331
   compiling, instead we are to test some platform dependent features
332
   and output a C header file with appropriate definitions.  */
333
 
334
int print_struct_values;
335
 
336
/* Tells the compiler what is the constant string class for Objc.  */
337
 
338
const char *constant_string_class_name;
339
 
340
 
341
/* C++ language option variables.  */
342
 
343
 
344
/* Nonzero means don't recognize any extension keywords.  */
345
 
346
int flag_no_gnu_keywords;
347
 
348
/* Nonzero means do emit exported implementations of functions even if
349
   they can be inlined.  */
350
 
351
int flag_implement_inlines = 1;
352
 
353
/* Nonzero means that implicit instantiations will be emitted if needed.  */
354
 
355
int flag_implicit_templates = 1;
356
 
357
/* Nonzero means that implicit instantiations of inline templates will be
358
   emitted if needed, even if instantiations of non-inline templates
359
   aren't.  */
360
 
361
int flag_implicit_inline_templates = 1;
362
 
363
/* Nonzero means generate separate instantiation control files and
364
   juggle them at link time.  */
365
 
366
int flag_use_repository;
367
 
368
/* Nonzero if we want to issue diagnostics that the standard says are not
369
   required.  */
370
 
371
int flag_optional_diags = 1;
372
 
373
/* Nonzero means we should attempt to elide constructors when possible.  */
374
 
375
int flag_elide_constructors = 1;
376
 
377
/* Nonzero means that member functions defined in class scope are
378
   inline by default.  */
379
 
380
int flag_default_inline = 1;
381
 
382
/* Controls whether compiler generates 'type descriptor' that give
383
   run-time type information.  */
384
 
385
int flag_rtti = 1;
386
 
387
/* Nonzero if we want to conserve space in the .o files.  We do this
388
   by putting uninitialized data and runtime initialized data into
389
   .common instead of .data at the expense of not flagging multiple
390
   definitions.  */
391
 
392
int flag_conserve_space;
393
 
394
/* Nonzero if we want to obey access control semantics.  */
395
 
396
int flag_access_control = 1;
397
 
398
/* Nonzero if we want to check the return value of new and avoid calling
399
   constructors if it is a null pointer.  */
400
 
401
int flag_check_new;
402
 
403
/* Nonzero if we want the new ISO rules for pushing a new scope for `for'
404
   initialization variables.
405
   0: Old rules, set by -fno-for-scope.
406
   2: New ISO rules, set by -ffor-scope.
407
   1: Try to implement new ISO rules, but with backup compatibility
408
   (and warnings).  This is the default, for now.  */
409
 
410
int flag_new_for_scope = 1;
411
 
412
/* Nonzero if we want to emit defined symbols with common-like linkage as
413
   weak symbols where possible, in order to conform to C++ semantics.
414
   Otherwise, emit them as local symbols.  */
415
 
416
int flag_weak = 1;
417
 
418
/* 0 means we want the preprocessor to not emit line directives for
419
   the current working directory.  1 means we want it to do it.  -1
420
   means we should decide depending on whether debugging information
421
   is being emitted or not.  */
422
 
423
int flag_working_directory = -1;
424
 
425
/* Nonzero to use __cxa_atexit, rather than atexit, to register
426
   destructors for local statics and global objects.  '2' means it has been
427
   set nonzero as a default, not by a command-line flag.  */
428
 
429
int flag_use_cxa_atexit = DEFAULT_USE_CXA_ATEXIT;
430
 
431
/* Nonzero to use __cxa_get_exception_ptr in C++ exception-handling
432
   code.  '2' means it has not been set explicitly on the command line.  */
433
 
434
int flag_use_cxa_get_exception_ptr = 2;
435
 
436
/* Nonzero means make the default pedwarns warnings instead of errors.
437
   The value of this flag is ignored if -pedantic is specified.  */
438
 
439
int flag_permissive;
440
 
441
/* Nonzero means to implement standard semantics for exception
442
   specifications, calling unexpected if an exception is thrown that
443
   doesn't match the specification.  Zero means to treat them as
444
   assertions and optimize accordingly, but not check them.  */
445
 
446
int flag_enforce_eh_specs = 1;
447
 
448
/* Nonzero means to generate thread-safe code for initializing local
449
   statics.  */
450
 
451
int flag_threadsafe_statics = 1;
452
 
453
/* Nonzero means warn about implicit declarations.  */
454
 
455
int warn_implicit = 1;
456
 
457
/* Maximum template instantiation depth.  This limit is rather
458
   arbitrary, but it exists to limit the time it takes to notice
459
   infinite template instantiations.  */
460
 
461
int max_tinst_depth = 500;
462
 
463
 
464
 
465
/* The elements of `ridpointers' are identifier nodes for the reserved
466
   type names and storage classes.  It is indexed by a RID_... value.  */
467
tree *ridpointers;
468
 
469
tree (*make_fname_decl) (tree, int);
470
 
471
/* Nonzero means the expression being parsed will never be evaluated.
472
   This is a count, since unevaluated expressions can nest.  */
473
int skip_evaluation;
474
 
475
/* Information about how a function name is generated.  */
476
struct fname_var_t
477
{
478
  tree *const decl;     /* pointer to the VAR_DECL.  */
479
  const unsigned rid;   /* RID number for the identifier.  */
480
  const int pretty;     /* How pretty is it? */
481
};
482
 
483
/* The three ways of getting then name of the current function.  */
484
 
485
const struct fname_var_t fname_vars[] =
486
{
487
  /* C99 compliant __func__, must be first.  */
488
  {&c99_function_name_decl_node, RID_C99_FUNCTION_NAME, 0},
489
  /* GCC __FUNCTION__ compliant.  */
490
  {&function_name_decl_node, RID_FUNCTION_NAME, 0},
491
  /* GCC __PRETTY_FUNCTION__ compliant.  */
492
  {&pretty_function_name_decl_node, RID_PRETTY_FUNCTION_NAME, 1},
493
  {NULL, 0, 0},
494
};
495
 
496
static int constant_fits_type_p (tree, tree);
497
static tree check_case_value (tree);
498
static bool check_case_bounds (tree, tree, tree *, tree *);
499
 
500
static tree handle_packed_attribute (tree *, tree, tree, int, bool *);
501
static tree handle_nocommon_attribute (tree *, tree, tree, int, bool *);
502
static tree handle_common_attribute (tree *, tree, tree, int, bool *);
503
static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
504
static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
505
static tree handle_always_inline_attribute (tree *, tree, tree, int,
506
                                            bool *);
507
static tree handle_gnu_inline_attribute (tree *, tree, tree, int,
508
                                         bool *);
509
static tree handle_flatten_attribute (tree *, tree, tree, int, bool *);
510
static tree handle_used_attribute (tree *, tree, tree, int, bool *);
511
static tree handle_unused_attribute (tree *, tree, tree, int, bool *);
512
static tree handle_externally_visible_attribute (tree *, tree, tree, int,
513
                                                 bool *);
514
static tree handle_const_attribute (tree *, tree, tree, int, bool *);
515
static tree handle_transparent_union_attribute (tree *, tree, tree,
516
                                                int, bool *);
517
static tree handle_constructor_attribute (tree *, tree, tree, int, bool *);
518
static tree handle_destructor_attribute (tree *, tree, tree, int, bool *);
519
static tree handle_mode_attribute (tree *, tree, tree, int, bool *);
520
static tree handle_section_attribute (tree *, tree, tree, int, bool *);
521
static tree handle_aligned_attribute (tree *, tree, tree, int, bool *);
522
static tree handle_weak_attribute (tree *, tree, tree, int, bool *) ;
523
static tree handle_alias_attribute (tree *, tree, tree, int, bool *);
524
static tree handle_weakref_attribute (tree *, tree, tree, int, bool *) ;
525
static tree handle_visibility_attribute (tree *, tree, tree, int,
526
                                         bool *);
527
static tree handle_tls_model_attribute (tree *, tree, tree, int,
528
                                        bool *);
529
static tree handle_no_instrument_function_attribute (tree *, tree,
530
                                                     tree, int, bool *);
531
static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
532
static tree handle_returns_twice_attribute (tree *, tree, tree, int, bool *);
533
static tree handle_no_limit_stack_attribute (tree *, tree, tree, int,
534
                                             bool *);
535
static tree handle_pure_attribute (tree *, tree, tree, int, bool *);
536
static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
537
static tree handle_deprecated_attribute (tree *, tree, tree, int,
538
                                         bool *);
539
static tree handle_vector_size_attribute (tree *, tree, tree, int,
540
                                          bool *);
541
static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
542
static tree handle_nothrow_attribute (tree *, tree, tree, int, bool *);
543
static tree handle_cleanup_attribute (tree *, tree, tree, int, bool *);
544
static tree handle_warn_unused_result_attribute (tree *, tree, tree, int,
545
                                                 bool *);
546
static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
547
 
548
static void check_function_nonnull (tree, tree);
549
static void check_nonnull_arg (void *, tree, unsigned HOST_WIDE_INT);
550
static bool nonnull_check_p (tree, unsigned HOST_WIDE_INT);
551
static bool get_nonnull_operand (tree, unsigned HOST_WIDE_INT *);
552
static int resort_field_decl_cmp (const void *, const void *);
553
 
554
/* Table of machine-independent attributes common to all C-like languages.  */
555
const struct attribute_spec c_common_attribute_table[] =
556
{
557
  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
558
  { "packed",                 0, 0, false, false, false,
559
                              handle_packed_attribute },
560
  { "nocommon",               0, 0, true,  false, false,
561
                              handle_nocommon_attribute },
562
  { "common",                 0, 0, true,  false, false,
563
                              handle_common_attribute },
564
  /* FIXME: logically, noreturn attributes should be listed as
565
     "false, true, true" and apply to function types.  But implementing this
566
     would require all the places in the compiler that use TREE_THIS_VOLATILE
567
     on a decl to identify non-returning functions to be located and fixed
568
     to check the function type instead.  */
569
  { "noreturn",               0, 0, true,  false, false,
570
                              handle_noreturn_attribute },
571
  { "volatile",               0, 0, true,  false, false,
572
                              handle_noreturn_attribute },
573
  { "noinline",               0, 0, true,  false, false,
574
                              handle_noinline_attribute },
575
  { "always_inline",          0, 0, true,  false, false,
576
                              handle_always_inline_attribute },
577
  { "gnu_inline",             0, 0, true,  false, false,
578
                              handle_gnu_inline_attribute },
579
  { "flatten",                0, 0, true,  false, false,
580
                              handle_flatten_attribute },
581
  { "used",                   0, 0, true,  false, false,
582
                              handle_used_attribute },
583
  { "unused",                 0, 0, false, false, false,
584
                              handle_unused_attribute },
585
  { "externally_visible",     0, 0, true,  false, false,
586
                              handle_externally_visible_attribute },
587
  /* The same comments as for noreturn attributes apply to const ones.  */
588
  { "const",                  0, 0, true,  false, false,
589
                              handle_const_attribute },
590
  { "transparent_union",      0, 0, false, false, false,
591
                              handle_transparent_union_attribute },
592
  { "constructor",            0, 0, true,  false, false,
593
                              handle_constructor_attribute },
594
  { "destructor",             0, 0, true,  false, false,
595
                              handle_destructor_attribute },
596
  { "mode",                   1, 1, false,  true, false,
597
                              handle_mode_attribute },
598
  { "section",                1, 1, true,  false, false,
599
                              handle_section_attribute },
600
  { "aligned",                0, 1, false, false, false,
601
                              handle_aligned_attribute },
602
  { "weak",                   0, 0, true,  false, false,
603
                              handle_weak_attribute },
604
  { "alias",                  1, 1, true,  false, false,
605
                              handle_alias_attribute },
606
  { "weakref",                0, 1, true,  false, false,
607
                              handle_weakref_attribute },
608
  { "no_instrument_function", 0, 0, true,  false, false,
609
                              handle_no_instrument_function_attribute },
610
  { "malloc",                 0, 0, true,  false, false,
611
                              handle_malloc_attribute },
612
  { "returns_twice",          0, 0, true,  false, false,
613
                              handle_returns_twice_attribute },
614
  { "no_stack_limit",         0, 0, true,  false, false,
615
                              handle_no_limit_stack_attribute },
616
  { "pure",                   0, 0, true,  false, false,
617
                              handle_pure_attribute },
618
  /* For internal use (marking of builtins) only.  The name contains space
619
     to prevent its usage in source code.  */
620
  { "no vops",                0, 0, true,  false, false,
621
                              handle_novops_attribute },
622
  { "deprecated",             0, 0, false, false, false,
623
                              handle_deprecated_attribute },
624
  { "vector_size",            1, 1, false, true, false,
625
                              handle_vector_size_attribute },
626
  { "visibility",             1, 1, false, false, false,
627
                              handle_visibility_attribute },
628
  { "tls_model",              1, 1, true,  false, false,
629
                              handle_tls_model_attribute },
630
  { "nonnull",                0, -1, false, true, true,
631
                              handle_nonnull_attribute },
632
  { "nothrow",                0, 0, true,  false, false,
633
                              handle_nothrow_attribute },
634
  { "may_alias",              0, 0, false, true, false, NULL },
635
  { "cleanup",                1, 1, true, false, false,
636
                              handle_cleanup_attribute },
637
  { "warn_unused_result",     0, 0, false, true, true,
638
                              handle_warn_unused_result_attribute },
639
  { "sentinel",               0, 1, false, true, true,
640
                              handle_sentinel_attribute },
641
  { NULL,                     0, 0, false, false, false, NULL }
642
};
643
 
644
/* Give the specifications for the format attributes, used by C and all
645
   descendants.  */
646
 
647
const struct attribute_spec c_common_format_attribute_table[] =
648
{
649
  /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
650
  { "format",                 3, 3, false, true,  true,
651
                              handle_format_attribute },
652
  { "format_arg",             1, 1, false, true,  true,
653
                              handle_format_arg_attribute },
654
  { NULL,                     0, 0, false, false, false, NULL }
655
};
656
 
657
/* Push current bindings for the function name VAR_DECLS.  */
658
 
659
void
660
start_fname_decls (void)
661
{
662
  unsigned ix;
663
  tree saved = NULL_TREE;
664
 
665
  for (ix = 0; fname_vars[ix].decl; ix++)
666
    {
667
      tree decl = *fname_vars[ix].decl;
668
 
669
      if (decl)
670
        {
671
          saved = tree_cons (decl, build_int_cst (NULL_TREE, ix), saved);
672
          *fname_vars[ix].decl = NULL_TREE;
673
        }
674
    }
675
  if (saved || saved_function_name_decls)
676
    /* Normally they'll have been NULL, so only push if we've got a
677
       stack, or they are non-NULL.  */
678
    saved_function_name_decls = tree_cons (saved, NULL_TREE,
679
                                           saved_function_name_decls);
680
}
681
 
682
/* Finish up the current bindings, adding them into the current function's
683
   statement tree.  This must be done _before_ finish_stmt_tree is called.
684
   If there is no current function, we must be at file scope and no statements
685
   are involved. Pop the previous bindings.  */
686
 
687
void
688
finish_fname_decls (void)
689
{
690
  unsigned ix;
691
  tree stmts = NULL_TREE;
692
  tree stack = saved_function_name_decls;
693
 
694
  for (; stack && TREE_VALUE (stack); stack = TREE_CHAIN (stack))
695
    append_to_statement_list (TREE_VALUE (stack), &stmts);
696
 
697
  if (stmts)
698
    {
699
      tree *bodyp = &DECL_SAVED_TREE (current_function_decl);
700
 
701
      if (TREE_CODE (*bodyp) == BIND_EXPR)
702
        bodyp = &BIND_EXPR_BODY (*bodyp);
703
 
704
      append_to_statement_list_force (*bodyp, &stmts);
705
      *bodyp = stmts;
706
    }
707
 
708
  for (ix = 0; fname_vars[ix].decl; ix++)
709
    *fname_vars[ix].decl = NULL_TREE;
710
 
711
  if (stack)
712
    {
713
      /* We had saved values, restore them.  */
714
      tree saved;
715
 
716
      for (saved = TREE_PURPOSE (stack); saved; saved = TREE_CHAIN (saved))
717
        {
718
          tree decl = TREE_PURPOSE (saved);
719
          unsigned ix = TREE_INT_CST_LOW (TREE_VALUE (saved));
720
 
721
          *fname_vars[ix].decl = decl;
722
        }
723
      stack = TREE_CHAIN (stack);
724
    }
725
  saved_function_name_decls = stack;
726
}
727
 
728
/* Return the text name of the current function, suitably prettified
729
   by PRETTY_P.  Return string must be freed by caller.  */
730
 
731
const char *
732
fname_as_string (int pretty_p)
733
{
734
  const char *name = "top level";
735
  char *namep;
736
  int vrb = 2;
737
 
738
  if (!pretty_p)
739
    {
740
      name = "";
741
      vrb = 0;
742
    }
743
 
744
  if (current_function_decl)
745
    name = lang_hooks.decl_printable_name (current_function_decl, vrb);
746
 
747
  if (c_lex_string_translate)
748
    {
749
      int len = strlen (name) + 3; /* Two for '"'s.  One for NULL.  */
750
      cpp_string cstr = { 0, 0 }, strname;
751
 
752
      namep = XNEWVEC (char, len);
753
      snprintf (namep, len, "\"%s\"", name);
754
      strname.text = (unsigned char *) namep;
755
      strname.len = len - 1;
756
 
757
      if (cpp_interpret_string (parse_in, &strname, 1, &cstr, false))
758
        {
759
          XDELETEVEC (namep);
760
          return (char *) cstr.text;
761
        }
762
    }
763
  else
764
    namep = xstrdup (name);
765
 
766
  return namep;
767
}
768
 
769
/* Expand DECL if it declares an entity not handled by the
770
   common code.  */
771
 
772
int
773
c_expand_decl (tree decl)
774
{
775
  if (TREE_CODE (decl) == VAR_DECL && !TREE_STATIC (decl))
776
    {
777
      /* Let the back-end know about this variable.  */
778
      if (!anon_aggr_type_p (TREE_TYPE (decl)))
779
        emit_local_var (decl);
780
      else
781
        expand_anon_union_decl (decl, NULL_TREE,
782
                                DECL_ANON_UNION_ELEMS (decl));
783
    }
784
  else
785
    return 0;
786
 
787
  return 1;
788
}
789
 
790
 
791
/* Return the VAR_DECL for a const char array naming the current
792
   function. If the VAR_DECL has not yet been created, create it
793
   now. RID indicates how it should be formatted and IDENTIFIER_NODE
794
   ID is its name (unfortunately C and C++ hold the RID values of
795
   keywords in different places, so we can't derive RID from ID in
796
   this language independent code.  */
797
 
798
tree
799
fname_decl (unsigned int rid, tree id)
800
{
801
  unsigned ix;
802
  tree decl = NULL_TREE;
803
 
804
  for (ix = 0; fname_vars[ix].decl; ix++)
805
    if (fname_vars[ix].rid == rid)
806
      break;
807
 
808
  decl = *fname_vars[ix].decl;
809
  if (!decl)
810
    {
811
      /* If a tree is built here, it would normally have the lineno of
812
         the current statement.  Later this tree will be moved to the
813
         beginning of the function and this line number will be wrong.
814
         To avoid this problem set the lineno to 0 here; that prevents
815
         it from appearing in the RTL.  */
816
      tree stmts;
817
      location_t saved_location = input_location;
818
#ifdef USE_MAPPED_LOCATION
819
      input_location = UNKNOWN_LOCATION;
820
#else
821
      input_line = 0;
822
#endif
823
 
824
      stmts = push_stmt_list ();
825
      decl = (*make_fname_decl) (id, fname_vars[ix].pretty);
826
      stmts = pop_stmt_list (stmts);
827
      if (!IS_EMPTY_STMT (stmts))
828
        saved_function_name_decls
829
          = tree_cons (decl, stmts, saved_function_name_decls);
830
      *fname_vars[ix].decl = decl;
831
      input_location = saved_location;
832
    }
833
  if (!ix && !current_function_decl)
834
    pedwarn ("%qD is not defined outside of function scope", decl);
835
 
836
  return decl;
837
}
838
 
839
/* Given a STRING_CST, give it a suitable array-of-chars data type.  */
840
 
841
tree
842
fix_string_type (tree value)
843
{
844
  const int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT;
845
  const int wide_flag = TREE_TYPE (value) == wchar_array_type_node;
846
  int length = TREE_STRING_LENGTH (value);
847
  int nchars;
848
  tree e_type, i_type, a_type;
849
 
850
  /* Compute the number of elements, for the array type.  */
851
  nchars = wide_flag ? length / wchar_bytes : length;
852
 
853
  /* C89 2.2.4.1, C99 5.2.4.1 (Translation limits).  The analogous
854
     limit in C++98 Annex B is very large (65536) and is not normative,
855
     so we do not diagnose it (warn_overlength_strings is forced off
856
     in c_common_post_options).  */
857
  if (warn_overlength_strings)
858
    {
859
      const int nchars_max = flag_isoc99 ? 4095 : 509;
860
      const int relevant_std = flag_isoc99 ? 99 : 90;
861
      if (nchars - 1 > nchars_max)
862
        /* Translators: The %d after 'ISO C' will be 90 or 99.  Do not
863
           separate the %d from the 'C'.  'ISO' should not be
864
           translated, but it may be moved after 'C%d' in languages
865
           where modifiers follow nouns.  */
866
        pedwarn ("string length %qd is greater than the length %qd "
867
                 "ISO C%d compilers are required to support",
868
                 nchars - 1, nchars_max, relevant_std);
869
    }
870
 
871
  /* Create the array type for the string constant.  The ISO C++
872
     standard says that a string literal has type `const char[N]' or
873
     `const wchar_t[N]'.  We use the same logic when invoked as a C
874
     front-end with -Wwrite-strings.
875
     ??? We should change the type of an expression depending on the
876
     state of a warning flag.  We should just be warning -- see how
877
     this is handled in the C++ front-end for the deprecated implicit
878
     conversion from string literals to `char*' or `wchar_t*'.
879
 
880
     The C++ front end relies on TYPE_MAIN_VARIANT of a cv-qualified
881
     array type being the unqualified version of that type.
882
     Therefore, if we are constructing an array of const char, we must
883
     construct the matching unqualified array type first.  The C front
884
     end does not require this, but it does no harm, so we do it
885
     unconditionally.  */
886
  e_type = wide_flag ? wchar_type_node : char_type_node;
887
  i_type = build_index_type (build_int_cst (NULL_TREE, nchars - 1));
888
  a_type = build_array_type (e_type, i_type);
889
  if (c_dialect_cxx() || warn_write_strings)
890
    a_type = c_build_qualified_type (a_type, TYPE_QUAL_CONST);
891
 
892
  TREE_TYPE (value) = a_type;
893
  TREE_CONSTANT (value) = 1;
894
  TREE_INVARIANT (value) = 1;
895
  TREE_READONLY (value) = 1;
896
  TREE_STATIC (value) = 1;
897
  return value;
898
}
899
 
900
/* Print a warning if a constant expression had overflow in folding.
901
   Invoke this function on every expression that the language
902
   requires to be a constant expression.
903
   Note the ANSI C standard says it is erroneous for a
904
   constant expression to overflow.  */
905
 
906
void
907
constant_expression_warning (tree value)
908
{
909
  if ((TREE_CODE (value) == INTEGER_CST || TREE_CODE (value) == REAL_CST
910
       || TREE_CODE (value) == VECTOR_CST
911
       || TREE_CODE (value) == COMPLEX_CST)
912
      && TREE_CONSTANT_OVERFLOW (value)
913
      && warn_overflow
914
      && pedantic)
915
    pedwarn ("overflow in constant expression");
916
}
917
 
918
/* Print a warning if an expression had overflow in folding.
919
   Invoke this function on every expression that
920
   (1) appears in the source code, and
921
   (2) might be a constant expression that overflowed, and
922
   (3) is not already checked by convert_and_check;
923
   however, do not invoke this function on operands of explicit casts.  */
924
 
925
void
926
overflow_warning (tree value)
927
{
928
  if ((TREE_CODE (value) == INTEGER_CST
929
       || (TREE_CODE (value) == COMPLEX_CST
930
           && TREE_CODE (TREE_REALPART (value)) == INTEGER_CST))
931
      && TREE_OVERFLOW (value))
932
    {
933
      TREE_OVERFLOW (value) = 0;
934
      if (skip_evaluation == 0)
935
        warning (OPT_Woverflow, "integer overflow in expression");
936
    }
937
  else if ((TREE_CODE (value) == REAL_CST
938
            || (TREE_CODE (value) == COMPLEX_CST
939
                && TREE_CODE (TREE_REALPART (value)) == REAL_CST))
940
           && TREE_OVERFLOW (value))
941
    {
942
      TREE_OVERFLOW (value) = 0;
943
      if (skip_evaluation == 0)
944
        warning (OPT_Woverflow, "floating point overflow in expression");
945
    }
946
  else if (TREE_CODE (value) == VECTOR_CST && TREE_OVERFLOW (value))
947
    {
948
      TREE_OVERFLOW (value) = 0;
949
      if (skip_evaluation == 0)
950
        warning (OPT_Woverflow, "vector overflow in expression");
951
    }
952
}
953
 
954
/* Print a warning if a large constant is truncated to unsigned,
955
   or if -Wconversion is used and a constant < 0 is converted to unsigned.
956
   Invoke this function on every expression that might be implicitly
957
   converted to an unsigned type.  */
958
 
959
static void
960
unsigned_conversion_warning (tree result, tree operand)
961
{
962
  tree type = TREE_TYPE (result);
963
 
964
  if (TREE_CODE (operand) == INTEGER_CST
965
      && TREE_CODE (type) == INTEGER_TYPE
966
      && TYPE_UNSIGNED (type)
967
      && skip_evaluation == 0
968
      && !int_fits_type_p (operand, type))
969
    {
970
      if (!int_fits_type_p (operand, c_common_signed_type (type)))
971
        /* This detects cases like converting -129 or 256 to unsigned char.  */
972
        warning (OPT_Woverflow,
973
                 "large integer implicitly truncated to unsigned type");
974
      else
975
        warning (OPT_Wconversion,
976
                 "negative integer implicitly converted to unsigned type");
977
    }
978
}
979
 
980
/* Print a warning about casts that might indicate violation
981
   of strict aliasing rules if -Wstrict-aliasing is used and
982
   strict aliasing mode is in effect. OTYPE is the original
983
   TREE_TYPE of EXPR, and TYPE the type we're casting to. */
984
 
985
void
986
strict_aliasing_warning (tree otype, tree type, tree expr)
987
{
988
  if (flag_strict_aliasing && warn_strict_aliasing
989
      && POINTER_TYPE_P (type) && POINTER_TYPE_P (otype)
990
      && TREE_CODE (expr) == ADDR_EXPR
991
      && (DECL_P (TREE_OPERAND (expr, 0))
992
          || handled_component_p (TREE_OPERAND (expr, 0)))
993
      && !VOID_TYPE_P (TREE_TYPE (type)))
994
    {
995
      /* Casting the address of an object to non void pointer. Warn
996
         if the cast breaks type based aliasing.  */
997
      if (!COMPLETE_TYPE_P (TREE_TYPE (type)))
998
        warning (OPT_Wstrict_aliasing, "type-punning to incomplete type "
999
                 "might break strict-aliasing rules");
1000
      else
1001
        {
1002
          HOST_WIDE_INT set1 = get_alias_set (TREE_TYPE (TREE_OPERAND (expr, 0)));
1003
          HOST_WIDE_INT set2 = get_alias_set (TREE_TYPE (type));
1004
 
1005
          if (!alias_sets_conflict_p (set1, set2))
1006
            warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1007
                     "pointer will break strict-aliasing rules");
1008
          else if (warn_strict_aliasing > 1
1009
                  && !alias_sets_might_conflict_p (set1, set2))
1010
            warning (OPT_Wstrict_aliasing, "dereferencing type-punned "
1011
                     "pointer might break strict-aliasing rules");
1012
        }
1013
    }
1014
}
1015
 
1016
 
1017
/* Print a warning about if (); or if () .. else; constructs
1018
   via the special empty statement node that we create.  INNER_THEN
1019
   and INNER_ELSE are the statement lists of the if and the else
1020
   block.  */
1021
 
1022
void
1023
empty_body_warning (tree inner_then, tree inner_else)
1024
{
1025
  if (extra_warnings)
1026
    {
1027
      if (TREE_CODE (inner_then) == STATEMENT_LIST
1028
          && STATEMENT_LIST_TAIL (inner_then))
1029
        inner_then = STATEMENT_LIST_TAIL (inner_then)->stmt;
1030
 
1031
      if (inner_else && TREE_CODE (inner_else) == STATEMENT_LIST
1032
          && STATEMENT_LIST_TAIL (inner_else))
1033
        inner_else = STATEMENT_LIST_TAIL (inner_else)->stmt;
1034
 
1035
      if (IS_EMPTY_STMT (inner_then) && !inner_else)
1036
        warning (OPT_Wextra, "%Hempty body in an if-statement",
1037
                 EXPR_LOCUS (inner_then));
1038
 
1039
      if (inner_else && IS_EMPTY_STMT (inner_else))
1040
        warning (OPT_Wextra, "%Hempty body in an else-statement",
1041
                 EXPR_LOCUS (inner_else));
1042
   }
1043
}
1044
 
1045
 
1046
/* Nonzero if constant C has a value that is permissible
1047
   for type TYPE (an INTEGER_TYPE).  */
1048
 
1049
static int
1050
constant_fits_type_p (tree c, tree type)
1051
{
1052
  if (TREE_CODE (c) == INTEGER_CST)
1053
    return int_fits_type_p (c, type);
1054
 
1055
  c = convert (type, c);
1056
  return !TREE_OVERFLOW (c);
1057
}
1058
 
1059
/* Nonzero if vector types T1 and T2 can be converted to each other
1060
   without an explicit cast.  */
1061
int
1062
vector_types_convertible_p (tree t1, tree t2)
1063
{
1064
  return targetm.vector_opaque_p (t1)
1065
         || targetm.vector_opaque_p (t2)
1066
         || (tree_int_cst_equal (TYPE_SIZE (t1), TYPE_SIZE (t2))
1067
             && (TREE_CODE (TREE_TYPE (t1)) != REAL_TYPE ||
1068
                 TYPE_PRECISION (t1) == TYPE_PRECISION (t2))
1069
             && INTEGRAL_TYPE_P (TREE_TYPE (t1))
1070
                == INTEGRAL_TYPE_P (TREE_TYPE (t2)));
1071
}
1072
 
1073
/* Convert EXPR to TYPE, warning about conversion problems with constants.
1074
   Invoke this function on every expression that is converted implicitly,
1075
   i.e. because of language rules and not because of an explicit cast.  */
1076
 
1077
tree
1078
convert_and_check (tree type, tree expr)
1079
{
1080
  tree t = convert (type, expr);
1081
  if (TREE_CODE (t) == INTEGER_CST)
1082
    {
1083
      if (TREE_OVERFLOW (t))
1084
        {
1085
          TREE_OVERFLOW (t) = 0;
1086
 
1087
          /* Do not diagnose overflow in a constant expression merely
1088
             because a conversion overflowed.  */
1089
          TREE_CONSTANT_OVERFLOW (t) = CONSTANT_CLASS_P (expr)
1090
                                       && TREE_CONSTANT_OVERFLOW (expr);
1091
 
1092
          /* No warning for converting 0x80000000 to int.  */
1093
          if (!(TYPE_UNSIGNED (type) < TYPE_UNSIGNED (TREE_TYPE (expr))
1094
                && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE
1095
                && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr))))
1096
            /* If EXPR fits in the unsigned version of TYPE,
1097
               don't warn unless pedantic.  */
1098
            if ((pedantic
1099
                 || TYPE_UNSIGNED (type)
1100
                 || !constant_fits_type_p (expr,
1101
                                           c_common_unsigned_type (type)))
1102
                && skip_evaluation == 0)
1103
              warning (OPT_Woverflow,
1104
                       "overflow in implicit constant conversion");
1105
        }
1106
      else
1107
        unsigned_conversion_warning (t, expr);
1108
    }
1109
  return t;
1110
}
1111
 
1112
/* A node in a list that describes references to variables (EXPR), which are
1113
   either read accesses if WRITER is zero, or write accesses, in which case
1114
   WRITER is the parent of EXPR.  */
1115
struct tlist
1116
{
1117
  struct tlist *next;
1118
  tree expr, writer;
1119
};
1120
 
1121
/* Used to implement a cache the results of a call to verify_tree.  We only
1122
   use this for SAVE_EXPRs.  */
1123
struct tlist_cache
1124
{
1125
  struct tlist_cache *next;
1126
  struct tlist *cache_before_sp;
1127
  struct tlist *cache_after_sp;
1128
  tree expr;
1129
};
1130
 
1131
/* Obstack to use when allocating tlist structures, and corresponding
1132
   firstobj.  */
1133
static struct obstack tlist_obstack;
1134
static char *tlist_firstobj = 0;
1135
 
1136
/* Keep track of the identifiers we've warned about, so we can avoid duplicate
1137
   warnings.  */
1138
static struct tlist *warned_ids;
1139
/* SAVE_EXPRs need special treatment.  We process them only once and then
1140
   cache the results.  */
1141
static struct tlist_cache *save_expr_cache;
1142
 
1143
static void add_tlist (struct tlist **, struct tlist *, tree, int);
1144
static void merge_tlist (struct tlist **, struct tlist *, int);
1145
static void verify_tree (tree, struct tlist **, struct tlist **, tree);
1146
static int warning_candidate_p (tree);
1147
static void warn_for_collisions (struct tlist *);
1148
static void warn_for_collisions_1 (tree, tree, struct tlist *, int);
1149
static struct tlist *new_tlist (struct tlist *, tree, tree);
1150
 
1151
/* Create a new struct tlist and fill in its fields.  */
1152
static struct tlist *
1153
new_tlist (struct tlist *next, tree t, tree writer)
1154
{
1155
  struct tlist *l;
1156
  l = XOBNEW (&tlist_obstack, struct tlist);
1157
  l->next = next;
1158
  l->expr = t;
1159
  l->writer = writer;
1160
  return l;
1161
}
1162
 
1163
/* Add duplicates of the nodes found in ADD to the list *TO.  If EXCLUDE_WRITER
1164
   is nonnull, we ignore any node we find which has a writer equal to it.  */
1165
 
1166
static void
1167
add_tlist (struct tlist **to, struct tlist *add, tree exclude_writer, int copy)
1168
{
1169
  while (add)
1170
    {
1171
      struct tlist *next = add->next;
1172
      if (!copy)
1173
        add->next = *to;
1174
      if (!exclude_writer || add->writer != exclude_writer)
1175
        *to = copy ? new_tlist (*to, add->expr, add->writer) : add;
1176
      add = next;
1177
    }
1178
}
1179
 
1180
/* Merge the nodes of ADD into TO.  This merging process is done so that for
1181
   each variable that already exists in TO, no new node is added; however if
1182
   there is a write access recorded in ADD, and an occurrence on TO is only
1183
   a read access, then the occurrence in TO will be modified to record the
1184
   write.  */
1185
 
1186
static void
1187
merge_tlist (struct tlist **to, struct tlist *add, int copy)
1188
{
1189
  struct tlist **end = to;
1190
 
1191
  while (*end)
1192
    end = &(*end)->next;
1193
 
1194
  while (add)
1195
    {
1196
      int found = 0;
1197
      struct tlist *tmp2;
1198
      struct tlist *next = add->next;
1199
 
1200
      for (tmp2 = *to; tmp2; tmp2 = tmp2->next)
1201
        if (tmp2->expr == add->expr)
1202
          {
1203
            found = 1;
1204
            if (!tmp2->writer)
1205
              tmp2->writer = add->writer;
1206
          }
1207
      if (!found)
1208
        {
1209
          *end = copy ? add : new_tlist (NULL, add->expr, add->writer);
1210
          end = &(*end)->next;
1211
          *end = 0;
1212
        }
1213
      add = next;
1214
    }
1215
}
1216
 
1217
/* WRITTEN is a variable, WRITER is its parent.  Warn if any of the variable
1218
   references in list LIST conflict with it, excluding reads if ONLY writers
1219
   is nonzero.  */
1220
 
1221
static void
1222
warn_for_collisions_1 (tree written, tree writer, struct tlist *list,
1223
                       int only_writes)
1224
{
1225
  struct tlist *tmp;
1226
 
1227
  /* Avoid duplicate warnings.  */
1228
  for (tmp = warned_ids; tmp; tmp = tmp->next)
1229
    if (tmp->expr == written)
1230
      return;
1231
 
1232
  while (list)
1233
    {
1234
      if (list->expr == written
1235
          && list->writer != writer
1236
          && (!only_writes || list->writer)
1237
          && DECL_NAME (list->expr))
1238
        {
1239
          warned_ids = new_tlist (warned_ids, written, NULL_TREE);
1240
          warning (0, "operation on %qE may be undefined", list->expr);
1241
        }
1242
      list = list->next;
1243
    }
1244
}
1245
 
1246
/* Given a list LIST of references to variables, find whether any of these
1247
   can cause conflicts due to missing sequence points.  */
1248
 
1249
static void
1250
warn_for_collisions (struct tlist *list)
1251
{
1252
  struct tlist *tmp;
1253
 
1254
  for (tmp = list; tmp; tmp = tmp->next)
1255
    {
1256
      if (tmp->writer)
1257
        warn_for_collisions_1 (tmp->expr, tmp->writer, list, 0);
1258
    }
1259
}
1260
 
1261
/* Return nonzero if X is a tree that can be verified by the sequence point
1262
   warnings.  */
1263
static int
1264
warning_candidate_p (tree x)
1265
{
1266
  return TREE_CODE (x) == VAR_DECL || TREE_CODE (x) == PARM_DECL;
1267
}
1268
 
1269
/* Walk the tree X, and record accesses to variables.  If X is written by the
1270
   parent tree, WRITER is the parent.
1271
   We store accesses in one of the two lists: PBEFORE_SP, and PNO_SP.  If this
1272
   expression or its only operand forces a sequence point, then everything up
1273
   to the sequence point is stored in PBEFORE_SP.  Everything else gets stored
1274
   in PNO_SP.
1275
   Once we return, we will have emitted warnings if any subexpression before
1276
   such a sequence point could be undefined.  On a higher level, however, the
1277
   sequence point may not be relevant, and we'll merge the two lists.
1278
 
1279
   Example: (b++, a) + b;
1280
   The call that processes the COMPOUND_EXPR will store the increment of B
1281
   in PBEFORE_SP, and the use of A in PNO_SP.  The higher-level call that
1282
   processes the PLUS_EXPR will need to merge the two lists so that
1283
   eventually, all accesses end up on the same list (and we'll warn about the
1284
   unordered subexpressions b++ and b.
1285
 
1286
   A note on merging.  If we modify the former example so that our expression
1287
   becomes
1288
     (b++, b) + a
1289
   care must be taken not simply to add all three expressions into the final
1290
   PNO_SP list.  The function merge_tlist takes care of that by merging the
1291
   before-SP list of the COMPOUND_EXPR into its after-SP list in a special
1292
   way, so that no more than one access to B is recorded.  */
1293
 
1294
static void
1295
verify_tree (tree x, struct tlist **pbefore_sp, struct tlist **pno_sp,
1296
             tree writer)
1297
{
1298
  struct tlist *tmp_before, *tmp_nosp, *tmp_list2, *tmp_list3;
1299
  enum tree_code code;
1300
  enum tree_code_class cl;
1301
 
1302
  /* X may be NULL if it is the operand of an empty statement expression
1303
     ({ }).  */
1304
  if (x == NULL)
1305
    return;
1306
 
1307
 restart:
1308
  code = TREE_CODE (x);
1309
  cl = TREE_CODE_CLASS (code);
1310
 
1311
  if (warning_candidate_p (x))
1312
    {
1313
      *pno_sp = new_tlist (*pno_sp, x, writer);
1314
      return;
1315
    }
1316
 
1317
  switch (code)
1318
    {
1319
    case CONSTRUCTOR:
1320
      return;
1321
 
1322
    case COMPOUND_EXPR:
1323
    case TRUTH_ANDIF_EXPR:
1324
    case TRUTH_ORIF_EXPR:
1325
      tmp_before = tmp_nosp = tmp_list3 = 0;
1326
      verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1327
      warn_for_collisions (tmp_nosp);
1328
      merge_tlist (pbefore_sp, tmp_before, 0);
1329
      merge_tlist (pbefore_sp, tmp_nosp, 0);
1330
      verify_tree (TREE_OPERAND (x, 1), &tmp_list3, pno_sp, NULL_TREE);
1331
      merge_tlist (pbefore_sp, tmp_list3, 0);
1332
      return;
1333
 
1334
    case COND_EXPR:
1335
      tmp_before = tmp_list2 = 0;
1336
      verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_list2, NULL_TREE);
1337
      warn_for_collisions (tmp_list2);
1338
      merge_tlist (pbefore_sp, tmp_before, 0);
1339
      merge_tlist (pbefore_sp, tmp_list2, 1);
1340
 
1341
      tmp_list3 = tmp_nosp = 0;
1342
      verify_tree (TREE_OPERAND (x, 1), &tmp_list3, &tmp_nosp, NULL_TREE);
1343
      warn_for_collisions (tmp_nosp);
1344
      merge_tlist (pbefore_sp, tmp_list3, 0);
1345
 
1346
      tmp_list3 = tmp_list2 = 0;
1347
      verify_tree (TREE_OPERAND (x, 2), &tmp_list3, &tmp_list2, NULL_TREE);
1348
      warn_for_collisions (tmp_list2);
1349
      merge_tlist (pbefore_sp, tmp_list3, 0);
1350
      /* Rather than add both tmp_nosp and tmp_list2, we have to merge the
1351
         two first, to avoid warning for (a ? b++ : b++).  */
1352
      merge_tlist (&tmp_nosp, tmp_list2, 0);
1353
      add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1354
      return;
1355
 
1356
    case PREDECREMENT_EXPR:
1357
    case PREINCREMENT_EXPR:
1358
    case POSTDECREMENT_EXPR:
1359
    case POSTINCREMENT_EXPR:
1360
      verify_tree (TREE_OPERAND (x, 0), pno_sp, pno_sp, x);
1361
      return;
1362
 
1363
    case MODIFY_EXPR:
1364
      tmp_before = tmp_nosp = tmp_list3 = 0;
1365
      verify_tree (TREE_OPERAND (x, 1), &tmp_before, &tmp_nosp, NULL_TREE);
1366
      verify_tree (TREE_OPERAND (x, 0), &tmp_list3, &tmp_list3, x);
1367
      /* Expressions inside the LHS are not ordered wrt. the sequence points
1368
         in the RHS.  Example:
1369
           *a = (a++, 2)
1370
         Despite the fact that the modification of "a" is in the before_sp
1371
         list (tmp_before), it conflicts with the use of "a" in the LHS.
1372
         We can handle this by adding the contents of tmp_list3
1373
         to those of tmp_before, and redoing the collision warnings for that
1374
         list.  */
1375
      add_tlist (&tmp_before, tmp_list3, x, 1);
1376
      warn_for_collisions (tmp_before);
1377
      /* Exclude the LHS itself here; we first have to merge it into the
1378
         tmp_nosp list.  This is done to avoid warning for "a = a"; if we
1379
         didn't exclude the LHS, we'd get it twice, once as a read and once
1380
         as a write.  */
1381
      add_tlist (pno_sp, tmp_list3, x, 0);
1382
      warn_for_collisions_1 (TREE_OPERAND (x, 0), x, tmp_nosp, 1);
1383
 
1384
      merge_tlist (pbefore_sp, tmp_before, 0);
1385
      if (warning_candidate_p (TREE_OPERAND (x, 0)))
1386
        merge_tlist (&tmp_nosp, new_tlist (NULL, TREE_OPERAND (x, 0), x), 0);
1387
      add_tlist (pno_sp, tmp_nosp, NULL_TREE, 1);
1388
      return;
1389
 
1390
    case CALL_EXPR:
1391
      /* We need to warn about conflicts among arguments and conflicts between
1392
         args and the function address.  Side effects of the function address,
1393
         however, are not ordered by the sequence point of the call.  */
1394
      tmp_before = tmp_nosp = tmp_list2 = tmp_list3 = 0;
1395
      verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1396
      if (TREE_OPERAND (x, 1))
1397
        verify_tree (TREE_OPERAND (x, 1), &tmp_list2, &tmp_list3, NULL_TREE);
1398
      merge_tlist (&tmp_list3, tmp_list2, 0);
1399
      add_tlist (&tmp_before, tmp_list3, NULL_TREE, 0);
1400
      add_tlist (&tmp_before, tmp_nosp, NULL_TREE, 0);
1401
      warn_for_collisions (tmp_before);
1402
      add_tlist (pbefore_sp, tmp_before, NULL_TREE, 0);
1403
      return;
1404
 
1405
    case TREE_LIST:
1406
      /* Scan all the list, e.g. indices of multi dimensional array.  */
1407
      while (x)
1408
        {
1409
          tmp_before = tmp_nosp = 0;
1410
          verify_tree (TREE_VALUE (x), &tmp_before, &tmp_nosp, NULL_TREE);
1411
          merge_tlist (&tmp_nosp, tmp_before, 0);
1412
          add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1413
          x = TREE_CHAIN (x);
1414
        }
1415
      return;
1416
 
1417
    case SAVE_EXPR:
1418
      {
1419
        struct tlist_cache *t;
1420
        for (t = save_expr_cache; t; t = t->next)
1421
          if (t->expr == x)
1422
            break;
1423
 
1424
        if (!t)
1425
          {
1426
            t = XOBNEW (&tlist_obstack, struct tlist_cache);
1427
            t->next = save_expr_cache;
1428
            t->expr = x;
1429
            save_expr_cache = t;
1430
 
1431
            tmp_before = tmp_nosp = 0;
1432
            verify_tree (TREE_OPERAND (x, 0), &tmp_before, &tmp_nosp, NULL_TREE);
1433
            warn_for_collisions (tmp_nosp);
1434
 
1435
            tmp_list3 = 0;
1436
            while (tmp_nosp)
1437
              {
1438
                struct tlist *t = tmp_nosp;
1439
                tmp_nosp = t->next;
1440
                merge_tlist (&tmp_list3, t, 0);
1441
              }
1442
            t->cache_before_sp = tmp_before;
1443
            t->cache_after_sp = tmp_list3;
1444
          }
1445
        merge_tlist (pbefore_sp, t->cache_before_sp, 1);
1446
        add_tlist (pno_sp, t->cache_after_sp, NULL_TREE, 1);
1447
        return;
1448
      }
1449
 
1450
    default:
1451
      /* For other expressions, simply recurse on their operands.
1452
         Manual tail recursion for unary expressions.
1453
         Other non-expressions need not be processed.  */
1454
      if (cl == tcc_unary)
1455
        {
1456
          x = TREE_OPERAND (x, 0);
1457
          writer = 0;
1458
          goto restart;
1459
        }
1460
      else if (IS_EXPR_CODE_CLASS (cl))
1461
        {
1462
          int lp;
1463
          int max = TREE_CODE_LENGTH (TREE_CODE (x));
1464
          for (lp = 0; lp < max; lp++)
1465
            {
1466
              tmp_before = tmp_nosp = 0;
1467
              verify_tree (TREE_OPERAND (x, lp), &tmp_before, &tmp_nosp, 0);
1468
              merge_tlist (&tmp_nosp, tmp_before, 0);
1469
              add_tlist (pno_sp, tmp_nosp, NULL_TREE, 0);
1470
            }
1471
        }
1472
      return;
1473
    }
1474
}
1475
 
1476
/* Try to warn for undefined behavior in EXPR due to missing sequence
1477
   points.  */
1478
 
1479
void
1480
verify_sequence_points (tree expr)
1481
{
1482
  struct tlist *before_sp = 0, *after_sp = 0;
1483
 
1484
  warned_ids = 0;
1485
  save_expr_cache = 0;
1486
  if (tlist_firstobj == 0)
1487
    {
1488
      gcc_obstack_init (&tlist_obstack);
1489
      tlist_firstobj = (char *) obstack_alloc (&tlist_obstack, 0);
1490
    }
1491
 
1492
  verify_tree (expr, &before_sp, &after_sp, 0);
1493
  warn_for_collisions (after_sp);
1494
  obstack_free (&tlist_obstack, tlist_firstobj);
1495
}
1496
 
1497
/* Validate the expression after `case' and apply default promotions.  */
1498
 
1499
static tree
1500
check_case_value (tree value)
1501
{
1502
  if (value == NULL_TREE)
1503
    return value;
1504
 
1505
  /* ??? Can we ever get nops here for a valid case value?  We
1506
     shouldn't for C.  */
1507
  STRIP_TYPE_NOPS (value);
1508
  /* In C++, the following is allowed:
1509
 
1510
       const int i = 3;
1511
       switch (...) { case i: ... }
1512
 
1513
     So, we try to reduce the VALUE to a constant that way.  */
1514
  if (c_dialect_cxx ())
1515
    {
1516
      value = decl_constant_value (value);
1517
      STRIP_TYPE_NOPS (value);
1518
      value = fold (value);
1519
    }
1520
 
1521
  if (TREE_CODE (value) == INTEGER_CST)
1522
    /* Promote char or short to int.  */
1523
    value = perform_integral_promotions (value);
1524
  else if (value != error_mark_node)
1525
    {
1526
      error ("case label does not reduce to an integer constant");
1527
      value = error_mark_node;
1528
    }
1529
 
1530
  constant_expression_warning (value);
1531
 
1532
  return value;
1533
}
1534
 
1535
/* See if the case values LOW and HIGH are in the range of the original
1536
   type (i.e. before the default conversion to int) of the switch testing
1537
   expression.
1538
   TYPE is the promoted type of the testing expression, and ORIG_TYPE is
1539
   the type before promoting it.  CASE_LOW_P is a pointer to the lower
1540
   bound of the case label, and CASE_HIGH_P is the upper bound or NULL
1541
   if the case is not a case range.
1542
   The caller has to make sure that we are not called with NULL for
1543
   CASE_LOW_P (i.e. the default case).
1544
   Returns true if the case label is in range of ORIG_TYPE (saturated or
1545
   untouched) or false if the label is out of range.  */
1546
 
1547
static bool
1548
check_case_bounds (tree type, tree orig_type,
1549
                   tree *case_low_p, tree *case_high_p)
1550
{
1551
  tree min_value, max_value;
1552
  tree case_low = *case_low_p;
1553
  tree case_high = case_high_p ? *case_high_p : case_low;
1554
 
1555
  /* If there was a problem with the original type, do nothing.  */
1556
  if (orig_type == error_mark_node)
1557
    return true;
1558
 
1559
  min_value = TYPE_MIN_VALUE (orig_type);
1560
  max_value = TYPE_MAX_VALUE (orig_type);
1561
 
1562
  /* Case label is less than minimum for type.  */
1563
  if (tree_int_cst_compare (case_low, min_value) < 0
1564
      && tree_int_cst_compare (case_high, min_value) < 0)
1565
    {
1566
      warning (0, "case label value is less than minimum value for type");
1567
      return false;
1568
    }
1569
 
1570
  /* Case value is greater than maximum for type.  */
1571
  if (tree_int_cst_compare (case_low, max_value) > 0
1572
      && tree_int_cst_compare (case_high, max_value) > 0)
1573
    {
1574
      warning (0, "case label value exceeds maximum value for type");
1575
      return false;
1576
    }
1577
 
1578
  /* Saturate lower case label value to minimum.  */
1579
  if (tree_int_cst_compare (case_high, min_value) >= 0
1580
      && tree_int_cst_compare (case_low, min_value) < 0)
1581
    {
1582
      warning (0, "lower value in case label range"
1583
               " less than minimum value for type");
1584
      case_low = min_value;
1585
    }
1586
 
1587
  /* Saturate upper case label value to maximum.  */
1588
  if (tree_int_cst_compare (case_low, max_value) <= 0
1589
      && tree_int_cst_compare (case_high, max_value) > 0)
1590
    {
1591
      warning (0, "upper value in case label range"
1592
               " exceeds maximum value for type");
1593
      case_high = max_value;
1594
    }
1595
 
1596
  if (*case_low_p != case_low)
1597
    *case_low_p = convert (type, case_low);
1598
  if (case_high_p && *case_high_p != case_high)
1599
    *case_high_p = convert (type, case_high);
1600
 
1601
  return true;
1602
}
1603
 
1604
/* Return an integer type with BITS bits of precision,
1605
   that is unsigned if UNSIGNEDP is nonzero, otherwise signed.  */
1606
 
1607
tree
1608
c_common_type_for_size (unsigned int bits, int unsignedp)
1609
{
1610
  if (bits == TYPE_PRECISION (integer_type_node))
1611
    return unsignedp ? unsigned_type_node : integer_type_node;
1612
 
1613
  if (bits == TYPE_PRECISION (signed_char_type_node))
1614
    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1615
 
1616
  if (bits == TYPE_PRECISION (short_integer_type_node))
1617
    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1618
 
1619
  if (bits == TYPE_PRECISION (long_integer_type_node))
1620
    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1621
 
1622
  if (bits == TYPE_PRECISION (long_long_integer_type_node))
1623
    return (unsignedp ? long_long_unsigned_type_node
1624
            : long_long_integer_type_node);
1625
 
1626
  if (bits == TYPE_PRECISION (widest_integer_literal_type_node))
1627
    return (unsignedp ? widest_unsigned_literal_type_node
1628
            : widest_integer_literal_type_node);
1629
 
1630
  if (bits <= TYPE_PRECISION (intQI_type_node))
1631
    return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1632
 
1633
  if (bits <= TYPE_PRECISION (intHI_type_node))
1634
    return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1635
 
1636
  if (bits <= TYPE_PRECISION (intSI_type_node))
1637
    return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1638
 
1639
  if (bits <= TYPE_PRECISION (intDI_type_node))
1640
    return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1641
 
1642
  return 0;
1643
}
1644
 
1645
/* Used for communication between c_common_type_for_mode and
1646
   c_register_builtin_type.  */
1647
static GTY(()) tree registered_builtin_types;
1648
 
1649
/* Return a data type that has machine mode MODE.
1650
   If the mode is an integer,
1651
   then UNSIGNEDP selects between signed and unsigned types.  */
1652
 
1653
tree
1654
c_common_type_for_mode (enum machine_mode mode, int unsignedp)
1655
{
1656
  tree t;
1657
 
1658
  if (mode == TYPE_MODE (integer_type_node))
1659
    return unsignedp ? unsigned_type_node : integer_type_node;
1660
 
1661
  if (mode == TYPE_MODE (signed_char_type_node))
1662
    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1663
 
1664
  if (mode == TYPE_MODE (short_integer_type_node))
1665
    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1666
 
1667
  if (mode == TYPE_MODE (long_integer_type_node))
1668
    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1669
 
1670
  if (mode == TYPE_MODE (long_long_integer_type_node))
1671
    return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node;
1672
 
1673
  if (mode == TYPE_MODE (widest_integer_literal_type_node))
1674
    return unsignedp ? widest_unsigned_literal_type_node
1675
                     : widest_integer_literal_type_node;
1676
 
1677
  if (mode == QImode)
1678
    return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1679
 
1680
  if (mode == HImode)
1681
    return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1682
 
1683
  if (mode == SImode)
1684
    return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1685
 
1686
  if (mode == DImode)
1687
    return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1688
 
1689
#if HOST_BITS_PER_WIDE_INT >= 64
1690
  if (mode == TYPE_MODE (intTI_type_node))
1691
    return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1692
#endif
1693
 
1694
  if (mode == TYPE_MODE (float_type_node))
1695
    return float_type_node;
1696
 
1697
  if (mode == TYPE_MODE (double_type_node))
1698
    return double_type_node;
1699
 
1700
  if (mode == TYPE_MODE (long_double_type_node))
1701
    return long_double_type_node;
1702
 
1703
  if (mode == TYPE_MODE (void_type_node))
1704
    return void_type_node;
1705
 
1706
  if (mode == TYPE_MODE (build_pointer_type (char_type_node)))
1707
    return (unsignedp
1708
            ? make_unsigned_type (GET_MODE_PRECISION (mode))
1709
            : make_signed_type (GET_MODE_PRECISION (mode)));
1710
 
1711
  if (mode == TYPE_MODE (build_pointer_type (integer_type_node)))
1712
    return (unsignedp
1713
            ? make_unsigned_type (GET_MODE_PRECISION (mode))
1714
            : make_signed_type (GET_MODE_PRECISION (mode)));
1715
 
1716
  if (COMPLEX_MODE_P (mode))
1717
    {
1718
      enum machine_mode inner_mode;
1719
      tree inner_type;
1720
 
1721
      if (mode == TYPE_MODE (complex_float_type_node))
1722
        return complex_float_type_node;
1723
      if (mode == TYPE_MODE (complex_double_type_node))
1724
        return complex_double_type_node;
1725
      if (mode == TYPE_MODE (complex_long_double_type_node))
1726
        return complex_long_double_type_node;
1727
 
1728
      if (mode == TYPE_MODE (complex_integer_type_node) && !unsignedp)
1729
        return complex_integer_type_node;
1730
 
1731
      inner_mode = GET_MODE_INNER (mode);
1732
      inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1733
      if (inner_type != NULL_TREE)
1734
        return build_complex_type (inner_type);
1735
    }
1736
  else if (VECTOR_MODE_P (mode))
1737
    {
1738
      enum machine_mode inner_mode = GET_MODE_INNER (mode);
1739
      tree inner_type = c_common_type_for_mode (inner_mode, unsignedp);
1740
      if (inner_type != NULL_TREE)
1741
        return build_vector_type_for_mode (inner_type, mode);
1742
    }
1743
 
1744
  if (mode == TYPE_MODE (dfloat32_type_node))
1745
    return dfloat32_type_node;
1746
  if (mode == TYPE_MODE (dfloat64_type_node))
1747
    return dfloat64_type_node;
1748
  if (mode == TYPE_MODE (dfloat128_type_node))
1749
    return dfloat128_type_node;
1750
 
1751
  for (t = registered_builtin_types; t; t = TREE_CHAIN (t))
1752
    if (TYPE_MODE (TREE_VALUE (t)) == mode)
1753
      return TREE_VALUE (t);
1754
 
1755
  return 0;
1756
}
1757
 
1758
/* Return an unsigned type the same as TYPE in other respects.  */
1759
tree
1760
c_common_unsigned_type (tree type)
1761
{
1762
  tree type1 = TYPE_MAIN_VARIANT (type);
1763
  if (type1 == signed_char_type_node || type1 == char_type_node)
1764
    return unsigned_char_type_node;
1765
  if (type1 == integer_type_node)
1766
    return unsigned_type_node;
1767
  if (type1 == short_integer_type_node)
1768
    return short_unsigned_type_node;
1769
  if (type1 == long_integer_type_node)
1770
    return long_unsigned_type_node;
1771
  if (type1 == long_long_integer_type_node)
1772
    return long_long_unsigned_type_node;
1773
  if (type1 == widest_integer_literal_type_node)
1774
    return widest_unsigned_literal_type_node;
1775
#if HOST_BITS_PER_WIDE_INT >= 64
1776
  if (type1 == intTI_type_node)
1777
    return unsigned_intTI_type_node;
1778
#endif
1779
  if (type1 == intDI_type_node)
1780
    return unsigned_intDI_type_node;
1781
  if (type1 == intSI_type_node)
1782
    return unsigned_intSI_type_node;
1783
  if (type1 == intHI_type_node)
1784
    return unsigned_intHI_type_node;
1785
  if (type1 == intQI_type_node)
1786
    return unsigned_intQI_type_node;
1787
 
1788
  return c_common_signed_or_unsigned_type (1, type);
1789
}
1790
 
1791
/* Return a signed type the same as TYPE in other respects.  */
1792
 
1793
tree
1794
c_common_signed_type (tree type)
1795
{
1796
  tree type1 = TYPE_MAIN_VARIANT (type);
1797
  if (type1 == unsigned_char_type_node || type1 == char_type_node)
1798
    return signed_char_type_node;
1799
  if (type1 == unsigned_type_node)
1800
    return integer_type_node;
1801
  if (type1 == short_unsigned_type_node)
1802
    return short_integer_type_node;
1803
  if (type1 == long_unsigned_type_node)
1804
    return long_integer_type_node;
1805
  if (type1 == long_long_unsigned_type_node)
1806
    return long_long_integer_type_node;
1807
  if (type1 == widest_unsigned_literal_type_node)
1808
    return widest_integer_literal_type_node;
1809
#if HOST_BITS_PER_WIDE_INT >= 64
1810
  if (type1 == unsigned_intTI_type_node)
1811
    return intTI_type_node;
1812
#endif
1813
  if (type1 == unsigned_intDI_type_node)
1814
    return intDI_type_node;
1815
  if (type1 == unsigned_intSI_type_node)
1816
    return intSI_type_node;
1817
  if (type1 == unsigned_intHI_type_node)
1818
    return intHI_type_node;
1819
  if (type1 == unsigned_intQI_type_node)
1820
    return intQI_type_node;
1821
 
1822
  return c_common_signed_or_unsigned_type (0, type);
1823
}
1824
 
1825
/* Return a type the same as TYPE except unsigned or
1826
   signed according to UNSIGNEDP.  */
1827
 
1828
tree
1829
c_common_signed_or_unsigned_type (int unsignedp, tree type)
1830
{
1831
  if (!INTEGRAL_TYPE_P (type)
1832
      || TYPE_UNSIGNED (type) == unsignedp)
1833
    return type;
1834
 
1835
  /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
1836
     the precision; they have precision set to match their range, but
1837
     may use a wider mode to match an ABI.  If we change modes, we may
1838
     wind up with bad conversions.  For INTEGER_TYPEs in C, must check
1839
     the precision as well, so as to yield correct results for
1840
     bit-field types.  C++ does not have these separate bit-field
1841
     types, and producing a signed or unsigned variant of an
1842
     ENUMERAL_TYPE may cause other problems as well.  */
1843
 
1844
#define TYPE_OK(node)                                                       \
1845
  (TYPE_MODE (type) == TYPE_MODE (node)                                     \
1846
   && (c_dialect_cxx () || TYPE_PRECISION (type) == TYPE_PRECISION (node)))
1847
  if (TYPE_OK (signed_char_type_node))
1848
    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1849
  if (TYPE_OK (integer_type_node))
1850
    return unsignedp ? unsigned_type_node : integer_type_node;
1851
  if (TYPE_OK (short_integer_type_node))
1852
    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1853
  if (TYPE_OK (long_integer_type_node))
1854
    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1855
  if (TYPE_OK (long_long_integer_type_node))
1856
    return (unsignedp ? long_long_unsigned_type_node
1857
            : long_long_integer_type_node);
1858
  if (TYPE_OK (widest_integer_literal_type_node))
1859
    return (unsignedp ? widest_unsigned_literal_type_node
1860
            : widest_integer_literal_type_node);
1861
 
1862
#if HOST_BITS_PER_WIDE_INT >= 64
1863
  if (TYPE_OK (intTI_type_node))
1864
    return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
1865
#endif
1866
  if (TYPE_OK (intDI_type_node))
1867
    return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
1868
  if (TYPE_OK (intSI_type_node))
1869
    return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
1870
  if (TYPE_OK (intHI_type_node))
1871
    return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
1872
  if (TYPE_OK (intQI_type_node))
1873
    return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
1874
#undef TYPE_OK
1875
 
1876
  if (c_dialect_cxx ())
1877
    return type;
1878
  else
1879
    return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
1880
}
1881
 
1882
/* Build a bit-field integer type for the given WIDTH and UNSIGNEDP.  */
1883
 
1884
tree
1885
c_build_bitfield_integer_type (unsigned HOST_WIDE_INT width, int unsignedp)
1886
{
1887
  /* Extended integer types of the same width as a standard type have
1888
     lesser rank, so those of the same width as int promote to int or
1889
     unsigned int and are valid for printf formats expecting int or
1890
     unsigned int.  To avoid such special cases, avoid creating
1891
     extended integer types for bit-fields if a standard integer type
1892
     is available.  */
1893
  if (width == TYPE_PRECISION (integer_type_node))
1894
    return unsignedp ? unsigned_type_node : integer_type_node;
1895
  if (width == TYPE_PRECISION (signed_char_type_node))
1896
    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
1897
  if (width == TYPE_PRECISION (short_integer_type_node))
1898
    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
1899
  if (width == TYPE_PRECISION (long_integer_type_node))
1900
    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
1901
  if (width == TYPE_PRECISION (long_long_integer_type_node))
1902
    return (unsignedp ? long_long_unsigned_type_node
1903
            : long_long_integer_type_node);
1904
  return build_nonstandard_integer_type (width, unsignedp);
1905
}
1906
 
1907
/* The C version of the register_builtin_type langhook.  */
1908
 
1909
void
1910
c_register_builtin_type (tree type, const char* name)
1911
{
1912
  tree decl;
1913
 
1914
  decl = build_decl (TYPE_DECL, get_identifier (name), type);
1915
  DECL_ARTIFICIAL (decl) = 1;
1916
  if (!TYPE_NAME (type))
1917
    TYPE_NAME (type) = decl;
1918
  pushdecl (decl);
1919
 
1920
  registered_builtin_types = tree_cons (0, type, registered_builtin_types);
1921
}
1922
 
1923
 
1924
/* Return the minimum number of bits needed to represent VALUE in a
1925
   signed or unsigned type, UNSIGNEDP says which.  */
1926
 
1927
unsigned int
1928
min_precision (tree value, int unsignedp)
1929
{
1930
  int log;
1931
 
1932
  /* If the value is negative, compute its negative minus 1.  The latter
1933
     adjustment is because the absolute value of the largest negative value
1934
     is one larger than the largest positive value.  This is equivalent to
1935
     a bit-wise negation, so use that operation instead.  */
1936
 
1937
  if (tree_int_cst_sgn (value) < 0)
1938
    value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
1939
 
1940
  /* Return the number of bits needed, taking into account the fact
1941
     that we need one more bit for a signed than unsigned type.  */
1942
 
1943
  if (integer_zerop (value))
1944
    log = 0;
1945
  else
1946
    log = tree_floor_log2 (value);
1947
 
1948
  return log + 1 + !unsignedp;
1949
}
1950
 
1951
/* Print an error message for invalid operands to arith operation
1952
   CODE.  */
1953
 
1954
void
1955
binary_op_error (enum tree_code code)
1956
{
1957
  const char *opname;
1958
 
1959
  switch (code)
1960
    {
1961
    case PLUS_EXPR:
1962
      opname = "+"; break;
1963
    case MINUS_EXPR:
1964
      opname = "-"; break;
1965
    case MULT_EXPR:
1966
      opname = "*"; break;
1967
    case MAX_EXPR:
1968
      opname = "max"; break;
1969
    case MIN_EXPR:
1970
      opname = "min"; break;
1971
    case EQ_EXPR:
1972
      opname = "=="; break;
1973
    case NE_EXPR:
1974
      opname = "!="; break;
1975
    case LE_EXPR:
1976
      opname = "<="; break;
1977
    case GE_EXPR:
1978
      opname = ">="; break;
1979
    case LT_EXPR:
1980
      opname = "<"; break;
1981
    case GT_EXPR:
1982
      opname = ">"; break;
1983
    case LSHIFT_EXPR:
1984
      opname = "<<"; break;
1985
    case RSHIFT_EXPR:
1986
      opname = ">>"; break;
1987
    case TRUNC_MOD_EXPR:
1988
    case FLOOR_MOD_EXPR:
1989
      opname = "%"; break;
1990
    case TRUNC_DIV_EXPR:
1991
    case FLOOR_DIV_EXPR:
1992
      opname = "/"; break;
1993
    case BIT_AND_EXPR:
1994
      opname = "&"; break;
1995
    case BIT_IOR_EXPR:
1996
      opname = "|"; break;
1997
    case TRUTH_ANDIF_EXPR:
1998
      opname = "&&"; break;
1999
    case TRUTH_ORIF_EXPR:
2000
      opname = "||"; break;
2001
    case BIT_XOR_EXPR:
2002
      opname = "^"; break;
2003
    default:
2004
      gcc_unreachable ();
2005
    }
2006
  error ("invalid operands to binary %s", opname);
2007
}
2008
 
2009
/* Subroutine of build_binary_op, used for comparison operations.
2010
   See if the operands have both been converted from subword integer types
2011
   and, if so, perhaps change them both back to their original type.
2012
   This function is also responsible for converting the two operands
2013
   to the proper common type for comparison.
2014
 
2015
   The arguments of this function are all pointers to local variables
2016
   of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1,
2017
   RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE.
2018
 
2019
   If this function returns nonzero, it means that the comparison has
2020
   a constant value.  What this function returns is an expression for
2021
   that value.  */
2022
 
2023
tree
2024
shorten_compare (tree *op0_ptr, tree *op1_ptr, tree *restype_ptr,
2025
                 enum tree_code *rescode_ptr)
2026
{
2027
  tree type;
2028
  tree op0 = *op0_ptr;
2029
  tree op1 = *op1_ptr;
2030
  int unsignedp0, unsignedp1;
2031
  int real1, real2;
2032
  tree primop0, primop1;
2033
  enum tree_code code = *rescode_ptr;
2034
 
2035
  /* Throw away any conversions to wider types
2036
     already present in the operands.  */
2037
 
2038
  primop0 = get_narrower (op0, &unsignedp0);
2039
  primop1 = get_narrower (op1, &unsignedp1);
2040
 
2041
  /* Handle the case that OP0 does not *contain* a conversion
2042
     but it *requires* conversion to FINAL_TYPE.  */
2043
 
2044
  if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr)
2045
    unsignedp0 = TYPE_UNSIGNED (TREE_TYPE (op0));
2046
  if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr)
2047
    unsignedp1 = TYPE_UNSIGNED (TREE_TYPE (op1));
2048
 
2049
  /* If one of the operands must be floated, we cannot optimize.  */
2050
  real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE;
2051
  real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE;
2052
 
2053
  /* If first arg is constant, swap the args (changing operation
2054
     so value is preserved), for canonicalization.  Don't do this if
2055
     the second arg is 0.  */
2056
 
2057
  if (TREE_CONSTANT (primop0)
2058
      && !integer_zerop (primop1) && !real_zerop (primop1))
2059
    {
2060
      tree tem = primop0;
2061
      int temi = unsignedp0;
2062
      primop0 = primop1;
2063
      primop1 = tem;
2064
      tem = op0;
2065
      op0 = op1;
2066
      op1 = tem;
2067
      *op0_ptr = op0;
2068
      *op1_ptr = op1;
2069
      unsignedp0 = unsignedp1;
2070
      unsignedp1 = temi;
2071
      temi = real1;
2072
      real1 = real2;
2073
      real2 = temi;
2074
 
2075
      switch (code)
2076
        {
2077
        case LT_EXPR:
2078
          code = GT_EXPR;
2079
          break;
2080
        case GT_EXPR:
2081
          code = LT_EXPR;
2082
          break;
2083
        case LE_EXPR:
2084
          code = GE_EXPR;
2085
          break;
2086
        case GE_EXPR:
2087
          code = LE_EXPR;
2088
          break;
2089
        default:
2090
          break;
2091
        }
2092
      *rescode_ptr = code;
2093
    }
2094
 
2095
  /* If comparing an integer against a constant more bits wide,
2096
     maybe we can deduce a value of 1 or 0 independent of the data.
2097
     Or else truncate the constant now
2098
     rather than extend the variable at run time.
2099
 
2100
     This is only interesting if the constant is the wider arg.
2101
     Also, it is not safe if the constant is unsigned and the
2102
     variable arg is signed, since in this case the variable
2103
     would be sign-extended and then regarded as unsigned.
2104
     Our technique fails in this case because the lowest/highest
2105
     possible unsigned results don't follow naturally from the
2106
     lowest/highest possible values of the variable operand.
2107
     For just EQ_EXPR and NE_EXPR there is another technique that
2108
     could be used: see if the constant can be faithfully represented
2109
     in the other operand's type, by truncating it and reextending it
2110
     and see if that preserves the constant's value.  */
2111
 
2112
  if (!real1 && !real2
2113
      && TREE_CODE (primop1) == INTEGER_CST
2114
      && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr))
2115
    {
2116
      int min_gt, max_gt, min_lt, max_lt;
2117
      tree maxval, minval;
2118
      /* 1 if comparison is nominally unsigned.  */
2119
      int unsignedp = TYPE_UNSIGNED (*restype_ptr);
2120
      tree val;
2121
 
2122
      type = c_common_signed_or_unsigned_type (unsignedp0,
2123
                                               TREE_TYPE (primop0));
2124
 
2125
      maxval = TYPE_MAX_VALUE (type);
2126
      minval = TYPE_MIN_VALUE (type);
2127
 
2128
      if (unsignedp && !unsignedp0)
2129
        *restype_ptr = c_common_signed_type (*restype_ptr);
2130
 
2131
      if (TREE_TYPE (primop1) != *restype_ptr)
2132
        {
2133
          /* Convert primop1 to target type, but do not introduce
2134
             additional overflow.  We know primop1 is an int_cst.  */
2135
          tree tmp = build_int_cst_wide (*restype_ptr,
2136
                                         TREE_INT_CST_LOW (primop1),
2137
                                         TREE_INT_CST_HIGH (primop1));
2138
 
2139
          primop1 = force_fit_type (tmp, 0, TREE_OVERFLOW (primop1),
2140
                                    TREE_CONSTANT_OVERFLOW (primop1));
2141
        }
2142
      if (type != *restype_ptr)
2143
        {
2144
          minval = convert (*restype_ptr, minval);
2145
          maxval = convert (*restype_ptr, maxval);
2146
        }
2147
 
2148
      if (unsignedp && unsignedp0)
2149
        {
2150
          min_gt = INT_CST_LT_UNSIGNED (primop1, minval);
2151
          max_gt = INT_CST_LT_UNSIGNED (primop1, maxval);
2152
          min_lt = INT_CST_LT_UNSIGNED (minval, primop1);
2153
          max_lt = INT_CST_LT_UNSIGNED (maxval, primop1);
2154
        }
2155
      else
2156
        {
2157
          min_gt = INT_CST_LT (primop1, minval);
2158
          max_gt = INT_CST_LT (primop1, maxval);
2159
          min_lt = INT_CST_LT (minval, primop1);
2160
          max_lt = INT_CST_LT (maxval, primop1);
2161
        }
2162
 
2163
      val = 0;
2164
      /* This used to be a switch, but Genix compiler can't handle that.  */
2165
      if (code == NE_EXPR)
2166
        {
2167
          if (max_lt || min_gt)
2168
            val = truthvalue_true_node;
2169
        }
2170
      else if (code == EQ_EXPR)
2171
        {
2172
          if (max_lt || min_gt)
2173
            val = truthvalue_false_node;
2174
        }
2175
      else if (code == LT_EXPR)
2176
        {
2177
          if (max_lt)
2178
            val = truthvalue_true_node;
2179
          if (!min_lt)
2180
            val = truthvalue_false_node;
2181
        }
2182
      else if (code == GT_EXPR)
2183
        {
2184
          if (min_gt)
2185
            val = truthvalue_true_node;
2186
          if (!max_gt)
2187
            val = truthvalue_false_node;
2188
        }
2189
      else if (code == LE_EXPR)
2190
        {
2191
          if (!max_gt)
2192
            val = truthvalue_true_node;
2193
          if (min_gt)
2194
            val = truthvalue_false_node;
2195
        }
2196
      else if (code == GE_EXPR)
2197
        {
2198
          if (!min_lt)
2199
            val = truthvalue_true_node;
2200
          if (max_lt)
2201
            val = truthvalue_false_node;
2202
        }
2203
 
2204
      /* If primop0 was sign-extended and unsigned comparison specd,
2205
         we did a signed comparison above using the signed type bounds.
2206
         But the comparison we output must be unsigned.
2207
 
2208
         Also, for inequalities, VAL is no good; but if the signed
2209
         comparison had *any* fixed result, it follows that the
2210
         unsigned comparison just tests the sign in reverse
2211
         (positive values are LE, negative ones GE).
2212
         So we can generate an unsigned comparison
2213
         against an extreme value of the signed type.  */
2214
 
2215
      if (unsignedp && !unsignedp0)
2216
        {
2217
          if (val != 0)
2218
            switch (code)
2219
              {
2220
              case LT_EXPR:
2221
              case GE_EXPR:
2222
                primop1 = TYPE_MIN_VALUE (type);
2223
                val = 0;
2224
                break;
2225
 
2226
              case LE_EXPR:
2227
              case GT_EXPR:
2228
                primop1 = TYPE_MAX_VALUE (type);
2229
                val = 0;
2230
                break;
2231
 
2232
              default:
2233
                break;
2234
              }
2235
          type = c_common_unsigned_type (type);
2236
        }
2237
 
2238
      if (TREE_CODE (primop0) != INTEGER_CST)
2239
        {
2240
          if (val == truthvalue_false_node)
2241
            warning (0, "comparison is always false due to limited range of data type");
2242
          if (val == truthvalue_true_node)
2243
            warning (0, "comparison is always true due to limited range of data type");
2244
        }
2245
 
2246
      if (val != 0)
2247
        {
2248
          /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2249
          if (TREE_SIDE_EFFECTS (primop0))
2250
            return build2 (COMPOUND_EXPR, TREE_TYPE (val), primop0, val);
2251
          return val;
2252
        }
2253
 
2254
      /* Value is not predetermined, but do the comparison
2255
         in the type of the operand that is not constant.
2256
         TYPE is already properly set.  */
2257
    }
2258
 
2259
  /* If either arg is decimal float and the other is float, find the
2260
     proper common type to use for comparison.  */
2261
  else if (real1 && real2
2262
           && (DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop0)))
2263
               || DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (primop1)))))
2264
    type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2265
 
2266
  else if (real1 && real2
2267
           && (TYPE_PRECISION (TREE_TYPE (primop0))
2268
               == TYPE_PRECISION (TREE_TYPE (primop1))))
2269
    type = TREE_TYPE (primop0);
2270
 
2271
  /* If args' natural types are both narrower than nominal type
2272
     and both extend in the same manner, compare them
2273
     in the type of the wider arg.
2274
     Otherwise must actually extend both to the nominal
2275
     common type lest different ways of extending
2276
     alter the result.
2277
     (eg, (short)-1 == (unsigned short)-1  should be 0.)  */
2278
 
2279
  else if (unsignedp0 == unsignedp1 && real1 == real2
2280
           && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)
2281
           && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr))
2282
    {
2283
      type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1));
2284
      type = c_common_signed_or_unsigned_type (unsignedp0
2285
                                               || TYPE_UNSIGNED (*restype_ptr),
2286
                                               type);
2287
      /* Make sure shorter operand is extended the right way
2288
         to match the longer operand.  */
2289
      primop0
2290
        = convert (c_common_signed_or_unsigned_type (unsignedp0,
2291
                                                     TREE_TYPE (primop0)),
2292
                   primop0);
2293
      primop1
2294
        = convert (c_common_signed_or_unsigned_type (unsignedp1,
2295
                                                     TREE_TYPE (primop1)),
2296
                   primop1);
2297
    }
2298
  else
2299
    {
2300
      /* Here we must do the comparison on the nominal type
2301
         using the args exactly as we received them.  */
2302
      type = *restype_ptr;
2303
      primop0 = op0;
2304
      primop1 = op1;
2305
 
2306
      if (!real1 && !real2 && integer_zerop (primop1)
2307
          && TYPE_UNSIGNED (*restype_ptr))
2308
        {
2309
          tree value = 0;
2310
          switch (code)
2311
            {
2312
            case GE_EXPR:
2313
              /* All unsigned values are >= 0, so we warn if extra warnings
2314
                 are requested.  However, if OP0 is a constant that is
2315
                 >= 0, the signedness of the comparison isn't an issue,
2316
                 so suppress the warning.  */
2317
              if (extra_warnings && !in_system_header
2318
                  && !(TREE_CODE (primop0) == INTEGER_CST
2319
                       && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2320
                                                   primop0))))
2321
                warning (0, "comparison of unsigned expression >= 0 is always true");
2322
              value = truthvalue_true_node;
2323
              break;
2324
 
2325
            case LT_EXPR:
2326
              if (extra_warnings && !in_system_header
2327
                  && !(TREE_CODE (primop0) == INTEGER_CST
2328
                       && !TREE_OVERFLOW (convert (c_common_signed_type (type),
2329
                                                   primop0))))
2330
                warning (0, "comparison of unsigned expression < 0 is always false");
2331
              value = truthvalue_false_node;
2332
              break;
2333
 
2334
            default:
2335
              break;
2336
            }
2337
 
2338
          if (value != 0)
2339
            {
2340
              /* Don't forget to evaluate PRIMOP0 if it has side effects.  */
2341
              if (TREE_SIDE_EFFECTS (primop0))
2342
                return build2 (COMPOUND_EXPR, TREE_TYPE (value),
2343
                               primop0, value);
2344
              return value;
2345
            }
2346
        }
2347
    }
2348
 
2349
  *op0_ptr = convert (type, primop0);
2350
  *op1_ptr = convert (type, primop1);
2351
 
2352
  *restype_ptr = truthvalue_type_node;
2353
 
2354
  return 0;
2355
}
2356
 
2357
/* Return a tree for the sum or difference (RESULTCODE says which)
2358
   of pointer PTROP and integer INTOP.  */
2359
 
2360
tree
2361
pointer_int_sum (enum tree_code resultcode, tree ptrop, tree intop)
2362
{
2363
  tree size_exp, ret;
2364
 
2365
  /* The result is a pointer of the same type that is being added.  */
2366
 
2367
  tree result_type = TREE_TYPE (ptrop);
2368
 
2369
  if (TREE_CODE (TREE_TYPE (result_type)) == VOID_TYPE)
2370
    {
2371
      if (pedantic || warn_pointer_arith)
2372
        pedwarn ("pointer of type %<void *%> used in arithmetic");
2373
      size_exp = integer_one_node;
2374
    }
2375
  else if (TREE_CODE (TREE_TYPE (result_type)) == FUNCTION_TYPE)
2376
    {
2377
      if (pedantic || warn_pointer_arith)
2378
        pedwarn ("pointer to a function used in arithmetic");
2379
      size_exp = integer_one_node;
2380
    }
2381
  else if (TREE_CODE (TREE_TYPE (result_type)) == METHOD_TYPE)
2382
    {
2383
      if (pedantic || warn_pointer_arith)
2384
        pedwarn ("pointer to member function used in arithmetic");
2385
      size_exp = integer_one_node;
2386
    }
2387
  else
2388
    size_exp = size_in_bytes (TREE_TYPE (result_type));
2389
 
2390
  /* We are manipulating pointer values, so we don't need to warn
2391
     about relying on undefined signed overflow.  We disable the
2392
     warning here because we use integer types so fold won't know that
2393
     they are really pointers.  */
2394
  fold_defer_overflow_warnings ();
2395
 
2396
  /* If what we are about to multiply by the size of the elements
2397
     contains a constant term, apply distributive law
2398
     and multiply that constant term separately.
2399
     This helps produce common subexpressions.  */
2400
 
2401
  if ((TREE_CODE (intop) == PLUS_EXPR || TREE_CODE (intop) == MINUS_EXPR)
2402
      && !TREE_CONSTANT (intop)
2403
      && TREE_CONSTANT (TREE_OPERAND (intop, 1))
2404
      && TREE_CONSTANT (size_exp)
2405
      /* If the constant comes from pointer subtraction,
2406
         skip this optimization--it would cause an error.  */
2407
      && TREE_CODE (TREE_TYPE (TREE_OPERAND (intop, 0))) == INTEGER_TYPE
2408
      /* If the constant is unsigned, and smaller than the pointer size,
2409
         then we must skip this optimization.  This is because it could cause
2410
         an overflow error if the constant is negative but INTOP is not.  */
2411
      && (!TYPE_UNSIGNED (TREE_TYPE (intop))
2412
          || (TYPE_PRECISION (TREE_TYPE (intop))
2413
              == TYPE_PRECISION (TREE_TYPE (ptrop)))))
2414
    {
2415
      enum tree_code subcode = resultcode;
2416
      tree int_type = TREE_TYPE (intop);
2417
      if (TREE_CODE (intop) == MINUS_EXPR)
2418
        subcode = (subcode == PLUS_EXPR ? MINUS_EXPR : PLUS_EXPR);
2419
      /* Convert both subexpression types to the type of intop,
2420
         because weird cases involving pointer arithmetic
2421
         can result in a sum or difference with different type args.  */
2422
      ptrop = build_binary_op (subcode, ptrop,
2423
                               convert (int_type, TREE_OPERAND (intop, 1)), 1);
2424
      intop = convert (int_type, TREE_OPERAND (intop, 0));
2425
    }
2426
 
2427
  /* Convert the integer argument to a type the same size as sizetype
2428
     so the multiply won't overflow spuriously.  */
2429
 
2430
  if (TYPE_PRECISION (TREE_TYPE (intop)) != TYPE_PRECISION (sizetype)
2431
      || TYPE_UNSIGNED (TREE_TYPE (intop)) != TYPE_UNSIGNED (sizetype))
2432
    intop = convert (c_common_type_for_size (TYPE_PRECISION (sizetype),
2433
                                             TYPE_UNSIGNED (sizetype)), intop);
2434
 
2435
  /* Replace the integer argument with a suitable product by the object size.
2436
     Do this multiplication as signed, then convert to the appropriate
2437
     pointer type (actually unsigned integral).  */
2438
 
2439
  intop = convert (result_type,
2440
                   build_binary_op (MULT_EXPR, intop,
2441
                                    convert (TREE_TYPE (intop), size_exp), 1));
2442
 
2443
  /* Create the sum or difference.  */
2444
  ret = fold_build2 (resultcode, result_type, ptrop, intop);
2445
 
2446
  fold_undefer_and_ignore_overflow_warnings ();
2447
 
2448
  return ret;
2449
}
2450
 
2451
/* Prepare expr to be an argument of a TRUTH_NOT_EXPR,
2452
   or for an `if' or `while' statement or ?..: exp.  It should already
2453
   have been validated to be of suitable type; otherwise, a bad
2454
   diagnostic may result.
2455
 
2456
   This preparation consists of taking the ordinary
2457
   representation of an expression expr and producing a valid tree
2458
   boolean expression describing whether expr is nonzero.  We could
2459
   simply always do build_binary_op (NE_EXPR, expr, truthvalue_false_node, 1),
2460
   but we optimize comparisons, &&, ||, and !.
2461
 
2462
   The resulting type should always be `truthvalue_type_node'.  */
2463
 
2464
tree
2465
c_common_truthvalue_conversion (tree expr)
2466
{
2467
  switch (TREE_CODE (expr))
2468
    {
2469
    case EQ_EXPR:   case NE_EXPR:   case UNEQ_EXPR: case LTGT_EXPR:
2470
    case LE_EXPR:   case GE_EXPR:   case LT_EXPR:   case GT_EXPR:
2471
    case UNLE_EXPR: case UNGE_EXPR: case UNLT_EXPR: case UNGT_EXPR:
2472
    case ORDERED_EXPR: case UNORDERED_EXPR:
2473
      if (TREE_TYPE (expr) == truthvalue_type_node)
2474
        return expr;
2475
      return build2 (TREE_CODE (expr), truthvalue_type_node,
2476
                     TREE_OPERAND (expr, 0), TREE_OPERAND (expr, 1));
2477
 
2478
    case TRUTH_ANDIF_EXPR:
2479
    case TRUTH_ORIF_EXPR:
2480
    case TRUTH_AND_EXPR:
2481
    case TRUTH_OR_EXPR:
2482
    case TRUTH_XOR_EXPR:
2483
      if (TREE_TYPE (expr) == truthvalue_type_node)
2484
        return expr;
2485
      return build2 (TREE_CODE (expr), truthvalue_type_node,
2486
                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2487
                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)));
2488
 
2489
    case TRUTH_NOT_EXPR:
2490
      if (TREE_TYPE (expr) == truthvalue_type_node)
2491
        return expr;
2492
      return build1 (TREE_CODE (expr), truthvalue_type_node,
2493
                 c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2494
 
2495
    case ERROR_MARK:
2496
      return expr;
2497
 
2498
    case INTEGER_CST:
2499
      /* Avoid integer_zerop to ignore TREE_CONSTANT_OVERFLOW.  */
2500
      return (TREE_INT_CST_LOW (expr) != 0 || TREE_INT_CST_HIGH (expr) != 0)
2501
             ? truthvalue_true_node
2502
             : truthvalue_false_node;
2503
 
2504
    case REAL_CST:
2505
      return real_compare (NE_EXPR, &TREE_REAL_CST (expr), &dconst0)
2506
             ? truthvalue_true_node
2507
             : truthvalue_false_node;
2508
 
2509
    case FUNCTION_DECL:
2510
      expr = build_unary_op (ADDR_EXPR, expr, 0);
2511
      /* Fall through.  */
2512
 
2513
    case ADDR_EXPR:
2514
      {
2515
        tree inner = TREE_OPERAND (expr, 0);
2516
        if (DECL_P (inner)
2517
            && (TREE_CODE (inner) == PARM_DECL
2518
                || TREE_CODE (inner) == LABEL_DECL
2519
                || !DECL_WEAK (inner)))
2520
          {
2521
            /* Common Ada/Pascal programmer's mistake.  We always warn
2522
               about this since it is so bad.  */
2523
            warning (OPT_Waddress,
2524
                     "the address of %qD will always evaluate as %<true%>",
2525
                     inner);
2526
            return truthvalue_true_node;
2527
          }
2528
 
2529
        /* If we are taking the address of an external decl, it might be
2530
           zero if it is weak, so we cannot optimize.  */
2531
        if (DECL_P (inner)
2532
            && DECL_EXTERNAL (inner))
2533
          break;
2534
 
2535
        if (TREE_SIDE_EFFECTS (inner))
2536
          return build2 (COMPOUND_EXPR, truthvalue_type_node,
2537
                         inner, truthvalue_true_node);
2538
        else
2539
          return truthvalue_true_node;
2540
      }
2541
 
2542
    case COMPLEX_EXPR:
2543
      return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))
2544
                               ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2545
                c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)),
2546
                c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2547
                              0);
2548
 
2549
    case NEGATE_EXPR:
2550
    case ABS_EXPR:
2551
    case FLOAT_EXPR:
2552
      /* These don't change whether an object is nonzero or zero.  */
2553
      return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2554
 
2555
    case LROTATE_EXPR:
2556
    case RROTATE_EXPR:
2557
      /* These don't change whether an object is zero or nonzero, but
2558
         we can't ignore them if their second arg has side-effects.  */
2559
      if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)))
2560
        return build2 (COMPOUND_EXPR, truthvalue_type_node,
2561
                       TREE_OPERAND (expr, 1),
2562
                       c_common_truthvalue_conversion (TREE_OPERAND (expr, 0)));
2563
      else
2564
        return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2565
 
2566
    case COND_EXPR:
2567
      /* Distribute the conversion into the arms of a COND_EXPR.  */
2568
      return fold_build3 (COND_EXPR, truthvalue_type_node,
2569
                TREE_OPERAND (expr, 0),
2570
                c_common_truthvalue_conversion (TREE_OPERAND (expr, 1)),
2571
                c_common_truthvalue_conversion (TREE_OPERAND (expr, 2)));
2572
 
2573
    case CONVERT_EXPR:
2574
    case NOP_EXPR:
2575
      /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE,
2576
         since that affects how `default_conversion' will behave.  */
2577
      if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE
2578
          || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE)
2579
        break;
2580
      /* If this is widening the argument, we can ignore it.  */
2581
      if (TYPE_PRECISION (TREE_TYPE (expr))
2582
          >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0))))
2583
        return c_common_truthvalue_conversion (TREE_OPERAND (expr, 0));
2584
      break;
2585
 
2586
    case MODIFY_EXPR:
2587
      if (!TREE_NO_WARNING (expr))
2588
        warning (OPT_Wparentheses,
2589
                 "suggest parentheses around assignment used as truth value");
2590
      break;
2591
 
2592
    default:
2593
      break;
2594
    }
2595
 
2596
  if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE)
2597
    {
2598
      tree t = save_expr (expr);
2599
      return (build_binary_op
2600
              ((TREE_SIDE_EFFECTS (expr)
2601
                ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR),
2602
        c_common_truthvalue_conversion (build_unary_op (REALPART_EXPR, t, 0)),
2603
        c_common_truthvalue_conversion (build_unary_op (IMAGPART_EXPR, t, 0)),
2604
               0));
2605
    }
2606
 
2607
  return build_binary_op (NE_EXPR, expr, integer_zero_node, 1);
2608
}
2609
 
2610
static void def_builtin_1  (enum built_in_function fncode,
2611
                            const char *name,
2612
                            enum built_in_class fnclass,
2613
                            tree fntype, tree libtype,
2614
                            bool both_p, bool fallback_p, bool nonansi_p,
2615
                            tree fnattrs, bool implicit_p);
2616
 
2617
/* Make a variant type in the proper way for C/C++, propagating qualifiers
2618
   down to the element type of an array.  */
2619
 
2620
tree
2621
c_build_qualified_type (tree type, int type_quals)
2622
{
2623
  if (type == error_mark_node)
2624
    return type;
2625
 
2626
  if (TREE_CODE (type) == ARRAY_TYPE)
2627
    {
2628
      tree t;
2629
      tree element_type = c_build_qualified_type (TREE_TYPE (type),
2630
                                                  type_quals);
2631
 
2632
      /* See if we already have an identically qualified type.  */
2633
      for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
2634
        {
2635
          if (TYPE_QUALS (strip_array_types (t)) == type_quals
2636
              && TYPE_NAME (t) == TYPE_NAME (type)
2637
              && TYPE_CONTEXT (t) == TYPE_CONTEXT (type)
2638
              && attribute_list_equal (TYPE_ATTRIBUTES (t),
2639
                                       TYPE_ATTRIBUTES (type)))
2640
            break;
2641
        }
2642
      if (!t)
2643
        {
2644
          t = build_variant_type_copy (type);
2645
          TREE_TYPE (t) = element_type;
2646
        }
2647
      return t;
2648
    }
2649
 
2650
  /* A restrict-qualified pointer type must be a pointer to object or
2651
     incomplete type.  Note that the use of POINTER_TYPE_P also allows
2652
     REFERENCE_TYPEs, which is appropriate for C++.  */
2653
  if ((type_quals & TYPE_QUAL_RESTRICT)
2654
      && (!POINTER_TYPE_P (type)
2655
          || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type))))
2656
    {
2657
      error ("invalid use of %<restrict%>");
2658
      type_quals &= ~TYPE_QUAL_RESTRICT;
2659
    }
2660
 
2661
  return build_qualified_type (type, type_quals);
2662
}
2663
 
2664
/* Apply the TYPE_QUALS to the new DECL.  */
2665
 
2666
void
2667
c_apply_type_quals_to_decl (int type_quals, tree decl)
2668
{
2669
  tree type = TREE_TYPE (decl);
2670
 
2671
  if (type == error_mark_node)
2672
    return;
2673
 
2674
  if (((type_quals & TYPE_QUAL_CONST)
2675
       || (type && TREE_CODE (type) == REFERENCE_TYPE))
2676
      /* An object declared 'const' is only readonly after it is
2677
         initialized.  We don't have any way of expressing this currently,
2678
         so we need to be conservative and unset TREE_READONLY for types
2679
         with constructors.  Otherwise aliasing code will ignore stores in
2680
         an inline constructor.  */
2681
      && !(type && TYPE_NEEDS_CONSTRUCTING (type)))
2682
    TREE_READONLY (decl) = 1;
2683
  if (type_quals & TYPE_QUAL_VOLATILE)
2684
    {
2685
      TREE_SIDE_EFFECTS (decl) = 1;
2686
      TREE_THIS_VOLATILE (decl) = 1;
2687
    }
2688
  if (type_quals & TYPE_QUAL_RESTRICT)
2689
    {
2690
      while (type && TREE_CODE (type) == ARRAY_TYPE)
2691
        /* Allow 'restrict' on arrays of pointers.
2692
           FIXME currently we just ignore it.  */
2693
        type = TREE_TYPE (type);
2694
      if (!type
2695
          || !POINTER_TYPE_P (type)
2696
          || !C_TYPE_OBJECT_OR_INCOMPLETE_P (TREE_TYPE (type)))
2697
        error ("invalid use of %<restrict%>");
2698
      else if (flag_strict_aliasing && type == TREE_TYPE (decl))
2699
        /* Indicate we need to make a unique alias set for this pointer.
2700
           We can't do it here because it might be pointing to an
2701
           incomplete type.  */
2702
        DECL_POINTER_ALIAS_SET (decl) = -2;
2703
    }
2704
}
2705
 
2706
/* Hash function for the problem of multiple type definitions in
2707
   different files.  This must hash all types that will compare
2708
   equal via comptypes to the same value.  In practice it hashes
2709
   on some of the simple stuff and leaves the details to comptypes.  */
2710
 
2711
static hashval_t
2712
c_type_hash (const void *p)
2713
{
2714
  int i = 0;
2715
  int shift, size;
2716
  tree t = (tree) p;
2717
  tree t2;
2718
  switch (TREE_CODE (t))
2719
    {
2720
    /* For pointers, hash on pointee type plus some swizzling.  */
2721
    case POINTER_TYPE:
2722
      return c_type_hash (TREE_TYPE (t)) ^ 0x3003003;
2723
    /* Hash on number of elements and total size.  */
2724
    case ENUMERAL_TYPE:
2725
      shift = 3;
2726
      t2 = TYPE_VALUES (t);
2727
      break;
2728
    case RECORD_TYPE:
2729
      shift = 0;
2730
      t2 = TYPE_FIELDS (t);
2731
      break;
2732
    case QUAL_UNION_TYPE:
2733
      shift = 1;
2734
      t2 = TYPE_FIELDS (t);
2735
      break;
2736
    case UNION_TYPE:
2737
      shift = 2;
2738
      t2 = TYPE_FIELDS (t);
2739
      break;
2740
    default:
2741
      gcc_unreachable ();
2742
    }
2743
  for (; t2; t2 = TREE_CHAIN (t2))
2744
    i++;
2745
  size = TREE_INT_CST_LOW (TYPE_SIZE (t));
2746
  return ((size << 24) | (i << shift));
2747
}
2748
 
2749
static GTY((param_is (union tree_node))) htab_t type_hash_table;
2750
 
2751
/* Return the typed-based alias set for T, which may be an expression
2752
   or a type.  Return -1 if we don't do anything special.  */
2753
 
2754
HOST_WIDE_INT
2755
c_common_get_alias_set (tree t)
2756
{
2757
  tree u;
2758
  PTR *slot;
2759
 
2760
  /* Permit type-punning when accessing a union, provided the access
2761
     is directly through the union.  For example, this code does not
2762
     permit taking the address of a union member and then storing
2763
     through it.  Even the type-punning allowed here is a GCC
2764
     extension, albeit a common and useful one; the C standard says
2765
     that such accesses have implementation-defined behavior.  */
2766
  for (u = t;
2767
       TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2768
       u = TREE_OPERAND (u, 0))
2769
    if (TREE_CODE (u) == COMPONENT_REF
2770
        && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2771
      return 0;
2772
 
2773
  /* That's all the expressions we handle specially.  */
2774
  if (!TYPE_P (t))
2775
    return -1;
2776
 
2777
  /* The C standard guarantees that any object may be accessed via an
2778
     lvalue that has character type.  */
2779
  if (t == char_type_node
2780
      || t == signed_char_type_node
2781
      || t == unsigned_char_type_node)
2782
    return 0;
2783
 
2784
  /* If it has the may_alias attribute, it can alias anything.  */
2785
  if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (t)))
2786
    return 0;
2787
 
2788
  /* The C standard specifically allows aliasing between signed and
2789
     unsigned variants of the same type.  We treat the signed
2790
     variant as canonical.  */
2791
  if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2792
    {
2793
      tree t1 = c_common_signed_type (t);
2794
 
2795
      /* t1 == t can happen for boolean nodes which are always unsigned.  */
2796
      if (t1 != t)
2797
        return get_alias_set (t1);
2798
    }
2799
  else if (POINTER_TYPE_P (t))
2800
    {
2801
      tree t1;
2802
 
2803
      /* Unfortunately, there is no canonical form of a pointer type.
2804
         In particular, if we have `typedef int I', then `int *', and
2805
         `I *' are different types.  So, we have to pick a canonical
2806
         representative.  We do this below.
2807
 
2808
         Technically, this approach is actually more conservative that
2809
         it needs to be.  In particular, `const int *' and `int *'
2810
         should be in different alias sets, according to the C and C++
2811
         standard, since their types are not the same, and so,
2812
         technically, an `int **' and `const int **' cannot point at
2813
         the same thing.
2814
 
2815
         But, the standard is wrong.  In particular, this code is
2816
         legal C++:
2817
 
2818
            int *ip;
2819
            int **ipp = &ip;
2820
            const int* const* cipp = ipp;
2821
 
2822
         And, it doesn't make sense for that to be legal unless you
2823
         can dereference IPP and CIPP.  So, we ignore cv-qualifiers on
2824
         the pointed-to types.  This issue has been reported to the
2825
         C++ committee.  */
2826
      t1 = build_type_no_quals (t);
2827
      if (t1 != t)
2828
        return get_alias_set (t1);
2829
    }
2830
 
2831
  /* Handle the case of multiple type nodes referring to "the same" type,
2832
     which occurs with IMA.  These share an alias set.  FIXME:  Currently only
2833
     C90 is handled.  (In C99 type compatibility is not transitive, which
2834
     complicates things mightily. The alias set splay trees can theoretically
2835
     represent this, but insertion is tricky when you consider all the
2836
     different orders things might arrive in.) */
2837
 
2838
  if (c_language != clk_c || flag_isoc99)
2839
    return -1;
2840
 
2841
  /* Save time if there's only one input file.  */
2842
  if (num_in_fnames == 1)
2843
    return -1;
2844
 
2845
  /* Pointers need special handling if they point to any type that
2846
     needs special handling (below).  */
2847
  if (TREE_CODE (t) == POINTER_TYPE)
2848
    {
2849
      tree t2;
2850
      /* Find bottom type under any nested POINTERs.  */
2851
      for (t2 = TREE_TYPE (t);
2852
     TREE_CODE (t2) == POINTER_TYPE;
2853
     t2 = TREE_TYPE (t2))
2854
  ;
2855
      if (TREE_CODE (t2) != RECORD_TYPE
2856
    && TREE_CODE (t2) != ENUMERAL_TYPE
2857
    && TREE_CODE (t2) != QUAL_UNION_TYPE
2858
    && TREE_CODE (t2) != UNION_TYPE)
2859
  return -1;
2860
      if (TYPE_SIZE (t2) == 0)
2861
  return -1;
2862
    }
2863
  /* These are the only cases that need special handling.  */
2864
  if (TREE_CODE (t) != RECORD_TYPE
2865
      && TREE_CODE (t) != ENUMERAL_TYPE
2866
      && TREE_CODE (t) != QUAL_UNION_TYPE
2867
      && TREE_CODE (t) != UNION_TYPE
2868
      && TREE_CODE (t) != POINTER_TYPE)
2869
    return -1;
2870
  /* Undefined? */
2871
  if (TYPE_SIZE (t) == 0)
2872
    return -1;
2873
 
2874
  /* Look up t in hash table.  Only one of the compatible types within each
2875
     alias set is recorded in the table.  */
2876
  if (!type_hash_table)
2877
    type_hash_table = htab_create_ggc (1021, c_type_hash,
2878
            (htab_eq) lang_hooks.types_compatible_p,
2879
            NULL);
2880
  slot = htab_find_slot (type_hash_table, t, INSERT);
2881
  if (*slot != NULL)
2882
    {
2883
      TYPE_ALIAS_SET (t) = TYPE_ALIAS_SET ((tree)*slot);
2884
      return TYPE_ALIAS_SET ((tree)*slot);
2885
    }
2886
  else
2887
    /* Our caller will assign and record (in t) a new alias set; all we need
2888
       to do is remember t in the hash table.  */
2889
    *slot = t;
2890
 
2891
  return -1;
2892
}
2893
 
2894
/* Compute the value of 'sizeof (TYPE)' or '__alignof__ (TYPE)', where the
2895
   second parameter indicates which OPERATOR is being applied.  The COMPLAIN
2896
   flag controls whether we should diagnose possibly ill-formed
2897
   constructs or not.  */
2898
 
2899
tree
2900
c_sizeof_or_alignof_type (tree type, bool is_sizeof, int complain)
2901
{
2902
  const char *op_name;
2903
  tree value = NULL;
2904
  enum tree_code type_code = TREE_CODE (type);
2905
 
2906
  op_name = is_sizeof ? "sizeof" : "__alignof__";
2907
 
2908
  if (type_code == FUNCTION_TYPE)
2909
    {
2910
      if (is_sizeof)
2911
        {
2912
          if (complain && (pedantic || warn_pointer_arith))
2913
            pedwarn ("invalid application of %<sizeof%> to a function type");
2914
          value = size_one_node;
2915
        }
2916
      else
2917
        value = size_int (FUNCTION_BOUNDARY / BITS_PER_UNIT);
2918
    }
2919
  else if (type_code == VOID_TYPE || type_code == ERROR_MARK)
2920
    {
2921
      if (type_code == VOID_TYPE
2922
          && complain && (pedantic || warn_pointer_arith))
2923
        pedwarn ("invalid application of %qs to a void type", op_name);
2924
      value = size_one_node;
2925
    }
2926
  else if (!COMPLETE_TYPE_P (type))
2927
    {
2928
      if (complain)
2929
        error ("invalid application of %qs to incomplete type %qT ",
2930
               op_name, type);
2931
      value = size_zero_node;
2932
    }
2933
  else
2934
    {
2935
      if (is_sizeof)
2936
        /* Convert in case a char is more than one unit.  */
2937
        value = size_binop (CEIL_DIV_EXPR, TYPE_SIZE_UNIT (type),
2938
                            size_int (TYPE_PRECISION (char_type_node)
2939
                                      / BITS_PER_UNIT));
2940
      else
2941
        value = size_int (TYPE_ALIGN_UNIT (type));
2942
    }
2943
 
2944
  /* VALUE will have an integer type with TYPE_IS_SIZETYPE set.
2945
     TYPE_IS_SIZETYPE means that certain things (like overflow) will
2946
     never happen.  However, this node should really have type
2947
     `size_t', which is just a typedef for an ordinary integer type.  */
2948
  value = fold_convert (size_type_node, value);
2949
  gcc_assert (!TYPE_IS_SIZETYPE (TREE_TYPE (value)));
2950
 
2951
  return value;
2952
}
2953
 
2954
/* Implement the __alignof keyword: Return the minimum required
2955
   alignment of EXPR, measured in bytes.  For VAR_DECL's and
2956
   FIELD_DECL's return DECL_ALIGN (which can be set from an
2957
   "aligned" __attribute__ specification).  */
2958
 
2959
tree
2960
c_alignof_expr (tree expr)
2961
{
2962
  tree t;
2963
 
2964
  if (TREE_CODE (expr) == VAR_DECL)
2965
    t = size_int (DECL_ALIGN_UNIT (expr));
2966
 
2967
  else if (TREE_CODE (expr) == COMPONENT_REF
2968
           && DECL_C_BIT_FIELD (TREE_OPERAND (expr, 1)))
2969
    {
2970
      error ("%<__alignof%> applied to a bit-field");
2971
      t = size_one_node;
2972
    }
2973
  else if (TREE_CODE (expr) == COMPONENT_REF
2974
           && TREE_CODE (TREE_OPERAND (expr, 1)) == FIELD_DECL)
2975
    t = size_int (DECL_ALIGN_UNIT (TREE_OPERAND (expr, 1)));
2976
 
2977
  else if (TREE_CODE (expr) == INDIRECT_REF)
2978
    {
2979
      tree t = TREE_OPERAND (expr, 0);
2980
      tree best = t;
2981
      int bestalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2982
 
2983
      while ((TREE_CODE (t) == NOP_EXPR || TREE_CODE (t) == CONVERT_EXPR)
2984
             && TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0))) == POINTER_TYPE)
2985
        {
2986
          int thisalign;
2987
 
2988
          t = TREE_OPERAND (t, 0);
2989
          thisalign = TYPE_ALIGN (TREE_TYPE (TREE_TYPE (t)));
2990
          if (thisalign > bestalign)
2991
            best = t, bestalign = thisalign;
2992
        }
2993
      return c_alignof (TREE_TYPE (TREE_TYPE (best)));
2994
    }
2995
  else
2996
    return c_alignof (TREE_TYPE (expr));
2997
 
2998
  return fold_convert (size_type_node, t);
2999
}
3000
 
3001
/* Handle C and C++ default attributes.  */
3002
 
3003
enum built_in_attribute
3004
{
3005
#define DEF_ATTR_NULL_TREE(ENUM) ENUM,
3006
#define DEF_ATTR_INT(ENUM, VALUE) ENUM,
3007
#define DEF_ATTR_IDENT(ENUM, STRING) ENUM,
3008
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) ENUM,
3009
#include "builtin-attrs.def"
3010
#undef DEF_ATTR_NULL_TREE
3011
#undef DEF_ATTR_INT
3012
#undef DEF_ATTR_IDENT
3013
#undef DEF_ATTR_TREE_LIST
3014
  ATTR_LAST
3015
};
3016
 
3017
static GTY(()) tree built_in_attributes[(int) ATTR_LAST];
3018
 
3019
static void c_init_attributes (void);
3020
 
3021
enum c_builtin_type
3022
{
3023
#define DEF_PRIMITIVE_TYPE(NAME, VALUE) NAME,
3024
#define DEF_FUNCTION_TYPE_0(NAME, RETURN) NAME,
3025
#define DEF_FUNCTION_TYPE_1(NAME, RETURN, ARG1) NAME,
3026
#define DEF_FUNCTION_TYPE_2(NAME, RETURN, ARG1, ARG2) NAME,
3027
#define DEF_FUNCTION_TYPE_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3028
#define DEF_FUNCTION_TYPE_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3029
#define DEF_FUNCTION_TYPE_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) NAME,
3030
#define DEF_FUNCTION_TYPE_6(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6) NAME,
3031
#define DEF_FUNCTION_TYPE_7(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7) NAME,
3032
#define DEF_FUNCTION_TYPE_VAR_0(NAME, RETURN) NAME,
3033
#define DEF_FUNCTION_TYPE_VAR_1(NAME, RETURN, ARG1) NAME,
3034
#define DEF_FUNCTION_TYPE_VAR_2(NAME, RETURN, ARG1, ARG2) NAME,
3035
#define DEF_FUNCTION_TYPE_VAR_3(NAME, RETURN, ARG1, ARG2, ARG3) NAME,
3036
#define DEF_FUNCTION_TYPE_VAR_4(NAME, RETURN, ARG1, ARG2, ARG3, ARG4) NAME,
3037
#define DEF_FUNCTION_TYPE_VAR_5(NAME, RETURN, ARG1, ARG2, ARG3, ARG4, ARG6) \
3038
  NAME,
3039
#define DEF_POINTER_TYPE(NAME, TYPE) NAME,
3040
#include "builtin-types.def"
3041
#undef DEF_PRIMITIVE_TYPE
3042
#undef DEF_FUNCTION_TYPE_0
3043
#undef DEF_FUNCTION_TYPE_1
3044
#undef DEF_FUNCTION_TYPE_2
3045
#undef DEF_FUNCTION_TYPE_3
3046
#undef DEF_FUNCTION_TYPE_4
3047
#undef DEF_FUNCTION_TYPE_5
3048
#undef DEF_FUNCTION_TYPE_6
3049
#undef DEF_FUNCTION_TYPE_7
3050
#undef DEF_FUNCTION_TYPE_VAR_0
3051
#undef DEF_FUNCTION_TYPE_VAR_1
3052
#undef DEF_FUNCTION_TYPE_VAR_2
3053
#undef DEF_FUNCTION_TYPE_VAR_3
3054
#undef DEF_FUNCTION_TYPE_VAR_4
3055
#undef DEF_FUNCTION_TYPE_VAR_5
3056
#undef DEF_POINTER_TYPE
3057
  BT_LAST
3058
};
3059
 
3060
typedef enum c_builtin_type builtin_type;
3061
 
3062
/* A temporary array for c_common_nodes_and_builtins.  Used in
3063
   communication with def_fn_type.  */
3064
static tree builtin_types[(int) BT_LAST + 1];
3065
 
3066
/* A helper function for c_common_nodes_and_builtins.  Build function type
3067
   for DEF with return type RET and N arguments.  If VAR is true, then the
3068
   function should be variadic after those N arguments.
3069
 
3070
   Takes special care not to ICE if any of the types involved are
3071
   error_mark_node, which indicates that said type is not in fact available
3072
   (see builtin_type_for_size).  In which case the function type as a whole
3073
   should be error_mark_node.  */
3074
 
3075
static void
3076
def_fn_type (builtin_type def, builtin_type ret, bool var, int n, ...)
3077
{
3078
  tree args = NULL, t;
3079
  va_list list;
3080
  int i;
3081
 
3082
  va_start (list, n);
3083
  for (i = 0; i < n; ++i)
3084
    {
3085
      builtin_type a = va_arg (list, builtin_type);
3086
      t = builtin_types[a];
3087
      if (t == error_mark_node)
3088
        goto egress;
3089
      args = tree_cons (NULL_TREE, t, args);
3090
    }
3091
  va_end (list);
3092
 
3093
  args = nreverse (args);
3094
  if (!var)
3095
    args = chainon (args, void_list_node);
3096
 
3097
  t = builtin_types[ret];
3098
  if (t == error_mark_node)
3099
    goto egress;
3100
  t = build_function_type (t, args);
3101
 
3102
 egress:
3103
  builtin_types[def] = t;
3104
}
3105
 
3106
/* Build tree nodes and builtin functions common to both C and C++ language
3107
   frontends.  */
3108
 
3109
void
3110
c_common_nodes_and_builtins (void)
3111
{
3112
  int wchar_type_size;
3113
  tree array_domain_type;
3114
  tree va_list_ref_type_node;
3115
  tree va_list_arg_type_node;
3116
 
3117
  /* Define `int' and `char' first so that dbx will output them first.  */
3118
  record_builtin_type (RID_INT, NULL, integer_type_node);
3119
  record_builtin_type (RID_CHAR, "char", char_type_node);
3120
 
3121
  /* `signed' is the same as `int'.  FIXME: the declarations of "signed",
3122
     "unsigned long", "long long unsigned" and "unsigned short" were in C++
3123
     but not C.  Are the conditionals here needed?  */
3124
  if (c_dialect_cxx ())
3125
    record_builtin_type (RID_SIGNED, NULL, integer_type_node);
3126
  record_builtin_type (RID_LONG, "long int", long_integer_type_node);
3127
  record_builtin_type (RID_UNSIGNED, "unsigned int", unsigned_type_node);
3128
  record_builtin_type (RID_MAX, "long unsigned int",
3129
                       long_unsigned_type_node);
3130
  if (c_dialect_cxx ())
3131
    record_builtin_type (RID_MAX, "unsigned long", long_unsigned_type_node);
3132
  record_builtin_type (RID_MAX, "long long int",
3133
                       long_long_integer_type_node);
3134
  record_builtin_type (RID_MAX, "long long unsigned int",
3135
                       long_long_unsigned_type_node);
3136
  if (c_dialect_cxx ())
3137
    record_builtin_type (RID_MAX, "long long unsigned",
3138
                         long_long_unsigned_type_node);
3139
  record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
3140
  record_builtin_type (RID_MAX, "short unsigned int",
3141
                       short_unsigned_type_node);
3142
  if (c_dialect_cxx ())
3143
    record_builtin_type (RID_MAX, "unsigned short",
3144
                         short_unsigned_type_node);
3145
 
3146
  /* Define both `signed char' and `unsigned char'.  */
3147
  record_builtin_type (RID_MAX, "signed char", signed_char_type_node);
3148
  record_builtin_type (RID_MAX, "unsigned char", unsigned_char_type_node);
3149
 
3150
  /* These are types that c_common_type_for_size and
3151
     c_common_type_for_mode use.  */
3152
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3153
                                         intQI_type_node));
3154
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3155
                                         intHI_type_node));
3156
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3157
                                         intSI_type_node));
3158
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3159
                                         intDI_type_node));
3160
#if HOST_BITS_PER_WIDE_INT >= 64
3161
  if (targetm.scalar_mode_supported_p (TImode))
3162
    lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3163
                                           get_identifier ("__int128_t"),
3164
                                           intTI_type_node));
3165
#endif
3166
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3167
                                         unsigned_intQI_type_node));
3168
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3169
                                         unsigned_intHI_type_node));
3170
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3171
                                         unsigned_intSI_type_node));
3172
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3173
                                         unsigned_intDI_type_node));
3174
#if HOST_BITS_PER_WIDE_INT >= 64
3175
  if (targetm.scalar_mode_supported_p (TImode))
3176
    lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3177
                                           get_identifier ("__uint128_t"),
3178
                                           unsigned_intTI_type_node));
3179
#endif
3180
 
3181
  /* Create the widest literal types.  */
3182
  widest_integer_literal_type_node
3183
    = make_signed_type (HOST_BITS_PER_WIDE_INT * 2);
3184
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3185
                                         widest_integer_literal_type_node));
3186
 
3187
  widest_unsigned_literal_type_node
3188
    = make_unsigned_type (HOST_BITS_PER_WIDE_INT * 2);
3189
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL, NULL_TREE,
3190
                                         widest_unsigned_literal_type_node));
3191
 
3192
  /* `unsigned long' is the standard type for sizeof.
3193
     Note that stddef.h uses `unsigned long',
3194
     and this must agree, even if long and int are the same size.  */
3195
  size_type_node =
3196
    TREE_TYPE (identifier_global_value (get_identifier (SIZE_TYPE)));
3197
  signed_size_type_node = c_common_signed_type (size_type_node);
3198
  set_sizetype (size_type_node);
3199
 
3200
  pid_type_node =
3201
    TREE_TYPE (identifier_global_value (get_identifier (PID_TYPE)));
3202
 
3203
  build_common_tree_nodes_2 (flag_short_double);
3204
 
3205
  record_builtin_type (RID_FLOAT, NULL, float_type_node);
3206
  record_builtin_type (RID_DOUBLE, NULL, double_type_node);
3207
  record_builtin_type (RID_MAX, "long double", long_double_type_node);
3208
 
3209
  /* Only supported decimal floating point extension if the target
3210
     actually supports underlying modes. */
3211
  if (targetm.scalar_mode_supported_p (SDmode)
3212
      && targetm.scalar_mode_supported_p (DDmode)
3213
      && targetm.scalar_mode_supported_p (TDmode))
3214
    {
3215
      record_builtin_type (RID_DFLOAT32, NULL, dfloat32_type_node);
3216
      record_builtin_type (RID_DFLOAT64, NULL, dfloat64_type_node);
3217
      record_builtin_type (RID_DFLOAT128, NULL, dfloat128_type_node);
3218
    }
3219
 
3220
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3221
                                         get_identifier ("complex int"),
3222
                                         complex_integer_type_node));
3223
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3224
                                         get_identifier ("complex float"),
3225
                                         complex_float_type_node));
3226
  lang_hooks.decls.pushdecl (build_decl (TYPE_DECL,
3227
                                         get_identifier ("complex double"),
3228
                                         complex_double_type_node));
3229
  lang_hooks.decls.pushdecl
3230
    (build_decl (TYPE_DECL, get_identifier ("complex long double"),
3231
                 complex_long_double_type_node));
3232
 
3233
  if (c_dialect_cxx ())
3234
    /* For C++, make fileptr_type_node a distinct void * type until
3235
       FILE type is defined.  */
3236
    fileptr_type_node = build_variant_type_copy (ptr_type_node);
3237
 
3238
  record_builtin_type (RID_VOID, NULL, void_type_node);
3239
 
3240
  /* This node must not be shared.  */
3241
  void_zero_node = make_node (INTEGER_CST);
3242
  TREE_TYPE (void_zero_node) = void_type_node;
3243
 
3244
  void_list_node = build_void_list_node ();
3245
 
3246
  /* Make a type to be the domain of a few array types
3247
     whose domains don't really matter.
3248
     200 is small enough that it always fits in size_t
3249
     and large enough that it can hold most function names for the
3250
     initializations of __FUNCTION__ and __PRETTY_FUNCTION__.  */
3251
  array_domain_type = build_index_type (size_int (200));
3252
 
3253
  /* Make a type for arrays of characters.
3254
     With luck nothing will ever really depend on the length of this
3255
     array type.  */
3256
  char_array_type_node
3257
    = build_array_type (char_type_node, array_domain_type);
3258
 
3259
  /* Likewise for arrays of ints.  */
3260
  int_array_type_node
3261
    = build_array_type (integer_type_node, array_domain_type);
3262
 
3263
  string_type_node = build_pointer_type (char_type_node);
3264
  const_string_type_node
3265
    = build_pointer_type (build_qualified_type
3266
                          (char_type_node, TYPE_QUAL_CONST));
3267
 
3268
  /* This is special for C++ so functions can be overloaded.  */
3269
  wchar_type_node = get_identifier (MODIFIED_WCHAR_TYPE);
3270
  wchar_type_node = TREE_TYPE (identifier_global_value (wchar_type_node));
3271
  wchar_type_size = TYPE_PRECISION (wchar_type_node);
3272
  if (c_dialect_cxx ())
3273
    {
3274
      if (TYPE_UNSIGNED (wchar_type_node))
3275
        wchar_type_node = make_unsigned_type (wchar_type_size);
3276
      else
3277
        wchar_type_node = make_signed_type (wchar_type_size);
3278
      record_builtin_type (RID_WCHAR, "wchar_t", wchar_type_node);
3279
    }
3280
  else
3281
    {
3282
      signed_wchar_type_node = c_common_signed_type (wchar_type_node);
3283
      unsigned_wchar_type_node = c_common_unsigned_type (wchar_type_node);
3284
    }
3285
 
3286
  /* This is for wide string constants.  */
3287
  wchar_array_type_node
3288
    = build_array_type (wchar_type_node, array_domain_type);
3289
 
3290
  wint_type_node =
3291
    TREE_TYPE (identifier_global_value (get_identifier (WINT_TYPE)));
3292
 
3293
  intmax_type_node =
3294
    TREE_TYPE (identifier_global_value (get_identifier (INTMAX_TYPE)));
3295
  uintmax_type_node =
3296
    TREE_TYPE (identifier_global_value (get_identifier (UINTMAX_TYPE)));
3297
 
3298
  default_function_type = build_function_type (integer_type_node, NULL_TREE);
3299
  ptrdiff_type_node
3300
    = TREE_TYPE (identifier_global_value (get_identifier (PTRDIFF_TYPE)));
3301
  unsigned_ptrdiff_type_node = c_common_unsigned_type (ptrdiff_type_node);
3302
 
3303
  lang_hooks.decls.pushdecl
3304
    (build_decl (TYPE_DECL, get_identifier ("__builtin_va_list"),
3305
                 va_list_type_node));
3306
 
3307
  if (TREE_CODE (va_list_type_node) == ARRAY_TYPE)
3308
    {
3309
      va_list_arg_type_node = va_list_ref_type_node =
3310
        build_pointer_type (TREE_TYPE (va_list_type_node));
3311
    }
3312
  else
3313
    {
3314
      va_list_arg_type_node = va_list_type_node;
3315
      va_list_ref_type_node = build_reference_type (va_list_type_node);
3316
    }
3317
 
3318
#define DEF_PRIMITIVE_TYPE(ENUM, VALUE) \
3319
  builtin_types[ENUM] = VALUE;
3320
#define DEF_FUNCTION_TYPE_0(ENUM, RETURN) \
3321
  def_fn_type (ENUM, RETURN, 0, 0);
3322
#define DEF_FUNCTION_TYPE_1(ENUM, RETURN, ARG1) \
3323
  def_fn_type (ENUM, RETURN, 0, 1, ARG1);
3324
#define DEF_FUNCTION_TYPE_2(ENUM, RETURN, ARG1, ARG2) \
3325
  def_fn_type (ENUM, RETURN, 0, 2, ARG1, ARG2);
3326
#define DEF_FUNCTION_TYPE_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3327
  def_fn_type (ENUM, RETURN, 0, 3, ARG1, ARG2, ARG3);
3328
#define DEF_FUNCTION_TYPE_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3329
  def_fn_type (ENUM, RETURN, 0, 4, ARG1, ARG2, ARG3, ARG4);
3330
#define DEF_FUNCTION_TYPE_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3331
  def_fn_type (ENUM, RETURN, 0, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3332
#define DEF_FUNCTION_TYPE_6(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3333
                            ARG6)                                       \
3334
  def_fn_type (ENUM, RETURN, 0, 6, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6);
3335
#define DEF_FUNCTION_TYPE_7(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5, \
3336
                            ARG6, ARG7)                                 \
3337
  def_fn_type (ENUM, RETURN, 0, 7, ARG1, ARG2, ARG3, ARG4, ARG5, ARG6, ARG7);
3338
#define DEF_FUNCTION_TYPE_VAR_0(ENUM, RETURN) \
3339
  def_fn_type (ENUM, RETURN, 1, 0);
3340
#define DEF_FUNCTION_TYPE_VAR_1(ENUM, RETURN, ARG1) \
3341
  def_fn_type (ENUM, RETURN, 1, 1, ARG1);
3342
#define DEF_FUNCTION_TYPE_VAR_2(ENUM, RETURN, ARG1, ARG2) \
3343
  def_fn_type (ENUM, RETURN, 1, 2, ARG1, ARG2);
3344
#define DEF_FUNCTION_TYPE_VAR_3(ENUM, RETURN, ARG1, ARG2, ARG3) \
3345
  def_fn_type (ENUM, RETURN, 1, 3, ARG1, ARG2, ARG3);
3346
#define DEF_FUNCTION_TYPE_VAR_4(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4) \
3347
  def_fn_type (ENUM, RETURN, 1, 4, ARG1, ARG2, ARG3, ARG4);
3348
#define DEF_FUNCTION_TYPE_VAR_5(ENUM, RETURN, ARG1, ARG2, ARG3, ARG4, ARG5) \
3349
  def_fn_type (ENUM, RETURN, 1, 5, ARG1, ARG2, ARG3, ARG4, ARG5);
3350
#define DEF_POINTER_TYPE(ENUM, TYPE) \
3351
  builtin_types[(int) ENUM] = build_pointer_type (builtin_types[(int) TYPE]);
3352
 
3353
#include "builtin-types.def"
3354
 
3355
#undef DEF_PRIMITIVE_TYPE
3356
#undef DEF_FUNCTION_TYPE_1
3357
#undef DEF_FUNCTION_TYPE_2
3358
#undef DEF_FUNCTION_TYPE_3
3359
#undef DEF_FUNCTION_TYPE_4
3360
#undef DEF_FUNCTION_TYPE_5
3361
#undef DEF_FUNCTION_TYPE_6
3362
#undef DEF_FUNCTION_TYPE_VAR_0
3363
#undef DEF_FUNCTION_TYPE_VAR_1
3364
#undef DEF_FUNCTION_TYPE_VAR_2
3365
#undef DEF_FUNCTION_TYPE_VAR_3
3366
#undef DEF_FUNCTION_TYPE_VAR_4
3367
#undef DEF_FUNCTION_TYPE_VAR_5
3368
#undef DEF_POINTER_TYPE
3369
  builtin_types[(int) BT_LAST] = NULL_TREE;
3370
 
3371
  c_init_attributes ();
3372
 
3373
#define DEF_BUILTIN(ENUM, NAME, CLASS, TYPE, LIBTYPE, BOTH_P, FALLBACK_P, \
3374
                    NONANSI_P, ATTRS, IMPLICIT, COND)                   \
3375
  if (NAME && COND)                                                     \
3376
    def_builtin_1 (ENUM, NAME, CLASS,                                   \
3377
                   builtin_types[(int) TYPE],                           \
3378
                   builtin_types[(int) LIBTYPE],                        \
3379
                   BOTH_P, FALLBACK_P, NONANSI_P,                       \
3380
                   built_in_attributes[(int) ATTRS], IMPLICIT);
3381
#include "builtins.def"
3382
#undef DEF_BUILTIN
3383
 
3384
  build_common_builtin_nodes ();
3385
 
3386
  targetm.init_builtins ();
3387
  if (flag_mudflap)
3388
    mudflap_init ();
3389
 
3390
  main_identifier_node = get_identifier ("main");
3391
 
3392
  /* Create the built-in __null node.  It is important that this is
3393
     not shared.  */
3394
  null_node = make_node (INTEGER_CST);
3395
  TREE_TYPE (null_node) = c_common_type_for_size (POINTER_SIZE, 0);
3396
 
3397
  /* Since builtin_types isn't gc'ed, don't export these nodes.  */
3398
  memset (builtin_types, 0, sizeof (builtin_types));
3399
}
3400
 
3401
/* Look up the function in built_in_decls that corresponds to DECL
3402
   and set ASMSPEC as its user assembler name.  DECL must be a
3403
   function decl that declares a builtin.  */
3404
 
3405
void
3406
set_builtin_user_assembler_name (tree decl, const char *asmspec)
3407
{
3408
  tree builtin;
3409
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL
3410
              && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
3411
              && asmspec != 0);
3412
 
3413
  builtin = built_in_decls [DECL_FUNCTION_CODE (decl)];
3414
  set_user_assembler_name (builtin, asmspec);
3415
  if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMCPY)
3416
    init_block_move_fn (asmspec);
3417
  else if (DECL_FUNCTION_CODE (decl) == BUILT_IN_MEMSET)
3418
    init_block_clear_fn (asmspec);
3419
}
3420
 
3421
/* The number of named compound-literals generated thus far.  */
3422
static GTY(()) int compound_literal_number;
3423
 
3424
/* Set DECL_NAME for DECL, a VAR_DECL for a compound-literal.  */
3425
 
3426
void
3427
set_compound_literal_name (tree decl)
3428
{
3429
  char *name;
3430
  ASM_FORMAT_PRIVATE_NAME (name, "__compound_literal",
3431
                           compound_literal_number);
3432
  compound_literal_number++;
3433
  DECL_NAME (decl) = get_identifier (name);
3434
}
3435
 
3436
tree
3437
build_va_arg (tree expr, tree type)
3438
{
3439
  return build1 (VA_ARG_EXPR, type, expr);
3440
}
3441
 
3442
 
3443
/* Linked list of disabled built-in functions.  */
3444
 
3445
typedef struct disabled_builtin
3446
{
3447
  const char *name;
3448
  struct disabled_builtin *next;
3449
} disabled_builtin;
3450
static disabled_builtin *disabled_builtins = NULL;
3451
 
3452
static bool builtin_function_disabled_p (const char *);
3453
 
3454
/* Disable a built-in function specified by -fno-builtin-NAME.  If NAME
3455
   begins with "__builtin_", give an error.  */
3456
 
3457
void
3458
disable_builtin_function (const char *name)
3459
{
3460
  if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
3461
    error ("cannot disable built-in function %qs", name);
3462
  else
3463
    {
3464
      disabled_builtin *new_disabled_builtin = XNEW (disabled_builtin);
3465
      new_disabled_builtin->name = name;
3466
      new_disabled_builtin->next = disabled_builtins;
3467
      disabled_builtins = new_disabled_builtin;
3468
    }
3469
}
3470
 
3471
 
3472
/* Return true if the built-in function NAME has been disabled, false
3473
   otherwise.  */
3474
 
3475
static bool
3476
builtin_function_disabled_p (const char *name)
3477
{
3478
  disabled_builtin *p;
3479
  for (p = disabled_builtins; p != NULL; p = p->next)
3480
    {
3481
      if (strcmp (name, p->name) == 0)
3482
        return true;
3483
    }
3484
  return false;
3485
}
3486
 
3487
 
3488
/* Worker for DEF_BUILTIN.
3489
   Possibly define a builtin function with one or two names.
3490
   Does not declare a non-__builtin_ function if flag_no_builtin, or if
3491
   nonansi_p and flag_no_nonansi_builtin.  */
3492
 
3493
static void
3494
def_builtin_1 (enum built_in_function fncode,
3495
               const char *name,
3496
               enum built_in_class fnclass,
3497
               tree fntype, tree libtype,
3498
               bool both_p, bool fallback_p, bool nonansi_p,
3499
               tree fnattrs, bool implicit_p)
3500
{
3501
  tree decl;
3502
  const char *libname;
3503
 
3504
  if (fntype == error_mark_node)
3505
    return;
3506
 
3507
  gcc_assert ((!both_p && !fallback_p)
3508
              || !strncmp (name, "__builtin_",
3509
                           strlen ("__builtin_")));
3510
 
3511
  libname = name + strlen ("__builtin_");
3512
  decl = lang_hooks.builtin_function (name, fntype, fncode, fnclass,
3513
                                      (fallback_p ? libname : NULL),
3514
                                      fnattrs);
3515
  if (both_p
3516
      && !flag_no_builtin && !builtin_function_disabled_p (libname)
3517
      && !(nonansi_p && flag_no_nonansi_builtin))
3518
    lang_hooks.builtin_function (libname, libtype, fncode, fnclass,
3519
                                 NULL, fnattrs);
3520
 
3521
  built_in_decls[(int) fncode] = decl;
3522
  if (implicit_p)
3523
    implicit_built_in_decls[(int) fncode] = decl;
3524
}
3525
 
3526
/* Nonzero if the type T promotes to int.  This is (nearly) the
3527
   integral promotions defined in ISO C99 6.3.1.1/2.  */
3528
 
3529
bool
3530
c_promoting_integer_type_p (tree t)
3531
{
3532
  switch (TREE_CODE (t))
3533
    {
3534
    case INTEGER_TYPE:
3535
      return (TYPE_MAIN_VARIANT (t) == char_type_node
3536
              || TYPE_MAIN_VARIANT (t) == signed_char_type_node
3537
              || TYPE_MAIN_VARIANT (t) == unsigned_char_type_node
3538
              || TYPE_MAIN_VARIANT (t) == short_integer_type_node
3539
              || TYPE_MAIN_VARIANT (t) == short_unsigned_type_node
3540
              || TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node));
3541
 
3542
    case ENUMERAL_TYPE:
3543
      /* ??? Technically all enumerations not larger than an int
3544
         promote to an int.  But this is used along code paths
3545
         that only want to notice a size change.  */
3546
      return TYPE_PRECISION (t) < TYPE_PRECISION (integer_type_node);
3547
 
3548
    case BOOLEAN_TYPE:
3549
      return 1;
3550
 
3551
    default:
3552
      return 0;
3553
    }
3554
}
3555
 
3556
/* Return 1 if PARMS specifies a fixed number of parameters
3557
   and none of their types is affected by default promotions.  */
3558
 
3559
int
3560
self_promoting_args_p (tree parms)
3561
{
3562
  tree t;
3563
  for (t = parms; t; t = TREE_CHAIN (t))
3564
    {
3565
      tree type = TREE_VALUE (t);
3566
 
3567
      if (type == error_mark_node)
3568
        continue;
3569
 
3570
      if (TREE_CHAIN (t) == 0 && type != void_type_node)
3571
        return 0;
3572
 
3573
      if (type == 0)
3574
        return 0;
3575
 
3576
      if (TYPE_MAIN_VARIANT (type) == float_type_node)
3577
        return 0;
3578
 
3579
      if (c_promoting_integer_type_p (type))
3580
        return 0;
3581
    }
3582
  return 1;
3583
}
3584
 
3585
/* Recursively examines the array elements of TYPE, until a non-array
3586
   element type is found.  */
3587
 
3588
tree
3589
strip_array_types (tree type)
3590
{
3591
  while (TREE_CODE (type) == ARRAY_TYPE)
3592
    type = TREE_TYPE (type);
3593
 
3594
  return type;
3595
}
3596
 
3597
/* Recursively remove any '*' or '&' operator from TYPE.  */
3598
tree
3599
strip_pointer_operator (tree t)
3600
{
3601
  while (POINTER_TYPE_P (t))
3602
    t = TREE_TYPE (t);
3603
  return t;
3604
}
3605
 
3606
/* Used to compare case labels.  K1 and K2 are actually tree nodes
3607
   representing case labels, or NULL_TREE for a `default' label.
3608
   Returns -1 if K1 is ordered before K2, -1 if K1 is ordered after
3609
   K2, and 0 if K1 and K2 are equal.  */
3610
 
3611
int
3612
case_compare (splay_tree_key k1, splay_tree_key k2)
3613
{
3614
  /* Consider a NULL key (such as arises with a `default' label) to be
3615
     smaller than anything else.  */
3616
  if (!k1)
3617
    return k2 ? -1 : 0;
3618
  else if (!k2)
3619
    return k1 ? 1 : 0;
3620
 
3621
  return tree_int_cst_compare ((tree) k1, (tree) k2);
3622
}
3623
 
3624
/* Process a case label for the range LOW_VALUE ... HIGH_VALUE.  If
3625
   LOW_VALUE and HIGH_VALUE are both NULL_TREE then this case label is
3626
   actually a `default' label.  If only HIGH_VALUE is NULL_TREE, then
3627
   case label was declared using the usual C/C++ syntax, rather than
3628
   the GNU case range extension.  CASES is a tree containing all the
3629
   case ranges processed so far; COND is the condition for the
3630
   switch-statement itself.  Returns the CASE_LABEL_EXPR created, or
3631
   ERROR_MARK_NODE if no CASE_LABEL_EXPR is created.  */
3632
 
3633
tree
3634
c_add_case_label (splay_tree cases, tree cond, tree orig_type,
3635
                  tree low_value, tree high_value)
3636
{
3637
  tree type;
3638
  tree label;
3639
  tree case_label;
3640
  splay_tree_node node;
3641
 
3642
  /* Create the LABEL_DECL itself.  */
3643
  label = create_artificial_label ();
3644
 
3645
  /* If there was an error processing the switch condition, bail now
3646
     before we get more confused.  */
3647
  if (!cond || cond == error_mark_node)
3648
    goto error_out;
3649
 
3650
  if ((low_value && TREE_TYPE (low_value)
3651
       && POINTER_TYPE_P (TREE_TYPE (low_value)))
3652
      || (high_value && TREE_TYPE (high_value)
3653
          && POINTER_TYPE_P (TREE_TYPE (high_value))))
3654
    {
3655
      error ("pointers are not permitted as case values");
3656
      goto error_out;
3657
    }
3658
 
3659
  /* Case ranges are a GNU extension.  */
3660
  if (high_value && pedantic)
3661
    pedwarn ("range expressions in switch statements are non-standard");
3662
 
3663
  type = TREE_TYPE (cond);
3664
  if (low_value)
3665
    {
3666
      low_value = check_case_value (low_value);
3667
      low_value = convert_and_check (type, low_value);
3668
      if (low_value == error_mark_node)
3669
        goto error_out;
3670
    }
3671
  if (high_value)
3672
    {
3673
      high_value = check_case_value (high_value);
3674
      high_value = convert_and_check (type, high_value);
3675
      if (high_value == error_mark_node)
3676
        goto error_out;
3677
    }
3678
 
3679
  if (low_value && high_value)
3680
    {
3681
      /* If the LOW_VALUE and HIGH_VALUE are the same, then this isn't
3682
         really a case range, even though it was written that way.
3683
         Remove the HIGH_VALUE to simplify later processing.  */
3684
      if (tree_int_cst_equal (low_value, high_value))
3685
        high_value = NULL_TREE;
3686
      else if (!tree_int_cst_lt (low_value, high_value))
3687
        warning (0, "empty range specified");
3688
    }
3689
 
3690
  /* See if the case is in range of the type of the original testing
3691
     expression.  If both low_value and high_value are out of range,
3692
     don't insert the case label and return NULL_TREE.  */
3693
  if (low_value
3694
      && !check_case_bounds (type, orig_type,
3695
                             &low_value, high_value ? &high_value : NULL))
3696
    return NULL_TREE;
3697
 
3698
  /* Look up the LOW_VALUE in the table of case labels we already
3699
     have.  */
3700
  node = splay_tree_lookup (cases, (splay_tree_key) low_value);
3701
  /* If there was not an exact match, check for overlapping ranges.
3702
     There's no need to do this if there's no LOW_VALUE or HIGH_VALUE;
3703
     that's a `default' label and the only overlap is an exact match.  */
3704
  if (!node && (low_value || high_value))
3705
    {
3706
      splay_tree_node low_bound;
3707
      splay_tree_node high_bound;
3708
 
3709
      /* Even though there wasn't an exact match, there might be an
3710
         overlap between this case range and another case range.
3711
         Since we've (inductively) not allowed any overlapping case
3712
         ranges, we simply need to find the greatest low case label
3713
         that is smaller that LOW_VALUE, and the smallest low case
3714
         label that is greater than LOW_VALUE.  If there is an overlap
3715
         it will occur in one of these two ranges.  */
3716
      low_bound = splay_tree_predecessor (cases,
3717
                                          (splay_tree_key) low_value);
3718
      high_bound = splay_tree_successor (cases,
3719
                                         (splay_tree_key) low_value);
3720
 
3721
      /* Check to see if the LOW_BOUND overlaps.  It is smaller than
3722
         the LOW_VALUE, so there is no need to check unless the
3723
         LOW_BOUND is in fact itself a case range.  */
3724
      if (low_bound
3725
          && CASE_HIGH ((tree) low_bound->value)
3726
          && tree_int_cst_compare (CASE_HIGH ((tree) low_bound->value),
3727
                                    low_value) >= 0)
3728
        node = low_bound;
3729
      /* Check to see if the HIGH_BOUND overlaps.  The low end of that
3730
         range is bigger than the low end of the current range, so we
3731
         are only interested if the current range is a real range, and
3732
         not an ordinary case label.  */
3733
      else if (high_bound
3734
               && high_value
3735
               && (tree_int_cst_compare ((tree) high_bound->key,
3736
                                         high_value)
3737
                   <= 0))
3738
        node = high_bound;
3739
    }
3740
  /* If there was an overlap, issue an error.  */
3741
  if (node)
3742
    {
3743
      tree duplicate = CASE_LABEL ((tree) node->value);
3744
 
3745
      if (high_value)
3746
        {
3747
          error ("duplicate (or overlapping) case value");
3748
          error ("%Jthis is the first entry overlapping that value", duplicate);
3749
        }
3750
      else if (low_value)
3751
        {
3752
          error ("duplicate case value") ;
3753
          error ("%Jpreviously used here", duplicate);
3754
        }
3755
      else
3756
        {
3757
          error ("multiple default labels in one switch");
3758
          error ("%Jthis is the first default label", duplicate);
3759
        }
3760
      goto error_out;
3761
    }
3762
 
3763
  /* Add a CASE_LABEL to the statement-tree.  */
3764
  case_label = add_stmt (build_case_label (low_value, high_value, label));
3765
  /* Register this case label in the splay tree.  */
3766
  splay_tree_insert (cases,
3767
                     (splay_tree_key) low_value,
3768
                     (splay_tree_value) case_label);
3769
 
3770
  return case_label;
3771
 
3772
 error_out:
3773
  /* Add a label so that the back-end doesn't think that the beginning of
3774
     the switch is unreachable.  Note that we do not add a case label, as
3775
     that just leads to duplicates and thence to failure later on.  */
3776
  if (!cases->root)
3777
    {
3778
      tree t = create_artificial_label ();
3779
      add_stmt (build_stmt (LABEL_EXPR, t));
3780
    }
3781
  return error_mark_node;
3782
}
3783
 
3784
/* Subroutines of c_do_switch_warnings, called via splay_tree_foreach.
3785
   Used to verify that case values match up with enumerator values.  */
3786
 
3787
static void
3788
match_case_to_enum_1 (tree key, tree type, tree label)
3789
{
3790
  char buf[2 + 2*HOST_BITS_PER_WIDE_INT/4 + 1];
3791
 
3792
  /* ??? Not working too hard to print the double-word value.
3793
     Should perhaps be done with %lwd in the diagnostic routines?  */
3794
  if (TREE_INT_CST_HIGH (key) == 0)
3795
    snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_UNSIGNED,
3796
              TREE_INT_CST_LOW (key));
3797
  else if (!TYPE_UNSIGNED (type)
3798
           && TREE_INT_CST_HIGH (key) == -1
3799
           && TREE_INT_CST_LOW (key) != 0)
3800
    snprintf (buf, sizeof (buf), "-" HOST_WIDE_INT_PRINT_UNSIGNED,
3801
              -TREE_INT_CST_LOW (key));
3802
  else
3803
    snprintf (buf, sizeof (buf), HOST_WIDE_INT_PRINT_DOUBLE_HEX,
3804
              TREE_INT_CST_HIGH (key), TREE_INT_CST_LOW (key));
3805
 
3806
  if (TYPE_NAME (type) == 0)
3807
    warning (0, "%Jcase value %qs not in enumerated type",
3808
             CASE_LABEL (label), buf);
3809
  else
3810
    warning (0, "%Jcase value %qs not in enumerated type %qT",
3811
             CASE_LABEL (label), buf, type);
3812
}
3813
 
3814
/* Subroutine of c_do_switch_warnings, called via splay_tree_foreach.
3815
   Used to verify that case values match up with enumerator values.  */
3816
 
3817
static int
3818
match_case_to_enum (splay_tree_node node, void *data)
3819
{
3820
  tree label = (tree) node->value;
3821
  tree type = (tree) data;
3822
 
3823
  /* Skip default case.  */
3824
  if (!CASE_LOW (label))
3825
    return 0;
3826
 
3827
  /* If CASE_LOW_SEEN is not set, that means CASE_LOW did not appear
3828
     when we did our enum->case scan.  Reset our scratch bit after.  */
3829
  if (!CASE_LOW_SEEN (label))
3830
    match_case_to_enum_1 (CASE_LOW (label), type, label);
3831
  else
3832
    CASE_LOW_SEEN (label) = 0;
3833
 
3834
  /* If CASE_HIGH is non-null, we have a range.  If CASE_HIGH_SEEN is
3835
     not set, that means that CASE_HIGH did not appear when we did our
3836
     enum->case scan.  Reset our scratch bit after.  */
3837
  if (CASE_HIGH (label))
3838
    {
3839
      if (!CASE_HIGH_SEEN (label))
3840
        match_case_to_enum_1 (CASE_HIGH (label), type, label);
3841
      else
3842
        CASE_HIGH_SEEN (label) = 0;
3843
    }
3844
 
3845
  return 0;
3846
}
3847
 
3848
/* Handle -Wswitch*.  Called from the front end after parsing the
3849
   switch construct.  */
3850
/* ??? Should probably be somewhere generic, since other languages
3851
   besides C and C++ would want this.  At the moment, however, C/C++
3852
   are the only tree-ssa languages that support enumerations at all,
3853
   so the point is moot.  */
3854
 
3855
void
3856
c_do_switch_warnings (splay_tree cases, location_t switch_location,
3857
                      tree type, tree cond)
3858
{
3859
  splay_tree_node default_node;
3860
  splay_tree_node node;
3861
  tree chain;
3862
 
3863
  if (!warn_switch && !warn_switch_enum && !warn_switch_default)
3864
    return;
3865
 
3866
  default_node = splay_tree_lookup (cases, (splay_tree_key) NULL);
3867
  if (!default_node)
3868
    warning (OPT_Wswitch_default, "%Hswitch missing default case",
3869
             &switch_location);
3870
 
3871
  /* From here on, we only care about about enumerated types.  */
3872
  if (!type || TREE_CODE (type) != ENUMERAL_TYPE)
3873
    return;
3874
 
3875
  /* If the switch expression was an enumerated type, check that
3876
     exactly all enumeration literals are covered by the cases.
3877
     The check is made when -Wswitch was specified and there is no
3878
     default case, or when -Wswitch-enum was specified.  */
3879
 
3880
  if (!warn_switch_enum
3881
      && !(warn_switch && !default_node))
3882
    return;
3883
 
3884
  /* Clearing COND if it is not an integer constant simplifies
3885
     the tests inside the loop below.  */
3886
  if (TREE_CODE (cond) != INTEGER_CST)
3887
    cond = NULL_TREE;
3888
 
3889
  /* The time complexity here is O(N*lg(N)) worst case, but for the
3890
      common case of monotonically increasing enumerators, it is
3891
      O(N), since the nature of the splay tree will keep the next
3892
      element adjacent to the root at all times.  */
3893
 
3894
  for (chain = TYPE_VALUES (type); chain; chain = TREE_CHAIN (chain))
3895
    {
3896
      tree value = TREE_VALUE (chain);
3897
      node = splay_tree_lookup (cases, (splay_tree_key) value);
3898
      if (node)
3899
        {
3900
          /* Mark the CASE_LOW part of the case entry as seen.  */
3901
          tree label = (tree) node->value;
3902
          CASE_LOW_SEEN (label) = 1;
3903
          continue;
3904
        }
3905
 
3906
      /* Even though there wasn't an exact match, there might be a
3907
         case range which includes the enumator's value.  */
3908
      node = splay_tree_predecessor (cases, (splay_tree_key) value);
3909
      if (node && CASE_HIGH ((tree) node->value))
3910
        {
3911
          tree label = (tree) node->value;
3912
          int cmp = tree_int_cst_compare (CASE_HIGH (label), value);
3913
          if (cmp >= 0)
3914
            {
3915
              /* If we match the upper bound exactly, mark the CASE_HIGH
3916
                 part of the case entry as seen.  */
3917
              if (cmp == 0)
3918
                CASE_HIGH_SEEN (label) = 1;
3919
              continue;
3920
            }
3921
        }
3922
 
3923
      /* We've now determined that this enumerated literal isn't
3924
         handled by the case labels of the switch statement.  */
3925
 
3926
      /* If the switch expression is a constant, we only really care
3927
         about whether that constant is handled by the switch.  */
3928
      if (cond && tree_int_cst_compare (cond, value))
3929
        continue;
3930
 
3931
      warning (0, "%Henumeration value %qE not handled in switch",
3932
               &switch_location, TREE_PURPOSE (chain));
3933
    }
3934
 
3935
  /* Warn if there are case expressions that don't correspond to
3936
     enumerators.  This can occur since C and C++ don't enforce
3937
     type-checking of assignments to enumeration variables.
3938
 
3939
     The time complexity here is now always O(N) worst case, since
3940
     we should have marked both the lower bound and upper bound of
3941
     every disjoint case label, with CASE_LOW_SEEN and CASE_HIGH_SEEN
3942
     above.  This scan also resets those fields.  */
3943
  splay_tree_foreach (cases, match_case_to_enum, type);
3944
}
3945
 
3946
/* Finish an expression taking the address of LABEL (an
3947
   IDENTIFIER_NODE).  Returns an expression for the address.  */
3948
 
3949
tree
3950
finish_label_address_expr (tree label)
3951
{
3952
  tree result;
3953
 
3954
  if (pedantic)
3955
    pedwarn ("taking the address of a label is non-standard");
3956
 
3957
  if (label == error_mark_node)
3958
    return error_mark_node;
3959
 
3960
  label = lookup_label (label);
3961
  if (label == NULL_TREE)
3962
    result = null_pointer_node;
3963
  else
3964
    {
3965
      TREE_USED (label) = 1;
3966
      result = build1 (ADDR_EXPR, ptr_type_node, label);
3967
      /* The current function in not necessarily uninlinable.
3968
         Computed gotos are incompatible with inlining, but the value
3969
         here could be used only in a diagnostic, for example.  */
3970
    }
3971
 
3972
  return result;
3973
}
3974
 
3975
/* Hook used by expand_expr to expand language-specific tree codes.  */
3976
/* The only things that should go here are bits needed to expand
3977
   constant initializers.  Everything else should be handled by the
3978
   gimplification routines.  */
3979
 
3980
rtx
3981
c_expand_expr (tree exp, rtx target, enum machine_mode tmode,
3982
               int modifier /* Actually enum_modifier.  */,
3983
               rtx *alt_rtl)
3984
{
3985
  switch (TREE_CODE (exp))
3986
    {
3987
    case COMPOUND_LITERAL_EXPR:
3988
      {
3989
        /* Initialize the anonymous variable declared in the compound
3990
           literal, then return the variable.  */
3991
        tree decl = COMPOUND_LITERAL_EXPR_DECL (exp);
3992
        emit_local_var (decl);
3993
        return expand_expr_real (decl, target, tmode, modifier, alt_rtl);
3994
      }
3995
 
3996
    default:
3997
      gcc_unreachable ();
3998
    }
3999
}
4000
 
4001
/* Hook used by staticp to handle language-specific tree codes.  */
4002
 
4003
tree
4004
c_staticp (tree exp)
4005
{
4006
  return (TREE_CODE (exp) == COMPOUND_LITERAL_EXPR
4007
          && TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (exp))
4008
          ? exp : NULL);
4009
}
4010
 
4011
 
4012
/* Given a boolean expression ARG, return a tree representing an increment
4013
   or decrement (as indicated by CODE) of ARG.  The front end must check for
4014
   invalid cases (e.g., decrement in C++).  */
4015
tree
4016
boolean_increment (enum tree_code code, tree arg)
4017
{
4018
  tree val;
4019
  tree true_res = boolean_true_node;
4020
 
4021
  arg = stabilize_reference (arg);
4022
  switch (code)
4023
    {
4024
    case PREINCREMENT_EXPR:
4025
      val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4026
      break;
4027
    case POSTINCREMENT_EXPR:
4028
      val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg, true_res);
4029
      arg = save_expr (arg);
4030
      val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4031
      val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4032
      break;
4033
    case PREDECREMENT_EXPR:
4034
      val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4035
                    invert_truthvalue (arg));
4036
      break;
4037
    case POSTDECREMENT_EXPR:
4038
      val = build2 (MODIFY_EXPR, TREE_TYPE (arg), arg,
4039
                    invert_truthvalue (arg));
4040
      arg = save_expr (arg);
4041
      val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), val, arg);
4042
      val = build2 (COMPOUND_EXPR, TREE_TYPE (arg), arg, val);
4043
      break;
4044
    default:
4045
      gcc_unreachable ();
4046
    }
4047
  TREE_SIDE_EFFECTS (val) = 1;
4048
  return val;
4049
}
4050
 
4051
/* Built-in macros for stddef.h, that require macros defined in this
4052
   file.  */
4053
void
4054
c_stddef_cpp_builtins(void)
4055
{
4056
  builtin_define_with_value ("__SIZE_TYPE__", SIZE_TYPE, 0);
4057
  builtin_define_with_value ("__PTRDIFF_TYPE__", PTRDIFF_TYPE, 0);
4058
  builtin_define_with_value ("__WCHAR_TYPE__", MODIFIED_WCHAR_TYPE, 0);
4059
  builtin_define_with_value ("__WINT_TYPE__", WINT_TYPE, 0);
4060
  builtin_define_with_value ("__INTMAX_TYPE__", INTMAX_TYPE, 0);
4061
  builtin_define_with_value ("__UINTMAX_TYPE__", UINTMAX_TYPE, 0);
4062
}
4063
 
4064
static void
4065
c_init_attributes (void)
4066
{
4067
  /* Fill in the built_in_attributes array.  */
4068
#define DEF_ATTR_NULL_TREE(ENUM)                                \
4069
  built_in_attributes[(int) ENUM] = NULL_TREE;
4070
#define DEF_ATTR_INT(ENUM, VALUE)                               \
4071
  built_in_attributes[(int) ENUM] = build_int_cst (NULL_TREE, VALUE);
4072
#define DEF_ATTR_IDENT(ENUM, STRING)                            \
4073
  built_in_attributes[(int) ENUM] = get_identifier (STRING);
4074
#define DEF_ATTR_TREE_LIST(ENUM, PURPOSE, VALUE, CHAIN) \
4075
  built_in_attributes[(int) ENUM]                       \
4076
    = tree_cons (built_in_attributes[(int) PURPOSE],    \
4077
                 built_in_attributes[(int) VALUE],      \
4078
                 built_in_attributes[(int) CHAIN]);
4079
#include "builtin-attrs.def"
4080
#undef DEF_ATTR_NULL_TREE
4081
#undef DEF_ATTR_INT
4082
#undef DEF_ATTR_IDENT
4083
#undef DEF_ATTR_TREE_LIST
4084
}
4085
 
4086
/* Attribute handlers common to C front ends.  */
4087
 
4088
/* Handle a "packed" attribute; arguments as in
4089
   struct attribute_spec.handler.  */
4090
 
4091
static tree
4092
handle_packed_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4093
                         int flags, bool *no_add_attrs)
4094
{
4095
  if (TYPE_P (*node))
4096
    {
4097
      if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4098
        *node = build_variant_type_copy (*node);
4099
      TYPE_PACKED (*node) = 1;
4100
    }
4101
  else if (TREE_CODE (*node) == FIELD_DECL)
4102
    {
4103
      if (TYPE_ALIGN (TREE_TYPE (*node)) <= BITS_PER_UNIT)
4104
        warning (OPT_Wattributes,
4105
                 "%qE attribute ignored for field of type %qT",
4106
                 name, TREE_TYPE (*node));
4107
      else
4108
        DECL_PACKED (*node) = 1;
4109
    }
4110
  /* We can't set DECL_PACKED for a VAR_DECL, because the bit is
4111
     used for DECL_REGISTER.  It wouldn't mean anything anyway.
4112
     We can't set DECL_PACKED on the type of a TYPE_DECL, because
4113
     that changes what the typedef is typing.  */
4114
  else
4115
    {
4116
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4117
      *no_add_attrs = true;
4118
    }
4119
 
4120
  return NULL_TREE;
4121
}
4122
 
4123
/* Handle a "nocommon" attribute; arguments as in
4124
   struct attribute_spec.handler.  */
4125
 
4126
static tree
4127
handle_nocommon_attribute (tree *node, tree name,
4128
                           tree ARG_UNUSED (args),
4129
                           int ARG_UNUSED (flags), bool *no_add_attrs)
4130
{
4131
  if (TREE_CODE (*node) == VAR_DECL)
4132
    DECL_COMMON (*node) = 0;
4133
  else
4134
    {
4135
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4136
      *no_add_attrs = true;
4137
    }
4138
 
4139
  return NULL_TREE;
4140
}
4141
 
4142
/* Handle a "common" attribute; arguments as in
4143
   struct attribute_spec.handler.  */
4144
 
4145
static tree
4146
handle_common_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4147
                         int ARG_UNUSED (flags), bool *no_add_attrs)
4148
{
4149
  if (TREE_CODE (*node) == VAR_DECL)
4150
    DECL_COMMON (*node) = 1;
4151
  else
4152
    {
4153
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4154
      *no_add_attrs = true;
4155
    }
4156
 
4157
  return NULL_TREE;
4158
}
4159
 
4160
/* Handle a "noreturn" attribute; arguments as in
4161
   struct attribute_spec.handler.  */
4162
 
4163
static tree
4164
handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4165
                           int ARG_UNUSED (flags), bool *no_add_attrs)
4166
{
4167
  tree type = TREE_TYPE (*node);
4168
 
4169
  /* See FIXME comment in c_common_attribute_table.  */
4170
  if (TREE_CODE (*node) == FUNCTION_DECL)
4171
    TREE_THIS_VOLATILE (*node) = 1;
4172
  else if (TREE_CODE (type) == POINTER_TYPE
4173
           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4174
    TREE_TYPE (*node)
4175
      = build_pointer_type
4176
        (build_type_variant (TREE_TYPE (type),
4177
                             TYPE_READONLY (TREE_TYPE (type)), 1));
4178
  else
4179
    {
4180
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4181
      *no_add_attrs = true;
4182
    }
4183
 
4184
  return NULL_TREE;
4185
}
4186
 
4187
/* Handle a "noinline" attribute; arguments as in
4188
   struct attribute_spec.handler.  */
4189
 
4190
static tree
4191
handle_noinline_attribute (tree *node, tree name,
4192
                           tree ARG_UNUSED (args),
4193
                           int ARG_UNUSED (flags), bool *no_add_attrs)
4194
{
4195
  if (TREE_CODE (*node) == FUNCTION_DECL)
4196
    DECL_UNINLINABLE (*node) = 1;
4197
  else
4198
    {
4199
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4200
      *no_add_attrs = true;
4201
    }
4202
 
4203
  return NULL_TREE;
4204
}
4205
 
4206
/* Handle a "always_inline" attribute; arguments as in
4207
   struct attribute_spec.handler.  */
4208
 
4209
static tree
4210
handle_always_inline_attribute (tree *node, tree name,
4211
                                tree ARG_UNUSED (args),
4212
                                int ARG_UNUSED (flags),
4213
                                bool *no_add_attrs)
4214
{
4215
  if (TREE_CODE (*node) == FUNCTION_DECL)
4216
    {
4217
      /* Do nothing else, just set the attribute.  We'll get at
4218
         it later with lookup_attribute.  */
4219
    }
4220
  else
4221
    {
4222
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4223
      *no_add_attrs = true;
4224
    }
4225
 
4226
  return NULL_TREE;
4227
}
4228
 
4229
/* Handle a "gnu_inline" attribute; arguments as in
4230
   struct attribute_spec.handler.  */
4231
 
4232
static tree
4233
handle_gnu_inline_attribute (tree *node, tree name,
4234
                             tree ARG_UNUSED (args),
4235
                             int ARG_UNUSED (flags),
4236
                             bool *no_add_attrs)
4237
{
4238
  if (TREE_CODE (*node) == FUNCTION_DECL && DECL_DECLARED_INLINE_P (*node))
4239
    {
4240
      /* Do nothing else, just set the attribute.  We'll get at
4241
         it later with lookup_attribute.  */
4242
    }
4243
  else
4244
    {
4245
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4246
      *no_add_attrs = true;
4247
    }
4248
 
4249
  return NULL_TREE;
4250
}
4251
 
4252
/* Handle a "flatten" attribute; arguments as in
4253
   struct attribute_spec.handler.  */
4254
 
4255
static tree
4256
handle_flatten_attribute (tree *node, tree name,
4257
                          tree args ATTRIBUTE_UNUSED,
4258
                          int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
4259
{
4260
  if (TREE_CODE (*node) == FUNCTION_DECL)
4261
    /* Do nothing else, just set the attribute.  We'll get at
4262
       it later with lookup_attribute.  */
4263
    ;
4264
  else
4265
    {
4266
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4267
      *no_add_attrs = true;
4268
    }
4269
 
4270
  return NULL_TREE;
4271
}
4272
 
4273
 
4274
/* Handle a "used" attribute; arguments as in
4275
   struct attribute_spec.handler.  */
4276
 
4277
static tree
4278
handle_used_attribute (tree *pnode, tree name, tree ARG_UNUSED (args),
4279
                       int ARG_UNUSED (flags), bool *no_add_attrs)
4280
{
4281
  tree node = *pnode;
4282
 
4283
  if (TREE_CODE (node) == FUNCTION_DECL
4284
      || (TREE_CODE (node) == VAR_DECL && TREE_STATIC (node)))
4285
    {
4286
      TREE_USED (node) = 1;
4287
      DECL_PRESERVE_P (node) = 1;
4288
    }
4289
  else
4290
    {
4291
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4292
      *no_add_attrs = true;
4293
    }
4294
 
4295
  return NULL_TREE;
4296
}
4297
 
4298
/* Handle a "unused" attribute; arguments as in
4299
   struct attribute_spec.handler.  */
4300
 
4301
static tree
4302
handle_unused_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4303
                         int flags, bool *no_add_attrs)
4304
{
4305
  if (DECL_P (*node))
4306
    {
4307
      tree decl = *node;
4308
 
4309
      if (TREE_CODE (decl) == PARM_DECL
4310
          || TREE_CODE (decl) == VAR_DECL
4311
          || TREE_CODE (decl) == FUNCTION_DECL
4312
          || TREE_CODE (decl) == LABEL_DECL
4313
          || TREE_CODE (decl) == TYPE_DECL)
4314
        TREE_USED (decl) = 1;
4315
      else
4316
        {
4317
          warning (OPT_Wattributes, "%qE attribute ignored", name);
4318
          *no_add_attrs = true;
4319
        }
4320
    }
4321
  else
4322
    {
4323
      if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4324
        *node = build_variant_type_copy (*node);
4325
      TREE_USED (*node) = 1;
4326
    }
4327
 
4328
  return NULL_TREE;
4329
}
4330
 
4331
/* Handle a "externally_visible" attribute; arguments as in
4332
   struct attribute_spec.handler.  */
4333
 
4334
static tree
4335
handle_externally_visible_attribute (tree *pnode, tree name,
4336
                                     tree ARG_UNUSED (args),
4337
                                     int ARG_UNUSED (flags),
4338
                                     bool *no_add_attrs)
4339
{
4340
  tree node = *pnode;
4341
 
4342
  if (TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
4343
    {
4344
      if ((!TREE_STATIC (node) && TREE_CODE (node) != FUNCTION_DECL
4345
           && !DECL_EXTERNAL (node)) || !TREE_PUBLIC (node))
4346
        {
4347
          warning (OPT_Wattributes,
4348
                   "%qE attribute have effect only on public objects", name);
4349
          *no_add_attrs = true;
4350
        }
4351
    }
4352
  else
4353
    {
4354
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4355
      *no_add_attrs = true;
4356
    }
4357
 
4358
  return NULL_TREE;
4359
}
4360
 
4361
/* Handle a "const" attribute; arguments as in
4362
   struct attribute_spec.handler.  */
4363
 
4364
static tree
4365
handle_const_attribute (tree *node, tree name, tree ARG_UNUSED (args),
4366
                        int ARG_UNUSED (flags), bool *no_add_attrs)
4367
{
4368
  tree type = TREE_TYPE (*node);
4369
 
4370
  /* See FIXME comment on noreturn in c_common_attribute_table.  */
4371
  if (TREE_CODE (*node) == FUNCTION_DECL)
4372
    TREE_READONLY (*node) = 1;
4373
  else if (TREE_CODE (type) == POINTER_TYPE
4374
           && TREE_CODE (TREE_TYPE (type)) == FUNCTION_TYPE)
4375
    TREE_TYPE (*node)
4376
      = build_pointer_type
4377
        (build_type_variant (TREE_TYPE (type), 1,
4378
                             TREE_THIS_VOLATILE (TREE_TYPE (type))));
4379
  else
4380
    {
4381
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4382
      *no_add_attrs = true;
4383
    }
4384
 
4385
  return NULL_TREE;
4386
}
4387
 
4388
/* Handle a "transparent_union" attribute; arguments as in
4389
   struct attribute_spec.handler.  */
4390
 
4391
static tree
4392
handle_transparent_union_attribute (tree *node, tree name,
4393
                                    tree ARG_UNUSED (args), int flags,
4394
                                    bool *no_add_attrs)
4395
{
4396
  tree type = NULL;
4397
 
4398
  *no_add_attrs = true;
4399
 
4400
  if (DECL_P (*node))
4401
    {
4402
      if (TREE_CODE (*node) != TYPE_DECL)
4403
        goto ignored;
4404
      node = &TREE_TYPE (*node);
4405
      type = *node;
4406
    }
4407
  else if (TYPE_P (*node))
4408
    type = *node;
4409
  else
4410
    goto ignored;
4411
 
4412
  if (TREE_CODE (type) == UNION_TYPE)
4413
    {
4414
      /* When IN_PLACE is set, leave the check for FIELDS and MODE to
4415
         the code in finish_struct.  */
4416
      if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4417
        {
4418
          if (TYPE_FIELDS (type) == NULL_TREE
4419
              || TYPE_MODE (type) != DECL_MODE (TYPE_FIELDS (type)))
4420
            goto ignored;
4421
 
4422
          /* A type variant isn't good enough, since we don't a cast
4423
             to such a type removed as a no-op.  */
4424
          *node = type = build_duplicate_type (type);
4425
        }
4426
 
4427
      TYPE_TRANSPARENT_UNION (type) = 1;
4428
      return NULL_TREE;
4429
    }
4430
 
4431
 ignored:
4432
  warning (OPT_Wattributes, "%qE attribute ignored", name);
4433
  return NULL_TREE;
4434
}
4435
 
4436
/* Handle a "constructor" attribute; arguments as in
4437
   struct attribute_spec.handler.  */
4438
 
4439
static tree
4440
handle_constructor_attribute (tree *node, tree name,
4441
                              tree ARG_UNUSED (args),
4442
                              int ARG_UNUSED (flags),
4443
                              bool *no_add_attrs)
4444
{
4445
  tree decl = *node;
4446
  tree type = TREE_TYPE (decl);
4447
 
4448
  if (TREE_CODE (decl) == FUNCTION_DECL
4449
      && TREE_CODE (type) == FUNCTION_TYPE
4450
      && decl_function_context (decl) == 0)
4451
    {
4452
      DECL_STATIC_CONSTRUCTOR (decl) = 1;
4453
      TREE_USED (decl) = 1;
4454
    }
4455
  else
4456
    {
4457
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4458
      *no_add_attrs = true;
4459
    }
4460
 
4461
  return NULL_TREE;
4462
}
4463
 
4464
/* Handle a "destructor" attribute; arguments as in
4465
   struct attribute_spec.handler.  */
4466
 
4467
static tree
4468
handle_destructor_attribute (tree *node, tree name,
4469
                             tree ARG_UNUSED (args),
4470
                             int ARG_UNUSED (flags),
4471
                             bool *no_add_attrs)
4472
{
4473
  tree decl = *node;
4474
  tree type = TREE_TYPE (decl);
4475
 
4476
  if (TREE_CODE (decl) == FUNCTION_DECL
4477
      && TREE_CODE (type) == FUNCTION_TYPE
4478
      && decl_function_context (decl) == 0)
4479
    {
4480
      DECL_STATIC_DESTRUCTOR (decl) = 1;
4481
      TREE_USED (decl) = 1;
4482
    }
4483
  else
4484
    {
4485
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4486
      *no_add_attrs = true;
4487
    }
4488
 
4489
  return NULL_TREE;
4490
}
4491
 
4492
/* Handle a "mode" attribute; arguments as in
4493
   struct attribute_spec.handler.  */
4494
 
4495
static tree
4496
handle_mode_attribute (tree *node, tree name, tree args,
4497
                       int ARG_UNUSED (flags), bool *no_add_attrs)
4498
{
4499
  tree type = *node;
4500
 
4501
  *no_add_attrs = true;
4502
 
4503
  if (TREE_CODE (TREE_VALUE (args)) != IDENTIFIER_NODE)
4504
    warning (OPT_Wattributes, "%qE attribute ignored", name);
4505
  else
4506
    {
4507
      int j;
4508
      const char *p = IDENTIFIER_POINTER (TREE_VALUE (args));
4509
      int len = strlen (p);
4510
      enum machine_mode mode = VOIDmode;
4511
      tree typefm;
4512
      bool valid_mode;
4513
 
4514
      if (len > 4 && p[0] == '_' && p[1] == '_'
4515
          && p[len - 1] == '_' && p[len - 2] == '_')
4516
        {
4517
          char *newp = (char *) alloca (len - 1);
4518
 
4519
          strcpy (newp, &p[2]);
4520
          newp[len - 4] = '\0';
4521
          p = newp;
4522
        }
4523
 
4524
      /* Change this type to have a type with the specified mode.
4525
         First check for the special modes.  */
4526
      if (!strcmp (p, "byte"))
4527
        mode = byte_mode;
4528
      else if (!strcmp (p, "word"))
4529
        mode = word_mode;
4530
      else if (!strcmp (p, "pointer"))
4531
        mode = ptr_mode;
4532
      else
4533
        for (j = 0; j < NUM_MACHINE_MODES; j++)
4534
          if (!strcmp (p, GET_MODE_NAME (j)))
4535
            {
4536
              mode = (enum machine_mode) j;
4537
              break;
4538
            }
4539
 
4540
      if (mode == VOIDmode)
4541
        {
4542
          error ("unknown machine mode %qs", p);
4543
          return NULL_TREE;
4544
        }
4545
 
4546
      valid_mode = false;
4547
      switch (GET_MODE_CLASS (mode))
4548
        {
4549
        case MODE_INT:
4550
        case MODE_PARTIAL_INT:
4551
        case MODE_FLOAT:
4552
        case MODE_DECIMAL_FLOAT:
4553
          valid_mode = targetm.scalar_mode_supported_p (mode);
4554
          break;
4555
 
4556
        case MODE_COMPLEX_INT:
4557
        case MODE_COMPLEX_FLOAT:
4558
          valid_mode = targetm.scalar_mode_supported_p (GET_MODE_INNER (mode));
4559
          break;
4560
 
4561
        case MODE_VECTOR_INT:
4562
        case MODE_VECTOR_FLOAT:
4563
          warning (OPT_Wattributes, "specifying vector types with "
4564
                   "__attribute__ ((mode)) is deprecated");
4565
          warning (OPT_Wattributes,
4566
                   "use __attribute__ ((vector_size)) instead");
4567
          valid_mode = vector_mode_valid_p (mode);
4568
          break;
4569
 
4570
        default:
4571
          break;
4572
        }
4573
      if (!valid_mode)
4574
        {
4575
          error ("unable to emulate %qs", p);
4576
          return NULL_TREE;
4577
        }
4578
 
4579
      if (POINTER_TYPE_P (type))
4580
        {
4581
          tree (*fn)(tree, enum machine_mode, bool);
4582
 
4583
          if (!targetm.valid_pointer_mode (mode))
4584
            {
4585
              error ("invalid pointer mode %qs", p);
4586
              return NULL_TREE;
4587
            }
4588
 
4589
          if (TREE_CODE (type) == POINTER_TYPE)
4590
            fn = build_pointer_type_for_mode;
4591
          else
4592
            fn = build_reference_type_for_mode;
4593
          typefm = fn (TREE_TYPE (type), mode, false);
4594
        }
4595
      else
4596
        typefm = lang_hooks.types.type_for_mode (mode, TYPE_UNSIGNED (type));
4597
 
4598
      if (typefm == NULL_TREE)
4599
        {
4600
          error ("no data type for mode %qs", p);
4601
          return NULL_TREE;
4602
        }
4603
      else if (TREE_CODE (type) == ENUMERAL_TYPE)
4604
        {
4605
          /* For enumeral types, copy the precision from the integer
4606
             type returned above.  If not an INTEGER_TYPE, we can't use
4607
             this mode for this type.  */
4608
          if (TREE_CODE (typefm) != INTEGER_TYPE)
4609
            {
4610
              error ("cannot use mode %qs for enumeral types", p);
4611
              return NULL_TREE;
4612
            }
4613
 
4614
          if (flags & ATTR_FLAG_TYPE_IN_PLACE)
4615
            {
4616
              TYPE_PRECISION (type) = TYPE_PRECISION (typefm);
4617
              typefm = type;
4618
            }
4619
          else
4620
            {
4621
              /* We cannot build a type variant, as there's code that assumes
4622
                 that TYPE_MAIN_VARIANT has the same mode.  This includes the
4623
                 debug generators.  Instead, create a subrange type.  This
4624
                 results in all of the enumeral values being emitted only once
4625
                 in the original, and the subtype gets them by reference.  */
4626
              if (TYPE_UNSIGNED (type))
4627
                typefm = make_unsigned_type (TYPE_PRECISION (typefm));
4628
              else
4629
                typefm = make_signed_type (TYPE_PRECISION (typefm));
4630
              TREE_TYPE (typefm) = type;
4631
            }
4632
        }
4633
      else if (VECTOR_MODE_P (mode)
4634
               ? TREE_CODE (type) != TREE_CODE (TREE_TYPE (typefm))
4635
               : TREE_CODE (type) != TREE_CODE (typefm))
4636
        {
4637
          error ("mode %qs applied to inappropriate type", p);
4638
          return NULL_TREE;
4639
        }
4640
 
4641
      *node = typefm;
4642
    }
4643
 
4644
  return NULL_TREE;
4645
}
4646
 
4647
/* Handle a "section" attribute; arguments as in
4648
   struct attribute_spec.handler.  */
4649
 
4650
static tree
4651
handle_section_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4652
                          int ARG_UNUSED (flags), bool *no_add_attrs)
4653
{
4654
  tree decl = *node;
4655
 
4656
  if (targetm.have_named_sections)
4657
    {
4658
      user_defined_section_attribute = true;
4659
 
4660
      if ((TREE_CODE (decl) == FUNCTION_DECL
4661
           || TREE_CODE (decl) == VAR_DECL)
4662
          && TREE_CODE (TREE_VALUE (args)) == STRING_CST)
4663
        {
4664
          if (TREE_CODE (decl) == VAR_DECL
4665
              && current_function_decl != NULL_TREE
4666
              && !TREE_STATIC (decl))
4667
            {
4668
              error ("%Jsection attribute cannot be specified for "
4669
                     "local variables", decl);
4670
              *no_add_attrs = true;
4671
            }
4672
 
4673
          /* The decl may have already been given a section attribute
4674
             from a previous declaration.  Ensure they match.  */
4675
          else if (DECL_SECTION_NAME (decl) != NULL_TREE
4676
                   && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
4677
                              TREE_STRING_POINTER (TREE_VALUE (args))) != 0)
4678
            {
4679
              error ("section of %q+D conflicts with previous declaration",
4680
                     *node);
4681
              *no_add_attrs = true;
4682
            }
4683
          else
4684
            DECL_SECTION_NAME (decl) = TREE_VALUE (args);
4685
        }
4686
      else
4687
        {
4688
          error ("section attribute not allowed for %q+D", *node);
4689
          *no_add_attrs = true;
4690
        }
4691
    }
4692
  else
4693
    {
4694
      error ("%Jsection attributes are not supported for this target", *node);
4695
      *no_add_attrs = true;
4696
    }
4697
 
4698
  return NULL_TREE;
4699
}
4700
 
4701
/* Handle a "aligned" attribute; arguments as in
4702
   struct attribute_spec.handler.  */
4703
 
4704
static tree
4705
handle_aligned_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4706
                          int flags, bool *no_add_attrs)
4707
{
4708
  tree decl = NULL_TREE;
4709
  tree *type = NULL;
4710
  int is_type = 0;
4711
  tree align_expr = (args ? TREE_VALUE (args)
4712
                     : size_int (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
4713
  int i;
4714
 
4715
  if (DECL_P (*node))
4716
    {
4717
      decl = *node;
4718
      type = &TREE_TYPE (decl);
4719
      is_type = TREE_CODE (*node) == TYPE_DECL;
4720
    }
4721
  else if (TYPE_P (*node))
4722
    type = node, is_type = 1;
4723
 
4724
  if (TREE_CODE (align_expr) != INTEGER_CST)
4725
    {
4726
      error ("requested alignment is not a constant");
4727
      *no_add_attrs = true;
4728
    }
4729
  else if ((i = tree_log2 (align_expr)) == -1)
4730
    {
4731
      error ("requested alignment is not a power of 2");
4732
      *no_add_attrs = true;
4733
    }
4734
  else if (i > HOST_BITS_PER_INT - 2)
4735
    {
4736
      error ("requested alignment is too large");
4737
      *no_add_attrs = true;
4738
    }
4739
  else if (is_type)
4740
    {
4741
      /* If we have a TYPE_DECL, then copy the type, so that we
4742
         don't accidentally modify a builtin type.  See pushdecl.  */
4743
      if (decl && TREE_TYPE (decl) != error_mark_node
4744
          && DECL_ORIGINAL_TYPE (decl) == NULL_TREE)
4745
        {
4746
          tree tt = TREE_TYPE (decl);
4747
          *type = build_variant_type_copy (*type);
4748
          DECL_ORIGINAL_TYPE (decl) = tt;
4749
          TYPE_NAME (*type) = decl;
4750
          TREE_USED (*type) = TREE_USED (decl);
4751
          TREE_TYPE (decl) = *type;
4752
        }
4753
      else if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
4754
        *type = build_variant_type_copy (*type);
4755
 
4756
      TYPE_ALIGN (*type) = (1 << i) * BITS_PER_UNIT;
4757
      TYPE_USER_ALIGN (*type) = 1;
4758
    }
4759
  else if (TREE_CODE (decl) != VAR_DECL
4760
           && TREE_CODE (decl) != FIELD_DECL)
4761
    {
4762
      error ("alignment may not be specified for %q+D", decl);
4763
      *no_add_attrs = true;
4764
    }
4765
  else
4766
    {
4767
      DECL_ALIGN (decl) = (1 << i) * BITS_PER_UNIT;
4768
      DECL_USER_ALIGN (decl) = 1;
4769
    }
4770
 
4771
  return NULL_TREE;
4772
}
4773
 
4774
/* Handle a "weak" attribute; arguments as in
4775
   struct attribute_spec.handler.  */
4776
 
4777
static tree
4778
handle_weak_attribute (tree *node, tree name,
4779
                       tree ARG_UNUSED (args),
4780
                       int ARG_UNUSED (flags),
4781
                       bool * ARG_UNUSED (no_add_attrs))
4782
{
4783
  if (TREE_CODE (*node) == FUNCTION_DECL
4784
      || TREE_CODE (*node) == VAR_DECL)
4785
    declare_weak (*node);
4786
  else
4787
    warning (OPT_Wattributes, "%qE attribute ignored", name);
4788
 
4789
 
4790
  return NULL_TREE;
4791
}
4792
 
4793
/* Handle an "alias" attribute; arguments as in
4794
   struct attribute_spec.handler.  */
4795
 
4796
static tree
4797
handle_alias_attribute (tree *node, tree name, tree args,
4798
                        int ARG_UNUSED (flags), bool *no_add_attrs)
4799
{
4800
  tree decl = *node;
4801
 
4802
  if ((TREE_CODE (decl) == FUNCTION_DECL && DECL_INITIAL (decl))
4803
      || (TREE_CODE (decl) != FUNCTION_DECL
4804
          && TREE_PUBLIC (decl) && !DECL_EXTERNAL (decl))
4805
      /* A static variable declaration is always a tentative definition,
4806
         but the alias is a non-tentative definition which overrides.  */
4807
      || (TREE_CODE (decl) != FUNCTION_DECL
4808
          && ! TREE_PUBLIC (decl) && DECL_INITIAL (decl)))
4809
    {
4810
      error ("%q+D defined both normally and as an alias", decl);
4811
      *no_add_attrs = true;
4812
    }
4813
 
4814
  /* Note that the very first time we process a nested declaration,
4815
     decl_function_context will not be set.  Indeed, *would* never
4816
     be set except for the DECL_INITIAL/DECL_EXTERNAL frobbery that
4817
     we do below.  After such frobbery, pushdecl would set the context.
4818
     In any case, this is never what we want.  */
4819
  else if (decl_function_context (decl) == 0 && current_function_decl == NULL)
4820
    {
4821
      tree id;
4822
 
4823
      id = TREE_VALUE (args);
4824
      if (TREE_CODE (id) != STRING_CST)
4825
        {
4826
          error ("alias argument not a string");
4827
          *no_add_attrs = true;
4828
          return NULL_TREE;
4829
        }
4830
      id = get_identifier (TREE_STRING_POINTER (id));
4831
      /* This counts as a use of the object pointed to.  */
4832
      TREE_USED (id) = 1;
4833
 
4834
      if (TREE_CODE (decl) == FUNCTION_DECL)
4835
        DECL_INITIAL (decl) = error_mark_node;
4836
      else
4837
        {
4838
          if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
4839
            DECL_EXTERNAL (decl) = 1;
4840
          else
4841
            DECL_EXTERNAL (decl) = 0;
4842
          TREE_STATIC (decl) = 1;
4843
        }
4844
    }
4845
  else
4846
    {
4847
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4848
      *no_add_attrs = true;
4849
    }
4850
 
4851
  return NULL_TREE;
4852
}
4853
 
4854
/* Handle a "weakref" attribute; arguments as in struct
4855
   attribute_spec.handler.  */
4856
 
4857
static tree
4858
handle_weakref_attribute (tree *node, tree ARG_UNUSED (name), tree args,
4859
                          int flags, bool *no_add_attrs)
4860
{
4861
  tree attr = NULL_TREE;
4862
 
4863
  /* We must ignore the attribute when it is associated with
4864
     local-scoped decls, since attribute alias is ignored and many
4865
     such symbols do not even have a DECL_WEAK field.  */
4866
  if (decl_function_context (*node) || current_function_decl)
4867
    {
4868
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4869
      *no_add_attrs = true;
4870
      return NULL_TREE;
4871
    }
4872
 
4873
  /* The idea here is that `weakref("name")' mutates into `weakref,
4874
     alias("name")', and weakref without arguments, in turn,
4875
     implicitly adds weak. */
4876
 
4877
  if (args)
4878
    {
4879
      attr = tree_cons (get_identifier ("alias"), args, attr);
4880
      attr = tree_cons (get_identifier ("weakref"), NULL_TREE, attr);
4881
 
4882
      *no_add_attrs = true;
4883
 
4884
      decl_attributes (node, attr, flags);
4885
    }
4886
  else
4887
    {
4888
      if (lookup_attribute ("alias", DECL_ATTRIBUTES (*node)))
4889
        error ("%Jweakref attribute must appear before alias attribute",
4890
               *node);
4891
 
4892
      /* Can't call declare_weak because it wants this to be TREE_PUBLIC,
4893
         and that isn't supported; and because it wants to add it to
4894
         the list of weak decls, which isn't helpful.  */
4895
      DECL_WEAK (*node) = 1;
4896
    }
4897
 
4898
  return NULL_TREE;
4899
}
4900
 
4901
/* Handle an "visibility" attribute; arguments as in
4902
   struct attribute_spec.handler.  */
4903
 
4904
static tree
4905
handle_visibility_attribute (tree *node, tree name, tree args,
4906
                             int ARG_UNUSED (flags),
4907
                             bool *ARG_UNUSED (no_add_attrs))
4908
{
4909
  tree decl = *node;
4910
  tree id = TREE_VALUE (args);
4911
  enum symbol_visibility vis;
4912
 
4913
  if (TYPE_P (*node))
4914
    {
4915
      if (TREE_CODE (*node) == ENUMERAL_TYPE)
4916
        /* OK */;
4917
      else if (TREE_CODE (*node) != RECORD_TYPE && TREE_CODE (*node) != UNION_TYPE)
4918
        {
4919
          warning (OPT_Wattributes, "%qE attribute ignored on non-class types",
4920
                   name);
4921
          return NULL_TREE;
4922
        }
4923
      else if (TYPE_FIELDS (*node))
4924
        {
4925
          error ("%qE attribute ignored because %qT is already defined",
4926
                 name, *node);
4927
          return NULL_TREE;
4928
        }
4929
    }
4930
  else if (decl_function_context (decl) != 0 || !TREE_PUBLIC (decl))
4931
    {
4932
      warning (OPT_Wattributes, "%qE attribute ignored", name);
4933
      return NULL_TREE;
4934
    }
4935
 
4936
  if (TREE_CODE (id) != STRING_CST)
4937
    {
4938
      error ("visibility argument not a string");
4939
      return NULL_TREE;
4940
    }
4941
 
4942
  /*  If this is a type, set the visibility on the type decl.  */
4943
  if (TYPE_P (decl))
4944
    {
4945
      decl = TYPE_NAME (decl);
4946
      if (!decl)
4947
        return NULL_TREE;
4948
      if (TREE_CODE (decl) == IDENTIFIER_NODE)
4949
        {
4950
           warning (OPT_Wattributes, "%qE attribute ignored on types",
4951
                    name);
4952
           return NULL_TREE;
4953
        }
4954
    }
4955
 
4956
  if (strcmp (TREE_STRING_POINTER (id), "default") == 0)
4957
    vis = VISIBILITY_DEFAULT;
4958
  else if (strcmp (TREE_STRING_POINTER (id), "internal") == 0)
4959
    vis = VISIBILITY_INTERNAL;
4960
  else if (strcmp (TREE_STRING_POINTER (id), "hidden") == 0)
4961
    vis = VISIBILITY_HIDDEN;
4962
  else if (strcmp (TREE_STRING_POINTER (id), "protected") == 0)
4963
    vis = VISIBILITY_PROTECTED;
4964
  else
4965
    {
4966
      error ("visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"");
4967
      vis = VISIBILITY_DEFAULT;
4968
    }
4969
 
4970
  if (DECL_VISIBILITY_SPECIFIED (decl)
4971
      && vis != DECL_VISIBILITY (decl)
4972
      && lookup_attribute ("visibility", (TYPE_P (*node)
4973
                                          ? TYPE_ATTRIBUTES (*node)
4974
                                          : DECL_ATTRIBUTES (decl))))
4975
    error ("%qD redeclared with different visibility", decl);
4976
 
4977
  DECL_VISIBILITY (decl) = vis;
4978
  DECL_VISIBILITY_SPECIFIED (decl) = 1;
4979
 
4980
  /* Go ahead and attach the attribute to the node as well.  This is needed
4981
     so we can determine whether we have VISIBILITY_DEFAULT because the
4982
     visibility was not specified, or because it was explicitly overridden
4983
     from the containing scope.  */
4984
 
4985
  return NULL_TREE;
4986
}
4987
 
4988
/* Determine the ELF symbol visibility for DECL, which is either a
4989
   variable or a function.  It is an error to use this function if a
4990
   definition of DECL is not available in this translation unit.
4991
   Returns true if the final visibility has been determined by this
4992
   function; false if the caller is free to make additional
4993
   modifications.  */
4994
 
4995
bool
4996
c_determine_visibility (tree decl)
4997
{
4998
  gcc_assert (TREE_CODE (decl) == VAR_DECL
4999
              || TREE_CODE (decl) == FUNCTION_DECL);
5000
 
5001
  /* If the user explicitly specified the visibility with an
5002
     attribute, honor that.  DECL_VISIBILITY will have been set during
5003
     the processing of the attribute.  We check for an explicit
5004
     attribute, rather than just checking DECL_VISIBILITY_SPECIFIED,
5005
     to distinguish the use of an attribute from the use of a "#pragma
5006
     GCC visibility push(...)"; in the latter case we still want other
5007
     considerations to be able to overrule the #pragma.  */
5008
  if (lookup_attribute ("visibility", DECL_ATTRIBUTES (decl)))
5009
    return true;
5010
 
5011
  /* Anything that is exported must have default visibility.  */
5012
  if (TARGET_DLLIMPORT_DECL_ATTRIBUTES
5013
      && lookup_attribute ("dllexport", DECL_ATTRIBUTES (decl)))
5014
    {
5015
      DECL_VISIBILITY (decl) = VISIBILITY_DEFAULT;
5016
      DECL_VISIBILITY_SPECIFIED (decl) = 1;
5017
      return true;
5018
    }
5019
 
5020
  /* Set default visibility to whatever the user supplied with
5021
     visibility_specified depending on #pragma GCC visibility.  */
5022
  if (!DECL_VISIBILITY_SPECIFIED (decl))
5023
    {
5024
      DECL_VISIBILITY (decl) = default_visibility;
5025
      DECL_VISIBILITY_SPECIFIED (decl) = visibility_options.inpragma;
5026
    }
5027
  return false;
5028
}
5029
 
5030
/* Handle an "tls_model" attribute; arguments as in
5031
   struct attribute_spec.handler.  */
5032
 
5033
static tree
5034
handle_tls_model_attribute (tree *node, tree name, tree args,
5035
                            int ARG_UNUSED (flags), bool *no_add_attrs)
5036
{
5037
  tree id;
5038
  tree decl = *node;
5039
  enum tls_model kind;
5040
 
5041
  *no_add_attrs = true;
5042
 
5043
  if (!DECL_THREAD_LOCAL_P (decl))
5044
    {
5045
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5046
      return NULL_TREE;
5047
    }
5048
 
5049
  kind = DECL_TLS_MODEL (decl);
5050
  id = TREE_VALUE (args);
5051
  if (TREE_CODE (id) != STRING_CST)
5052
    {
5053
      error ("tls_model argument not a string");
5054
      return NULL_TREE;
5055
    }
5056
 
5057
  if (!strcmp (TREE_STRING_POINTER (id), "local-exec"))
5058
    kind = TLS_MODEL_LOCAL_EXEC;
5059
  else if (!strcmp (TREE_STRING_POINTER (id), "initial-exec"))
5060
    kind = TLS_MODEL_INITIAL_EXEC;
5061
  else if (!strcmp (TREE_STRING_POINTER (id), "local-dynamic"))
5062
    kind = optimize ? TLS_MODEL_LOCAL_DYNAMIC : TLS_MODEL_GLOBAL_DYNAMIC;
5063
  else if (!strcmp (TREE_STRING_POINTER (id), "global-dynamic"))
5064
    kind = TLS_MODEL_GLOBAL_DYNAMIC;
5065
  else
5066
    error ("tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"");
5067
 
5068
  DECL_TLS_MODEL (decl) = kind;
5069
  return NULL_TREE;
5070
}
5071
 
5072
/* Handle a "no_instrument_function" attribute; arguments as in
5073
   struct attribute_spec.handler.  */
5074
 
5075
static tree
5076
handle_no_instrument_function_attribute (tree *node, tree name,
5077
                                         tree ARG_UNUSED (args),
5078
                                         int ARG_UNUSED (flags),
5079
                                         bool *no_add_attrs)
5080
{
5081
  tree decl = *node;
5082
 
5083
  if (TREE_CODE (decl) != FUNCTION_DECL)
5084
    {
5085
      error ("%J%qE attribute applies only to functions", decl, name);
5086
      *no_add_attrs = true;
5087
    }
5088
  else if (DECL_INITIAL (decl))
5089
    {
5090
      error ("%Jcan%'t set %qE attribute after definition", decl, name);
5091
      *no_add_attrs = true;
5092
    }
5093
  else
5094
    DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1;
5095
 
5096
  return NULL_TREE;
5097
}
5098
 
5099
/* Handle a "malloc" attribute; arguments as in
5100
   struct attribute_spec.handler.  */
5101
 
5102
static tree
5103
handle_malloc_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5104
                         int ARG_UNUSED (flags), bool *no_add_attrs)
5105
{
5106
  if (TREE_CODE (*node) == FUNCTION_DECL
5107
      && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (*node))))
5108
    DECL_IS_MALLOC (*node) = 1;
5109
  else
5110
    {
5111
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5112
      *no_add_attrs = true;
5113
    }
5114
 
5115
  return NULL_TREE;
5116
}
5117
 
5118
/* Handle a "returns_twice" attribute; arguments as in
5119
   struct attribute_spec.handler.  */
5120
 
5121
static tree
5122
handle_returns_twice_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5123
                         int ARG_UNUSED (flags), bool *no_add_attrs)
5124
{
5125
  if (TREE_CODE (*node) == FUNCTION_DECL)
5126
    DECL_IS_RETURNS_TWICE (*node) = 1;
5127
  else
5128
    {
5129
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5130
      *no_add_attrs = true;
5131
    }
5132
 
5133
  return NULL_TREE;
5134
}
5135
 
5136
/* Handle a "no_limit_stack" attribute; arguments as in
5137
   struct attribute_spec.handler.  */
5138
 
5139
static tree
5140
handle_no_limit_stack_attribute (tree *node, tree name,
5141
                                 tree ARG_UNUSED (args),
5142
                                 int ARG_UNUSED (flags),
5143
                                 bool *no_add_attrs)
5144
{
5145
  tree decl = *node;
5146
 
5147
  if (TREE_CODE (decl) != FUNCTION_DECL)
5148
    {
5149
      error ("%J%qE attribute applies only to functions", decl, name);
5150
      *no_add_attrs = true;
5151
    }
5152
  else if (DECL_INITIAL (decl))
5153
    {
5154
      error ("%Jcan%'t set %qE attribute after definition", decl, name);
5155
      *no_add_attrs = true;
5156
    }
5157
  else
5158
    DECL_NO_LIMIT_STACK (decl) = 1;
5159
 
5160
  return NULL_TREE;
5161
}
5162
 
5163
/* Handle a "pure" attribute; arguments as in
5164
   struct attribute_spec.handler.  */
5165
 
5166
static tree
5167
handle_pure_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5168
                       int ARG_UNUSED (flags), bool *no_add_attrs)
5169
{
5170
  if (TREE_CODE (*node) == FUNCTION_DECL)
5171
    DECL_IS_PURE (*node) = 1;
5172
  /* ??? TODO: Support types.  */
5173
  else
5174
    {
5175
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5176
      *no_add_attrs = true;
5177
    }
5178
 
5179
  return NULL_TREE;
5180
}
5181
 
5182
/* Handle a "no vops" attribute; arguments as in
5183
   struct attribute_spec.handler.  */
5184
 
5185
static tree
5186
handle_novops_attribute (tree *node, tree ARG_UNUSED (name),
5187
                         tree ARG_UNUSED (args), int ARG_UNUSED (flags),
5188
                         bool *ARG_UNUSED (no_add_attrs))
5189
{
5190
  gcc_assert (TREE_CODE (*node) == FUNCTION_DECL);
5191
  DECL_IS_NOVOPS (*node) = 1;
5192
  return NULL_TREE;
5193
}
5194
 
5195
/* Handle a "deprecated" attribute; arguments as in
5196
   struct attribute_spec.handler.  */
5197
 
5198
static tree
5199
handle_deprecated_attribute (tree *node, tree name,
5200
                             tree ARG_UNUSED (args), int flags,
5201
                             bool *no_add_attrs)
5202
{
5203
  tree type = NULL_TREE;
5204
  int warn = 0;
5205
  tree what = NULL_TREE;
5206
 
5207
  if (DECL_P (*node))
5208
    {
5209
      tree decl = *node;
5210
      type = TREE_TYPE (decl);
5211
 
5212
      if (TREE_CODE (decl) == TYPE_DECL
5213
          || TREE_CODE (decl) == PARM_DECL
5214
          || TREE_CODE (decl) == VAR_DECL
5215
          || TREE_CODE (decl) == FUNCTION_DECL
5216
          || TREE_CODE (decl) == FIELD_DECL)
5217
        TREE_DEPRECATED (decl) = 1;
5218
      else
5219
        warn = 1;
5220
    }
5221
  else if (TYPE_P (*node))
5222
    {
5223
      if (!(flags & (int) ATTR_FLAG_TYPE_IN_PLACE))
5224
        *node = build_variant_type_copy (*node);
5225
      TREE_DEPRECATED (*node) = 1;
5226
      type = *node;
5227
    }
5228
  else
5229
    warn = 1;
5230
 
5231
  if (warn)
5232
    {
5233
      *no_add_attrs = true;
5234
      if (type && TYPE_NAME (type))
5235
        {
5236
          if (TREE_CODE (TYPE_NAME (type)) == IDENTIFIER_NODE)
5237
            what = TYPE_NAME (*node);
5238
          else if (TREE_CODE (TYPE_NAME (type)) == TYPE_DECL
5239
                   && DECL_NAME (TYPE_NAME (type)))
5240
            what = DECL_NAME (TYPE_NAME (type));
5241
        }
5242
      if (what)
5243
        warning (OPT_Wattributes, "%qE attribute ignored for %qE", name, what);
5244
      else
5245
        warning (OPT_Wattributes, "%qE attribute ignored", name);
5246
    }
5247
 
5248
  return NULL_TREE;
5249
}
5250
 
5251
/* Handle a "vector_size" attribute; arguments as in
5252
   struct attribute_spec.handler.  */
5253
 
5254
static tree
5255
handle_vector_size_attribute (tree *node, tree name, tree args,
5256
                              int ARG_UNUSED (flags),
5257
                              bool *no_add_attrs)
5258
{
5259
  unsigned HOST_WIDE_INT vecsize, nunits;
5260
  enum machine_mode orig_mode;
5261
  tree type = *node, new_type, size;
5262
 
5263
  *no_add_attrs = true;
5264
 
5265
  size = TREE_VALUE (args);
5266
 
5267
  if (!host_integerp (size, 1))
5268
    {
5269
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5270
      return NULL_TREE;
5271
    }
5272
 
5273
  /* Get the vector size (in bytes).  */
5274
  vecsize = tree_low_cst (size, 1);
5275
 
5276
  /* We need to provide for vector pointers, vector arrays, and
5277
     functions returning vectors.  For example:
5278
 
5279
       __attribute__((vector_size(16))) short *foo;
5280
 
5281
     In this case, the mode is SI, but the type being modified is
5282
     HI, so we need to look further.  */
5283
 
5284
  while (POINTER_TYPE_P (type)
5285
         || TREE_CODE (type) == FUNCTION_TYPE
5286
         || TREE_CODE (type) == METHOD_TYPE
5287
         || TREE_CODE (type) == ARRAY_TYPE)
5288
    type = TREE_TYPE (type);
5289
 
5290
  /* Get the mode of the type being modified.  */
5291
  orig_mode = TYPE_MODE (type);
5292
 
5293
  if (TREE_CODE (type) == RECORD_TYPE
5294
      || TREE_CODE (type) == UNION_TYPE
5295
      || TREE_CODE (type) == VECTOR_TYPE
5296
      || (!SCALAR_FLOAT_MODE_P (orig_mode)
5297
          && GET_MODE_CLASS (orig_mode) != MODE_INT)
5298
      || !host_integerp (TYPE_SIZE_UNIT (type), 1))
5299
    {
5300
      error ("invalid vector type for attribute %qE", name);
5301
      return NULL_TREE;
5302
    }
5303
 
5304
  if (vecsize % tree_low_cst (TYPE_SIZE_UNIT (type), 1))
5305
    {
5306
      error ("vector size not an integral multiple of component size");
5307
      return NULL;
5308
    }
5309
 
5310
  if (vecsize == 0)
5311
    {
5312
      error ("zero vector size");
5313
      return NULL;
5314
    }
5315
 
5316
  /* Calculate how many units fit in the vector.  */
5317
  nunits = vecsize / tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5318
  if (nunits & (nunits - 1))
5319
    {
5320
      error ("number of components of the vector not a power of two");
5321
      return NULL_TREE;
5322
    }
5323
 
5324
  new_type = build_vector_type (type, nunits);
5325
 
5326
  /* Build back pointers if needed.  */
5327
  *node = reconstruct_complex_type (*node, new_type);
5328
 
5329
  return NULL_TREE;
5330
}
5331
 
5332
/* Handle the "nonnull" attribute.  */
5333
static tree
5334
handle_nonnull_attribute (tree *node, tree ARG_UNUSED (name),
5335
                          tree args, int ARG_UNUSED (flags),
5336
                          bool *no_add_attrs)
5337
{
5338
  tree type = *node;
5339
  unsigned HOST_WIDE_INT attr_arg_num;
5340
 
5341
  /* If no arguments are specified, all pointer arguments should be
5342
     non-null.  Verify a full prototype is given so that the arguments
5343
     will have the correct types when we actually check them later.  */
5344
  if (!args)
5345
    {
5346
      if (!TYPE_ARG_TYPES (type))
5347
        {
5348
          error ("nonnull attribute without arguments on a non-prototype");
5349
          *no_add_attrs = true;
5350
        }
5351
      return NULL_TREE;
5352
    }
5353
 
5354
  /* Argument list specified.  Verify that each argument number references
5355
     a pointer argument.  */
5356
  for (attr_arg_num = 1; args; args = TREE_CHAIN (args))
5357
    {
5358
      tree argument;
5359
      unsigned HOST_WIDE_INT arg_num = 0, ck_num;
5360
 
5361
      if (!get_nonnull_operand (TREE_VALUE (args), &arg_num))
5362
        {
5363
          error ("nonnull argument has invalid operand number (argument %lu)",
5364
                 (unsigned long) attr_arg_num);
5365
          *no_add_attrs = true;
5366
          return NULL_TREE;
5367
        }
5368
 
5369
      argument = TYPE_ARG_TYPES (type);
5370
      if (argument)
5371
        {
5372
          for (ck_num = 1; ; ck_num++)
5373
            {
5374
              if (!argument || ck_num == arg_num)
5375
                break;
5376
              argument = TREE_CHAIN (argument);
5377
            }
5378
 
5379
          if (!argument
5380
              || TREE_CODE (TREE_VALUE (argument)) == VOID_TYPE)
5381
            {
5382
              error ("nonnull argument with out-of-range operand number (argument %lu, operand %lu)",
5383
                     (unsigned long) attr_arg_num, (unsigned long) arg_num);
5384
              *no_add_attrs = true;
5385
              return NULL_TREE;
5386
            }
5387
 
5388
          if (TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE)
5389
            {
5390
              error ("nonnull argument references non-pointer operand (argument %lu, operand %lu)",
5391
                   (unsigned long) attr_arg_num, (unsigned long) arg_num);
5392
              *no_add_attrs = true;
5393
              return NULL_TREE;
5394
            }
5395
        }
5396
    }
5397
 
5398
  return NULL_TREE;
5399
}
5400
 
5401
/* Check the argument list of a function call for null in argument slots
5402
   that are marked as requiring a non-null pointer argument.  */
5403
 
5404
static void
5405
check_function_nonnull (tree attrs, tree params)
5406
{
5407
  tree a, args, param;
5408
  int param_num;
5409
 
5410
  for (a = attrs; a; a = TREE_CHAIN (a))
5411
    {
5412
      if (is_attribute_p ("nonnull", TREE_PURPOSE (a)))
5413
        {
5414
          args = TREE_VALUE (a);
5415
 
5416
          /* Walk the argument list.  If we encounter an argument number we
5417
             should check for non-null, do it.  If the attribute has no args,
5418
             then every pointer argument is checked (in which case the check
5419
             for pointer type is done in check_nonnull_arg).  */
5420
          for (param = params, param_num = 1; ;
5421
               param_num++, param = TREE_CHAIN (param))
5422
            {
5423
              if (!param)
5424
        break;
5425
              if (!args || nonnull_check_p (args, param_num))
5426
        check_function_arguments_recurse (check_nonnull_arg, NULL,
5427
                                          TREE_VALUE (param),
5428
                                          param_num);
5429
            }
5430
        }
5431
    }
5432
}
5433
 
5434
/* Check that the Nth argument of a function call (counting backwards
5435
   from the end) is a (pointer)0.  */
5436
 
5437
static void
5438
check_function_sentinel (tree attrs, tree params, tree typelist)
5439
{
5440
  tree attr = lookup_attribute ("sentinel", attrs);
5441
 
5442
  if (attr)
5443
    {
5444
      /* Skip over the named arguments.  */
5445
      while (typelist && params)
5446
      {
5447
        typelist = TREE_CHAIN (typelist);
5448
        params = TREE_CHAIN (params);
5449
      }
5450
 
5451
      if (typelist || !params)
5452
        warning (OPT_Wformat,
5453
                 "not enough variable arguments to fit a sentinel");
5454
      else
5455
        {
5456
          tree sentinel, end;
5457
          unsigned pos = 0;
5458
 
5459
          if (TREE_VALUE (attr))
5460
            {
5461
              tree p = TREE_VALUE (TREE_VALUE (attr));
5462
              pos = TREE_INT_CST_LOW (p);
5463
            }
5464
 
5465
          sentinel = end = params;
5466
 
5467
          /* Advance `end' ahead of `sentinel' by `pos' positions.  */
5468
          while (pos > 0 && TREE_CHAIN (end))
5469
            {
5470
              pos--;
5471
              end = TREE_CHAIN (end);
5472
            }
5473
          if (pos > 0)
5474
            {
5475
              warning (OPT_Wformat,
5476
                       "not enough variable arguments to fit a sentinel");
5477
              return;
5478
            }
5479
 
5480
          /* Now advance both until we find the last parameter.  */
5481
          while (TREE_CHAIN (end))
5482
            {
5483
              end = TREE_CHAIN (end);
5484
              sentinel = TREE_CHAIN (sentinel);
5485
            }
5486
 
5487
          /* Validate the sentinel.  */
5488
          if ((!POINTER_TYPE_P (TREE_TYPE (TREE_VALUE (sentinel)))
5489
               || !integer_zerop (TREE_VALUE (sentinel)))
5490
              /* Although __null (in C++) is only an integer we allow it
5491
                 nevertheless, as we are guaranteed that it's exactly
5492
                 as wide as a pointer, and we don't want to force
5493
                 users to cast the NULL they have written there.
5494
                 We warn with -Wstrict-null-sentinel, though.  */
5495
              && (warn_strict_null_sentinel
5496
                  || null_node != TREE_VALUE (sentinel)))
5497
            warning (OPT_Wformat, "missing sentinel in function call");
5498
        }
5499
    }
5500
}
5501
 
5502
/* Helper for check_function_nonnull; given a list of operands which
5503
   must be non-null in ARGS, determine if operand PARAM_NUM should be
5504
   checked.  */
5505
 
5506
static bool
5507
nonnull_check_p (tree args, unsigned HOST_WIDE_INT param_num)
5508
{
5509
  unsigned HOST_WIDE_INT arg_num = 0;
5510
 
5511
  for (; args; args = TREE_CHAIN (args))
5512
    {
5513
      bool found = get_nonnull_operand (TREE_VALUE (args), &arg_num);
5514
 
5515
      gcc_assert (found);
5516
 
5517
      if (arg_num == param_num)
5518
        return true;
5519
    }
5520
  return false;
5521
}
5522
 
5523
/* Check that the function argument PARAM (which is operand number
5524
   PARAM_NUM) is non-null.  This is called by check_function_nonnull
5525
   via check_function_arguments_recurse.  */
5526
 
5527
static void
5528
check_nonnull_arg (void * ARG_UNUSED (ctx), tree param,
5529
                   unsigned HOST_WIDE_INT param_num)
5530
{
5531
  /* Just skip checking the argument if it's not a pointer.  This can
5532
     happen if the "nonnull" attribute was given without an operand
5533
     list (which means to check every pointer argument).  */
5534
 
5535
  if (TREE_CODE (TREE_TYPE (param)) != POINTER_TYPE)
5536
    return;
5537
 
5538
  if (integer_zerop (param))
5539
    warning (OPT_Wnonnull, "null argument where non-null required "
5540
             "(argument %lu)", (unsigned long) param_num);
5541
}
5542
 
5543
/* Helper for nonnull attribute handling; fetch the operand number
5544
   from the attribute argument list.  */
5545
 
5546
static bool
5547
get_nonnull_operand (tree arg_num_expr, unsigned HOST_WIDE_INT *valp)
5548
{
5549
  /* Verify the arg number is a constant.  */
5550
  if (TREE_CODE (arg_num_expr) != INTEGER_CST
5551
      || TREE_INT_CST_HIGH (arg_num_expr) != 0)
5552
    return false;
5553
 
5554
  *valp = TREE_INT_CST_LOW (arg_num_expr);
5555
  return true;
5556
}
5557
 
5558
/* Handle a "nothrow" attribute; arguments as in
5559
   struct attribute_spec.handler.  */
5560
 
5561
static tree
5562
handle_nothrow_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5563
                          int ARG_UNUSED (flags), bool *no_add_attrs)
5564
{
5565
  if (TREE_CODE (*node) == FUNCTION_DECL)
5566
    TREE_NOTHROW (*node) = 1;
5567
  /* ??? TODO: Support types.  */
5568
  else
5569
    {
5570
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5571
      *no_add_attrs = true;
5572
    }
5573
 
5574
  return NULL_TREE;
5575
}
5576
 
5577
/* Handle a "cleanup" attribute; arguments as in
5578
   struct attribute_spec.handler.  */
5579
 
5580
static tree
5581
handle_cleanup_attribute (tree *node, tree name, tree args,
5582
                          int ARG_UNUSED (flags), bool *no_add_attrs)
5583
{
5584
  tree decl = *node;
5585
  tree cleanup_id, cleanup_decl;
5586
 
5587
  /* ??? Could perhaps support cleanups on TREE_STATIC, much like we do
5588
     for global destructors in C++.  This requires infrastructure that
5589
     we don't have generically at the moment.  It's also not a feature
5590
     we'd be missing too much, since we do have attribute constructor.  */
5591
  if (TREE_CODE (decl) != VAR_DECL || TREE_STATIC (decl))
5592
    {
5593
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5594
      *no_add_attrs = true;
5595
      return NULL_TREE;
5596
    }
5597
 
5598
  /* Verify that the argument is a function in scope.  */
5599
  /* ??? We could support pointers to functions here as well, if
5600
     that was considered desirable.  */
5601
  cleanup_id = TREE_VALUE (args);
5602
  if (TREE_CODE (cleanup_id) != IDENTIFIER_NODE)
5603
    {
5604
      error ("cleanup argument not an identifier");
5605
      *no_add_attrs = true;
5606
      return NULL_TREE;
5607
    }
5608
  cleanup_decl = lookup_name (cleanup_id);
5609
  if (!cleanup_decl || TREE_CODE (cleanup_decl) != FUNCTION_DECL)
5610
    {
5611
      error ("cleanup argument not a function");
5612
      *no_add_attrs = true;
5613
      return NULL_TREE;
5614
    }
5615
 
5616
  /* That the function has proper type is checked with the
5617
     eventual call to build_function_call.  */
5618
 
5619
  return NULL_TREE;
5620
}
5621
 
5622
/* Handle a "warn_unused_result" attribute.  No special handling.  */
5623
 
5624
static tree
5625
handle_warn_unused_result_attribute (tree *node, tree name,
5626
                               tree ARG_UNUSED (args),
5627
                               int ARG_UNUSED (flags), bool *no_add_attrs)
5628
{
5629
  /* Ignore the attribute for functions not returning any value.  */
5630
  if (VOID_TYPE_P (TREE_TYPE (*node)))
5631
    {
5632
      warning (OPT_Wattributes, "%qE attribute ignored", name);
5633
      *no_add_attrs = true;
5634
    }
5635
 
5636
  return NULL_TREE;
5637
}
5638
 
5639
/* Handle a "sentinel" attribute.  */
5640
 
5641
static tree
5642
handle_sentinel_attribute (tree *node, tree name, tree args,
5643
                           int ARG_UNUSED (flags), bool *no_add_attrs)
5644
{
5645
  tree params = TYPE_ARG_TYPES (*node);
5646
 
5647
  if (!params)
5648
    {
5649
      warning (OPT_Wattributes,
5650
               "%qE attribute requires prototypes with named arguments", name);
5651
      *no_add_attrs = true;
5652
    }
5653
  else
5654
    {
5655
      while (TREE_CHAIN (params))
5656
        params = TREE_CHAIN (params);
5657
 
5658
      if (VOID_TYPE_P (TREE_VALUE (params)))
5659
        {
5660
          warning (OPT_Wattributes,
5661
                   "%qE attribute only applies to variadic functions", name);
5662
          *no_add_attrs = true;
5663
        }
5664
    }
5665
 
5666
  if (args)
5667
    {
5668
      tree position = TREE_VALUE (args);
5669
 
5670
      if (TREE_CODE (position) != INTEGER_CST)
5671
        {
5672
          warning (0, "requested position is not an integer constant");
5673
          *no_add_attrs = true;
5674
        }
5675
      else
5676
        {
5677
          if (tree_int_cst_lt (position, integer_zero_node))
5678
            {
5679
              warning (0, "requested position is less than zero");
5680
              *no_add_attrs = true;
5681
            }
5682
        }
5683
    }
5684
 
5685
  return NULL_TREE;
5686
}
5687
 
5688
/* Check for valid arguments being passed to a function.  */
5689
void
5690
check_function_arguments (tree attrs, tree params, tree typelist)
5691
{
5692
  /* Check for null being passed in a pointer argument that must be
5693
     non-null.  We also need to do this if format checking is enabled.  */
5694
 
5695
  if (warn_nonnull)
5696
    check_function_nonnull (attrs, params);
5697
 
5698
  /* Check for errors in format strings.  */
5699
 
5700
  if (warn_format || warn_missing_format_attribute)
5701
      check_function_format (attrs, params);
5702
 
5703
  if (warn_format)
5704
    check_function_sentinel (attrs, params, typelist);
5705
}
5706
 
5707
/* Generic argument checking recursion routine.  PARAM is the argument to
5708
   be checked.  PARAM_NUM is the number of the argument.  CALLBACK is invoked
5709
   once the argument is resolved.  CTX is context for the callback.  */
5710
void
5711
check_function_arguments_recurse (void (*callback)
5712
                                  (void *, tree, unsigned HOST_WIDE_INT),
5713
                                  void *ctx, tree param,
5714
                                  unsigned HOST_WIDE_INT param_num)
5715
{
5716
  if ((TREE_CODE (param) == NOP_EXPR || TREE_CODE (param) == CONVERT_EXPR)
5717
      && (TYPE_PRECISION (TREE_TYPE (param))
5718
          == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (param, 0)))))
5719
    {
5720
      /* Strip coercion.  */
5721
      check_function_arguments_recurse (callback, ctx,
5722
                                        TREE_OPERAND (param, 0), param_num);
5723
      return;
5724
    }
5725
 
5726
  if (TREE_CODE (param) == CALL_EXPR)
5727
    {
5728
      tree type = TREE_TYPE (TREE_TYPE (TREE_OPERAND (param, 0)));
5729
      tree attrs;
5730
      bool found_format_arg = false;
5731
 
5732
      /* See if this is a call to a known internationalization function
5733
         that modifies a format arg.  Such a function may have multiple
5734
         format_arg attributes (for example, ngettext).  */
5735
 
5736
      for (attrs = TYPE_ATTRIBUTES (type);
5737
           attrs;
5738
           attrs = TREE_CHAIN (attrs))
5739
        if (is_attribute_p ("format_arg", TREE_PURPOSE (attrs)))
5740
          {
5741
            tree inner_args;
5742
            tree format_num_expr;
5743
            int format_num;
5744
            int i;
5745
 
5746
            /* Extract the argument number, which was previously checked
5747
               to be valid.  */
5748
            format_num_expr = TREE_VALUE (TREE_VALUE (attrs));
5749
 
5750
            gcc_assert (TREE_CODE (format_num_expr) == INTEGER_CST
5751
                        && !TREE_INT_CST_HIGH (format_num_expr));
5752
 
5753
            format_num = TREE_INT_CST_LOW (format_num_expr);
5754
 
5755
            for (inner_args = TREE_OPERAND (param, 1), i = 1;
5756
                 inner_args != 0;
5757
                 inner_args = TREE_CHAIN (inner_args), i++)
5758
              if (i == format_num)
5759
                {
5760
                  check_function_arguments_recurse (callback, ctx,
5761
                                                    TREE_VALUE (inner_args),
5762
                                                    param_num);
5763
                  found_format_arg = true;
5764
                  break;
5765
                }
5766
          }
5767
 
5768
      /* If we found a format_arg attribute and did a recursive check,
5769
         we are done with checking this argument.  Otherwise, we continue
5770
         and this will be considered a non-literal.  */
5771
      if (found_format_arg)
5772
        return;
5773
    }
5774
 
5775
  if (TREE_CODE (param) == COND_EXPR)
5776
    {
5777
      /* Check both halves of the conditional expression.  */
5778
      check_function_arguments_recurse (callback, ctx,
5779
                                        TREE_OPERAND (param, 1), param_num);
5780
      check_function_arguments_recurse (callback, ctx,
5781
                                        TREE_OPERAND (param, 2), param_num);
5782
      return;
5783
    }
5784
 
5785
  (*callback) (ctx, param, param_num);
5786
}
5787
 
5788
/* Function to help qsort sort FIELD_DECLs by name order.  */
5789
 
5790
int
5791
field_decl_cmp (const void *x_p, const void *y_p)
5792
{
5793
  const tree *const x = (const tree *const) x_p;
5794
  const tree *const y = (const tree *const) y_p;
5795
 
5796
  if (DECL_NAME (*x) == DECL_NAME (*y))
5797
    /* A nontype is "greater" than a type.  */
5798
    return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5799
  if (DECL_NAME (*x) == NULL_TREE)
5800
    return -1;
5801
  if (DECL_NAME (*y) == NULL_TREE)
5802
    return 1;
5803
  if (DECL_NAME (*x) < DECL_NAME (*y))
5804
    return -1;
5805
  return 1;
5806
}
5807
 
5808
static struct {
5809
  gt_pointer_operator new_value;
5810
  void *cookie;
5811
} resort_data;
5812
 
5813
/* This routine compares two fields like field_decl_cmp but using the
5814
pointer operator in resort_data.  */
5815
 
5816
static int
5817
resort_field_decl_cmp (const void *x_p, const void *y_p)
5818
{
5819
  const tree *const x = (const tree *const) x_p;
5820
  const tree *const y = (const tree *const) y_p;
5821
 
5822
  if (DECL_NAME (*x) == DECL_NAME (*y))
5823
    /* A nontype is "greater" than a type.  */
5824
    return (TREE_CODE (*y) == TYPE_DECL) - (TREE_CODE (*x) == TYPE_DECL);
5825
  if (DECL_NAME (*x) == NULL_TREE)
5826
    return -1;
5827
  if (DECL_NAME (*y) == NULL_TREE)
5828
    return 1;
5829
  {
5830
    tree d1 = DECL_NAME (*x);
5831
    tree d2 = DECL_NAME (*y);
5832
    resort_data.new_value (&d1, resort_data.cookie);
5833
    resort_data.new_value (&d2, resort_data.cookie);
5834
    if (d1 < d2)
5835
      return -1;
5836
  }
5837
  return 1;
5838
}
5839
 
5840
/* Resort DECL_SORTED_FIELDS because pointers have been reordered.  */
5841
 
5842
void
5843
resort_sorted_fields (void *obj,
5844
                      void * ARG_UNUSED (orig_obj),
5845
                      gt_pointer_operator new_value,
5846
                      void *cookie)
5847
{
5848
  struct sorted_fields_type *sf = (struct sorted_fields_type *) obj;
5849
  resort_data.new_value = new_value;
5850
  resort_data.cookie = cookie;
5851
  qsort (&sf->elts[0], sf->len, sizeof (tree),
5852
         resort_field_decl_cmp);
5853
}
5854
 
5855
/* Subroutine of c_parse_error.
5856
   Return the result of concatenating LHS and RHS. RHS is really
5857
   a string literal, its first character is indicated by RHS_START and
5858
   RHS_SIZE is its length (including the terminating NUL character).
5859
 
5860
   The caller is responsible for deleting the returned pointer.  */
5861
 
5862
static char *
5863
catenate_strings (const char *lhs, const char *rhs_start, int rhs_size)
5864
{
5865
  const int lhs_size = strlen (lhs);
5866
  char *result = XNEWVEC (char, lhs_size + rhs_size);
5867
  strncpy (result, lhs, lhs_size);
5868
  strncpy (result + lhs_size, rhs_start, rhs_size);
5869
  return result;
5870
}
5871
 
5872
/* Issue the error given by GMSGID, indicating that it occurred before
5873
   TOKEN, which had the associated VALUE.  */
5874
 
5875
void
5876
c_parse_error (const char *gmsgid, enum cpp_ttype token, tree value)
5877
{
5878
#define catenate_messages(M1, M2) catenate_strings ((M1), (M2), sizeof (M2))
5879
 
5880
  char *message = NULL;
5881
 
5882
  if (token == CPP_EOF)
5883
    message = catenate_messages (gmsgid, " at end of input");
5884
  else if (token == CPP_CHAR || token == CPP_WCHAR)
5885
    {
5886
      unsigned int val = TREE_INT_CST_LOW (value);
5887
      const char *const ell = (token == CPP_CHAR) ? "" : "L";
5888
      if (val <= UCHAR_MAX && ISGRAPH (val))
5889
        message = catenate_messages (gmsgid, " before %s'%c'");
5890
      else
5891
        message = catenate_messages (gmsgid, " before %s'\\x%x'");
5892
 
5893
      error (message, ell, val);
5894
      free (message);
5895
      message = NULL;
5896
    }
5897
  else if (token == CPP_STRING || token == CPP_WSTRING)
5898
    message = catenate_messages (gmsgid, " before string constant");
5899
  else if (token == CPP_NUMBER)
5900
    message = catenate_messages (gmsgid, " before numeric constant");
5901
  else if (token == CPP_NAME)
5902
    {
5903
      message = catenate_messages (gmsgid, " before %qE");
5904
      error (message, value);
5905
      free (message);
5906
      message = NULL;
5907
    }
5908
  else if (token == CPP_PRAGMA)
5909
    message = catenate_messages (gmsgid, " before %<#pragma%>");
5910
  else if (token == CPP_PRAGMA_EOL)
5911
    message = catenate_messages (gmsgid, " before end of line");
5912
  else if (token < N_TTYPES)
5913
    {
5914
      message = catenate_messages (gmsgid, " before %qs token");
5915
      error (message, cpp_type2name (token));
5916
      free (message);
5917
      message = NULL;
5918
    }
5919
  else
5920
    error (gmsgid);
5921
 
5922
  if (message)
5923
    {
5924
      error (message);
5925
      free (message);
5926
    }
5927
#undef catenate_messages
5928
}
5929
 
5930
/* Walk a gimplified function and warn for functions whose return value is
5931
   ignored and attribute((warn_unused_result)) is set.  This is done before
5932
   inlining, so we don't have to worry about that.  */
5933
 
5934
void
5935
c_warn_unused_result (tree *top_p)
5936
{
5937
  tree t = *top_p;
5938
  tree_stmt_iterator i;
5939
  tree fdecl, ftype;
5940
 
5941
  switch (TREE_CODE (t))
5942
    {
5943
    case STATEMENT_LIST:
5944
      for (i = tsi_start (*top_p); !tsi_end_p (i); tsi_next (&i))
5945
        c_warn_unused_result (tsi_stmt_ptr (i));
5946
      break;
5947
 
5948
    case COND_EXPR:
5949
      c_warn_unused_result (&COND_EXPR_THEN (t));
5950
      c_warn_unused_result (&COND_EXPR_ELSE (t));
5951
      break;
5952
    case BIND_EXPR:
5953
      c_warn_unused_result (&BIND_EXPR_BODY (t));
5954
      break;
5955
    case TRY_FINALLY_EXPR:
5956
    case TRY_CATCH_EXPR:
5957
      c_warn_unused_result (&TREE_OPERAND (t, 0));
5958
      c_warn_unused_result (&TREE_OPERAND (t, 1));
5959
      break;
5960
    case CATCH_EXPR:
5961
      c_warn_unused_result (&CATCH_BODY (t));
5962
      break;
5963
    case EH_FILTER_EXPR:
5964
      c_warn_unused_result (&EH_FILTER_FAILURE (t));
5965
      break;
5966
 
5967
    case CALL_EXPR:
5968
      if (TREE_USED (t))
5969
        break;
5970
 
5971
      /* This is a naked call, as opposed to a CALL_EXPR nested inside
5972
         a MODIFY_EXPR.  All calls whose value is ignored should be
5973
         represented like this.  Look for the attribute.  */
5974
      fdecl = get_callee_fndecl (t);
5975
      if (fdecl)
5976
        ftype = TREE_TYPE (fdecl);
5977
      else
5978
        {
5979
          ftype = TREE_TYPE (TREE_OPERAND (t, 0));
5980
          /* Look past pointer-to-function to the function type itself.  */
5981
          ftype = TREE_TYPE (ftype);
5982
        }
5983
 
5984
      if (lookup_attribute ("warn_unused_result", TYPE_ATTRIBUTES (ftype)))
5985
        {
5986
          if (fdecl)
5987
            warning (0, "%Hignoring return value of %qD, "
5988
                     "declared with attribute warn_unused_result",
5989
                     EXPR_LOCUS (t), fdecl);
5990
          else
5991
            warning (0, "%Hignoring return value of function "
5992
                     "declared with attribute warn_unused_result",
5993
                     EXPR_LOCUS (t));
5994
        }
5995
      break;
5996
 
5997
    default:
5998
      /* Not a container, not a call, or a call whose value is used.  */
5999
      break;
6000
    }
6001
}
6002
 
6003
/* Convert a character from the host to the target execution character
6004
   set.  cpplib handles this, mostly.  */
6005
 
6006
HOST_WIDE_INT
6007
c_common_to_target_charset (HOST_WIDE_INT c)
6008
{
6009
  /* Character constants in GCC proper are sign-extended under -fsigned-char,
6010
     zero-extended under -fno-signed-char.  cpplib insists that characters
6011
     and character constants are always unsigned.  Hence we must convert
6012
     back and forth.  */
6013
  cppchar_t uc = ((cppchar_t)c) & ((((cppchar_t)1) << CHAR_BIT)-1);
6014
 
6015
  uc = cpp_host_to_exec_charset (parse_in, uc);
6016
 
6017
  if (flag_signed_char)
6018
    return ((HOST_WIDE_INT)uc) << (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE)
6019
                               >> (HOST_BITS_PER_WIDE_INT - CHAR_TYPE_SIZE);
6020
  else
6021
    return uc;
6022
}
6023
 
6024
/* Build the result of __builtin_offsetof.  EXPR is a nested sequence of
6025
   component references, with STOP_REF, or alternatively an INDIRECT_REF of
6026
   NULL, at the bottom; much like the traditional rendering of offsetof as a
6027
   macro.  Returns the folded and properly cast result.  */
6028
 
6029
static tree
6030
fold_offsetof_1 (tree expr, tree stop_ref)
6031
{
6032
  enum tree_code code = PLUS_EXPR;
6033
  tree base, off, t;
6034
 
6035
  if (expr == stop_ref && TREE_CODE (expr) != ERROR_MARK)
6036
    return size_zero_node;
6037
 
6038
  switch (TREE_CODE (expr))
6039
    {
6040
    case ERROR_MARK:
6041
      return expr;
6042
 
6043
    case VAR_DECL:
6044
      error ("cannot apply %<offsetof%> to static data member %qD", expr);
6045
      return error_mark_node;
6046
 
6047
    case CALL_EXPR:
6048
      error ("cannot apply %<offsetof%> when %<operator[]%> is overloaded");
6049
      return error_mark_node;
6050
 
6051
    case INTEGER_CST:
6052
      gcc_assert (integer_zerop (expr));
6053
      return size_zero_node;
6054
 
6055
    case NOP_EXPR:
6056
    case INDIRECT_REF:
6057
      base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6058
      gcc_assert (base == error_mark_node || base == size_zero_node);
6059
      return base;
6060
 
6061
    case COMPONENT_REF:
6062
      base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6063
      if (base == error_mark_node)
6064
        return base;
6065
 
6066
      t = TREE_OPERAND (expr, 1);
6067
      if (DECL_C_BIT_FIELD (t))
6068
        {
6069
          error ("attempt to take address of bit-field structure "
6070
                 "member %qD", t);
6071
          return error_mark_node;
6072
        }
6073
      off = size_binop (PLUS_EXPR, DECL_FIELD_OFFSET (t),
6074
                        size_int (tree_low_cst (DECL_FIELD_BIT_OFFSET (t), 1)
6075
                                  / BITS_PER_UNIT));
6076
      break;
6077
 
6078
    case ARRAY_REF:
6079
      base = fold_offsetof_1 (TREE_OPERAND (expr, 0), stop_ref);
6080
      if (base == error_mark_node)
6081
        return base;
6082
 
6083
      t = TREE_OPERAND (expr, 1);
6084
      if (TREE_CODE (t) == INTEGER_CST && tree_int_cst_sgn (t) < 0)
6085
        {
6086
          code = MINUS_EXPR;
6087
          t = fold_build1 (NEGATE_EXPR, TREE_TYPE (t), t);
6088
        }
6089
      t = convert (sizetype, t);
6090
      off = size_binop (MULT_EXPR, TYPE_SIZE_UNIT (TREE_TYPE (expr)), t);
6091
      break;
6092
 
6093
    case COMPOUND_EXPR:
6094
      /* Handle static members of volatile structs.  */
6095
      t = TREE_OPERAND (expr, 1);
6096
      gcc_assert (TREE_CODE (t) == VAR_DECL);
6097
      return fold_offsetof_1 (t, stop_ref);
6098
 
6099
    default:
6100
      gcc_unreachable ();
6101
    }
6102
 
6103
  return size_binop (code, base, off);
6104
}
6105
 
6106
tree
6107
fold_offsetof (tree expr, tree stop_ref)
6108
{
6109
  /* Convert back from the internal sizetype to size_t.  */
6110
  return convert (size_type_node, fold_offsetof_1 (expr, stop_ref));
6111
}
6112
 
6113
/* Print an error message for an invalid lvalue.  USE says
6114
   how the lvalue is being used and so selects the error message.  */
6115
 
6116
void
6117
lvalue_error (enum lvalue_use use)
6118
{
6119
  switch (use)
6120
    {
6121
    case lv_assign:
6122
      error ("lvalue required as left operand of assignment");
6123
      break;
6124
    case lv_increment:
6125
      error ("lvalue required as increment operand");
6126
      break;
6127
    case lv_decrement:
6128
      error ("lvalue required as decrement operand");
6129
      break;
6130
    case lv_addressof:
6131
      error ("lvalue required as unary %<&%> operand");
6132
      break;
6133
    case lv_asm:
6134
      error ("lvalue required in asm statement");
6135
      break;
6136
    default:
6137
      gcc_unreachable ();
6138
    }
6139
}
6140
 
6141
/* *PTYPE is an incomplete array.  Complete it with a domain based on
6142
   INITIAL_VALUE.  If INITIAL_VALUE is not present, use 1 if DO_DEFAULT
6143
   is true.  Return 0 if successful, 1 if INITIAL_VALUE can't be deciphered,
6144
   2 if INITIAL_VALUE was NULL, and 3 if INITIAL_VALUE was empty.  */
6145
 
6146
int
6147
complete_array_type (tree *ptype, tree initial_value, bool do_default)
6148
{
6149
  tree maxindex, type, main_type, elt, unqual_elt;
6150
  int failure = 0, quals;
6151
 
6152
  maxindex = size_zero_node;
6153
  if (initial_value)
6154
    {
6155
      if (TREE_CODE (initial_value) == STRING_CST)
6156
        {
6157
          int eltsize
6158
            = int_size_in_bytes (TREE_TYPE (TREE_TYPE (initial_value)));
6159
          maxindex = size_int (TREE_STRING_LENGTH (initial_value)/eltsize - 1);
6160
        }
6161
      else if (TREE_CODE (initial_value) == CONSTRUCTOR)
6162
        {
6163
          VEC(constructor_elt,gc) *v = CONSTRUCTOR_ELTS (initial_value);
6164
 
6165
          if (VEC_empty (constructor_elt, v))
6166
            {
6167
              if (pedantic)
6168
                failure = 3;
6169
              maxindex = integer_minus_one_node;
6170
            }
6171
          else
6172
            {
6173
              tree curindex;
6174
              unsigned HOST_WIDE_INT cnt;
6175
              constructor_elt *ce;
6176
 
6177
              if (VEC_index (constructor_elt, v, 0)->index)
6178
                maxindex = fold_convert (sizetype,
6179
                                         VEC_index (constructor_elt,
6180
                                                    v, 0)->index);
6181
              curindex = maxindex;
6182
 
6183
              for (cnt = 1;
6184
                   VEC_iterate (constructor_elt, v, cnt, ce);
6185
                   cnt++)
6186
                {
6187
                  if (ce->index)
6188
                    curindex = fold_convert (sizetype, ce->index);
6189
                  else
6190
                    curindex = size_binop (PLUS_EXPR, curindex, size_one_node);
6191
 
6192
                  if (tree_int_cst_lt (maxindex, curindex))
6193
                    maxindex = curindex;
6194
                }
6195
            }
6196
        }
6197
      else
6198
        {
6199
          /* Make an error message unless that happened already.  */
6200
          if (initial_value != error_mark_node)
6201
            failure = 1;
6202
        }
6203
    }
6204
  else
6205
    {
6206
      failure = 2;
6207
      if (!do_default)
6208
        return failure;
6209
    }
6210
 
6211
  type = *ptype;
6212
  elt = TREE_TYPE (type);
6213
  quals = TYPE_QUALS (strip_array_types (elt));
6214
  if (quals == 0)
6215
    unqual_elt = elt;
6216
  else
6217
    unqual_elt = c_build_qualified_type (elt, TYPE_UNQUALIFIED);
6218
 
6219
  /* Using build_distinct_type_copy and modifying things afterward instead
6220
     of using build_array_type to create a new type preserves all of the
6221
     TYPE_LANG_FLAG_? bits that the front end may have set.  */
6222
  main_type = build_distinct_type_copy (TYPE_MAIN_VARIANT (type));
6223
  TREE_TYPE (main_type) = unqual_elt;
6224
  TYPE_DOMAIN (main_type) = build_index_type (maxindex);
6225
  layout_type (main_type);
6226
 
6227
  if (quals == 0)
6228
    type = main_type;
6229
  else
6230
    type = c_build_qualified_type (main_type, quals);
6231
 
6232
  *ptype = type;
6233
  return failure;
6234
}
6235
 
6236
 
6237
/* Used to help initialize the builtin-types.def table.  When a type of
6238
   the correct size doesn't exist, use error_mark_node instead of NULL.
6239
   The later results in segfaults even when a decl using the type doesn't
6240
   get invoked.  */
6241
 
6242
tree
6243
builtin_type_for_size (int size, bool unsignedp)
6244
{
6245
  tree type = lang_hooks.types.type_for_size (size, unsignedp);
6246
  return type ? type : error_mark_node;
6247
}
6248
 
6249
/* A helper function for resolve_overloaded_builtin in resolving the
6250
   overloaded __sync_ builtins.  Returns a positive power of 2 if the
6251
   first operand of PARAMS is a pointer to a supported data type.
6252
   Returns 0 if an error is encountered.  */
6253
 
6254
static int
6255
sync_resolve_size (tree function, tree params)
6256
{
6257
  tree type;
6258
  int size;
6259
 
6260
  if (params == NULL)
6261
    {
6262
      error ("too few arguments to function %qE", function);
6263
      return 0;
6264
    }
6265
 
6266
  type = TREE_TYPE (TREE_VALUE (params));
6267
  if (TREE_CODE (type) != POINTER_TYPE)
6268
    goto incompatible;
6269
 
6270
  type = TREE_TYPE (type);
6271
  if (!INTEGRAL_TYPE_P (type) && !POINTER_TYPE_P (type))
6272
    goto incompatible;
6273
 
6274
  size = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
6275
  if (size == 1 || size == 2 || size == 4 || size == 8 || size == 16)
6276
    return size;
6277
 
6278
 incompatible:
6279
  error ("incompatible type for argument %d of %qE", 1, function);
6280
  return 0;
6281
}
6282
 
6283
/* A helper function for resolve_overloaded_builtin.  Adds casts to
6284
   PARAMS to make arguments match up with those of FUNCTION.  Drops
6285
   the variadic arguments at the end.  Returns false if some error
6286
   was encountered; true on success.  */
6287
 
6288
static bool
6289
sync_resolve_params (tree orig_function, tree function, tree params)
6290
{
6291
  tree arg_types = TYPE_ARG_TYPES (TREE_TYPE (function));
6292
  tree ptype;
6293
  int number;
6294
 
6295
  /* We've declared the implementation functions to use "volatile void *"
6296
     as the pointer parameter, so we shouldn't get any complaints from the
6297
     call to check_function_arguments what ever type the user used.  */
6298
  arg_types = TREE_CHAIN (arg_types);
6299
  ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6300
  number = 2;
6301
 
6302
  /* For the rest of the values, we need to cast these to FTYPE, so that we
6303
     don't get warnings for passing pointer types, etc.  */
6304
  while (arg_types != void_list_node)
6305
    {
6306
      tree val;
6307
 
6308
      params = TREE_CHAIN (params);
6309
      if (params == NULL)
6310
        {
6311
          error ("too few arguments to function %qE", orig_function);
6312
          return false;
6313
        }
6314
 
6315
      /* ??? Ideally for the first conversion we'd use convert_for_assignment
6316
         so that we get warnings for anything that doesn't match the pointer
6317
         type.  This isn't portable across the C and C++ front ends atm.  */
6318
      val = TREE_VALUE (params);
6319
      val = convert (ptype, val);
6320
      val = convert (TREE_VALUE (arg_types), val);
6321
      TREE_VALUE (params) = val;
6322
 
6323
      arg_types = TREE_CHAIN (arg_types);
6324
      number++;
6325
    }
6326
 
6327
  /* The definition of these primitives is variadic, with the remaining
6328
     being "an optional list of variables protected by the memory barrier".
6329
     No clue what that's supposed to mean, precisely, but we consider all
6330
     call-clobbered variables to be protected so we're safe.  */
6331
  TREE_CHAIN (params) = NULL;
6332
 
6333
  return true;
6334
}
6335
 
6336
/* A helper function for resolve_overloaded_builtin.  Adds a cast to
6337
   RESULT to make it match the type of the first pointer argument in
6338
   PARAMS.  */
6339
 
6340
static tree
6341
sync_resolve_return (tree params, tree result)
6342
{
6343
  tree ptype = TREE_TYPE (TREE_TYPE (TREE_VALUE (params)));
6344
  ptype = TYPE_MAIN_VARIANT (ptype);
6345
  return convert (ptype, result);
6346
}
6347
 
6348
/* Some builtin functions are placeholders for other expressions.  This
6349
   function should be called immediately after parsing the call expression
6350
   before surrounding code has committed to the type of the expression.
6351
 
6352
   FUNCTION is the DECL that has been invoked; it is known to be a builtin.
6353
   PARAMS is the argument list for the call.  The return value is non-null
6354
   when expansion is complete, and null if normal processing should
6355
   continue.  */
6356
 
6357
tree
6358
resolve_overloaded_builtin (tree function, tree params)
6359
{
6360
  enum built_in_function orig_code = DECL_FUNCTION_CODE (function);
6361
  switch (DECL_BUILT_IN_CLASS (function))
6362
    {
6363
    case BUILT_IN_NORMAL:
6364
      break;
6365
    case BUILT_IN_MD:
6366
      if (targetm.resolve_overloaded_builtin)
6367
        return targetm.resolve_overloaded_builtin (function, params);
6368
      else
6369
        return NULL_TREE;
6370
    default:
6371
      return NULL_TREE;
6372
    }
6373
 
6374
  /* Handle BUILT_IN_NORMAL here.  */
6375
  switch (orig_code)
6376
    {
6377
    case BUILT_IN_FETCH_AND_ADD_N:
6378
    case BUILT_IN_FETCH_AND_SUB_N:
6379
    case BUILT_IN_FETCH_AND_OR_N:
6380
    case BUILT_IN_FETCH_AND_AND_N:
6381
    case BUILT_IN_FETCH_AND_XOR_N:
6382
    case BUILT_IN_FETCH_AND_NAND_N:
6383
    case BUILT_IN_ADD_AND_FETCH_N:
6384
    case BUILT_IN_SUB_AND_FETCH_N:
6385
    case BUILT_IN_OR_AND_FETCH_N:
6386
    case BUILT_IN_AND_AND_FETCH_N:
6387
    case BUILT_IN_XOR_AND_FETCH_N:
6388
    case BUILT_IN_NAND_AND_FETCH_N:
6389
    case BUILT_IN_BOOL_COMPARE_AND_SWAP_N:
6390
    case BUILT_IN_VAL_COMPARE_AND_SWAP_N:
6391
    case BUILT_IN_LOCK_TEST_AND_SET_N:
6392
    case BUILT_IN_LOCK_RELEASE_N:
6393
      {
6394
        int n = sync_resolve_size (function, params);
6395
        tree new_function, result;
6396
 
6397
        if (n == 0)
6398
          return error_mark_node;
6399
 
6400
        new_function = built_in_decls[orig_code + exact_log2 (n) + 1];
6401
        if (!sync_resolve_params (function, new_function, params))
6402
          return error_mark_node;
6403
 
6404
        result = build_function_call (new_function, params);
6405
        if (orig_code != BUILT_IN_BOOL_COMPARE_AND_SWAP_N
6406
            && orig_code != BUILT_IN_LOCK_RELEASE_N)
6407
          result = sync_resolve_return (params, result);
6408
 
6409
        return result;
6410
      }
6411
 
6412
    default:
6413
      return NULL_TREE;
6414
    }
6415
}
6416
 
6417
/* Ignoring their sign, return true if two scalar types are the same.  */
6418
bool
6419
same_scalar_type_ignoring_signedness (tree t1, tree t2)
6420
{
6421
  enum tree_code c1 = TREE_CODE (t1), c2 = TREE_CODE (t2);
6422
 
6423
  gcc_assert ((c1 == INTEGER_TYPE || c1 == REAL_TYPE)
6424
              && (c2 == INTEGER_TYPE || c2 == REAL_TYPE));
6425
 
6426
  /* Equality works here because c_common_signed_type uses
6427
     TYPE_MAIN_VARIANT.  */
6428
  return lang_hooks.types.signed_type (t1)
6429
    == lang_hooks.types.signed_type (t2);
6430
}
6431
 
6432
/* Check for missing format attributes on function pointers.  LTYPE is
6433
   the new type or left-hand side type.  RTYPE is the old type or
6434
   right-hand side type.  Returns TRUE if LTYPE is missing the desired
6435
   attribute.  */
6436
 
6437
bool
6438
check_missing_format_attribute (tree ltype, tree rtype)
6439
{
6440
  tree const ttr = TREE_TYPE (rtype), ttl = TREE_TYPE (ltype);
6441
  tree ra;
6442
 
6443
  for (ra = TYPE_ATTRIBUTES (ttr); ra; ra = TREE_CHAIN (ra))
6444
    if (is_attribute_p ("format", TREE_PURPOSE (ra)))
6445
      break;
6446
  if (ra)
6447
    {
6448
      tree la;
6449
      for (la = TYPE_ATTRIBUTES (ttl); la; la = TREE_CHAIN (la))
6450
        if (is_attribute_p ("format", TREE_PURPOSE (la)))
6451
          break;
6452
      return !la;
6453
    }
6454
  else
6455
    return false;
6456
}
6457
 
6458
/* Subscripting with type char is likely to lose on a machine where
6459
   chars are signed.  So warn on any machine, but optionally.  Don't
6460
   warn for unsigned char since that type is safe.  Don't warn for
6461
   signed char because anyone who uses that must have done so
6462
   deliberately. Furthermore, we reduce the false positive load by
6463
   warning only for non-constant value of type char.  */
6464
 
6465
void
6466
warn_array_subscript_with_type_char (tree index)
6467
{
6468
  if (TYPE_MAIN_VARIANT (TREE_TYPE (index)) == char_type_node
6469
      && TREE_CODE (index) != INTEGER_CST)
6470
    warning (OPT_Wchar_subscripts, "array subscript has type %<char%>");
6471
}
6472
 
6473
 
6474
#include "gt-c-common.h"

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.