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

Subversion Repositories altor32

[/] [altor32/] [trunk/] [gcc-x64/] [or1knd-elf/] [lib/] [gcc/] [or1knd-elf/] [4.8.0/] [plugin/] [include/] [c-family/] [c-common.h] - Blame information for rev 35

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 35 ultra_embe
/* Definitions for c-common.c.
2
   Copyright (C) 1987, 1993, 1994, 1995, 1997, 1998, 1999, 2000, 2001, 2002,
3
   2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
#ifndef GCC_C_COMMON_H
23
#define GCC_C_COMMON_H
24
 
25
#include "splay-tree.h"
26
#include "cpplib.h"
27
#include "ggc.h"
28
#include "tree.h"
29
 
30
/* In order for the format checking to accept the C frontend
31
   diagnostic framework extensions, you must include this file before
32
   diagnostic-core.h, not after.  The C front end formats are a subset of those
33
   for C++, so they are the appropriate set to use in common code;
34
   cp-tree.h overrides this for C++.  */
35
#if defined(GCC_DIAGNOSTIC_CORE_H)
36
#error \
37
In order for the format checking to accept the C front end diagnostic \
38
framework extensions, you must include this file before diagnostic-core.h \
39
never after.
40
#endif
41
#ifndef GCC_DIAG_STYLE
42
#define GCC_DIAG_STYLE __gcc_cdiag__
43
#endif
44
#include "diagnostic-core.h"
45
 
46
/* Usage of TREE_LANG_FLAG_?:
47
   0: IDENTIFIER_MARKED (used by search routines).
48
      C_MAYBE_CONST_EXPR_INT_OPERANDS (in C_MAYBE_CONST_EXPR, for C)
49
   1: C_DECLARED_LABEL_FLAG (in LABEL_DECL)
50
      STATEMENT_LIST_STMT_EXPR (in STATEMENT_LIST)
51
      C_MAYBE_CONST_EXPR_NON_CONST (in C_MAYBE_CONST_EXPR, for C)
52
   2: unused
53
   3: STATEMENT_LIST_HAS_LABEL (in STATEMENT_LIST)
54
   4: unused
55
*/
56
 
57
/* Reserved identifiers.  This is the union of all the keywords for C,
58
   C++, and Objective-C.  All the type modifiers have to be in one
59
   block at the beginning, because they are used as mask bits.  There
60
   are 28 type modifiers; if we add many more we will have to redesign
61
   the mask mechanism.  */
62
 
63
enum rid
64
{
65
  /* Modifiers: */
66
  /* C, in empirical order of frequency.  */
67
  RID_STATIC = 0,
68
  RID_UNSIGNED, RID_LONG,    RID_CONST, RID_EXTERN,
69
  RID_REGISTER, RID_TYPEDEF, RID_SHORT, RID_INLINE,
70
  RID_VOLATILE, RID_SIGNED,  RID_AUTO,  RID_RESTRICT,
71
  RID_NORETURN,
72
 
73
  /* C extensions */
74
  RID_COMPLEX, RID_THREAD, RID_SAT,
75
 
76
  /* C++ */
77
  RID_FRIEND, RID_VIRTUAL, RID_EXPLICIT, RID_EXPORT, RID_MUTABLE,
78
 
79
  /* ObjC ("PQ" reserved words - they do not appear after a '@' and
80
     are keywords only in specific contexts)  */
81
  RID_IN, RID_OUT, RID_INOUT, RID_BYCOPY, RID_BYREF, RID_ONEWAY,
82
 
83
  /* ObjC ("PATTR" reserved words - they do not appear after a '@'
84
     and are keywords only as property attributes)  */
85
  RID_GETTER, RID_SETTER,
86
  RID_READONLY, RID_READWRITE,
87
  RID_ASSIGN, RID_RETAIN, RID_COPY,
88
  RID_NONATOMIC,
89
 
90
  /* C (reserved and imaginary types not implemented, so any use is a
91
     syntax error) */
92
  RID_IMAGINARY,
93
 
94
  /* C */
95
  RID_INT,     RID_CHAR,   RID_FLOAT,    RID_DOUBLE, RID_VOID,
96
  RID_INT128,
97
  RID_ENUM,    RID_STRUCT, RID_UNION,    RID_IF,     RID_ELSE,
98
  RID_WHILE,   RID_DO,     RID_FOR,      RID_SWITCH, RID_CASE,
99
  RID_DEFAULT, RID_BREAK,  RID_CONTINUE, RID_RETURN, RID_GOTO,
100
  RID_SIZEOF,
101
 
102
  /* C extensions */
103
  RID_ASM,       RID_TYPEOF,   RID_ALIGNOF,  RID_ATTRIBUTE,  RID_VA_ARG,
104
  RID_EXTENSION, RID_IMAGPART, RID_REALPART, RID_LABEL,      RID_CHOOSE_EXPR,
105
  RID_TYPES_COMPATIBLE_P,      RID_BUILTIN_COMPLEX,          RID_BUILTIN_SHUFFLE,
106
  RID_DFLOAT32, RID_DFLOAT64, RID_DFLOAT128,
107
  RID_FRACT, RID_ACCUM,
108
 
109
  /* C11 */
110
  RID_ALIGNAS,
111
 
112
  /* This means to warn that this is a C++ keyword, and then treat it
113
     as a normal identifier.  */
114
  RID_CXX_COMPAT_WARN,
115
 
116
  /* GNU transactional memory extension */
117
  RID_TRANSACTION_ATOMIC, RID_TRANSACTION_RELAXED, RID_TRANSACTION_CANCEL,
118
 
119
  /* Too many ways of getting the name of a function as a string */
120
  RID_FUNCTION_NAME, RID_PRETTY_FUNCTION_NAME, RID_C99_FUNCTION_NAME,
121
 
122
  /* C++ (some of these are keywords in Objective-C as well, but only
123
     if they appear after a '@') */
124
  RID_BOOL,     RID_WCHAR,    RID_CLASS,
125
  RID_PUBLIC,   RID_PRIVATE,  RID_PROTECTED,
126
  RID_TEMPLATE, RID_NULL,     RID_CATCH,
127
  RID_DELETE,   RID_FALSE,    RID_NAMESPACE,
128
  RID_NEW,      RID_OFFSETOF, RID_OPERATOR,
129
  RID_THIS,     RID_THROW,    RID_TRUE,
130
  RID_TRY,      RID_TYPENAME, RID_TYPEID,
131
  RID_USING,    RID_CHAR16,   RID_CHAR32,
132
 
133
  /* casts */
134
  RID_CONSTCAST, RID_DYNCAST, RID_REINTCAST, RID_STATCAST,
135
 
136
  /* C++ extensions */
137
  RID_BASES,                   RID_DIRECT_BASES,
138
  RID_HAS_NOTHROW_ASSIGN,      RID_HAS_NOTHROW_CONSTRUCTOR,
139
  RID_HAS_NOTHROW_COPY,        RID_HAS_TRIVIAL_ASSIGN,
140
  RID_HAS_TRIVIAL_CONSTRUCTOR, RID_HAS_TRIVIAL_COPY,
141
  RID_HAS_TRIVIAL_DESTRUCTOR,  RID_HAS_VIRTUAL_DESTRUCTOR,
142
  RID_IS_ABSTRACT,             RID_IS_BASE_OF,
143
  RID_IS_CLASS,                RID_IS_CONVERTIBLE_TO,
144
  RID_IS_EMPTY,                RID_IS_ENUM,
145
  RID_IS_FINAL,                RID_IS_LITERAL_TYPE,
146
  RID_IS_POD,                  RID_IS_POLYMORPHIC,
147
  RID_IS_STD_LAYOUT,           RID_IS_TRIVIAL,
148
  RID_IS_UNION,                RID_UNDERLYING_TYPE,
149
 
150
  /* C++11 */
151
  RID_CONSTEXPR, RID_DECLTYPE, RID_NOEXCEPT, RID_NULLPTR, RID_STATIC_ASSERT,
152
 
153
  /* Objective-C ("AT" reserved words - they are only keywords when
154
     they follow '@')  */
155
  RID_AT_ENCODE,   RID_AT_END,
156
  RID_AT_CLASS,    RID_AT_ALIAS,     RID_AT_DEFS,
157
  RID_AT_PRIVATE,  RID_AT_PROTECTED, RID_AT_PUBLIC,  RID_AT_PACKAGE,
158
  RID_AT_PROTOCOL, RID_AT_SELECTOR,
159
  RID_AT_THROW,    RID_AT_TRY,       RID_AT_CATCH,
160
  RID_AT_FINALLY,  RID_AT_SYNCHRONIZED,
161
  RID_AT_OPTIONAL, RID_AT_REQUIRED, RID_AT_PROPERTY,
162
  RID_AT_SYNTHESIZE, RID_AT_DYNAMIC,
163
  RID_AT_INTERFACE,
164
  RID_AT_IMPLEMENTATION,
165
 
166
  /* Named address support, mapping the keyword to a particular named address
167
     number.  Named address space 0 is reserved for the generic address.  If
168
     there are more than 254 named addresses, the addr_space_t type will need
169
     to be grown from an unsigned char to unsigned short.  */
170
  RID_ADDR_SPACE_0,             /* generic address */
171
  RID_ADDR_SPACE_1,
172
  RID_ADDR_SPACE_2,
173
  RID_ADDR_SPACE_3,
174
  RID_ADDR_SPACE_4,
175
  RID_ADDR_SPACE_5,
176
  RID_ADDR_SPACE_6,
177
  RID_ADDR_SPACE_7,
178
  RID_ADDR_SPACE_8,
179
  RID_ADDR_SPACE_9,
180
  RID_ADDR_SPACE_10,
181
  RID_ADDR_SPACE_11,
182
  RID_ADDR_SPACE_12,
183
  RID_ADDR_SPACE_13,
184
  RID_ADDR_SPACE_14,
185
  RID_ADDR_SPACE_15,
186
 
187
  RID_FIRST_ADDR_SPACE = RID_ADDR_SPACE_0,
188
  RID_LAST_ADDR_SPACE = RID_ADDR_SPACE_15,
189
 
190
  RID_MAX,
191
 
192
  RID_FIRST_MODIFIER = RID_STATIC,
193
  RID_LAST_MODIFIER = RID_ONEWAY,
194
 
195
  RID_FIRST_CXX0X = RID_CONSTEXPR,
196
  RID_LAST_CXX0X = RID_STATIC_ASSERT,
197
  RID_FIRST_AT = RID_AT_ENCODE,
198
  RID_LAST_AT = RID_AT_IMPLEMENTATION,
199
  RID_FIRST_PQ = RID_IN,
200
  RID_LAST_PQ = RID_ONEWAY,
201
  RID_FIRST_PATTR = RID_GETTER,
202
  RID_LAST_PATTR = RID_NONATOMIC
203
};
204
 
205
#define OBJC_IS_AT_KEYWORD(rid) \
206
  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_AT && \
207
   (unsigned int) (rid) <= (unsigned int) RID_LAST_AT)
208
 
209
#define OBJC_IS_PQ_KEYWORD(rid) \
210
  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PQ && \
211
   (unsigned int) (rid) <= (unsigned int) RID_LAST_PQ)
212
 
213
#define OBJC_IS_PATTR_KEYWORD(rid) \
214
  ((unsigned int) (rid) >= (unsigned int) RID_FIRST_PATTR && \
215
   (unsigned int) (rid) <= (unsigned int) RID_LAST_PATTR)
216
 
217
/* OBJC_IS_CXX_KEYWORD recognizes the 'CXX_OBJC' keywords (such as
218
   'class') which are shared in a subtle way between Objective-C and
219
   C++.  When the lexer is lexing in Objective-C/Objective-C++, if it
220
   finds '@' followed by one of these identifiers (eg, '@class'), it
221
   recognizes the whole as an Objective-C keyword.  If the identifier
222
   is found elsewhere, it follows the rules of the C/C++ language.
223
 */
224
#define OBJC_IS_CXX_KEYWORD(rid) \
225
  (rid == RID_CLASS                                                     \
226
   || rid == RID_PUBLIC || rid == RID_PROTECTED || rid == RID_PRIVATE   \
227
   || rid == RID_TRY || rid == RID_THROW || rid == RID_CATCH)
228
 
229
/* The elements of `ridpointers' are identifier nodes for the reserved
230
   type names and storage classes.  It is indexed by a RID_... value.  */
231
extern GTY ((length ("(int) RID_MAX"))) tree *ridpointers;
232
 
233
/* Standard named or nameless data types of the C compiler.  */
234
 
235
enum c_tree_index
236
{
237
    CTI_CHAR16_TYPE,
238
    CTI_CHAR32_TYPE,
239
    CTI_WCHAR_TYPE,
240
    CTI_UNDERLYING_WCHAR_TYPE,
241
    CTI_WINT_TYPE,
242
    CTI_SIGNED_SIZE_TYPE, /* For format checking only.  */
243
    CTI_UNSIGNED_PTRDIFF_TYPE, /* For format checking only.  */
244
    CTI_INTMAX_TYPE,
245
    CTI_UINTMAX_TYPE,
246
    CTI_WIDEST_INT_LIT_TYPE,
247
    CTI_WIDEST_UINT_LIT_TYPE,
248
 
249
    /* Types for <stdint.h>, that may not be defined on all
250
       targets.  */
251
    CTI_SIG_ATOMIC_TYPE,
252
    CTI_INT8_TYPE,
253
    CTI_INT16_TYPE,
254
    CTI_INT32_TYPE,
255
    CTI_INT64_TYPE,
256
    CTI_UINT8_TYPE,
257
    CTI_UINT16_TYPE,
258
    CTI_UINT32_TYPE,
259
    CTI_UINT64_TYPE,
260
    CTI_INT_LEAST8_TYPE,
261
    CTI_INT_LEAST16_TYPE,
262
    CTI_INT_LEAST32_TYPE,
263
    CTI_INT_LEAST64_TYPE,
264
    CTI_UINT_LEAST8_TYPE,
265
    CTI_UINT_LEAST16_TYPE,
266
    CTI_UINT_LEAST32_TYPE,
267
    CTI_UINT_LEAST64_TYPE,
268
    CTI_INT_FAST8_TYPE,
269
    CTI_INT_FAST16_TYPE,
270
    CTI_INT_FAST32_TYPE,
271
    CTI_INT_FAST64_TYPE,
272
    CTI_UINT_FAST8_TYPE,
273
    CTI_UINT_FAST16_TYPE,
274
    CTI_UINT_FAST32_TYPE,
275
    CTI_UINT_FAST64_TYPE,
276
    CTI_INTPTR_TYPE,
277
    CTI_UINTPTR_TYPE,
278
 
279
    CTI_CHAR_ARRAY_TYPE,
280
    CTI_CHAR16_ARRAY_TYPE,
281
    CTI_CHAR32_ARRAY_TYPE,
282
    CTI_WCHAR_ARRAY_TYPE,
283
    CTI_INT_ARRAY_TYPE,
284
    CTI_STRING_TYPE,
285
    CTI_CONST_STRING_TYPE,
286
 
287
    /* Type for boolean expressions (bool in C++, int in C).  */
288
    CTI_TRUTHVALUE_TYPE,
289
    CTI_TRUTHVALUE_TRUE,
290
    CTI_TRUTHVALUE_FALSE,
291
 
292
    CTI_DEFAULT_FUNCTION_TYPE,
293
 
294
    /* These are not types, but we have to look them up all the time.  */
295
    CTI_FUNCTION_NAME_DECL,
296
    CTI_PRETTY_FUNCTION_NAME_DECL,
297
    CTI_C99_FUNCTION_NAME_DECL,
298
    CTI_SAVED_FUNCTION_NAME_DECLS,
299
 
300
    CTI_VOID_ZERO,
301
 
302
    CTI_NULL,
303
 
304
    CTI_MAX
305
};
306
 
307
#define C_CPP_HASHNODE(id) \
308
  (&(((struct c_common_identifier *) (id))->node))
309
#define C_RID_CODE(id) \
310
  ((enum rid) (((struct c_common_identifier *) (id))->node.rid_code))
311
#define C_SET_RID_CODE(id, code) \
312
  (((struct c_common_identifier *) (id))->node.rid_code = (unsigned char) code)
313
 
314
/* Identifier part common to the C front ends.  Inherits from
315
   tree_identifier, despite appearances.  */
316
struct GTY(()) c_common_identifier {
317
  struct tree_common common;
318
  struct cpp_hashnode node;
319
};
320
 
321
/* An entry in the reserved keyword table.  */
322
 
323
struct c_common_resword
324
{
325
  const char *const word;
326
  ENUM_BITFIELD(rid) const rid : 16;
327
  const unsigned int disable   : 16;
328
};
329
 
330
/* Extra cpp_ttype values for C++.  */
331
 
332
/* A token type for keywords, as opposed to ordinary identifiers.  */
333
#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1))
334
 
335
/* A token type for template-ids.  If a template-id is processed while
336
   parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token;
337
   the value of the CPP_TEMPLATE_ID is whatever was returned by
338
   cp_parser_template_id.  */
339
#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1))
340
 
341
/* A token type for nested-name-specifiers.  If a
342
   nested-name-specifier is processed while parsing tentatively, it is
343
   replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the
344
   CPP_NESTED_NAME_SPECIFIER is whatever was returned by
345
   cp_parser_nested_name_specifier_opt.  */
346
#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1))
347
 
348
/* A token type for pre-parsed C++0x decltype.  */
349
#define CPP_DECLTYPE ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1))
350
 
351
/* The number of token types, including C++-specific ones.  */
352
#define N_CP_TTYPES ((int) (CPP_DECLTYPE + 1))
353
 
354
/* Disable mask.  Keywords are disabled if (reswords[i].disable &
355
   mask) is _true_.  Thus for keywords which are present in all
356
   languages the disable field is zero.  */
357
 
358
#define D_CONLY         0x001   /* C only (not in C++).  */
359
#define D_CXXONLY       0x002   /* C++ only (not in C).  */
360
#define D_C99           0x004   /* In C, C99 only.  */
361
#define D_CXX0X         0x008   /* In C++, C++0X only.  */
362
#define D_EXT           0x010   /* GCC extension.  */
363
#define D_EXT89         0x020   /* GCC extension incorporated in C99.  */
364
#define D_ASM           0x040   /* Disabled by -fno-asm.  */
365
#define D_OBJC          0x080   /* In Objective C and neither C nor C++.  */
366
#define D_CXX_OBJC      0x100   /* In Objective C, and C++, but not C.  */
367
#define D_CXXWARN       0x200   /* In C warn with -Wcxx-compat.  */
368
 
369
/* The reserved keyword table.  */
370
extern const struct c_common_resword c_common_reswords[];
371
 
372
/* The number of items in the reserved keyword table.  */
373
extern const unsigned int num_c_common_reswords;
374
 
375
#define char16_type_node                c_global_trees[CTI_CHAR16_TYPE]
376
#define char32_type_node                c_global_trees[CTI_CHAR32_TYPE]
377
#define wchar_type_node                 c_global_trees[CTI_WCHAR_TYPE]
378
#define underlying_wchar_type_node      c_global_trees[CTI_UNDERLYING_WCHAR_TYPE]
379
#define wint_type_node                  c_global_trees[CTI_WINT_TYPE]
380
#define signed_size_type_node           c_global_trees[CTI_SIGNED_SIZE_TYPE]
381
#define unsigned_ptrdiff_type_node      c_global_trees[CTI_UNSIGNED_PTRDIFF_TYPE]
382
#define intmax_type_node                c_global_trees[CTI_INTMAX_TYPE]
383
#define uintmax_type_node               c_global_trees[CTI_UINTMAX_TYPE]
384
#define widest_integer_literal_type_node c_global_trees[CTI_WIDEST_INT_LIT_TYPE]
385
#define widest_unsigned_literal_type_node c_global_trees[CTI_WIDEST_UINT_LIT_TYPE]
386
 
387
#define sig_atomic_type_node            c_global_trees[CTI_SIG_ATOMIC_TYPE]
388
#define int8_type_node                  c_global_trees[CTI_INT8_TYPE]
389
#define int16_type_node                 c_global_trees[CTI_INT16_TYPE]
390
#define int32_type_node                 c_global_trees[CTI_INT32_TYPE]
391
#define int64_type_node                 c_global_trees[CTI_INT64_TYPE]
392
#define uint8_type_node                 c_global_trees[CTI_UINT8_TYPE]
393
#define c_uint16_type_node              c_global_trees[CTI_UINT16_TYPE]
394
#define c_uint32_type_node              c_global_trees[CTI_UINT32_TYPE]
395
#define c_uint64_type_node              c_global_trees[CTI_UINT64_TYPE]
396
#define int_least8_type_node            c_global_trees[CTI_INT_LEAST8_TYPE]
397
#define int_least16_type_node           c_global_trees[CTI_INT_LEAST16_TYPE]
398
#define int_least32_type_node           c_global_trees[CTI_INT_LEAST32_TYPE]
399
#define int_least64_type_node           c_global_trees[CTI_INT_LEAST64_TYPE]
400
#define uint_least8_type_node           c_global_trees[CTI_UINT_LEAST8_TYPE]
401
#define uint_least16_type_node          c_global_trees[CTI_UINT_LEAST16_TYPE]
402
#define uint_least32_type_node          c_global_trees[CTI_UINT_LEAST32_TYPE]
403
#define uint_least64_type_node          c_global_trees[CTI_UINT_LEAST64_TYPE]
404
#define int_fast8_type_node             c_global_trees[CTI_INT_FAST8_TYPE]
405
#define int_fast16_type_node            c_global_trees[CTI_INT_FAST16_TYPE]
406
#define int_fast32_type_node            c_global_trees[CTI_INT_FAST32_TYPE]
407
#define int_fast64_type_node            c_global_trees[CTI_INT_FAST64_TYPE]
408
#define uint_fast8_type_node            c_global_trees[CTI_UINT_FAST8_TYPE]
409
#define uint_fast16_type_node           c_global_trees[CTI_UINT_FAST16_TYPE]
410
#define uint_fast32_type_node           c_global_trees[CTI_UINT_FAST32_TYPE]
411
#define uint_fast64_type_node           c_global_trees[CTI_UINT_FAST64_TYPE]
412
#define intptr_type_node                c_global_trees[CTI_INTPTR_TYPE]
413
#define uintptr_type_node               c_global_trees[CTI_UINTPTR_TYPE]
414
 
415
#define truthvalue_type_node            c_global_trees[CTI_TRUTHVALUE_TYPE]
416
#define truthvalue_true_node            c_global_trees[CTI_TRUTHVALUE_TRUE]
417
#define truthvalue_false_node           c_global_trees[CTI_TRUTHVALUE_FALSE]
418
 
419
#define char_array_type_node            c_global_trees[CTI_CHAR_ARRAY_TYPE]
420
#define char16_array_type_node          c_global_trees[CTI_CHAR16_ARRAY_TYPE]
421
#define char32_array_type_node          c_global_trees[CTI_CHAR32_ARRAY_TYPE]
422
#define wchar_array_type_node           c_global_trees[CTI_WCHAR_ARRAY_TYPE]
423
#define int_array_type_node             c_global_trees[CTI_INT_ARRAY_TYPE]
424
#define string_type_node                c_global_trees[CTI_STRING_TYPE]
425
#define const_string_type_node          c_global_trees[CTI_CONST_STRING_TYPE]
426
 
427
#define default_function_type           c_global_trees[CTI_DEFAULT_FUNCTION_TYPE]
428
 
429
#define function_name_decl_node         c_global_trees[CTI_FUNCTION_NAME_DECL]
430
#define pretty_function_name_decl_node  c_global_trees[CTI_PRETTY_FUNCTION_NAME_DECL]
431
#define c99_function_name_decl_node             c_global_trees[CTI_C99_FUNCTION_NAME_DECL]
432
#define saved_function_name_decls       c_global_trees[CTI_SAVED_FUNCTION_NAME_DECLS]
433
 
434
/* A node for `((void) 0)'.  */
435
#define void_zero_node                  c_global_trees[CTI_VOID_ZERO]
436
 
437
/* The node for C++ `__null'.  */
438
#define null_node                       c_global_trees[CTI_NULL]
439
 
440
extern GTY(()) tree c_global_trees[CTI_MAX];
441
 
442
/* In a RECORD_TYPE, a sorted array of the fields of the type, not a
443
   tree for size reasons.  */
444
struct GTY((variable_size)) sorted_fields_type {
445
  int len;
446
  tree GTY((length ("%h.len"))) elts[1];
447
};
448
 
449
/* Mark which labels are explicitly declared.
450
   These may be shadowed, and may be referenced from nested functions.  */
451
#define C_DECLARED_LABEL_FLAG(label) TREE_LANG_FLAG_1 (label)
452
 
453
typedef enum c_language_kind
454
{
455
  clk_c         = 0,             /* C90, C94 or C99 */
456
  clk_objc      = 1,            /* clk_c with ObjC features.  */
457
  clk_cxx       = 2,            /* ANSI/ISO C++ */
458
  clk_objcxx    = 3             /* clk_cxx with ObjC features.  */
459
}
460
c_language_kind;
461
 
462
/* To test for a specific language use c_language, defined by each
463
   front end.  For "ObjC features" or "not C++" use the macros.  */
464
extern c_language_kind c_language;
465
 
466
#define c_dialect_cxx()         ((c_language & clk_cxx) != 0)
467
#define c_dialect_objc()        ((c_language & clk_objc) != 0)
468
 
469
/* The various name of operator that appears in error messages. */
470
typedef enum ref_operator {
471
  /* NULL */
472
  RO_NULL,
473
  /* array indexing */
474
  RO_ARRAY_INDEXING,
475
  /* unary * */
476
  RO_UNARY_STAR,
477
  /* -> */
478
  RO_ARROW,
479
  /* implicit conversion */
480
  RO_IMPLICIT_CONVERSION,
481
  /* ->* */
482
  RO_ARROW_STAR
483
} ref_operator;
484
 
485
/* Information about a statement tree.  */
486
 
487
struct GTY(()) stmt_tree_s {
488
  /* A stack of statement lists being collected.  */
489
  vec<tree, va_gc> *x_cur_stmt_list;
490
 
491
  /* In C++, Nonzero if we should treat statements as full
492
     expressions.  In particular, this variable is non-zero if at the
493
     end of a statement we should destroy any temporaries created
494
     during that statement.  Similarly, if, at the end of a block, we
495
     should destroy any local variables in this block.  Normally, this
496
     variable is nonzero, since those are the normal semantics of
497
     C++.
498
 
499
     This flag has no effect in C.  */
500
  int stmts_are_full_exprs_p;
501
};
502
 
503
typedef struct stmt_tree_s *stmt_tree;
504
 
505
/* Global state pertinent to the current function.  Some C dialects
506
   extend this structure with additional fields.  */
507
 
508
struct GTY(()) c_language_function {
509
  /* While we are parsing the function, this contains information
510
     about the statement-tree that we are building.  */
511
  struct stmt_tree_s x_stmt_tree;
512
 
513
  /* Vector of locally defined typedefs, for
514
     -Wunused-local-typedefs.  */
515
  vec<tree, va_gc> *local_typedefs;
516
};
517
 
518
#define stmt_list_stack (current_stmt_tree ()->x_cur_stmt_list)
519
 
520
/* When building a statement-tree, this is the current statement list
521
   being collected.  */
522
#define cur_stmt_list   (stmt_list_stack->last ())
523
 
524
#define building_stmt_list_p() (stmt_list_stack && !stmt_list_stack->is_empty())
525
 
526
/* Language-specific hooks.  */
527
 
528
/* If non-NULL, this function is called after a precompile header file
529
   is loaded.  */
530
extern void (*lang_post_pch_load) (void);
531
 
532
extern void push_file_scope (void);
533
extern void pop_file_scope (void);
534
extern stmt_tree current_stmt_tree (void);
535
extern tree push_stmt_list (void);
536
extern tree pop_stmt_list (tree);
537
extern tree add_stmt (tree);
538
extern void push_cleanup (tree, tree, bool);
539
extern tree pushdecl_top_level (tree);
540
extern tree pushdecl (tree);
541
extern tree build_modify_expr (location_t, tree, tree, enum tree_code,
542
                               location_t, tree, tree);
543
extern tree build_indirect_ref (location_t, tree, ref_operator);
544
 
545
extern int field_decl_cmp (const void *, const void *);
546
extern void resort_sorted_fields (void *, void *, gt_pointer_operator,
547
                                  void *);
548
extern bool has_c_linkage (const_tree decl);
549
 
550
/* Switches common to the C front ends.  */
551
 
552
/* Nonzero means don't output line number information.  */
553
 
554
extern char flag_no_line_commands;
555
 
556
/* Nonzero causes -E output not to be done, but directives such as
557
   #define that have side effects are still obeyed.  */
558
 
559
extern char flag_no_output;
560
 
561
/* Nonzero means dump macros in some fashion; contains the 'D', 'M',
562
   'N' or 'U' of the command line switch.  */
563
 
564
extern char flag_dump_macros;
565
 
566
/* Nonzero means pass #include lines through to the output.  */
567
 
568
extern char flag_dump_includes;
569
 
570
/* Nonzero means process PCH files while preprocessing.  */
571
 
572
extern bool flag_pch_preprocess;
573
 
574
/* The file name to which we should write a precompiled header, or
575
   NULL if no header will be written in this compile.  */
576
 
577
extern const char *pch_file;
578
 
579
/* Nonzero if an ISO standard was selected.  It rejects macros in the
580
   user's namespace.  */
581
 
582
extern int flag_iso;
583
 
584
/* C/ObjC language option variables.  */
585
 
586
 
587
/* Nonzero means allow type mismatches in conditional expressions;
588
   just make their values `void'.  */
589
 
590
extern int flag_cond_mismatch;
591
 
592
/* Nonzero means enable C89 Amendment 1 features.  */
593
 
594
extern int flag_isoc94;
595
 
596
/* Nonzero means use the ISO C99 (or C11) dialect of C.  */
597
 
598
extern int flag_isoc99;
599
 
600
/* Nonzero means use the ISO C11 dialect of C.  */
601
 
602
extern int flag_isoc11;
603
 
604
/* Nonzero means that we have builtin functions, and main is an int.  */
605
 
606
extern int flag_hosted;
607
 
608
/* ObjC language option variables.  */
609
 
610
 
611
/* Tells the compiler that this is a special run.  Do not perform any
612
   compiling, instead we are to test some platform dependent features
613
   and output a C header file with appropriate definitions.  */
614
 
615
extern int print_struct_values;
616
 
617
/* Tells the compiler what is the constant string class for ObjC.  */
618
 
619
extern const char *constant_string_class_name;
620
 
621
 
622
/* C++ language option variables.  */
623
 
624
 
625
/* Nonzero means generate separate instantiation control files and
626
   juggle them at link time.  */
627
 
628
extern int flag_use_repository;
629
 
630
/* The supported C++ dialects.  */
631
 
632
enum cxx_dialect {
633
  /* C++98 with TC1  */
634
  cxx98,
635
  cxx03 = cxx98,
636
  /* C++11  */
637
  cxx0x,
638
  cxx11 = cxx0x,
639
  /* C++1y (C++17?) */
640
  cxx1y
641
};
642
 
643
/* The C++ dialect being used. C++98 is the default.  */
644
extern enum cxx_dialect cxx_dialect;
645
 
646
/* Maximum template instantiation depth.  This limit is rather
647
   arbitrary, but it exists to limit the time it takes to notice
648
   excessively recursive template instantiations.  */
649
 
650
extern int max_tinst_depth;
651
 
652
/* Nonzero means that we should not issue warnings about problems that
653
   occur when the code is executed, because the code being processed
654
   is not expected to be executed.  This is set during parsing.  This
655
   is used for cases like sizeof() and "0 ? a : b".  This is a count,
656
   not a bool, because unexecuted expressions can nest.  */
657
 
658
extern int c_inhibit_evaluation_warnings;
659
 
660
/* Whether lexing has been completed, so subsequent preprocessor
661
   errors should use the compiler's input_location.  */
662
 
663
extern bool done_lexing;
664
 
665
/* C types are partitioned into three subsets: object, function, and
666
   incomplete types.  */
667
#define C_TYPE_OBJECT_P(type) \
668
  (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type))
669
 
670
#define C_TYPE_INCOMPLETE_P(type) \
671
  (TREE_CODE (type) != FUNCTION_TYPE && TYPE_SIZE (type) == 0)
672
 
673
#define C_TYPE_FUNCTION_P(type) \
674
  (TREE_CODE (type) == FUNCTION_TYPE)
675
 
676
/* For convenience we define a single macro to identify the class of
677
   object or incomplete types.  */
678
#define C_TYPE_OBJECT_OR_INCOMPLETE_P(type) \
679
  (!C_TYPE_FUNCTION_P (type))
680
 
681
struct visibility_flags
682
{
683
  unsigned inpragma : 1;        /* True when in #pragma GCC visibility.  */
684
  unsigned inlines_hidden : 1;  /* True when -finlineshidden in effect.  */
685
};
686
 
687
/* Global visibility options.  */
688
extern struct visibility_flags visibility_options;
689
 
690
/* Attribute table common to the C front ends.  */
691
extern const struct attribute_spec c_common_attribute_table[];
692
extern const struct attribute_spec c_common_format_attribute_table[];
693
 
694
/* Pointer to function to lazily generate the VAR_DECL for __FUNCTION__ etc.
695
   ID is the identifier to use, NAME is the string.
696
   TYPE_DEP indicates whether it depends on type of the function or not
697
   (i.e. __PRETTY_FUNCTION__).  */
698
 
699
extern tree (*make_fname_decl) (location_t, tree, int);
700
 
701
/* In c-decl.c and cp/tree.c.  FIXME.  */
702
extern void c_register_addr_space (const char *str, addr_space_t as);
703
 
704
/* In c-common.c.  */
705
extern bool in_late_binary_op;
706
extern const char *c_addr_space_name (addr_space_t as);
707
extern tree identifier_global_value (tree);
708
extern tree c_linkage_bindings (tree);
709
extern void record_builtin_type (enum rid, const char *, tree);
710
extern tree build_void_list_node (void);
711
extern void start_fname_decls (void);
712
extern void finish_fname_decls (void);
713
extern const char *fname_as_string (int);
714
extern tree fname_decl (location_t, unsigned, tree);
715
 
716
extern int check_user_alignment (const_tree, bool);
717
extern void check_function_arguments (const_tree, int, tree *);
718
extern void check_function_arguments_recurse (void (*)
719
                                              (void *, tree,
720
                                               unsigned HOST_WIDE_INT),
721
                                              void *, tree,
722
                                              unsigned HOST_WIDE_INT);
723
extern bool check_builtin_function_arguments (tree, int, tree *);
724
extern void check_function_format (tree, int, tree *);
725
extern tree handle_format_attribute (tree *, tree, tree, int, bool *);
726
extern tree handle_format_arg_attribute (tree *, tree, tree, int, bool *);
727
extern bool attribute_takes_identifier_p (const_tree);
728
extern bool c_common_handle_option (size_t, const char *, int, int, location_t,
729
                                    const struct cl_option_handlers *);
730
extern bool default_handle_c_option (size_t, const char *, int);
731
extern tree c_common_type_for_mode (enum machine_mode, int);
732
extern tree c_common_type_for_size (unsigned int, int);
733
extern tree c_common_fixed_point_type_for_size (unsigned int, unsigned int,
734
                                                int, int);
735
extern tree c_common_unsigned_type (tree);
736
extern tree c_common_signed_type (tree);
737
extern tree c_common_signed_or_unsigned_type (int, tree);
738
extern void c_common_init_ts (void);
739
extern tree c_build_bitfield_integer_type (unsigned HOST_WIDE_INT, int);
740
extern bool unsafe_conversion_p (tree, tree, bool);
741
extern bool decl_with_nonnull_addr_p (const_tree);
742
extern tree c_fully_fold (tree, bool, bool *);
743
extern tree decl_constant_value_for_optimization (tree);
744
extern tree c_wrap_maybe_const (tree, bool);
745
extern tree c_save_expr (tree);
746
extern tree c_common_truthvalue_conversion (location_t, tree);
747
extern void c_apply_type_quals_to_decl (int, tree);
748
extern tree c_sizeof_or_alignof_type (location_t, tree, bool, int);
749
extern tree c_alignof_expr (location_t, tree);
750
/* Print an error message for invalid operands to arith operation CODE.
751
   NOP_EXPR is used as a special case (see truthvalue_conversion).  */
752
extern void binary_op_error (location_t, enum tree_code, tree, tree);
753
extern tree fix_string_type (tree);
754
extern void constant_expression_warning (tree);
755
extern void constant_expression_error (tree);
756
extern bool strict_aliasing_warning (tree, tree, tree);
757
extern void sizeof_pointer_memaccess_warning (location_t *, tree,
758
                                              vec<tree, va_gc> *, tree *,
759
                                              bool (*) (tree, tree));
760
extern void warnings_for_convert_and_check (tree, tree, tree);
761
extern tree convert_and_check (tree, tree);
762
extern void overflow_warning (location_t, tree);
763
extern bool warn_if_unused_value (const_tree, location_t);
764
extern void warn_logical_operator (location_t, enum tree_code, tree,
765
                                   enum tree_code, tree, enum tree_code, tree);
766
extern void check_main_parameter_types (tree decl);
767
extern bool c_determine_visibility (tree);
768
extern bool same_scalar_type_ignoring_signedness (tree, tree);
769
extern void mark_valid_location_for_stdc_pragma (bool);
770
extern bool valid_location_for_stdc_pragma_p (void);
771
extern void set_float_const_decimal64 (void);
772
extern void clear_float_const_decimal64 (void);
773
extern bool float_const_decimal64_p (void);
774
 
775
extern bool keyword_begins_type_specifier (enum rid);
776
extern bool keyword_is_storage_class_specifier (enum rid);
777
extern bool keyword_is_type_qualifier (enum rid);
778
extern bool keyword_is_decl_specifier (enum rid);
779
extern bool cxx_fundamental_alignment_p (unsigned);
780
 
781
#define c_sizeof(LOC, T)  c_sizeof_or_alignof_type (LOC, T, true, 1)
782
#define c_alignof(LOC, T) c_sizeof_or_alignof_type (LOC, T, false, 1)
783
 
784
/* Subroutine of build_binary_op, used for certain operations.  */
785
extern tree shorten_binary_op (tree result_type, tree op0, tree op1, bool bitwise);
786
 
787
/* Subroutine of build_binary_op, used for comparison operations.
788
   See if the operands have both been converted from subword integer types
789
   and, if so, perhaps change them both back to their original type.  */
790
extern tree shorten_compare (tree *, tree *, tree *, enum tree_code *);
791
 
792
extern tree pointer_int_sum (location_t, enum tree_code, tree, tree);
793
 
794
/* Add qualifiers to a type, in the fashion for C.  */
795
extern tree c_build_qualified_type (tree, int);
796
 
797
/* Build tree nodes and builtin functions common to both C and C++ language
798
   frontends.  */
799
extern void c_common_nodes_and_builtins (void);
800
 
801
extern void disable_builtin_function (const char *);
802
 
803
extern void set_compound_literal_name (tree decl);
804
 
805
extern tree build_va_arg (location_t, tree, tree);
806
 
807
extern const unsigned int c_family_lang_mask;
808
extern unsigned int c_common_option_lang_mask (void);
809
extern void c_common_initialize_diagnostics (diagnostic_context *);
810
extern bool c_common_complain_wrong_lang_p (const struct cl_option *);
811
extern void c_common_init_options_struct (struct gcc_options *);
812
extern void c_common_init_options (unsigned int, struct cl_decoded_option *);
813
extern bool c_common_post_options (const char **);
814
extern bool c_common_init (void);
815
extern void c_common_finish (void);
816
extern void c_common_parse_file (void);
817
extern alias_set_type c_common_get_alias_set (tree);
818
extern void c_register_builtin_type (tree, const char*);
819
extern bool c_promoting_integer_type_p (const_tree);
820
extern int self_promoting_args_p (const_tree);
821
extern tree strip_pointer_operator (tree);
822
extern tree strip_pointer_or_array_types (tree);
823
extern HOST_WIDE_INT c_common_to_target_charset (HOST_WIDE_INT);
824
 
825
/* This is the basic parsing function.  */
826
extern void c_parse_file (void);
827
 
828
extern void warn_for_omitted_condop (location_t, tree);
829
 
830
/* These macros provide convenient access to the various _STMT nodes.  */
831
 
832
/* Nonzero if a given STATEMENT_LIST represents the outermost binding
833
   if a statement expression.  */
834
#define STATEMENT_LIST_STMT_EXPR(NODE) \
835
  TREE_LANG_FLAG_1 (STATEMENT_LIST_CHECK (NODE))
836
 
837
/* Nonzero if a label has been added to the statement list.  */
838
#define STATEMENT_LIST_HAS_LABEL(NODE) \
839
  TREE_LANG_FLAG_3 (STATEMENT_LIST_CHECK (NODE))
840
 
841
/* C_MAYBE_CONST_EXPR accessors.  */
842
#define C_MAYBE_CONST_EXPR_PRE(NODE)                    \
843
  TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 0)
844
#define C_MAYBE_CONST_EXPR_EXPR(NODE)                   \
845
  TREE_OPERAND (C_MAYBE_CONST_EXPR_CHECK (NODE), 1)
846
#define C_MAYBE_CONST_EXPR_INT_OPERANDS(NODE)           \
847
  TREE_LANG_FLAG_0 (C_MAYBE_CONST_EXPR_CHECK (NODE))
848
#define C_MAYBE_CONST_EXPR_NON_CONST(NODE)              \
849
  TREE_LANG_FLAG_1 (C_MAYBE_CONST_EXPR_CHECK (NODE))
850
#define EXPR_INT_CONST_OPERANDS(EXPR)                   \
851
  (INTEGRAL_TYPE_P (TREE_TYPE (EXPR))                   \
852
   && (TREE_CODE (EXPR) == INTEGER_CST                  \
853
       || (TREE_CODE (EXPR) == C_MAYBE_CONST_EXPR       \
854
           && C_MAYBE_CONST_EXPR_INT_OPERANDS (EXPR))))
855
 
856
/* In a FIELD_DECL, nonzero if the decl was originally a bitfield.  */
857
#define DECL_C_BIT_FIELD(NODE) \
858
  (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) == 1)
859
#define SET_DECL_C_BIT_FIELD(NODE) \
860
  (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 1)
861
#define CLEAR_DECL_C_BIT_FIELD(NODE) \
862
  (DECL_LANG_FLAG_4 (FIELD_DECL_CHECK (NODE)) = 0)
863
 
864
extern tree do_case (location_t, tree, tree);
865
extern tree build_stmt (location_t, enum tree_code, ...);
866
extern tree build_real_imag_expr (location_t, enum tree_code, tree);
867
 
868
/* These functions must be defined by each front-end which implements
869
   a variant of the C language.  They are used in c-common.c.  */
870
 
871
extern tree build_unary_op (location_t, enum tree_code, tree, int);
872
extern tree build_binary_op (location_t, enum tree_code, tree, tree, int);
873
extern tree perform_integral_promotions (tree);
874
 
875
/* These functions must be defined by each front-end which implements
876
   a variant of the C language.  They are used by port files.  */
877
 
878
extern tree default_conversion (tree);
879
 
880
/* Given two integer or real types, return the type for their sum.
881
   Given two compatible ANSI C types, returns the merged type.  */
882
 
883
extern tree common_type (tree, tree);
884
 
885
extern tree decl_constant_value (tree);
886
 
887
/* Handle increment and decrement of boolean types.  */
888
extern tree boolean_increment (enum tree_code, tree);
889
 
890
extern int case_compare (splay_tree_key, splay_tree_key);
891
 
892
extern tree c_add_case_label (location_t, splay_tree, tree, tree, tree, tree);
893
 
894
extern void c_do_switch_warnings (splay_tree, location_t, tree, tree);
895
 
896
extern tree build_function_call (location_t, tree, tree);
897
 
898
extern tree build_function_call_vec (location_t, tree, vec<tree, va_gc> *,
899
                                     vec<tree, va_gc> *);
900
 
901
extern tree resolve_overloaded_builtin (location_t, tree, vec<tree, va_gc> *);
902
 
903
extern tree finish_label_address_expr (tree, location_t);
904
 
905
/* Same function prototype, but the C and C++ front ends have
906
   different implementations.  Used in c-common.c.  */
907
extern tree lookup_label (tree);
908
extern tree lookup_name (tree);
909
extern bool lvalue_p (const_tree);
910
 
911
extern bool vector_targets_convertible_p (const_tree t1, const_tree t2);
912
extern bool vector_types_convertible_p (const_tree t1, const_tree t2, bool emit_lax_note);
913
extern tree c_build_vec_perm_expr (location_t, tree, tree, tree);
914
 
915
extern rtx c_expand_expr (tree, rtx, enum machine_mode, int, rtx *);
916
 
917
extern void init_c_lex (void);
918
 
919
extern void c_cpp_builtins (cpp_reader *);
920
extern void c_cpp_builtins_optimize_pragma (cpp_reader *, tree, tree);
921
extern bool c_cpp_error (cpp_reader *, int, int, location_t, unsigned int,
922
                         const char *, va_list *)
923
     ATTRIBUTE_GCC_DIAG(6,0);
924
 
925
extern bool parse_optimize_options (tree, bool);
926
 
927
/* Positive if an implicit `extern "C"' scope has just been entered;
928
   negative if such a scope has just been exited.  */
929
extern GTY(()) int pending_lang_change;
930
 
931
/* Information recorded about each file examined during compilation.  */
932
 
933
struct c_fileinfo
934
{
935
  int time;     /* Time spent in the file.  */
936
 
937
  /* Flags used only by C++.
938
     INTERFACE_ONLY nonzero means that we are in an "interface" section
939
     of the compiler.  INTERFACE_UNKNOWN nonzero means we cannot trust
940
     the value of INTERFACE_ONLY.  If INTERFACE_UNKNOWN is zero and
941
     INTERFACE_ONLY is zero, it means that we are responsible for
942
     exporting definitions that others might need.  */
943
  short interface_only;
944
  short interface_unknown;
945
};
946
 
947
struct c_fileinfo *get_fileinfo (const char *);
948
extern void dump_time_statistics (void);
949
 
950
extern bool c_dump_tree (void *, tree);
951
 
952
extern void verify_sequence_points (tree);
953
 
954
extern tree fold_offsetof_1 (tree);
955
extern tree fold_offsetof (tree);
956
 
957
/* Places where an lvalue, or modifiable lvalue, may be required.
958
   Used to select diagnostic messages in lvalue_error and
959
   readonly_error.  */
960
enum lvalue_use {
961
  lv_assign,
962
  lv_increment,
963
  lv_decrement,
964
  lv_addressof,
965
  lv_asm
966
};
967
 
968
extern void readonly_error (tree, enum lvalue_use);
969
extern void lvalue_error (location_t, enum lvalue_use);
970
extern void invalid_indirection_error (location_t, tree, ref_operator);
971
 
972
extern int complete_array_type (tree *, tree, bool);
973
 
974
extern tree builtin_type_for_size (int, bool);
975
 
976
extern void c_common_mark_addressable_vec (tree);
977
 
978
extern void warn_array_subscript_with_type_char (tree);
979
extern void warn_about_parentheses (location_t,
980
                                    enum tree_code,
981
                                    enum tree_code, tree,
982
                                    enum tree_code, tree);
983
extern void warn_for_unused_label (tree label);
984
extern void warn_for_div_by_zero (location_t, tree divisor);
985
extern void warn_for_sign_compare (location_t,
986
                                   tree orig_op0, tree orig_op1,
987
                                   tree op0, tree op1,
988
                                   tree result_type,
989
                                   enum tree_code resultcode);
990
extern void do_warn_double_promotion (tree, tree, tree, const char *,
991
                                      location_t);
992
extern void set_underlying_type (tree);
993
extern void record_locally_defined_typedef (tree);
994
extern void maybe_record_typedef_use (tree);
995
extern void maybe_warn_unused_local_typedefs (void);
996
extern vec<tree, va_gc> *make_tree_vector (void);
997
extern void release_tree_vector (vec<tree, va_gc> *);
998
extern vec<tree, va_gc> *make_tree_vector_single (tree);
999
extern vec<tree, va_gc> *make_tree_vector_from_list (tree);
1000
extern vec<tree, va_gc> *make_tree_vector_copy (const vec<tree, va_gc> *);
1001
 
1002
/* In c-gimplify.c  */
1003
extern void c_genericize (tree);
1004
extern int c_gimplify_expr (tree *, gimple_seq *, gimple_seq *);
1005
extern tree c_build_bind_expr (location_t, tree, tree);
1006
 
1007
/* In c-pch.c  */
1008
extern void pch_init (void);
1009
extern void pch_cpp_save_state (void);
1010
extern int c_common_valid_pch (cpp_reader *pfile, const char *name, int fd);
1011
extern void c_common_read_pch (cpp_reader *pfile, const char *name, int fd,
1012
                               const char *orig);
1013
extern void c_common_write_pch (void);
1014
extern void c_common_no_more_pch (void);
1015
extern void c_common_pch_pragma (cpp_reader *pfile, const char *);
1016
 
1017
/* In *-checksum.c */
1018
extern const unsigned char executable_checksum[16];
1019
 
1020
/* In c-cppbuiltin.c  */
1021
extern void builtin_define_std (const char *macro);
1022
extern void builtin_define_with_value (const char *, const char *, int);
1023
extern void c_stddef_cpp_builtins (void);
1024
extern void fe_file_change (const struct line_map *);
1025
extern void c_parse_error (const char *, enum cpp_ttype, tree, unsigned char);
1026
 
1027
/* In c-ppoutput.c  */
1028
extern void init_pp_output (FILE *);
1029
extern void preprocess_file (cpp_reader *);
1030
extern void pp_file_change (const struct line_map *);
1031
extern void pp_dir_change (cpp_reader *, const char *);
1032
extern bool check_missing_format_attribute (tree, tree);
1033
 
1034
/* In c-omp.c  */
1035
extern tree c_finish_omp_master (location_t, tree);
1036
extern tree c_finish_omp_critical (location_t, tree, tree);
1037
extern tree c_finish_omp_ordered (location_t, tree);
1038
extern void c_finish_omp_barrier (location_t);
1039
extern tree c_finish_omp_atomic (location_t, enum tree_code, enum tree_code,
1040
                                 tree, tree, tree, tree, tree);
1041
extern void c_finish_omp_flush (location_t);
1042
extern void c_finish_omp_taskwait (location_t);
1043
extern void c_finish_omp_taskyield (location_t);
1044
extern tree c_finish_omp_for (location_t, tree, tree, tree, tree, tree, tree);
1045
extern void c_split_parallel_clauses (location_t, tree, tree *, tree *);
1046
extern enum omp_clause_default_kind c_omp_predetermined_sharing (tree);
1047
 
1048
/* Not in c-omp.c; provided by the front end.  */
1049
extern bool c_omp_sharing_predetermined (tree);
1050
extern tree c_omp_remap_decl (tree, bool);
1051
extern void record_types_used_by_current_var_decl (tree);
1052
 
1053
/* Return next tree in the chain for chain_next walking of tree nodes.  */
1054
static inline tree
1055
c_tree_chain_next (tree t)
1056
{
1057
  /* TREE_CHAIN of a type is TYPE_STUB_DECL, which is different
1058
     kind of object, never a long chain of nodes.  Prefer
1059
     TYPE_NEXT_VARIANT for types.  */
1060
  if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_TYPE_COMMON))
1061
    return TYPE_NEXT_VARIANT (t);
1062
  /* Otherwise, if there is TREE_CHAIN, return it.  */
1063
  if (CODE_CONTAINS_STRUCT (TREE_CODE (t), TS_COMMON))
1064
    return TREE_CHAIN (t);
1065
  return NULL;
1066
}
1067
 
1068
/* Mask used by tm_stmt_attr.  */
1069
#define TM_STMT_ATTR_OUTER      2
1070
#define TM_STMT_ATTR_ATOMIC     4
1071
#define TM_STMT_ATTR_RELAXED    8
1072
 
1073
extern int parse_tm_stmt_attr (tree, int);
1074
 
1075
/* Mask used by tm_attr_to_mask and tm_mask_to_attr.  Note that these
1076
   are ordered specifically such that more restrictive attributes are
1077
   at lower bit positions.  This fact is known by the C++ tm attribute
1078
   inheritance code such that least bit extraction (mask & -mask) results
1079
   in the most restrictive attribute.  */
1080
#define TM_ATTR_SAFE                    1
1081
#define TM_ATTR_CALLABLE                2
1082
#define TM_ATTR_PURE                    4
1083
#define TM_ATTR_IRREVOCABLE             8
1084
#define TM_ATTR_MAY_CANCEL_OUTER        16
1085
 
1086
extern int tm_attr_to_mask (tree);
1087
extern tree tm_mask_to_attr (int);
1088
extern tree find_tm_attribute (tree);
1089
 
1090
/* A suffix-identifier value doublet that represents user-defined literals
1091
   for C++-0x.  */
1092
enum overflow_type {
1093
  OT_UNDERFLOW = -1,
1094
  OT_NONE,
1095
  OT_OVERFLOW
1096
};
1097
 
1098
struct GTY(()) tree_userdef_literal {
1099
  struct tree_base base;
1100
  tree suffix_id;
1101
  tree value;
1102
  tree num_string;
1103
  enum overflow_type overflow;
1104
};
1105
 
1106
#define USERDEF_LITERAL_SUFFIX_ID(NODE) \
1107
  (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->suffix_id)
1108
 
1109
#define USERDEF_LITERAL_VALUE(NODE) \
1110
  (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->value)
1111
 
1112
#define USERDEF_LITERAL_OVERFLOW(NODE) \
1113
  (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->overflow)
1114
 
1115
#define USERDEF_LITERAL_NUM_STRING(NODE) \
1116
  (((struct tree_userdef_literal *)USERDEF_LITERAL_CHECK (NODE))->num_string)
1117
 
1118
#define USERDEF_LITERAL_TYPE(NODE) \
1119
  (TREE_TYPE (USERDEF_LITERAL_VALUE (NODE)))
1120
 
1121
extern tree build_userdef_literal (tree suffix_id, tree value,
1122
                                   enum overflow_type overflow,
1123
                                   tree num_string);
1124
 
1125
extern void convert_vector_to_pointer_for_subscript (location_t, tree*, tree);
1126
 
1127
/* Possibe cases of scalar_to_vector conversion.  */
1128
enum stv_conv {
1129
  stv_error,        /* Error occured.  */
1130
  stv_nothing,      /* Nothing happened.  */
1131
  stv_firstarg,     /* First argument must be expanded.  */
1132
  stv_secondarg     /* Second argument must be expanded.  */
1133
};
1134
 
1135
extern enum stv_conv scalar_to_vector (location_t loc, enum tree_code code,
1136
                                       tree op0, tree op1, bool);
1137
 
1138
#endif /* ! GCC_C_COMMON_H */

powered by: WebSVN 2.1.0

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