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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [tree.c] - Blame information for rev 280

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 280 jeremybenn
/* Language-independent node constructors for parse phase of GNU compiler.
2
   Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3
   1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
4
   Free Software Foundation, Inc.
5
 
6
This file is part of GCC.
7
 
8
GCC is free software; you can redistribute it and/or modify it under
9
the terms of the GNU General Public License as published by the Free
10
Software Foundation; either version 3, or (at your option) any later
11
version.
12
 
13
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14
WARRANTY; without even the implied warranty of MERCHANTABILITY or
15
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16
for more details.
17
 
18
You should have received a copy of the GNU General Public License
19
along with GCC; see the file COPYING3.  If not see
20
<http://www.gnu.org/licenses/>.  */
21
 
22
/* This file contains the low level primitives for operating on tree nodes,
23
   including allocation, list operations, interning of identifiers,
24
   construction of data type nodes and statement nodes,
25
   and construction of type conversion nodes.  It also contains
26
   tables index by tree code that describe how to take apart
27
   nodes of that code.
28
 
29
   It is intended to be language-independent, but occasionally
30
   calls language-dependent routines defined (for C) in typecheck.c.  */
31
 
32
#include "config.h"
33
#include "system.h"
34
#include "coretypes.h"
35
#include "tm.h"
36
#include "flags.h"
37
#include "tree.h"
38
#include "real.h"
39
#include "tm_p.h"
40
#include "function.h"
41
#include "obstack.h"
42
#include "toplev.h"
43
#include "ggc.h"
44
#include "hashtab.h"
45
#include "output.h"
46
#include "target.h"
47
#include "langhooks.h"
48
#include "tree-inline.h"
49
#include "tree-iterator.h"
50
#include "basic-block.h"
51
#include "tree-flow.h"
52
#include "params.h"
53
#include "pointer-set.h"
54
#include "fixed-value.h"
55
#include "tree-pass.h"
56
#include "langhooks-def.h"
57
#include "diagnostic.h"
58
#include "cgraph.h"
59
#include "timevar.h"
60
#include "except.h"
61
#include "debug.h"
62
#include "intl.h"
63
 
64
/* Tree code classes.  */
65
 
66
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) TYPE,
67
#define END_OF_BASE_TREE_CODES tcc_exceptional,
68
 
69
const enum tree_code_class tree_code_type[] = {
70
#include "all-tree.def"
71
};
72
 
73
#undef DEFTREECODE
74
#undef END_OF_BASE_TREE_CODES
75
 
76
/* Table indexed by tree code giving number of expression
77
   operands beyond the fixed part of the node structure.
78
   Not used for types or decls.  */
79
 
80
#define DEFTREECODE(SYM, NAME, TYPE, LENGTH) LENGTH,
81
#define END_OF_BASE_TREE_CODES 0,
82
 
83
const unsigned char tree_code_length[] = {
84
#include "all-tree.def"
85
};
86
 
87
#undef DEFTREECODE
88
#undef END_OF_BASE_TREE_CODES
89
 
90
/* Names of tree components.
91
   Used for printing out the tree and error messages.  */
92
#define DEFTREECODE(SYM, NAME, TYPE, LEN) NAME,
93
#define END_OF_BASE_TREE_CODES "@dummy",
94
 
95
const char *const tree_code_name[] = {
96
#include "all-tree.def"
97
};
98
 
99
#undef DEFTREECODE
100
#undef END_OF_BASE_TREE_CODES
101
 
102
/* Each tree code class has an associated string representation.
103
   These must correspond to the tree_code_class entries.  */
104
 
105
const char *const tree_code_class_strings[] =
106
{
107
  "exceptional",
108
  "constant",
109
  "type",
110
  "declaration",
111
  "reference",
112
  "comparison",
113
  "unary",
114
  "binary",
115
  "statement",
116
  "vl_exp",
117
  "expression"
118
};
119
 
120
/* obstack.[ch] explicitly declined to prototype this.  */
121
extern int _obstack_allocated_p (struct obstack *h, void *obj);
122
 
123
#ifdef GATHER_STATISTICS
124
/* Statistics-gathering stuff.  */
125
 
126
int tree_node_counts[(int) all_kinds];
127
int tree_node_sizes[(int) all_kinds];
128
 
129
/* Keep in sync with tree.h:enum tree_node_kind.  */
130
static const char * const tree_node_kind_names[] = {
131
  "decls",
132
  "types",
133
  "blocks",
134
  "stmts",
135
  "refs",
136
  "exprs",
137
  "constants",
138
  "identifiers",
139
  "perm_tree_lists",
140
  "temp_tree_lists",
141
  "vecs",
142
  "binfos",
143
  "ssa names",
144
  "constructors",
145
  "random kinds",
146
  "lang_decl kinds",
147
  "lang_type kinds",
148
  "omp clauses",
149
};
150
#endif /* GATHER_STATISTICS */
151
 
152
/* Unique id for next decl created.  */
153
static GTY(()) int next_decl_uid;
154
/* Unique id for next type created.  */
155
static GTY(()) int next_type_uid = 1;
156
/* Unique id for next debug decl created.  Use negative numbers,
157
   to catch erroneous uses.  */
158
static GTY(()) int next_debug_decl_uid;
159
 
160
/* Since we cannot rehash a type after it is in the table, we have to
161
   keep the hash code.  */
162
 
163
struct GTY(()) type_hash {
164
  unsigned long hash;
165
  tree type;
166
};
167
 
168
/* Initial size of the hash table (rounded to next prime).  */
169
#define TYPE_HASH_INITIAL_SIZE 1000
170
 
171
/* Now here is the hash table.  When recording a type, it is added to
172
   the slot whose index is the hash code.  Note that the hash table is
173
   used for several kinds of types (function types, array types and
174
   array index range types, for now).  While all these live in the
175
   same table, they are completely independent, and the hash code is
176
   computed differently for each of these.  */
177
 
178
static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
179
     htab_t type_hash_table;
180
 
181
/* Hash table and temporary node for larger integer const values.  */
182
static GTY (()) tree int_cst_node;
183
static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
184
     htab_t int_cst_hash_table;
185
 
186
/* Hash table for optimization flags and target option flags.  Use the same
187
   hash table for both sets of options.  Nodes for building the current
188
   optimization and target option nodes.  The assumption is most of the time
189
   the options created will already be in the hash table, so we avoid
190
   allocating and freeing up a node repeatably.  */
191
static GTY (()) tree cl_optimization_node;
192
static GTY (()) tree cl_target_option_node;
193
static GTY ((if_marked ("ggc_marked_p"), param_is (union tree_node)))
194
     htab_t cl_option_hash_table;
195
 
196
/* General tree->tree mapping  structure for use in hash tables.  */
197
 
198
 
199
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
200
     htab_t debug_expr_for_decl;
201
 
202
static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
203
     htab_t value_expr_for_decl;
204
 
205
static GTY ((if_marked ("tree_priority_map_marked_p"),
206
             param_is (struct tree_priority_map)))
207
  htab_t init_priority_for_decl;
208
 
209
static void set_type_quals (tree, int);
210
static int type_hash_eq (const void *, const void *);
211
static hashval_t type_hash_hash (const void *);
212
static hashval_t int_cst_hash_hash (const void *);
213
static int int_cst_hash_eq (const void *, const void *);
214
static hashval_t cl_option_hash_hash (const void *);
215
static int cl_option_hash_eq (const void *, const void *);
216
static void print_type_hash_statistics (void);
217
static void print_debug_expr_statistics (void);
218
static void print_value_expr_statistics (void);
219
static int type_hash_marked_p (const void *);
220
static unsigned int type_hash_list (const_tree, hashval_t);
221
static unsigned int attribute_hash_list (const_tree, hashval_t);
222
 
223
tree global_trees[TI_MAX];
224
tree integer_types[itk_none];
225
 
226
unsigned char tree_contains_struct[MAX_TREE_CODES][64];
227
 
228
/* Number of operands for each OpenMP clause.  */
229
unsigned const char omp_clause_num_ops[] =
230
{
231
  0, /* OMP_CLAUSE_ERROR  */
232
  1, /* OMP_CLAUSE_PRIVATE  */
233
  1, /* OMP_CLAUSE_SHARED  */
234
  1, /* OMP_CLAUSE_FIRSTPRIVATE  */
235
  2, /* OMP_CLAUSE_LASTPRIVATE  */
236
  4, /* OMP_CLAUSE_REDUCTION  */
237
  1, /* OMP_CLAUSE_COPYIN  */
238
  1, /* OMP_CLAUSE_COPYPRIVATE  */
239
  1, /* OMP_CLAUSE_IF  */
240
  1, /* OMP_CLAUSE_NUM_THREADS  */
241
  1, /* OMP_CLAUSE_SCHEDULE  */
242
  0, /* OMP_CLAUSE_NOWAIT  */
243
  0, /* OMP_CLAUSE_ORDERED  */
244
  0, /* OMP_CLAUSE_DEFAULT  */
245
  3, /* OMP_CLAUSE_COLLAPSE  */
246
 
247
};
248
 
249
const char * const omp_clause_code_name[] =
250
{
251
  "error_clause",
252
  "private",
253
  "shared",
254
  "firstprivate",
255
  "lastprivate",
256
  "reduction",
257
  "copyin",
258
  "copyprivate",
259
  "if",
260
  "num_threads",
261
  "schedule",
262
  "nowait",
263
  "ordered",
264
  "default",
265
  "collapse",
266
  "untied"
267
};
268
 
269
 
270
/* Return the tree node structure used by tree code CODE.  */
271
 
272
static inline enum tree_node_structure_enum
273
tree_node_structure_for_code (enum tree_code code)
274
{
275
  switch (TREE_CODE_CLASS (code))
276
    {
277
    case tcc_declaration:
278
      {
279
        switch (code)
280
          {
281
          case FIELD_DECL:
282
            return TS_FIELD_DECL;
283
          case PARM_DECL:
284
            return TS_PARM_DECL;
285
          case VAR_DECL:
286
            return TS_VAR_DECL;
287
          case LABEL_DECL:
288
            return TS_LABEL_DECL;
289
          case RESULT_DECL:
290
            return TS_RESULT_DECL;
291
          case DEBUG_EXPR_DECL:
292
            return TS_DECL_WRTL;
293
          case CONST_DECL:
294
            return TS_CONST_DECL;
295
          case TYPE_DECL:
296
            return TS_TYPE_DECL;
297
          case FUNCTION_DECL:
298
            return TS_FUNCTION_DECL;
299
          default:
300
            return TS_DECL_NON_COMMON;
301
          }
302
      }
303
    case tcc_type:
304
      return TS_TYPE;
305
    case tcc_reference:
306
    case tcc_comparison:
307
    case tcc_unary:
308
    case tcc_binary:
309
    case tcc_expression:
310
    case tcc_statement:
311
    case tcc_vl_exp:
312
      return TS_EXP;
313
    default:  /* tcc_constant and tcc_exceptional */
314
      break;
315
    }
316
  switch (code)
317
    {
318
      /* tcc_constant cases.  */
319
    case INTEGER_CST:           return TS_INT_CST;
320
    case REAL_CST:              return TS_REAL_CST;
321
    case FIXED_CST:             return TS_FIXED_CST;
322
    case COMPLEX_CST:           return TS_COMPLEX;
323
    case VECTOR_CST:            return TS_VECTOR;
324
    case STRING_CST:            return TS_STRING;
325
      /* tcc_exceptional cases.  */
326
    case ERROR_MARK:            return TS_COMMON;
327
    case IDENTIFIER_NODE:       return TS_IDENTIFIER;
328
    case TREE_LIST:             return TS_LIST;
329
    case TREE_VEC:              return TS_VEC;
330
    case SSA_NAME:              return TS_SSA_NAME;
331
    case PLACEHOLDER_EXPR:      return TS_COMMON;
332
    case STATEMENT_LIST:        return TS_STATEMENT_LIST;
333
    case BLOCK:                 return TS_BLOCK;
334
    case CONSTRUCTOR:           return TS_CONSTRUCTOR;
335
    case TREE_BINFO:            return TS_BINFO;
336
    case OMP_CLAUSE:            return TS_OMP_CLAUSE;
337
    case OPTIMIZATION_NODE:     return TS_OPTIMIZATION;
338
    case TARGET_OPTION_NODE:    return TS_TARGET_OPTION;
339
 
340
    default:
341
      gcc_unreachable ();
342
    }
343
}
344
 
345
 
346
/* Initialize tree_contains_struct to describe the hierarchy of tree
347
   nodes.  */
348
 
349
static void
350
initialize_tree_contains_struct (void)
351
{
352
  unsigned i;
353
 
354
#define MARK_TS_BASE(C)                                 \
355
  do {                                                  \
356
    tree_contains_struct[C][TS_BASE] = 1;               \
357
  } while (0)
358
 
359
#define MARK_TS_COMMON(C)                               \
360
  do {                                                  \
361
    MARK_TS_BASE (C);                                   \
362
    tree_contains_struct[C][TS_COMMON] = 1;             \
363
  } while (0)
364
 
365
#define MARK_TS_DECL_MINIMAL(C)                         \
366
  do {                                                  \
367
    MARK_TS_COMMON (C);                                 \
368
    tree_contains_struct[C][TS_DECL_MINIMAL] = 1;       \
369
  } while (0)
370
 
371
#define MARK_TS_DECL_COMMON(C)                          \
372
  do {                                                  \
373
    MARK_TS_DECL_MINIMAL (C);                           \
374
    tree_contains_struct[C][TS_DECL_COMMON] = 1;        \
375
  } while (0)
376
 
377
#define MARK_TS_DECL_WRTL(C)                            \
378
  do {                                                  \
379
    MARK_TS_DECL_COMMON (C);                            \
380
    tree_contains_struct[C][TS_DECL_WRTL] = 1;          \
381
  } while (0)
382
 
383
#define MARK_TS_DECL_WITH_VIS(C)                        \
384
  do {                                                  \
385
    MARK_TS_DECL_WRTL (C);                              \
386
    tree_contains_struct[C][TS_DECL_WITH_VIS] = 1;      \
387
  } while (0)
388
 
389
#define MARK_TS_DECL_NON_COMMON(C)                      \
390
  do {                                                  \
391
    MARK_TS_DECL_WITH_VIS (C);                          \
392
    tree_contains_struct[C][TS_DECL_NON_COMMON] = 1;    \
393
  } while (0)
394
 
395
  for (i = ERROR_MARK; i < LAST_AND_UNUSED_TREE_CODE; i++)
396
    {
397
      enum tree_code code;
398
      enum tree_node_structure_enum ts_code;
399
 
400
      code = (enum tree_code) i;
401
      ts_code = tree_node_structure_for_code (code);
402
 
403
      /* Mark the TS structure itself.  */
404
      tree_contains_struct[code][ts_code] = 1;
405
 
406
      /* Mark all the structures that TS is derived from.  */
407
      switch (ts_code)
408
        {
409
        case TS_COMMON:
410
          MARK_TS_BASE (code);
411
          break;
412
 
413
        case TS_INT_CST:
414
        case TS_REAL_CST:
415
        case TS_FIXED_CST:
416
        case TS_VECTOR:
417
        case TS_STRING:
418
        case TS_COMPLEX:
419
        case TS_IDENTIFIER:
420
        case TS_DECL_MINIMAL:
421
        case TS_TYPE:
422
        case TS_LIST:
423
        case TS_VEC:
424
        case TS_EXP:
425
        case TS_SSA_NAME:
426
        case TS_BLOCK:
427
        case TS_BINFO:
428
        case TS_STATEMENT_LIST:
429
        case TS_CONSTRUCTOR:
430
        case TS_OMP_CLAUSE:
431
        case TS_OPTIMIZATION:
432
        case TS_TARGET_OPTION:
433
          MARK_TS_COMMON (code);
434
          break;
435
 
436
        case TS_DECL_COMMON:
437
          MARK_TS_DECL_MINIMAL (code);
438
          break;
439
 
440
        case TS_DECL_WRTL:
441
          MARK_TS_DECL_COMMON (code);
442
          break;
443
 
444
        case TS_DECL_NON_COMMON:
445
          MARK_TS_DECL_WITH_VIS (code);
446
          break;
447
 
448
        case TS_DECL_WITH_VIS:
449
        case TS_PARM_DECL:
450
        case TS_LABEL_DECL:
451
        case TS_RESULT_DECL:
452
        case TS_CONST_DECL:
453
          MARK_TS_DECL_WRTL (code);
454
          break;
455
 
456
        case TS_FIELD_DECL:
457
          MARK_TS_DECL_COMMON (code);
458
          break;
459
 
460
        case TS_VAR_DECL:
461
          MARK_TS_DECL_WITH_VIS (code);
462
          break;
463
 
464
        case TS_TYPE_DECL:
465
        case TS_FUNCTION_DECL:
466
          MARK_TS_DECL_NON_COMMON (code);
467
          break;
468
 
469
        default:
470
          gcc_unreachable ();
471
        }
472
    }
473
 
474
  /* Basic consistency checks for attributes used in fold.  */
475
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_NON_COMMON]);
476
  gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_NON_COMMON]);
477
  gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_NON_COMMON]);
478
  gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_COMMON]);
479
  gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_COMMON]);
480
  gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_COMMON]);
481
  gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_COMMON]);
482
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_COMMON]);
483
  gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_COMMON]);
484
  gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_COMMON]);
485
  gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_COMMON]);
486
  gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_COMMON]);
487
  gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_WRTL]);
488
  gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WRTL]);
489
  gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_WRTL]);
490
  gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_WRTL]);
491
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WRTL]);
492
  gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_WRTL]);
493
  gcc_assert (tree_contains_struct[CONST_DECL][TS_DECL_MINIMAL]);
494
  gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_MINIMAL]);
495
  gcc_assert (tree_contains_struct[PARM_DECL][TS_DECL_MINIMAL]);
496
  gcc_assert (tree_contains_struct[RESULT_DECL][TS_DECL_MINIMAL]);
497
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_MINIMAL]);
498
  gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_MINIMAL]);
499
  gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_MINIMAL]);
500
  gcc_assert (tree_contains_struct[LABEL_DECL][TS_DECL_MINIMAL]);
501
  gcc_assert (tree_contains_struct[FIELD_DECL][TS_DECL_MINIMAL]);
502
  gcc_assert (tree_contains_struct[VAR_DECL][TS_DECL_WITH_VIS]);
503
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_DECL_WITH_VIS]);
504
  gcc_assert (tree_contains_struct[TYPE_DECL][TS_DECL_WITH_VIS]);
505
  gcc_assert (tree_contains_struct[TRANSLATION_UNIT_DECL][TS_DECL_WITH_VIS]);
506
  gcc_assert (tree_contains_struct[VAR_DECL][TS_VAR_DECL]);
507
  gcc_assert (tree_contains_struct[FIELD_DECL][TS_FIELD_DECL]);
508
  gcc_assert (tree_contains_struct[PARM_DECL][TS_PARM_DECL]);
509
  gcc_assert (tree_contains_struct[LABEL_DECL][TS_LABEL_DECL]);
510
  gcc_assert (tree_contains_struct[RESULT_DECL][TS_RESULT_DECL]);
511
  gcc_assert (tree_contains_struct[CONST_DECL][TS_CONST_DECL]);
512
  gcc_assert (tree_contains_struct[TYPE_DECL][TS_TYPE_DECL]);
513
  gcc_assert (tree_contains_struct[FUNCTION_DECL][TS_FUNCTION_DECL]);
514
  gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_MINIMAL]);
515
  gcc_assert (tree_contains_struct[IMPORTED_DECL][TS_DECL_COMMON]);
516
 
517
#undef MARK_TS_BASE
518
#undef MARK_TS_COMMON
519
#undef MARK_TS_DECL_MINIMAL
520
#undef MARK_TS_DECL_COMMON
521
#undef MARK_TS_DECL_WRTL
522
#undef MARK_TS_DECL_WITH_VIS
523
#undef MARK_TS_DECL_NON_COMMON
524
}
525
 
526
 
527
/* Init tree.c.  */
528
 
529
void
530
init_ttree (void)
531
{
532
  /* Initialize the hash table of types.  */
533
  type_hash_table = htab_create_ggc (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
534
                                     type_hash_eq, 0);
535
 
536
  debug_expr_for_decl = htab_create_ggc (512, tree_map_hash,
537
                                         tree_map_eq, 0);
538
 
539
  value_expr_for_decl = htab_create_ggc (512, tree_map_hash,
540
                                         tree_map_eq, 0);
541
  init_priority_for_decl = htab_create_ggc (512, tree_priority_map_hash,
542
                                            tree_priority_map_eq, 0);
543
 
544
  int_cst_hash_table = htab_create_ggc (1024, int_cst_hash_hash,
545
                                        int_cst_hash_eq, NULL);
546
 
547
  int_cst_node = make_node (INTEGER_CST);
548
 
549
  cl_option_hash_table = htab_create_ggc (64, cl_option_hash_hash,
550
                                          cl_option_hash_eq, NULL);
551
 
552
  cl_optimization_node = make_node (OPTIMIZATION_NODE);
553
  cl_target_option_node = make_node (TARGET_OPTION_NODE);
554
 
555
  /* Initialize the tree_contains_struct array.  */
556
  initialize_tree_contains_struct ();
557
  lang_hooks.init_ts ();
558
}
559
 
560
 
561
/* The name of the object as the assembler will see it (but before any
562
   translations made by ASM_OUTPUT_LABELREF).  Often this is the same
563
   as DECL_NAME.  It is an IDENTIFIER_NODE.  */
564
tree
565
decl_assembler_name (tree decl)
566
{
567
  if (!DECL_ASSEMBLER_NAME_SET_P (decl))
568
    lang_hooks.set_decl_assembler_name (decl);
569
  return DECL_WITH_VIS_CHECK (decl)->decl_with_vis.assembler_name;
570
}
571
 
572
/* Compare ASMNAME with the DECL_ASSEMBLER_NAME of DECL.  */
573
 
574
bool
575
decl_assembler_name_equal (tree decl, const_tree asmname)
576
{
577
  tree decl_asmname = DECL_ASSEMBLER_NAME (decl);
578
  const char *decl_str;
579
  const char *asmname_str;
580
  bool test = false;
581
 
582
  if (decl_asmname == asmname)
583
    return true;
584
 
585
  decl_str = IDENTIFIER_POINTER (decl_asmname);
586
  asmname_str = IDENTIFIER_POINTER (asmname);
587
 
588
 
589
  /* If the target assembler name was set by the user, things are trickier.
590
     We have a leading '*' to begin with.  After that, it's arguable what
591
     is the correct thing to do with -fleading-underscore.  Arguably, we've
592
     historically been doing the wrong thing in assemble_alias by always
593
     printing the leading underscore.  Since we're not changing that, make
594
     sure user_label_prefix follows the '*' before matching.  */
595
  if (decl_str[0] == '*')
596
    {
597
      size_t ulp_len = strlen (user_label_prefix);
598
 
599
      decl_str ++;
600
 
601
      if (ulp_len == 0)
602
        test = true;
603
      else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
604
        decl_str += ulp_len, test=true;
605
      else
606
        decl_str --;
607
    }
608
  if (asmname_str[0] == '*')
609
    {
610
      size_t ulp_len = strlen (user_label_prefix);
611
 
612
      asmname_str ++;
613
 
614
      if (ulp_len == 0)
615
        test = true;
616
      else if (strncmp (asmname_str, user_label_prefix, ulp_len) == 0)
617
        asmname_str += ulp_len, test=true;
618
      else
619
        asmname_str --;
620
    }
621
 
622
  if (!test)
623
    return false;
624
  return strcmp (decl_str, asmname_str) == 0;
625
}
626
 
627
/* Hash asmnames ignoring the user specified marks.  */
628
 
629
hashval_t
630
decl_assembler_name_hash (const_tree asmname)
631
{
632
  if (IDENTIFIER_POINTER (asmname)[0] == '*')
633
    {
634
      const char *decl_str = IDENTIFIER_POINTER (asmname) + 1;
635
      size_t ulp_len = strlen (user_label_prefix);
636
 
637
      if (ulp_len == 0)
638
        ;
639
      else if (strncmp (decl_str, user_label_prefix, ulp_len) == 0)
640
        decl_str += ulp_len;
641
 
642
      return htab_hash_string (decl_str);
643
    }
644
 
645
  return htab_hash_string (IDENTIFIER_POINTER (asmname));
646
}
647
 
648
/* Compute the number of bytes occupied by a tree with code CODE.
649
   This function cannot be used for nodes that have variable sizes,
650
   including TREE_VEC, STRING_CST, and CALL_EXPR.  */
651
size_t
652
tree_code_size (enum tree_code code)
653
{
654
  switch (TREE_CODE_CLASS (code))
655
    {
656
    case tcc_declaration:  /* A decl node */
657
      {
658
        switch (code)
659
          {
660
          case FIELD_DECL:
661
            return sizeof (struct tree_field_decl);
662
          case PARM_DECL:
663
            return sizeof (struct tree_parm_decl);
664
          case VAR_DECL:
665
            return sizeof (struct tree_var_decl);
666
          case LABEL_DECL:
667
            return sizeof (struct tree_label_decl);
668
          case RESULT_DECL:
669
            return sizeof (struct tree_result_decl);
670
          case CONST_DECL:
671
            return sizeof (struct tree_const_decl);
672
          case TYPE_DECL:
673
            return sizeof (struct tree_type_decl);
674
          case FUNCTION_DECL:
675
            return sizeof (struct tree_function_decl);
676
          case DEBUG_EXPR_DECL:
677
            return sizeof (struct tree_decl_with_rtl);
678
          default:
679
            return sizeof (struct tree_decl_non_common);
680
          }
681
      }
682
 
683
    case tcc_type:  /* a type node */
684
      return sizeof (struct tree_type);
685
 
686
    case tcc_reference:   /* a reference */
687
    case tcc_expression:  /* an expression */
688
    case tcc_statement:   /* an expression with side effects */
689
    case tcc_comparison:  /* a comparison expression */
690
    case tcc_unary:       /* a unary arithmetic expression */
691
    case tcc_binary:      /* a binary arithmetic expression */
692
      return (sizeof (struct tree_exp)
693
              + (TREE_CODE_LENGTH (code) - 1) * sizeof (tree));
694
 
695
    case tcc_constant:  /* a constant */
696
      switch (code)
697
        {
698
        case INTEGER_CST:       return sizeof (struct tree_int_cst);
699
        case REAL_CST:          return sizeof (struct tree_real_cst);
700
        case FIXED_CST:         return sizeof (struct tree_fixed_cst);
701
        case COMPLEX_CST:       return sizeof (struct tree_complex);
702
        case VECTOR_CST:        return sizeof (struct tree_vector);
703
        case STRING_CST:        gcc_unreachable ();
704
        default:
705
          return lang_hooks.tree_size (code);
706
        }
707
 
708
    case tcc_exceptional:  /* something random, like an identifier.  */
709
      switch (code)
710
        {
711
        case IDENTIFIER_NODE:   return lang_hooks.identifier_size;
712
        case TREE_LIST:         return sizeof (struct tree_list);
713
 
714
        case ERROR_MARK:
715
        case PLACEHOLDER_EXPR:  return sizeof (struct tree_common);
716
 
717
        case TREE_VEC:
718
        case OMP_CLAUSE:        gcc_unreachable ();
719
 
720
        case SSA_NAME:          return sizeof (struct tree_ssa_name);
721
 
722
        case STATEMENT_LIST:    return sizeof (struct tree_statement_list);
723
        case BLOCK:             return sizeof (struct tree_block);
724
        case CONSTRUCTOR:       return sizeof (struct tree_constructor);
725
        case OPTIMIZATION_NODE: return sizeof (struct tree_optimization_option);
726
        case TARGET_OPTION_NODE: return sizeof (struct tree_target_option);
727
 
728
        default:
729
          return lang_hooks.tree_size (code);
730
        }
731
 
732
    default:
733
      gcc_unreachable ();
734
    }
735
}
736
 
737
/* Compute the number of bytes occupied by NODE.  This routine only
738
   looks at TREE_CODE, except for those nodes that have variable sizes.  */
739
size_t
740
tree_size (const_tree node)
741
{
742
  const enum tree_code code = TREE_CODE (node);
743
  switch (code)
744
    {
745
    case TREE_BINFO:
746
      return (offsetof (struct tree_binfo, base_binfos)
747
              + VEC_embedded_size (tree, BINFO_N_BASE_BINFOS (node)));
748
 
749
    case TREE_VEC:
750
      return (sizeof (struct tree_vec)
751
              + (TREE_VEC_LENGTH (node) - 1) * sizeof (tree));
752
 
753
    case STRING_CST:
754
      return TREE_STRING_LENGTH (node) + offsetof (struct tree_string, str) + 1;
755
 
756
    case OMP_CLAUSE:
757
      return (sizeof (struct tree_omp_clause)
758
              + (omp_clause_num_ops[OMP_CLAUSE_CODE (node)] - 1)
759
                * sizeof (tree));
760
 
761
    default:
762
      if (TREE_CODE_CLASS (code) == tcc_vl_exp)
763
        return (sizeof (struct tree_exp)
764
                + (VL_EXP_OPERAND_LENGTH (node) - 1) * sizeof (tree));
765
      else
766
        return tree_code_size (code);
767
    }
768
}
769
 
770
/* Return a newly allocated node of code CODE.  For decl and type
771
   nodes, some other fields are initialized.  The rest of the node is
772
   initialized to zero.  This function cannot be used for TREE_VEC or
773
   OMP_CLAUSE nodes, which is enforced by asserts in tree_code_size.
774
 
775
   Achoo!  I got a code in the node.  */
776
 
777
tree
778
make_node_stat (enum tree_code code MEM_STAT_DECL)
779
{
780
  tree t;
781
  enum tree_code_class type = TREE_CODE_CLASS (code);
782
  size_t length = tree_code_size (code);
783
#ifdef GATHER_STATISTICS
784
  tree_node_kind kind;
785
 
786
  switch (type)
787
    {
788
    case tcc_declaration:  /* A decl node */
789
      kind = d_kind;
790
      break;
791
 
792
    case tcc_type:  /* a type node */
793
      kind = t_kind;
794
      break;
795
 
796
    case tcc_statement:  /* an expression with side effects */
797
      kind = s_kind;
798
      break;
799
 
800
    case tcc_reference:  /* a reference */
801
      kind = r_kind;
802
      break;
803
 
804
    case tcc_expression:  /* an expression */
805
    case tcc_comparison:  /* a comparison expression */
806
    case tcc_unary:  /* a unary arithmetic expression */
807
    case tcc_binary:  /* a binary arithmetic expression */
808
      kind = e_kind;
809
      break;
810
 
811
    case tcc_constant:  /* a constant */
812
      kind = c_kind;
813
      break;
814
 
815
    case tcc_exceptional:  /* something random, like an identifier.  */
816
      switch (code)
817
        {
818
        case IDENTIFIER_NODE:
819
          kind = id_kind;
820
          break;
821
 
822
        case TREE_VEC:
823
          kind = vec_kind;
824
          break;
825
 
826
        case TREE_BINFO:
827
          kind = binfo_kind;
828
          break;
829
 
830
        case SSA_NAME:
831
          kind = ssa_name_kind;
832
          break;
833
 
834
        case BLOCK:
835
          kind = b_kind;
836
          break;
837
 
838
        case CONSTRUCTOR:
839
          kind = constr_kind;
840
          break;
841
 
842
        default:
843
          kind = x_kind;
844
          break;
845
        }
846
      break;
847
 
848
    default:
849
      gcc_unreachable ();
850
    }
851
 
852
  tree_node_counts[(int) kind]++;
853
  tree_node_sizes[(int) kind] += length;
854
#endif
855
 
856
  if (code == IDENTIFIER_NODE)
857
    t = (tree) ggc_alloc_zone_pass_stat (length, &tree_id_zone);
858
  else
859
    t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
860
 
861
  memset (t, 0, length);
862
 
863
  TREE_SET_CODE (t, code);
864
 
865
  switch (type)
866
    {
867
    case tcc_statement:
868
      TREE_SIDE_EFFECTS (t) = 1;
869
      break;
870
 
871
    case tcc_declaration:
872
      if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON))
873
        {
874
          if (code == FUNCTION_DECL)
875
            {
876
              DECL_ALIGN (t) = FUNCTION_BOUNDARY;
877
              DECL_MODE (t) = FUNCTION_MODE;
878
            }
879
          else
880
            DECL_ALIGN (t) = 1;
881
        }
882
      DECL_SOURCE_LOCATION (t) = input_location;
883
      if (TREE_CODE (t) == DEBUG_EXPR_DECL)
884
        DECL_UID (t) = --next_debug_decl_uid;
885
      else
886
        DECL_UID (t) = next_decl_uid++;
887
      if (TREE_CODE (t) == LABEL_DECL)
888
        LABEL_DECL_UID (t) = -1;
889
 
890
      break;
891
 
892
    case tcc_type:
893
      TYPE_UID (t) = next_type_uid++;
894
      TYPE_ALIGN (t) = BITS_PER_UNIT;
895
      TYPE_USER_ALIGN (t) = 0;
896
      TYPE_MAIN_VARIANT (t) = t;
897
      TYPE_CANONICAL (t) = t;
898
 
899
      /* Default to no attributes for type, but let target change that.  */
900
      TYPE_ATTRIBUTES (t) = NULL_TREE;
901
      targetm.set_default_type_attributes (t);
902
 
903
      /* We have not yet computed the alias set for this type.  */
904
      TYPE_ALIAS_SET (t) = -1;
905
      break;
906
 
907
    case tcc_constant:
908
      TREE_CONSTANT (t) = 1;
909
      break;
910
 
911
    case tcc_expression:
912
      switch (code)
913
        {
914
        case INIT_EXPR:
915
        case MODIFY_EXPR:
916
        case VA_ARG_EXPR:
917
        case PREDECREMENT_EXPR:
918
        case PREINCREMENT_EXPR:
919
        case POSTDECREMENT_EXPR:
920
        case POSTINCREMENT_EXPR:
921
          /* All of these have side-effects, no matter what their
922
             operands are.  */
923
          TREE_SIDE_EFFECTS (t) = 1;
924
          break;
925
 
926
        default:
927
          break;
928
        }
929
      break;
930
 
931
    default:
932
      /* Other classes need no special treatment.  */
933
      break;
934
    }
935
 
936
  return t;
937
}
938
 
939
/* Return a new node with the same contents as NODE except that its
940
   TREE_CHAIN is zero and it has a fresh uid.  */
941
 
942
tree
943
copy_node_stat (tree node MEM_STAT_DECL)
944
{
945
  tree t;
946
  enum tree_code code = TREE_CODE (node);
947
  size_t length;
948
 
949
  gcc_assert (code != STATEMENT_LIST);
950
 
951
  length = tree_size (node);
952
  t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
953
  memcpy (t, node, length);
954
 
955
  TREE_CHAIN (t) = 0;
956
  TREE_ASM_WRITTEN (t) = 0;
957
  TREE_VISITED (t) = 0;
958
  if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
959
    *DECL_VAR_ANN_PTR (t) = 0;
960
 
961
  if (TREE_CODE_CLASS (code) == tcc_declaration)
962
    {
963
      if (code == DEBUG_EXPR_DECL)
964
        DECL_UID (t) = --next_debug_decl_uid;
965
      else
966
        DECL_UID (t) = next_decl_uid++;
967
      if ((TREE_CODE (node) == PARM_DECL || TREE_CODE (node) == VAR_DECL)
968
          && DECL_HAS_VALUE_EXPR_P (node))
969
        {
970
          SET_DECL_VALUE_EXPR (t, DECL_VALUE_EXPR (node));
971
          DECL_HAS_VALUE_EXPR_P (t) = 1;
972
        }
973
      if (TREE_CODE (node) == VAR_DECL && DECL_HAS_INIT_PRIORITY_P (node))
974
        {
975
          SET_DECL_INIT_PRIORITY (t, DECL_INIT_PRIORITY (node));
976
          DECL_HAS_INIT_PRIORITY_P (t) = 1;
977
        }
978
    }
979
  else if (TREE_CODE_CLASS (code) == tcc_type)
980
    {
981
      TYPE_UID (t) = next_type_uid++;
982
      /* The following is so that the debug code for
983
         the copy is different from the original type.
984
         The two statements usually duplicate each other
985
         (because they clear fields of the same union),
986
         but the optimizer should catch that.  */
987
      TYPE_SYMTAB_POINTER (t) = 0;
988
      TYPE_SYMTAB_ADDRESS (t) = 0;
989
 
990
      /* Do not copy the values cache.  */
991
      if (TYPE_CACHED_VALUES_P(t))
992
        {
993
          TYPE_CACHED_VALUES_P (t) = 0;
994
          TYPE_CACHED_VALUES (t) = NULL_TREE;
995
        }
996
    }
997
 
998
  return t;
999
}
1000
 
1001
/* Return a copy of a chain of nodes, chained through the TREE_CHAIN field.
1002
   For example, this can copy a list made of TREE_LIST nodes.  */
1003
 
1004
tree
1005
copy_list (tree list)
1006
{
1007
  tree head;
1008
  tree prev, next;
1009
 
1010
  if (list == 0)
1011
    return 0;
1012
 
1013
  head = prev = copy_node (list);
1014
  next = TREE_CHAIN (list);
1015
  while (next)
1016
    {
1017
      TREE_CHAIN (prev) = copy_node (next);
1018
      prev = TREE_CHAIN (prev);
1019
      next = TREE_CHAIN (next);
1020
    }
1021
  return head;
1022
}
1023
 
1024
 
1025
/* Create an INT_CST node with a LOW value sign extended.  */
1026
 
1027
tree
1028
build_int_cst (tree type, HOST_WIDE_INT low)
1029
{
1030
  /* Support legacy code.  */
1031
  if (!type)
1032
    type = integer_type_node;
1033
 
1034
  return build_int_cst_wide (type, low, low < 0 ? -1 : 0);
1035
}
1036
 
1037
/* Create an INT_CST node with a LOW value zero extended.  */
1038
 
1039
tree
1040
build_int_cstu (tree type, unsigned HOST_WIDE_INT low)
1041
{
1042
  return build_int_cst_wide (type, low, 0);
1043
}
1044
 
1045
/* Create an INT_CST node with a LOW value in TYPE.  The value is sign extended
1046
   if it is negative.  This function is similar to build_int_cst, but
1047
   the extra bits outside of the type precision are cleared.  Constants
1048
   with these extra bits may confuse the fold so that it detects overflows
1049
   even in cases when they do not occur, and in general should be avoided.
1050
   We cannot however make this a default behavior of build_int_cst without
1051
   more intrusive changes, since there are parts of gcc that rely on the extra
1052
   precision of the integer constants.  */
1053
 
1054
tree
1055
build_int_cst_type (tree type, HOST_WIDE_INT low)
1056
{
1057
  unsigned HOST_WIDE_INT low1;
1058
  HOST_WIDE_INT hi;
1059
 
1060
  gcc_assert (type);
1061
 
1062
  fit_double_type (low, low < 0 ? -1 : 0, &low1, &hi, type);
1063
 
1064
  return build_int_cst_wide (type, low1, hi);
1065
}
1066
 
1067
/* Create an INT_CST node of TYPE and value HI:LOW.  The value is truncated
1068
   and sign extended according to the value range of TYPE.  */
1069
 
1070
tree
1071
build_int_cst_wide_type (tree type,
1072
                         unsigned HOST_WIDE_INT low, HOST_WIDE_INT high)
1073
{
1074
  fit_double_type (low, high, &low, &high, type);
1075
  return build_int_cst_wide (type, low, high);
1076
}
1077
 
1078
/* These are the hash table functions for the hash table of INTEGER_CST
1079
   nodes of a sizetype.  */
1080
 
1081
/* Return the hash code code X, an INTEGER_CST.  */
1082
 
1083
static hashval_t
1084
int_cst_hash_hash (const void *x)
1085
{
1086
  const_tree const t = (const_tree) x;
1087
 
1088
  return (TREE_INT_CST_HIGH (t) ^ TREE_INT_CST_LOW (t)
1089
          ^ htab_hash_pointer (TREE_TYPE (t)));
1090
}
1091
 
1092
/* Return nonzero if the value represented by *X (an INTEGER_CST tree node)
1093
   is the same as that given by *Y, which is the same.  */
1094
 
1095
static int
1096
int_cst_hash_eq (const void *x, const void *y)
1097
{
1098
  const_tree const xt = (const_tree) x;
1099
  const_tree const yt = (const_tree) y;
1100
 
1101
  return (TREE_TYPE (xt) == TREE_TYPE (yt)
1102
          && TREE_INT_CST_HIGH (xt) == TREE_INT_CST_HIGH (yt)
1103
          && TREE_INT_CST_LOW (xt) == TREE_INT_CST_LOW (yt));
1104
}
1105
 
1106
/* Create an INT_CST node of TYPE and value HI:LOW.
1107
   The returned node is always shared.  For small integers we use a
1108
   per-type vector cache, for larger ones we use a single hash table.  */
1109
 
1110
tree
1111
build_int_cst_wide (tree type, unsigned HOST_WIDE_INT low, HOST_WIDE_INT hi)
1112
{
1113
  tree t;
1114
  int ix = -1;
1115
  int limit = 0;
1116
 
1117
  gcc_assert (type);
1118
 
1119
  switch (TREE_CODE (type))
1120
    {
1121
    case POINTER_TYPE:
1122
    case REFERENCE_TYPE:
1123
      /* Cache NULL pointer.  */
1124
      if (!hi && !low)
1125
        {
1126
          limit = 1;
1127
          ix = 0;
1128
        }
1129
      break;
1130
 
1131
    case BOOLEAN_TYPE:
1132
      /* Cache false or true.  */
1133
      limit = 2;
1134
      if (!hi && low < 2)
1135
        ix = low;
1136
      break;
1137
 
1138
    case INTEGER_TYPE:
1139
    case OFFSET_TYPE:
1140
      if (TYPE_UNSIGNED (type))
1141
        {
1142
          /* Cache 0..N */
1143
          limit = INTEGER_SHARE_LIMIT;
1144
          if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1145
            ix = low;
1146
        }
1147
      else
1148
        {
1149
          /* Cache -1..N */
1150
          limit = INTEGER_SHARE_LIMIT + 1;
1151
          if (!hi && low < (unsigned HOST_WIDE_INT)INTEGER_SHARE_LIMIT)
1152
            ix = low + 1;
1153
          else if (hi == -1 && low == -(unsigned HOST_WIDE_INT)1)
1154
            ix = 0;
1155
        }
1156
      break;
1157
 
1158
    case ENUMERAL_TYPE:
1159
      break;
1160
 
1161
    default:
1162
      gcc_unreachable ();
1163
    }
1164
 
1165
  if (ix >= 0)
1166
    {
1167
      /* Look for it in the type's vector of small shared ints.  */
1168
      if (!TYPE_CACHED_VALUES_P (type))
1169
        {
1170
          TYPE_CACHED_VALUES_P (type) = 1;
1171
          TYPE_CACHED_VALUES (type) = make_tree_vec (limit);
1172
        }
1173
 
1174
      t = TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix);
1175
      if (t)
1176
        {
1177
          /* Make sure no one is clobbering the shared constant.  */
1178
          gcc_assert (TREE_TYPE (t) == type);
1179
          gcc_assert (TREE_INT_CST_LOW (t) == low);
1180
          gcc_assert (TREE_INT_CST_HIGH (t) == hi);
1181
        }
1182
      else
1183
        {
1184
          /* Create a new shared int.  */
1185
          t = make_node (INTEGER_CST);
1186
 
1187
          TREE_INT_CST_LOW (t) = low;
1188
          TREE_INT_CST_HIGH (t) = hi;
1189
          TREE_TYPE (t) = type;
1190
 
1191
          TREE_VEC_ELT (TYPE_CACHED_VALUES (type), ix) = t;
1192
        }
1193
    }
1194
  else
1195
    {
1196
      /* Use the cache of larger shared ints.  */
1197
      void **slot;
1198
 
1199
      TREE_INT_CST_LOW (int_cst_node) = low;
1200
      TREE_INT_CST_HIGH (int_cst_node) = hi;
1201
      TREE_TYPE (int_cst_node) = type;
1202
 
1203
      slot = htab_find_slot (int_cst_hash_table, int_cst_node, INSERT);
1204
      t = (tree) *slot;
1205
      if (!t)
1206
        {
1207
          /* Insert this one into the hash table.  */
1208
          t = int_cst_node;
1209
          *slot = t;
1210
          /* Make a new node for next time round.  */
1211
          int_cst_node = make_node (INTEGER_CST);
1212
        }
1213
    }
1214
 
1215
  return t;
1216
}
1217
 
1218
/* Builds an integer constant in TYPE such that lowest BITS bits are ones
1219
   and the rest are zeros.  */
1220
 
1221
tree
1222
build_low_bits_mask (tree type, unsigned bits)
1223
{
1224
  unsigned HOST_WIDE_INT low;
1225
  HOST_WIDE_INT high;
1226
  unsigned HOST_WIDE_INT all_ones = ~(unsigned HOST_WIDE_INT) 0;
1227
 
1228
  gcc_assert (bits <= TYPE_PRECISION (type));
1229
 
1230
  if (bits == TYPE_PRECISION (type)
1231
      && !TYPE_UNSIGNED (type))
1232
    {
1233
      /* Sign extended all-ones mask.  */
1234
      low = all_ones;
1235
      high = -1;
1236
    }
1237
  else if (bits <= HOST_BITS_PER_WIDE_INT)
1238
    {
1239
      low = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
1240
      high = 0;
1241
    }
1242
  else
1243
    {
1244
      bits -= HOST_BITS_PER_WIDE_INT;
1245
      low = all_ones;
1246
      high = all_ones >> (HOST_BITS_PER_WIDE_INT - bits);
1247
    }
1248
 
1249
  return build_int_cst_wide (type, low, high);
1250
}
1251
 
1252
/* Checks that X is integer constant that can be expressed in (unsigned)
1253
   HOST_WIDE_INT without loss of precision.  */
1254
 
1255
bool
1256
cst_and_fits_in_hwi (const_tree x)
1257
{
1258
  if (TREE_CODE (x) != INTEGER_CST)
1259
    return false;
1260
 
1261
  if (TYPE_PRECISION (TREE_TYPE (x)) > HOST_BITS_PER_WIDE_INT)
1262
    return false;
1263
 
1264
  return (TREE_INT_CST_HIGH (x) == 0
1265
          || TREE_INT_CST_HIGH (x) == -1);
1266
}
1267
 
1268
/* Return a new VECTOR_CST node whose type is TYPE and whose values
1269
   are in a list pointed to by VALS.  */
1270
 
1271
tree
1272
build_vector (tree type, tree vals)
1273
{
1274
  tree v = make_node (VECTOR_CST);
1275
  int over = 0;
1276
  tree link;
1277
 
1278
  TREE_VECTOR_CST_ELTS (v) = vals;
1279
  TREE_TYPE (v) = type;
1280
 
1281
  /* Iterate through elements and check for overflow.  */
1282
  for (link = vals; link; link = TREE_CHAIN (link))
1283
    {
1284
      tree value = TREE_VALUE (link);
1285
 
1286
      /* Don't crash if we get an address constant.  */
1287
      if (!CONSTANT_CLASS_P (value))
1288
        continue;
1289
 
1290
      over |= TREE_OVERFLOW (value);
1291
    }
1292
 
1293
  TREE_OVERFLOW (v) = over;
1294
  return v;
1295
}
1296
 
1297
/* Return a new VECTOR_CST node whose type is TYPE and whose values
1298
   are extracted from V, a vector of CONSTRUCTOR_ELT.  */
1299
 
1300
tree
1301
build_vector_from_ctor (tree type, VEC(constructor_elt,gc) *v)
1302
{
1303
  tree list = NULL_TREE;
1304
  unsigned HOST_WIDE_INT idx;
1305
  tree value;
1306
 
1307
  FOR_EACH_CONSTRUCTOR_VALUE (v, idx, value)
1308
    list = tree_cons (NULL_TREE, value, list);
1309
  return build_vector (type, nreverse (list));
1310
}
1311
 
1312
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1313
   are in the VEC pointed to by VALS.  */
1314
tree
1315
build_constructor (tree type, VEC(constructor_elt,gc) *vals)
1316
{
1317
  tree c = make_node (CONSTRUCTOR);
1318
  TREE_TYPE (c) = type;
1319
  CONSTRUCTOR_ELTS (c) = vals;
1320
  return c;
1321
}
1322
 
1323
/* Build a CONSTRUCTOR node made of a single initializer, with the specified
1324
   INDEX and VALUE.  */
1325
tree
1326
build_constructor_single (tree type, tree index, tree value)
1327
{
1328
  VEC(constructor_elt,gc) *v;
1329
  constructor_elt *elt;
1330
  tree t;
1331
 
1332
  v = VEC_alloc (constructor_elt, gc, 1);
1333
  elt = VEC_quick_push (constructor_elt, v, NULL);
1334
  elt->index = index;
1335
  elt->value = value;
1336
 
1337
  t = build_constructor (type, v);
1338
  TREE_CONSTANT (t) = TREE_CONSTANT (value);
1339
  return t;
1340
}
1341
 
1342
 
1343
/* Return a new CONSTRUCTOR node whose type is TYPE and whose values
1344
   are in a list pointed to by VALS.  */
1345
tree
1346
build_constructor_from_list (tree type, tree vals)
1347
{
1348
  tree t, val;
1349
  VEC(constructor_elt,gc) *v = NULL;
1350
  bool constant_p = true;
1351
 
1352
  if (vals)
1353
    {
1354
      v = VEC_alloc (constructor_elt, gc, list_length (vals));
1355
      for (t = vals; t; t = TREE_CHAIN (t))
1356
        {
1357
          constructor_elt *elt = VEC_quick_push (constructor_elt, v, NULL);
1358
          val = TREE_VALUE (t);
1359
          elt->index = TREE_PURPOSE (t);
1360
          elt->value = val;
1361
          if (!TREE_CONSTANT (val))
1362
            constant_p = false;
1363
        }
1364
    }
1365
 
1366
  t = build_constructor (type, v);
1367
  TREE_CONSTANT (t) = constant_p;
1368
  return t;
1369
}
1370
 
1371
/* Return a new FIXED_CST node whose type is TYPE and value is F.  */
1372
 
1373
tree
1374
build_fixed (tree type, FIXED_VALUE_TYPE f)
1375
{
1376
  tree v;
1377
  FIXED_VALUE_TYPE *fp;
1378
 
1379
  v = make_node (FIXED_CST);
1380
  fp = GGC_NEW (FIXED_VALUE_TYPE);
1381
  memcpy (fp, &f, sizeof (FIXED_VALUE_TYPE));
1382
 
1383
  TREE_TYPE (v) = type;
1384
  TREE_FIXED_CST_PTR (v) = fp;
1385
  return v;
1386
}
1387
 
1388
/* Return a new REAL_CST node whose type is TYPE and value is D.  */
1389
 
1390
tree
1391
build_real (tree type, REAL_VALUE_TYPE d)
1392
{
1393
  tree v;
1394
  REAL_VALUE_TYPE *dp;
1395
  int overflow = 0;
1396
 
1397
  /* ??? Used to check for overflow here via CHECK_FLOAT_TYPE.
1398
     Consider doing it via real_convert now.  */
1399
 
1400
  v = make_node (REAL_CST);
1401
  dp = GGC_NEW (REAL_VALUE_TYPE);
1402
  memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
1403
 
1404
  TREE_TYPE (v) = type;
1405
  TREE_REAL_CST_PTR (v) = dp;
1406
  TREE_OVERFLOW (v) = overflow;
1407
  return v;
1408
}
1409
 
1410
/* Return a new REAL_CST node whose type is TYPE
1411
   and whose value is the integer value of the INTEGER_CST node I.  */
1412
 
1413
REAL_VALUE_TYPE
1414
real_value_from_int_cst (const_tree type, const_tree i)
1415
{
1416
  REAL_VALUE_TYPE d;
1417
 
1418
  /* Clear all bits of the real value type so that we can later do
1419
     bitwise comparisons to see if two values are the same.  */
1420
  memset (&d, 0, sizeof d);
1421
 
1422
  real_from_integer (&d, type ? TYPE_MODE (type) : VOIDmode,
1423
                     TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
1424
                     TYPE_UNSIGNED (TREE_TYPE (i)));
1425
  return d;
1426
}
1427
 
1428
/* Given a tree representing an integer constant I, return a tree
1429
   representing the same value as a floating-point constant of type TYPE.  */
1430
 
1431
tree
1432
build_real_from_int_cst (tree type, const_tree i)
1433
{
1434
  tree v;
1435
  int overflow = TREE_OVERFLOW (i);
1436
 
1437
  v = build_real (type, real_value_from_int_cst (type, i));
1438
 
1439
  TREE_OVERFLOW (v) |= overflow;
1440
  return v;
1441
}
1442
 
1443
/* Return a newly constructed STRING_CST node whose value is
1444
   the LEN characters at STR.
1445
   The TREE_TYPE is not initialized.  */
1446
 
1447
tree
1448
build_string (int len, const char *str)
1449
{
1450
  tree s;
1451
  size_t length;
1452
 
1453
  /* Do not waste bytes provided by padding of struct tree_string.  */
1454
  length = len + offsetof (struct tree_string, str) + 1;
1455
 
1456
#ifdef GATHER_STATISTICS
1457
  tree_node_counts[(int) c_kind]++;
1458
  tree_node_sizes[(int) c_kind] += length;
1459
#endif
1460
 
1461
  s = ggc_alloc_tree (length);
1462
 
1463
  memset (s, 0, sizeof (struct tree_common));
1464
  TREE_SET_CODE (s, STRING_CST);
1465
  TREE_CONSTANT (s) = 1;
1466
  TREE_STRING_LENGTH (s) = len;
1467
  memcpy (s->string.str, str, len);
1468
  s->string.str[len] = '\0';
1469
 
1470
  return s;
1471
}
1472
 
1473
/* Return a newly constructed COMPLEX_CST node whose value is
1474
   specified by the real and imaginary parts REAL and IMAG.
1475
   Both REAL and IMAG should be constant nodes.  TYPE, if specified,
1476
   will be the type of the COMPLEX_CST; otherwise a new type will be made.  */
1477
 
1478
tree
1479
build_complex (tree type, tree real, tree imag)
1480
{
1481
  tree t = make_node (COMPLEX_CST);
1482
 
1483
  TREE_REALPART (t) = real;
1484
  TREE_IMAGPART (t) = imag;
1485
  TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
1486
  TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
1487
  return t;
1488
}
1489
 
1490
/* Return a constant of arithmetic type TYPE which is the
1491
   multiplicative identity of the set TYPE.  */
1492
 
1493
tree
1494
build_one_cst (tree type)
1495
{
1496
  switch (TREE_CODE (type))
1497
    {
1498
    case INTEGER_TYPE: case ENUMERAL_TYPE: case BOOLEAN_TYPE:
1499
    case POINTER_TYPE: case REFERENCE_TYPE:
1500
    case OFFSET_TYPE:
1501
      return build_int_cst (type, 1);
1502
 
1503
    case REAL_TYPE:
1504
      return build_real (type, dconst1);
1505
 
1506
    case FIXED_POINT_TYPE:
1507
      /* We can only generate 1 for accum types.  */
1508
      gcc_assert (ALL_SCALAR_ACCUM_MODE_P (TYPE_MODE (type)));
1509
      return build_fixed (type, FCONST1(TYPE_MODE (type)));
1510
 
1511
    case VECTOR_TYPE:
1512
      {
1513
        tree scalar, cst;
1514
        int i;
1515
 
1516
        scalar = build_one_cst (TREE_TYPE (type));
1517
 
1518
        /* Create 'vect_cst_ = {cst,cst,...,cst}'  */
1519
        cst = NULL_TREE;
1520
        for (i = TYPE_VECTOR_SUBPARTS (type); --i >= 0; )
1521
          cst = tree_cons (NULL_TREE, scalar, cst);
1522
 
1523
        return build_vector (type, cst);
1524
      }
1525
 
1526
    case COMPLEX_TYPE:
1527
      return build_complex (type,
1528
                            build_one_cst (TREE_TYPE (type)),
1529
                            fold_convert (TREE_TYPE (type), integer_zero_node));
1530
 
1531
    default:
1532
      gcc_unreachable ();
1533
    }
1534
}
1535
 
1536
/* Build a BINFO with LEN language slots.  */
1537
 
1538
tree
1539
make_tree_binfo_stat (unsigned base_binfos MEM_STAT_DECL)
1540
{
1541
  tree t;
1542
  size_t length = (offsetof (struct tree_binfo, base_binfos)
1543
                   + VEC_embedded_size (tree, base_binfos));
1544
 
1545
#ifdef GATHER_STATISTICS
1546
  tree_node_counts[(int) binfo_kind]++;
1547
  tree_node_sizes[(int) binfo_kind] += length;
1548
#endif
1549
 
1550
  t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1551
 
1552
  memset (t, 0, offsetof (struct tree_binfo, base_binfos));
1553
 
1554
  TREE_SET_CODE (t, TREE_BINFO);
1555
 
1556
  VEC_embedded_init (tree, BINFO_BASE_BINFOS (t), base_binfos);
1557
 
1558
  return t;
1559
}
1560
 
1561
 
1562
/* Build a newly constructed TREE_VEC node of length LEN.  */
1563
 
1564
tree
1565
make_tree_vec_stat (int len MEM_STAT_DECL)
1566
{
1567
  tree t;
1568
  int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
1569
 
1570
#ifdef GATHER_STATISTICS
1571
  tree_node_counts[(int) vec_kind]++;
1572
  tree_node_sizes[(int) vec_kind] += length;
1573
#endif
1574
 
1575
  t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
1576
 
1577
  memset (t, 0, length);
1578
 
1579
  TREE_SET_CODE (t, TREE_VEC);
1580
  TREE_VEC_LENGTH (t) = len;
1581
 
1582
  return t;
1583
}
1584
 
1585
/* Return 1 if EXPR is the integer constant zero or a complex constant
1586
   of zero.  */
1587
 
1588
int
1589
integer_zerop (const_tree expr)
1590
{
1591
  STRIP_NOPS (expr);
1592
 
1593
  return ((TREE_CODE (expr) == INTEGER_CST
1594
           && TREE_INT_CST_LOW (expr) == 0
1595
           && TREE_INT_CST_HIGH (expr) == 0)
1596
          || (TREE_CODE (expr) == COMPLEX_CST
1597
              && integer_zerop (TREE_REALPART (expr))
1598
              && integer_zerop (TREE_IMAGPART (expr))));
1599
}
1600
 
1601
/* Return 1 if EXPR is the integer constant one or the corresponding
1602
   complex constant.  */
1603
 
1604
int
1605
integer_onep (const_tree expr)
1606
{
1607
  STRIP_NOPS (expr);
1608
 
1609
  return ((TREE_CODE (expr) == INTEGER_CST
1610
           && TREE_INT_CST_LOW (expr) == 1
1611
           && TREE_INT_CST_HIGH (expr) == 0)
1612
          || (TREE_CODE (expr) == COMPLEX_CST
1613
              && integer_onep (TREE_REALPART (expr))
1614
              && integer_zerop (TREE_IMAGPART (expr))));
1615
}
1616
 
1617
/* Return 1 if EXPR is an integer containing all 1's in as much precision as
1618
   it contains.  Likewise for the corresponding complex constant.  */
1619
 
1620
int
1621
integer_all_onesp (const_tree expr)
1622
{
1623
  int prec;
1624
  int uns;
1625
 
1626
  STRIP_NOPS (expr);
1627
 
1628
  if (TREE_CODE (expr) == COMPLEX_CST
1629
      && integer_all_onesp (TREE_REALPART (expr))
1630
      && integer_zerop (TREE_IMAGPART (expr)))
1631
    return 1;
1632
 
1633
  else if (TREE_CODE (expr) != INTEGER_CST)
1634
    return 0;
1635
 
1636
  uns = TYPE_UNSIGNED (TREE_TYPE (expr));
1637
  if (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1638
      && TREE_INT_CST_HIGH (expr) == -1)
1639
    return 1;
1640
  if (!uns)
1641
    return 0;
1642
 
1643
  /* Note that using TYPE_PRECISION here is wrong.  We care about the
1644
     actual bits, not the (arbitrary) range of the type.  */
1645
  prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
1646
  if (prec >= HOST_BITS_PER_WIDE_INT)
1647
    {
1648
      HOST_WIDE_INT high_value;
1649
      int shift_amount;
1650
 
1651
      shift_amount = prec - HOST_BITS_PER_WIDE_INT;
1652
 
1653
      /* Can not handle precisions greater than twice the host int size.  */
1654
      gcc_assert (shift_amount <= HOST_BITS_PER_WIDE_INT);
1655
      if (shift_amount == HOST_BITS_PER_WIDE_INT)
1656
        /* Shifting by the host word size is undefined according to the ANSI
1657
           standard, so we must handle this as a special case.  */
1658
        high_value = -1;
1659
      else
1660
        high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
1661
 
1662
      return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
1663
              && TREE_INT_CST_HIGH (expr) == high_value);
1664
    }
1665
  else
1666
    return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
1667
}
1668
 
1669
/* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
1670
   one bit on).  */
1671
 
1672
int
1673
integer_pow2p (const_tree expr)
1674
{
1675
  int prec;
1676
  HOST_WIDE_INT high, low;
1677
 
1678
  STRIP_NOPS (expr);
1679
 
1680
  if (TREE_CODE (expr) == COMPLEX_CST
1681
      && integer_pow2p (TREE_REALPART (expr))
1682
      && integer_zerop (TREE_IMAGPART (expr)))
1683
    return 1;
1684
 
1685
  if (TREE_CODE (expr) != INTEGER_CST)
1686
    return 0;
1687
 
1688
  prec = TYPE_PRECISION (TREE_TYPE (expr));
1689
  high = TREE_INT_CST_HIGH (expr);
1690
  low = TREE_INT_CST_LOW (expr);
1691
 
1692
  /* First clear all bits that are beyond the type's precision in case
1693
     we've been sign extended.  */
1694
 
1695
  if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1696
    ;
1697
  else if (prec > HOST_BITS_PER_WIDE_INT)
1698
    high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1699
  else
1700
    {
1701
      high = 0;
1702
      if (prec < HOST_BITS_PER_WIDE_INT)
1703
        low &= ~((HOST_WIDE_INT) (-1) << prec);
1704
    }
1705
 
1706
  if (high == 0 && low == 0)
1707
    return 0;
1708
 
1709
  return ((high == 0 && (low & (low - 1)) == 0)
1710
          || (low == 0 && (high & (high - 1)) == 0));
1711
}
1712
 
1713
/* Return 1 if EXPR is an integer constant other than zero or a
1714
   complex constant other than zero.  */
1715
 
1716
int
1717
integer_nonzerop (const_tree expr)
1718
{
1719
  STRIP_NOPS (expr);
1720
 
1721
  return ((TREE_CODE (expr) == INTEGER_CST
1722
           && (TREE_INT_CST_LOW (expr) != 0
1723
               || TREE_INT_CST_HIGH (expr) != 0))
1724
          || (TREE_CODE (expr) == COMPLEX_CST
1725
              && (integer_nonzerop (TREE_REALPART (expr))
1726
                  || integer_nonzerop (TREE_IMAGPART (expr)))));
1727
}
1728
 
1729
/* Return 1 if EXPR is the fixed-point constant zero.  */
1730
 
1731
int
1732
fixed_zerop (const_tree expr)
1733
{
1734
  return (TREE_CODE (expr) == FIXED_CST
1735
          && double_int_zero_p (TREE_FIXED_CST (expr).data));
1736
}
1737
 
1738
/* Return the power of two represented by a tree node known to be a
1739
   power of two.  */
1740
 
1741
int
1742
tree_log2 (const_tree expr)
1743
{
1744
  int prec;
1745
  HOST_WIDE_INT high, low;
1746
 
1747
  STRIP_NOPS (expr);
1748
 
1749
  if (TREE_CODE (expr) == COMPLEX_CST)
1750
    return tree_log2 (TREE_REALPART (expr));
1751
 
1752
  prec = TYPE_PRECISION (TREE_TYPE (expr));
1753
  high = TREE_INT_CST_HIGH (expr);
1754
  low = TREE_INT_CST_LOW (expr);
1755
 
1756
  /* First clear all bits that are beyond the type's precision in case
1757
     we've been sign extended.  */
1758
 
1759
  if (prec == 2 * HOST_BITS_PER_WIDE_INT)
1760
    ;
1761
  else if (prec > HOST_BITS_PER_WIDE_INT)
1762
    high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1763
  else
1764
    {
1765
      high = 0;
1766
      if (prec < HOST_BITS_PER_WIDE_INT)
1767
        low &= ~((HOST_WIDE_INT) (-1) << prec);
1768
    }
1769
 
1770
  return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
1771
          : exact_log2 (low));
1772
}
1773
 
1774
/* Similar, but return the largest integer Y such that 2 ** Y is less
1775
   than or equal to EXPR.  */
1776
 
1777
int
1778
tree_floor_log2 (const_tree expr)
1779
{
1780
  int prec;
1781
  HOST_WIDE_INT high, low;
1782
 
1783
  STRIP_NOPS (expr);
1784
 
1785
  if (TREE_CODE (expr) == COMPLEX_CST)
1786
    return tree_log2 (TREE_REALPART (expr));
1787
 
1788
  prec = TYPE_PRECISION (TREE_TYPE (expr));
1789
  high = TREE_INT_CST_HIGH (expr);
1790
  low = TREE_INT_CST_LOW (expr);
1791
 
1792
  /* First clear all bits that are beyond the type's precision in case
1793
     we've been sign extended.  Ignore if type's precision hasn't been set
1794
     since what we are doing is setting it.  */
1795
 
1796
  if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
1797
    ;
1798
  else if (prec > HOST_BITS_PER_WIDE_INT)
1799
    high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
1800
  else
1801
    {
1802
      high = 0;
1803
      if (prec < HOST_BITS_PER_WIDE_INT)
1804
        low &= ~((HOST_WIDE_INT) (-1) << prec);
1805
    }
1806
 
1807
  return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
1808
          : floor_log2 (low));
1809
}
1810
 
1811
/* Return 1 if EXPR is the real constant zero.  Trailing zeroes matter for
1812
   decimal float constants, so don't return 1 for them.  */
1813
 
1814
int
1815
real_zerop (const_tree expr)
1816
{
1817
  STRIP_NOPS (expr);
1818
 
1819
  return ((TREE_CODE (expr) == REAL_CST
1820
           && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0)
1821
           && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1822
          || (TREE_CODE (expr) == COMPLEX_CST
1823
              && real_zerop (TREE_REALPART (expr))
1824
              && real_zerop (TREE_IMAGPART (expr))));
1825
}
1826
 
1827
/* Return 1 if EXPR is the real constant one in real or complex form.
1828
   Trailing zeroes matter for decimal float constants, so don't return
1829
   1 for them.  */
1830
 
1831
int
1832
real_onep (const_tree expr)
1833
{
1834
  STRIP_NOPS (expr);
1835
 
1836
  return ((TREE_CODE (expr) == REAL_CST
1837
           && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1)
1838
           && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1839
          || (TREE_CODE (expr) == COMPLEX_CST
1840
              && real_onep (TREE_REALPART (expr))
1841
              && real_zerop (TREE_IMAGPART (expr))));
1842
}
1843
 
1844
/* Return 1 if EXPR is the real constant two.  Trailing zeroes matter
1845
   for decimal float constants, so don't return 1 for them.  */
1846
 
1847
int
1848
real_twop (const_tree expr)
1849
{
1850
  STRIP_NOPS (expr);
1851
 
1852
  return ((TREE_CODE (expr) == REAL_CST
1853
           && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2)
1854
           && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1855
          || (TREE_CODE (expr) == COMPLEX_CST
1856
              && real_twop (TREE_REALPART (expr))
1857
              && real_zerop (TREE_IMAGPART (expr))));
1858
}
1859
 
1860
/* Return 1 if EXPR is the real constant minus one.  Trailing zeroes
1861
   matter for decimal float constants, so don't return 1 for them.  */
1862
 
1863
int
1864
real_minus_onep (const_tree expr)
1865
{
1866
  STRIP_NOPS (expr);
1867
 
1868
  return ((TREE_CODE (expr) == REAL_CST
1869
           && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1)
1870
           && !(DECIMAL_FLOAT_MODE_P (TYPE_MODE (TREE_TYPE (expr)))))
1871
          || (TREE_CODE (expr) == COMPLEX_CST
1872
              && real_minus_onep (TREE_REALPART (expr))
1873
              && real_zerop (TREE_IMAGPART (expr))));
1874
}
1875
 
1876
/* Nonzero if EXP is a constant or a cast of a constant.  */
1877
 
1878
int
1879
really_constant_p (const_tree exp)
1880
{
1881
  /* This is not quite the same as STRIP_NOPS.  It does more.  */
1882
  while (CONVERT_EXPR_P (exp)
1883
         || TREE_CODE (exp) == NON_LVALUE_EXPR)
1884
    exp = TREE_OPERAND (exp, 0);
1885
  return TREE_CONSTANT (exp);
1886
}
1887
 
1888
/* Return first list element whose TREE_VALUE is ELEM.
1889
   Return 0 if ELEM is not in LIST.  */
1890
 
1891
tree
1892
value_member (tree elem, tree list)
1893
{
1894
  while (list)
1895
    {
1896
      if (elem == TREE_VALUE (list))
1897
        return list;
1898
      list = TREE_CHAIN (list);
1899
    }
1900
  return NULL_TREE;
1901
}
1902
 
1903
/* Return first list element whose TREE_PURPOSE is ELEM.
1904
   Return 0 if ELEM is not in LIST.  */
1905
 
1906
tree
1907
purpose_member (const_tree elem, tree list)
1908
{
1909
  while (list)
1910
    {
1911
      if (elem == TREE_PURPOSE (list))
1912
        return list;
1913
      list = TREE_CHAIN (list);
1914
    }
1915
  return NULL_TREE;
1916
}
1917
 
1918
/* Returns element number IDX (zero-origin) of chain CHAIN, or
1919
   NULL_TREE.  */
1920
 
1921
tree
1922
chain_index (int idx, tree chain)
1923
{
1924
  for (; chain && idx > 0; --idx)
1925
    chain = TREE_CHAIN (chain);
1926
  return chain;
1927
}
1928
 
1929
/* Return nonzero if ELEM is part of the chain CHAIN.  */
1930
 
1931
int
1932
chain_member (const_tree elem, const_tree chain)
1933
{
1934
  while (chain)
1935
    {
1936
      if (elem == chain)
1937
        return 1;
1938
      chain = TREE_CHAIN (chain);
1939
    }
1940
 
1941
  return 0;
1942
}
1943
 
1944
/* Return the length of a chain of nodes chained through TREE_CHAIN.
1945
   We expect a null pointer to mark the end of the chain.
1946
   This is the Lisp primitive `length'.  */
1947
 
1948
int
1949
list_length (const_tree t)
1950
{
1951
  const_tree p = t;
1952
#ifdef ENABLE_TREE_CHECKING
1953
  const_tree q = t;
1954
#endif
1955
  int len = 0;
1956
 
1957
  while (p)
1958
    {
1959
      p = TREE_CHAIN (p);
1960
#ifdef ENABLE_TREE_CHECKING
1961
      if (len % 2)
1962
        q = TREE_CHAIN (q);
1963
      gcc_assert (p != q);
1964
#endif
1965
      len++;
1966
    }
1967
 
1968
  return len;
1969
}
1970
 
1971
/* Returns the number of FIELD_DECLs in TYPE.  */
1972
 
1973
int
1974
fields_length (const_tree type)
1975
{
1976
  tree t = TYPE_FIELDS (type);
1977
  int count = 0;
1978
 
1979
  for (; t; t = TREE_CHAIN (t))
1980
    if (TREE_CODE (t) == FIELD_DECL)
1981
      ++count;
1982
 
1983
  return count;
1984
}
1985
 
1986
/* Returns the first FIELD_DECL in the TYPE_FIELDS of the RECORD_TYPE or
1987
   UNION_TYPE TYPE, or NULL_TREE if none.  */
1988
 
1989
tree
1990
first_field (const_tree type)
1991
{
1992
  tree t = TYPE_FIELDS (type);
1993
  while (t && TREE_CODE (t) != FIELD_DECL)
1994
    t = TREE_CHAIN (t);
1995
  return t;
1996
}
1997
 
1998
/* Concatenate two chains of nodes (chained through TREE_CHAIN)
1999
   by modifying the last node in chain 1 to point to chain 2.
2000
   This is the Lisp primitive `nconc'.  */
2001
 
2002
tree
2003
chainon (tree op1, tree op2)
2004
{
2005
  tree t1;
2006
 
2007
  if (!op1)
2008
    return op2;
2009
  if (!op2)
2010
    return op1;
2011
 
2012
  for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
2013
    continue;
2014
  TREE_CHAIN (t1) = op2;
2015
 
2016
#ifdef ENABLE_TREE_CHECKING
2017
  {
2018
    tree t2;
2019
    for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
2020
      gcc_assert (t2 != t1);
2021
  }
2022
#endif
2023
 
2024
  return op1;
2025
}
2026
 
2027
/* Return the last node in a chain of nodes (chained through TREE_CHAIN).  */
2028
 
2029
tree
2030
tree_last (tree chain)
2031
{
2032
  tree next;
2033
  if (chain)
2034
    while ((next = TREE_CHAIN (chain)))
2035
      chain = next;
2036
  return chain;
2037
}
2038
 
2039
/* Reverse the order of elements in the chain T,
2040
   and return the new head of the chain (old last element).  */
2041
 
2042
tree
2043
nreverse (tree t)
2044
{
2045
  tree prev = 0, decl, next;
2046
  for (decl = t; decl; decl = next)
2047
    {
2048
      next = TREE_CHAIN (decl);
2049
      TREE_CHAIN (decl) = prev;
2050
      prev = decl;
2051
    }
2052
  return prev;
2053
}
2054
 
2055
/* Return a newly created TREE_LIST node whose
2056
   purpose and value fields are PARM and VALUE.  */
2057
 
2058
tree
2059
build_tree_list_stat (tree parm, tree value MEM_STAT_DECL)
2060
{
2061
  tree t = make_node_stat (TREE_LIST PASS_MEM_STAT);
2062
  TREE_PURPOSE (t) = parm;
2063
  TREE_VALUE (t) = value;
2064
  return t;
2065
}
2066
 
2067
/* Build a chain of TREE_LIST nodes from a vector.  */
2068
 
2069
tree
2070
build_tree_list_vec_stat (const VEC(tree,gc) *vec MEM_STAT_DECL)
2071
{
2072
  tree ret = NULL_TREE;
2073
  tree *pp = &ret;
2074
  unsigned int i;
2075
  tree t;
2076
  for (i = 0; VEC_iterate (tree, vec, i, t); ++i)
2077
    {
2078
      *pp = build_tree_list_stat (NULL, t PASS_MEM_STAT);
2079
      pp = &TREE_CHAIN (*pp);
2080
    }
2081
  return ret;
2082
}
2083
 
2084
/* Return a newly created TREE_LIST node whose
2085
   purpose and value fields are PURPOSE and VALUE
2086
   and whose TREE_CHAIN is CHAIN.  */
2087
 
2088
tree
2089
tree_cons_stat (tree purpose, tree value, tree chain MEM_STAT_DECL)
2090
{
2091
  tree node;
2092
 
2093
  node = (tree) ggc_alloc_zone_pass_stat (sizeof (struct tree_list), &tree_zone);
2094
 
2095
  memset (node, 0, sizeof (struct tree_common));
2096
 
2097
#ifdef GATHER_STATISTICS
2098
  tree_node_counts[(int) x_kind]++;
2099
  tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
2100
#endif
2101
 
2102
  TREE_SET_CODE (node, TREE_LIST);
2103
  TREE_CHAIN (node) = chain;
2104
  TREE_PURPOSE (node) = purpose;
2105
  TREE_VALUE (node) = value;
2106
  return node;
2107
}
2108
 
2109
/* Return the elements of a CONSTRUCTOR as a TREE_LIST.  */
2110
 
2111
tree
2112
ctor_to_list (tree ctor)
2113
{
2114
  tree list = NULL_TREE;
2115
  tree *p = &list;
2116
  unsigned ix;
2117
  tree purpose, val;
2118
 
2119
  FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (ctor), ix, purpose, val)
2120
    {
2121
      *p = build_tree_list (purpose, val);
2122
      p = &TREE_CHAIN (*p);
2123
    }
2124
 
2125
  return list;
2126
}
2127
 
2128
/* Return the values of the elements of a CONSTRUCTOR as a vector of
2129
   trees.  */
2130
 
2131
VEC(tree,gc) *
2132
ctor_to_vec (tree ctor)
2133
{
2134
  VEC(tree, gc) *vec = VEC_alloc (tree, gc, CONSTRUCTOR_NELTS (ctor));
2135
  unsigned int ix;
2136
  tree val;
2137
 
2138
  FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (ctor), ix, val)
2139
    VEC_quick_push (tree, vec, val);
2140
 
2141
  return vec;
2142
}
2143
 
2144
/* Return the size nominally occupied by an object of type TYPE
2145
   when it resides in memory.  The value is measured in units of bytes,
2146
   and its data type is that normally used for type sizes
2147
   (which is the first type created by make_signed_type or
2148
   make_unsigned_type).  */
2149
 
2150
tree
2151
size_in_bytes (const_tree type)
2152
{
2153
  tree t;
2154
 
2155
  if (type == error_mark_node)
2156
    return integer_zero_node;
2157
 
2158
  type = TYPE_MAIN_VARIANT (type);
2159
  t = TYPE_SIZE_UNIT (type);
2160
 
2161
  if (t == 0)
2162
    {
2163
      lang_hooks.types.incomplete_type_error (NULL_TREE, type);
2164
      return size_zero_node;
2165
    }
2166
 
2167
  return t;
2168
}
2169
 
2170
/* Return the size of TYPE (in bytes) as a wide integer
2171
   or return -1 if the size can vary or is larger than an integer.  */
2172
 
2173
HOST_WIDE_INT
2174
int_size_in_bytes (const_tree type)
2175
{
2176
  tree t;
2177
 
2178
  if (type == error_mark_node)
2179
    return 0;
2180
 
2181
  type = TYPE_MAIN_VARIANT (type);
2182
  t = TYPE_SIZE_UNIT (type);
2183
  if (t == 0
2184
      || TREE_CODE (t) != INTEGER_CST
2185
      || TREE_INT_CST_HIGH (t) != 0
2186
      /* If the result would appear negative, it's too big to represent.  */
2187
      || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
2188
    return -1;
2189
 
2190
  return TREE_INT_CST_LOW (t);
2191
}
2192
 
2193
/* Return the maximum size of TYPE (in bytes) as a wide integer
2194
   or return -1 if the size can vary or is larger than an integer.  */
2195
 
2196
HOST_WIDE_INT
2197
max_int_size_in_bytes (const_tree type)
2198
{
2199
  HOST_WIDE_INT size = -1;
2200
  tree size_tree;
2201
 
2202
  /* If this is an array type, check for a possible MAX_SIZE attached.  */
2203
 
2204
  if (TREE_CODE (type) == ARRAY_TYPE)
2205
    {
2206
      size_tree = TYPE_ARRAY_MAX_SIZE (type);
2207
 
2208
      if (size_tree && host_integerp (size_tree, 1))
2209
        size = tree_low_cst (size_tree, 1);
2210
    }
2211
 
2212
  /* If we still haven't been able to get a size, see if the language
2213
     can compute a maximum size.  */
2214
 
2215
  if (size == -1)
2216
    {
2217
      size_tree = lang_hooks.types.max_size (type);
2218
 
2219
      if (size_tree && host_integerp (size_tree, 1))
2220
        size = tree_low_cst (size_tree, 1);
2221
    }
2222
 
2223
  return size;
2224
}
2225
 
2226
/* Returns a tree for the size of EXP in bytes.  */
2227
 
2228
tree
2229
tree_expr_size (const_tree exp)
2230
{
2231
  if (DECL_P (exp)
2232
      && DECL_SIZE_UNIT (exp) != 0)
2233
    return DECL_SIZE_UNIT (exp);
2234
  else
2235
    return size_in_bytes (TREE_TYPE (exp));
2236
}
2237
 
2238
/* Return the bit position of FIELD, in bits from the start of the record.
2239
   This is a tree of type bitsizetype.  */
2240
 
2241
tree
2242
bit_position (const_tree field)
2243
{
2244
  return bit_from_pos (DECL_FIELD_OFFSET (field),
2245
                       DECL_FIELD_BIT_OFFSET (field));
2246
}
2247
 
2248
/* Likewise, but return as an integer.  It must be representable in
2249
   that way (since it could be a signed value, we don't have the
2250
   option of returning -1 like int_size_in_byte can.  */
2251
 
2252
HOST_WIDE_INT
2253
int_bit_position (const_tree field)
2254
{
2255
  return tree_low_cst (bit_position (field), 0);
2256
}
2257
 
2258
/* Return the byte position of FIELD, in bytes from the start of the record.
2259
   This is a tree of type sizetype.  */
2260
 
2261
tree
2262
byte_position (const_tree field)
2263
{
2264
  return byte_from_pos (DECL_FIELD_OFFSET (field),
2265
                        DECL_FIELD_BIT_OFFSET (field));
2266
}
2267
 
2268
/* Likewise, but return as an integer.  It must be representable in
2269
   that way (since it could be a signed value, we don't have the
2270
   option of returning -1 like int_size_in_byte can.  */
2271
 
2272
HOST_WIDE_INT
2273
int_byte_position (const_tree field)
2274
{
2275
  return tree_low_cst (byte_position (field), 0);
2276
}
2277
 
2278
/* Return the strictest alignment, in bits, that T is known to have.  */
2279
 
2280
unsigned int
2281
expr_align (const_tree t)
2282
{
2283
  unsigned int align0, align1;
2284
 
2285
  switch (TREE_CODE (t))
2286
    {
2287
    CASE_CONVERT:  case NON_LVALUE_EXPR:
2288
      /* If we have conversions, we know that the alignment of the
2289
         object must meet each of the alignments of the types.  */
2290
      align0 = expr_align (TREE_OPERAND (t, 0));
2291
      align1 = TYPE_ALIGN (TREE_TYPE (t));
2292
      return MAX (align0, align1);
2293
 
2294
    case SAVE_EXPR:         case COMPOUND_EXPR:       case MODIFY_EXPR:
2295
    case INIT_EXPR:         case TARGET_EXPR:         case WITH_CLEANUP_EXPR:
2296
    case CLEANUP_POINT_EXPR:
2297
      /* These don't change the alignment of an object.  */
2298
      return expr_align (TREE_OPERAND (t, 0));
2299
 
2300
    case COND_EXPR:
2301
      /* The best we can do is say that the alignment is the least aligned
2302
         of the two arms.  */
2303
      align0 = expr_align (TREE_OPERAND (t, 1));
2304
      align1 = expr_align (TREE_OPERAND (t, 2));
2305
      return MIN (align0, align1);
2306
 
2307
      /* FIXME: LABEL_DECL and CONST_DECL never have DECL_ALIGN set
2308
         meaningfully, it's always 1.  */
2309
    case LABEL_DECL:     case CONST_DECL:
2310
    case VAR_DECL:       case PARM_DECL:   case RESULT_DECL:
2311
    case FUNCTION_DECL:
2312
      gcc_assert (DECL_ALIGN (t) != 0);
2313
      return DECL_ALIGN (t);
2314
 
2315
    default:
2316
      break;
2317
    }
2318
 
2319
  /* Otherwise take the alignment from that of the type.  */
2320
  return TYPE_ALIGN (TREE_TYPE (t));
2321
}
2322
 
2323
/* Return, as a tree node, the number of elements for TYPE (which is an
2324
   ARRAY_TYPE) minus one. This counts only elements of the top array.  */
2325
 
2326
tree
2327
array_type_nelts (const_tree type)
2328
{
2329
  tree index_type, min, max;
2330
 
2331
  /* If they did it with unspecified bounds, then we should have already
2332
     given an error about it before we got here.  */
2333
  if (! TYPE_DOMAIN (type))
2334
    return error_mark_node;
2335
 
2336
  index_type = TYPE_DOMAIN (type);
2337
  min = TYPE_MIN_VALUE (index_type);
2338
  max = TYPE_MAX_VALUE (index_type);
2339
 
2340
  return (integer_zerop (min)
2341
          ? max
2342
          : fold_build2 (MINUS_EXPR, TREE_TYPE (max), max, min));
2343
}
2344
 
2345
/* If arg is static -- a reference to an object in static storage -- then
2346
   return the object.  This is not the same as the C meaning of `static'.
2347
   If arg isn't static, return NULL.  */
2348
 
2349
tree
2350
staticp (tree arg)
2351
{
2352
  switch (TREE_CODE (arg))
2353
    {
2354
    case FUNCTION_DECL:
2355
      /* Nested functions are static, even though taking their address will
2356
         involve a trampoline as we unnest the nested function and create
2357
         the trampoline on the tree level.  */
2358
      return arg;
2359
 
2360
    case VAR_DECL:
2361
      return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2362
              && ! DECL_THREAD_LOCAL_P (arg)
2363
              && ! DECL_DLLIMPORT_P (arg)
2364
              ? arg : NULL);
2365
 
2366
    case CONST_DECL:
2367
      return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
2368
              ? arg : NULL);
2369
 
2370
    case CONSTRUCTOR:
2371
      return TREE_STATIC (arg) ? arg : NULL;
2372
 
2373
    case LABEL_DECL:
2374
    case STRING_CST:
2375
      return arg;
2376
 
2377
    case COMPONENT_REF:
2378
      /* If the thing being referenced is not a field, then it is
2379
         something language specific.  */
2380
      gcc_assert (TREE_CODE (TREE_OPERAND (arg, 1)) == FIELD_DECL);
2381
 
2382
      /* If we are referencing a bitfield, we can't evaluate an
2383
         ADDR_EXPR at compile time and so it isn't a constant.  */
2384
      if (DECL_BIT_FIELD (TREE_OPERAND (arg, 1)))
2385
        return NULL;
2386
 
2387
      return staticp (TREE_OPERAND (arg, 0));
2388
 
2389
    case BIT_FIELD_REF:
2390
      return NULL;
2391
 
2392
    case MISALIGNED_INDIRECT_REF:
2393
    case ALIGN_INDIRECT_REF:
2394
    case INDIRECT_REF:
2395
      return TREE_CONSTANT (TREE_OPERAND (arg, 0)) ? arg : NULL;
2396
 
2397
    case ARRAY_REF:
2398
    case ARRAY_RANGE_REF:
2399
      if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
2400
          && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
2401
        return staticp (TREE_OPERAND (arg, 0));
2402
      else
2403
        return NULL;
2404
 
2405
    case COMPOUND_LITERAL_EXPR:
2406
      return TREE_STATIC (COMPOUND_LITERAL_EXPR_DECL (arg)) ? arg : NULL;
2407
 
2408
    default:
2409
      return NULL;
2410
    }
2411
}
2412
 
2413
 
2414
 
2415
 
2416
/* Return whether OP is a DECL whose address is function-invariant.  */
2417
 
2418
bool
2419
decl_address_invariant_p (const_tree op)
2420
{
2421
  /* The conditions below are slightly less strict than the one in
2422
     staticp.  */
2423
 
2424
  switch (TREE_CODE (op))
2425
    {
2426
    case PARM_DECL:
2427
    case RESULT_DECL:
2428
    case LABEL_DECL:
2429
    case FUNCTION_DECL:
2430
      return true;
2431
 
2432
    case VAR_DECL:
2433
      if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2434
           && !DECL_DLLIMPORT_P (op))
2435
          || DECL_THREAD_LOCAL_P (op)
2436
          || DECL_CONTEXT (op) == current_function_decl
2437
          || decl_function_context (op) == current_function_decl)
2438
        return true;
2439
      break;
2440
 
2441
    case CONST_DECL:
2442
      if ((TREE_STATIC (op) || DECL_EXTERNAL (op))
2443
          || decl_function_context (op) == current_function_decl)
2444
        return true;
2445
      break;
2446
 
2447
    default:
2448
      break;
2449
    }
2450
 
2451
  return false;
2452
}
2453
 
2454
/* Return whether OP is a DECL whose address is interprocedural-invariant.  */
2455
 
2456
bool
2457
decl_address_ip_invariant_p (const_tree op)
2458
{
2459
  /* The conditions below are slightly less strict than the one in
2460
     staticp.  */
2461
 
2462
  switch (TREE_CODE (op))
2463
    {
2464
    case LABEL_DECL:
2465
    case FUNCTION_DECL:
2466
    case STRING_CST:
2467
      return true;
2468
 
2469
    case VAR_DECL:
2470
      if (((TREE_STATIC (op) || DECL_EXTERNAL (op))
2471
           && !DECL_DLLIMPORT_P (op))
2472
          || DECL_THREAD_LOCAL_P (op))
2473
        return true;
2474
      break;
2475
 
2476
    case CONST_DECL:
2477
      if ((TREE_STATIC (op) || DECL_EXTERNAL (op)))
2478
        return true;
2479
      break;
2480
 
2481
    default:
2482
      break;
2483
    }
2484
 
2485
  return false;
2486
}
2487
 
2488
 
2489
/* Return true if T is function-invariant (internal function, does
2490
   not handle arithmetic; that's handled in skip_simple_arithmetic and
2491
   tree_invariant_p).  */
2492
 
2493
static bool tree_invariant_p (tree t);
2494
 
2495
static bool
2496
tree_invariant_p_1 (tree t)
2497
{
2498
  tree op;
2499
 
2500
  if (TREE_CONSTANT (t)
2501
      || (TREE_READONLY (t) && !TREE_SIDE_EFFECTS (t)))
2502
    return true;
2503
 
2504
  switch (TREE_CODE (t))
2505
    {
2506
    case SAVE_EXPR:
2507
      return true;
2508
 
2509
    case ADDR_EXPR:
2510
      op = TREE_OPERAND (t, 0);
2511
      while (handled_component_p (op))
2512
        {
2513
          switch (TREE_CODE (op))
2514
            {
2515
            case ARRAY_REF:
2516
            case ARRAY_RANGE_REF:
2517
              if (!tree_invariant_p (TREE_OPERAND (op, 1))
2518
                  || TREE_OPERAND (op, 2) != NULL_TREE
2519
                  || TREE_OPERAND (op, 3) != NULL_TREE)
2520
                return false;
2521
              break;
2522
 
2523
            case COMPONENT_REF:
2524
              if (TREE_OPERAND (op, 2) != NULL_TREE)
2525
                return false;
2526
              break;
2527
 
2528
            default:;
2529
            }
2530
          op = TREE_OPERAND (op, 0);
2531
        }
2532
 
2533
      return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
2534
 
2535
    default:
2536
      break;
2537
    }
2538
 
2539
  return false;
2540
}
2541
 
2542
/* Return true if T is function-invariant.  */
2543
 
2544
static bool
2545
tree_invariant_p (tree t)
2546
{
2547
  tree inner = skip_simple_arithmetic (t);
2548
  return tree_invariant_p_1 (inner);
2549
}
2550
 
2551
/* Wrap a SAVE_EXPR around EXPR, if appropriate.
2552
   Do this to any expression which may be used in more than one place,
2553
   but must be evaluated only once.
2554
 
2555
   Normally, expand_expr would reevaluate the expression each time.
2556
   Calling save_expr produces something that is evaluated and recorded
2557
   the first time expand_expr is called on it.  Subsequent calls to
2558
   expand_expr just reuse the recorded value.
2559
 
2560
   The call to expand_expr that generates code that actually computes
2561
   the value is the first call *at compile time*.  Subsequent calls
2562
   *at compile time* generate code to use the saved value.
2563
   This produces correct result provided that *at run time* control
2564
   always flows through the insns made by the first expand_expr
2565
   before reaching the other places where the save_expr was evaluated.
2566
   You, the caller of save_expr, must make sure this is so.
2567
 
2568
   Constants, and certain read-only nodes, are returned with no
2569
   SAVE_EXPR because that is safe.  Expressions containing placeholders
2570
   are not touched; see tree.def for an explanation of what these
2571
   are used for.  */
2572
 
2573
tree
2574
save_expr (tree expr)
2575
{
2576
  tree t = fold (expr);
2577
  tree inner;
2578
 
2579
  /* If the tree evaluates to a constant, then we don't want to hide that
2580
     fact (i.e. this allows further folding, and direct checks for constants).
2581
     However, a read-only object that has side effects cannot be bypassed.
2582
     Since it is no problem to reevaluate literals, we just return the
2583
     literal node.  */
2584
  inner = skip_simple_arithmetic (t);
2585
  if (TREE_CODE (inner) == ERROR_MARK)
2586
    return inner;
2587
 
2588
  if (tree_invariant_p_1 (inner))
2589
    return t;
2590
 
2591
  /* If INNER contains a PLACEHOLDER_EXPR, we must evaluate it each time, since
2592
     it means that the size or offset of some field of an object depends on
2593
     the value within another field.
2594
 
2595
     Note that it must not be the case that T contains both a PLACEHOLDER_EXPR
2596
     and some variable since it would then need to be both evaluated once and
2597
     evaluated more than once.  Front-ends must assure this case cannot
2598
     happen by surrounding any such subexpressions in their own SAVE_EXPR
2599
     and forcing evaluation at the proper time.  */
2600
  if (contains_placeholder_p (inner))
2601
    return t;
2602
 
2603
  t = build1 (SAVE_EXPR, TREE_TYPE (expr), t);
2604
  SET_EXPR_LOCATION (t, EXPR_LOCATION (expr));
2605
 
2606
  /* This expression might be placed ahead of a jump to ensure that the
2607
     value was computed on both sides of the jump.  So make sure it isn't
2608
     eliminated as dead.  */
2609
  TREE_SIDE_EFFECTS (t) = 1;
2610
  return t;
2611
}
2612
 
2613
/* Look inside EXPR and into any simple arithmetic operations.  Return
2614
   the innermost non-arithmetic node.  */
2615
 
2616
tree
2617
skip_simple_arithmetic (tree expr)
2618
{
2619
  tree inner;
2620
 
2621
  /* We don't care about whether this can be used as an lvalue in this
2622
     context.  */
2623
  while (TREE_CODE (expr) == NON_LVALUE_EXPR)
2624
    expr = TREE_OPERAND (expr, 0);
2625
 
2626
  /* If we have simple operations applied to a SAVE_EXPR or to a SAVE_EXPR and
2627
     a constant, it will be more efficient to not make another SAVE_EXPR since
2628
     it will allow better simplification and GCSE will be able to merge the
2629
     computations if they actually occur.  */
2630
  inner = expr;
2631
  while (1)
2632
    {
2633
      if (UNARY_CLASS_P (inner))
2634
        inner = TREE_OPERAND (inner, 0);
2635
      else if (BINARY_CLASS_P (inner))
2636
        {
2637
          if (tree_invariant_p (TREE_OPERAND (inner, 1)))
2638
            inner = TREE_OPERAND (inner, 0);
2639
          else if (tree_invariant_p (TREE_OPERAND (inner, 0)))
2640
            inner = TREE_OPERAND (inner, 1);
2641
          else
2642
            break;
2643
        }
2644
      else
2645
        break;
2646
    }
2647
 
2648
  return inner;
2649
}
2650
 
2651
 
2652
/* Return which tree structure is used by T.  */
2653
 
2654
enum tree_node_structure_enum
2655
tree_node_structure (const_tree t)
2656
{
2657
  const enum tree_code code = TREE_CODE (t);
2658
  return tree_node_structure_for_code (code);
2659
}
2660
 
2661
/* Set various status flags when building a CALL_EXPR object T.  */
2662
 
2663
static void
2664
process_call_operands (tree t)
2665
{
2666
  bool side_effects = TREE_SIDE_EFFECTS (t);
2667
  bool read_only = false;
2668
  int i = call_expr_flags (t);
2669
 
2670
  /* Calls have side-effects, except those to const or pure functions.  */
2671
  if ((i & ECF_LOOPING_CONST_OR_PURE) || !(i & (ECF_CONST | ECF_PURE)))
2672
    side_effects = true;
2673
  /* Propagate TREE_READONLY of arguments for const functions.  */
2674
  if (i & ECF_CONST)
2675
    read_only = true;
2676
 
2677
  if (!side_effects || read_only)
2678
    for (i = 1; i < TREE_OPERAND_LENGTH (t); i++)
2679
      {
2680
        tree op = TREE_OPERAND (t, i);
2681
        if (op && TREE_SIDE_EFFECTS (op))
2682
          side_effects = true;
2683
        if (op && !TREE_READONLY (op) && !CONSTANT_CLASS_P (op))
2684
          read_only = false;
2685
      }
2686
 
2687
  TREE_SIDE_EFFECTS (t) = side_effects;
2688
  TREE_READONLY (t) = read_only;
2689
}
2690
 
2691
/* Return 1 if EXP contains a PLACEHOLDER_EXPR; i.e., if it represents a size
2692
   or offset that depends on a field within a record.  */
2693
 
2694
bool
2695
contains_placeholder_p (const_tree exp)
2696
{
2697
  enum tree_code code;
2698
 
2699
  if (!exp)
2700
    return 0;
2701
 
2702
  code = TREE_CODE (exp);
2703
  if (code == PLACEHOLDER_EXPR)
2704
    return 1;
2705
 
2706
  switch (TREE_CODE_CLASS (code))
2707
    {
2708
    case tcc_reference:
2709
      /* Don't look at any PLACEHOLDER_EXPRs that might be in index or bit
2710
         position computations since they will be converted into a
2711
         WITH_RECORD_EXPR involving the reference, which will assume
2712
         here will be valid.  */
2713
      return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2714
 
2715
    case tcc_exceptional:
2716
      if (code == TREE_LIST)
2717
        return (CONTAINS_PLACEHOLDER_P (TREE_VALUE (exp))
2718
                || CONTAINS_PLACEHOLDER_P (TREE_CHAIN (exp)));
2719
      break;
2720
 
2721
    case tcc_unary:
2722
    case tcc_binary:
2723
    case tcc_comparison:
2724
    case tcc_expression:
2725
      switch (code)
2726
        {
2727
        case COMPOUND_EXPR:
2728
          /* Ignoring the first operand isn't quite right, but works best.  */
2729
          return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1));
2730
 
2731
        case COND_EXPR:
2732
          return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2733
                  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1))
2734
                  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 2)));
2735
 
2736
        case SAVE_EXPR:
2737
          /* The save_expr function never wraps anything containing
2738
             a PLACEHOLDER_EXPR. */
2739
          return 0;
2740
 
2741
        default:
2742
          break;
2743
        }
2744
 
2745
      switch (TREE_CODE_LENGTH (code))
2746
        {
2747
        case 1:
2748
          return CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0));
2749
        case 2:
2750
          return (CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 0))
2751
                  || CONTAINS_PLACEHOLDER_P (TREE_OPERAND (exp, 1)));
2752
        default:
2753
          return 0;
2754
        }
2755
 
2756
    case tcc_vl_exp:
2757
      switch (code)
2758
        {
2759
        case CALL_EXPR:
2760
          {
2761
            const_tree arg;
2762
            const_call_expr_arg_iterator iter;
2763
            FOR_EACH_CONST_CALL_EXPR_ARG (arg, iter, exp)
2764
              if (CONTAINS_PLACEHOLDER_P (arg))
2765
                return 1;
2766
            return 0;
2767
          }
2768
        default:
2769
          return 0;
2770
        }
2771
 
2772
    default:
2773
      return 0;
2774
    }
2775
  return 0;
2776
}
2777
 
2778
/* Return true if any part of the computation of TYPE involves a
2779
   PLACEHOLDER_EXPR.  This includes size, bounds, qualifiers
2780
   (for QUAL_UNION_TYPE) and field positions.  */
2781
 
2782
static bool
2783
type_contains_placeholder_1 (const_tree type)
2784
{
2785
  /* If the size contains a placeholder or the parent type (component type in
2786
     the case of arrays) type involves a placeholder, this type does.  */
2787
  if (CONTAINS_PLACEHOLDER_P (TYPE_SIZE (type))
2788
      || CONTAINS_PLACEHOLDER_P (TYPE_SIZE_UNIT (type))
2789
      || (TREE_TYPE (type) != 0
2790
          && type_contains_placeholder_p (TREE_TYPE (type))))
2791
    return true;
2792
 
2793
  /* Now do type-specific checks.  Note that the last part of the check above
2794
     greatly limits what we have to do below.  */
2795
  switch (TREE_CODE (type))
2796
    {
2797
    case VOID_TYPE:
2798
    case COMPLEX_TYPE:
2799
    case ENUMERAL_TYPE:
2800
    case BOOLEAN_TYPE:
2801
    case POINTER_TYPE:
2802
    case OFFSET_TYPE:
2803
    case REFERENCE_TYPE:
2804
    case METHOD_TYPE:
2805
    case FUNCTION_TYPE:
2806
    case VECTOR_TYPE:
2807
      return false;
2808
 
2809
    case INTEGER_TYPE:
2810
    case REAL_TYPE:
2811
    case FIXED_POINT_TYPE:
2812
      /* Here we just check the bounds.  */
2813
      return (CONTAINS_PLACEHOLDER_P (TYPE_MIN_VALUE (type))
2814
              || CONTAINS_PLACEHOLDER_P (TYPE_MAX_VALUE (type)));
2815
 
2816
    case ARRAY_TYPE:
2817
      /* We're already checked the component type (TREE_TYPE), so just check
2818
         the index type.  */
2819
      return type_contains_placeholder_p (TYPE_DOMAIN (type));
2820
 
2821
    case RECORD_TYPE:
2822
    case UNION_TYPE:
2823
    case QUAL_UNION_TYPE:
2824
      {
2825
        tree field;
2826
 
2827
        for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
2828
          if (TREE_CODE (field) == FIELD_DECL
2829
              && (CONTAINS_PLACEHOLDER_P (DECL_FIELD_OFFSET (field))
2830
                  || (TREE_CODE (type) == QUAL_UNION_TYPE
2831
                      && CONTAINS_PLACEHOLDER_P (DECL_QUALIFIER (field)))
2832
                  || type_contains_placeholder_p (TREE_TYPE (field))))
2833
            return true;
2834
 
2835
        return false;
2836
      }
2837
 
2838
    default:
2839
      gcc_unreachable ();
2840
    }
2841
}
2842
 
2843
bool
2844
type_contains_placeholder_p (tree type)
2845
{
2846
  bool result;
2847
 
2848
  /* If the contains_placeholder_bits field has been initialized,
2849
     then we know the answer.  */
2850
  if (TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) > 0)
2851
    return TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) - 1;
2852
 
2853
  /* Indicate that we've seen this type node, and the answer is false.
2854
     This is what we want to return if we run into recursion via fields.  */
2855
  TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = 1;
2856
 
2857
  /* Compute the real value.  */
2858
  result = type_contains_placeholder_1 (type);
2859
 
2860
  /* Store the real value.  */
2861
  TYPE_CONTAINS_PLACEHOLDER_INTERNAL (type) = result + 1;
2862
 
2863
  return result;
2864
}
2865
 
2866
/* Push tree EXP onto vector QUEUE if it is not already present.  */
2867
 
2868
static void
2869
push_without_duplicates (tree exp, VEC (tree, heap) **queue)
2870
{
2871
  unsigned int i;
2872
  tree iter;
2873
 
2874
  for (i = 0; VEC_iterate (tree, *queue, i, iter); i++)
2875
    if (simple_cst_equal (iter, exp) == 1)
2876
      break;
2877
 
2878
  if (!iter)
2879
    VEC_safe_push (tree, heap, *queue, exp);
2880
}
2881
 
2882
/* Given a tree EXP, find all occurences of references to fields
2883
   in a PLACEHOLDER_EXPR and place them in vector REFS without
2884
   duplicates.  Also record VAR_DECLs and CONST_DECLs.  Note that
2885
   we assume here that EXP contains only arithmetic expressions
2886
   or CALL_EXPRs with PLACEHOLDER_EXPRs occurring only in their
2887
   argument list.  */
2888
 
2889
void
2890
find_placeholder_in_expr (tree exp, VEC (tree, heap) **refs)
2891
{
2892
  enum tree_code code = TREE_CODE (exp);
2893
  tree inner;
2894
  int i;
2895
 
2896
  /* We handle TREE_LIST and COMPONENT_REF separately.  */
2897
  if (code == TREE_LIST)
2898
    {
2899
      FIND_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), refs);
2900
      FIND_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), refs);
2901
    }
2902
  else if (code == COMPONENT_REF)
2903
    {
2904
      for (inner = TREE_OPERAND (exp, 0);
2905
           REFERENCE_CLASS_P (inner);
2906
           inner = TREE_OPERAND (inner, 0))
2907
        ;
2908
 
2909
      if (TREE_CODE (inner) == PLACEHOLDER_EXPR)
2910
        push_without_duplicates (exp, refs);
2911
      else
2912
        FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), refs);
2913
   }
2914
  else
2915
    switch (TREE_CODE_CLASS (code))
2916
      {
2917
      case tcc_constant:
2918
        break;
2919
 
2920
      case tcc_declaration:
2921
        /* Variables allocated to static storage can stay.  */
2922
        if (!TREE_STATIC (exp))
2923
          push_without_duplicates (exp, refs);
2924
        break;
2925
 
2926
      case tcc_expression:
2927
        /* This is the pattern built in ada/make_aligning_type.  */
2928
        if (code == ADDR_EXPR
2929
            && TREE_CODE (TREE_OPERAND (exp, 0)) == PLACEHOLDER_EXPR)
2930
          {
2931
            push_without_duplicates (exp, refs);
2932
            break;
2933
          }
2934
 
2935
        /* Fall through...  */
2936
 
2937
      case tcc_exceptional:
2938
      case tcc_unary:
2939
      case tcc_binary:
2940
      case tcc_comparison:
2941
      case tcc_reference:
2942
        for (i = 0; i < TREE_CODE_LENGTH (code); i++)
2943
          FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2944
        break;
2945
 
2946
      case tcc_vl_exp:
2947
        for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
2948
          FIND_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, i), refs);
2949
        break;
2950
 
2951
      default:
2952
        gcc_unreachable ();
2953
      }
2954
}
2955
 
2956
/* Given a tree EXP, a FIELD_DECL F, and a replacement value R,
2957
   return a tree with all occurrences of references to F in a
2958
   PLACEHOLDER_EXPR replaced by R.  Also handle VAR_DECLs and
2959
   CONST_DECLs.  Note that we assume here that EXP contains only
2960
   arithmetic expressions or CALL_EXPRs with PLACEHOLDER_EXPRs
2961
   occurring only in their argument list.  */
2962
 
2963
tree
2964
substitute_in_expr (tree exp, tree f, tree r)
2965
{
2966
  enum tree_code code = TREE_CODE (exp);
2967
  tree op0, op1, op2, op3;
2968
  tree new_tree;
2969
 
2970
  /* We handle TREE_LIST and COMPONENT_REF separately.  */
2971
  if (code == TREE_LIST)
2972
    {
2973
      op0 = SUBSTITUTE_IN_EXPR (TREE_CHAIN (exp), f, r);
2974
      op1 = SUBSTITUTE_IN_EXPR (TREE_VALUE (exp), f, r);
2975
      if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
2976
        return exp;
2977
 
2978
      return tree_cons (TREE_PURPOSE (exp), op1, op0);
2979
    }
2980
  else if (code == COMPONENT_REF)
2981
    {
2982
      tree inner;
2983
 
2984
      /* If this expression is getting a value from a PLACEHOLDER_EXPR
2985
         and it is the right field, replace it with R.  */
2986
      for (inner = TREE_OPERAND (exp, 0);
2987
           REFERENCE_CLASS_P (inner);
2988
           inner = TREE_OPERAND (inner, 0))
2989
        ;
2990
 
2991
      /* The field.  */
2992
      op1 = TREE_OPERAND (exp, 1);
2993
 
2994
      if (TREE_CODE (inner) == PLACEHOLDER_EXPR && op1 == f)
2995
        return r;
2996
 
2997
      /* If this expression hasn't been completed let, leave it alone.  */
2998
      if (TREE_CODE (inner) == PLACEHOLDER_EXPR && !TREE_TYPE (inner))
2999
        return exp;
3000
 
3001
      op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3002
      if (op0 == TREE_OPERAND (exp, 0))
3003
        return exp;
3004
 
3005
      new_tree
3006
        = fold_build3 (COMPONENT_REF, TREE_TYPE (exp), op0, op1, NULL_TREE);
3007
   }
3008
  else
3009
    switch (TREE_CODE_CLASS (code))
3010
      {
3011
      case tcc_constant:
3012
        return exp;
3013
 
3014
      case tcc_declaration:
3015
        if (exp == f)
3016
          return r;
3017
        else
3018
          return exp;
3019
 
3020
      case tcc_expression:
3021
        if (exp == f)
3022
          return r;
3023
 
3024
        /* Fall through...  */
3025
 
3026
      case tcc_exceptional:
3027
      case tcc_unary:
3028
      case tcc_binary:
3029
      case tcc_comparison:
3030
      case tcc_reference:
3031
        switch (TREE_CODE_LENGTH (code))
3032
          {
3033
          case 0:
3034
            return exp;
3035
 
3036
          case 1:
3037
            op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3038
            if (op0 == TREE_OPERAND (exp, 0))
3039
              return exp;
3040
 
3041
            new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3042
            break;
3043
 
3044
          case 2:
3045
            op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3046
            op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3047
 
3048
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3049
              return exp;
3050
 
3051
            new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3052
            break;
3053
 
3054
          case 3:
3055
            op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3056
            op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3057
            op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3058
 
3059
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3060
                && op2 == TREE_OPERAND (exp, 2))
3061
              return exp;
3062
 
3063
            new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3064
            break;
3065
 
3066
          case 4:
3067
            op0 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 0), f, r);
3068
            op1 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 1), f, r);
3069
            op2 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 2), f, r);
3070
            op3 = SUBSTITUTE_IN_EXPR (TREE_OPERAND (exp, 3), f, r);
3071
 
3072
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3073
                && op2 == TREE_OPERAND (exp, 2)
3074
                && op3 == TREE_OPERAND (exp, 3))
3075
              return exp;
3076
 
3077
            new_tree
3078
              = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3079
            break;
3080
 
3081
          default:
3082
            gcc_unreachable ();
3083
          }
3084
        break;
3085
 
3086
      case tcc_vl_exp:
3087
        {
3088
          int i;
3089
 
3090
          new_tree = NULL_TREE;
3091
 
3092
          /* If we are trying to replace F with a constant, inline back
3093
             functions which do nothing else than computing a value from
3094
             the arguments they are passed.  This makes it possible to
3095
             fold partially or entirely the replacement expression.  */
3096
          if (CONSTANT_CLASS_P (r) && code == CALL_EXPR)
3097
            {
3098
              tree t = maybe_inline_call_in_expr (exp);
3099
              if (t)
3100
                return SUBSTITUTE_IN_EXPR (t, f, r);
3101
            }
3102
 
3103
          for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3104
            {
3105
              tree op = TREE_OPERAND (exp, i);
3106
              tree new_op = SUBSTITUTE_IN_EXPR (op, f, r);
3107
              if (new_op != op)
3108
                {
3109
                  if (!new_tree)
3110
                    new_tree = copy_node (exp);
3111
                  TREE_OPERAND (new_tree, i) = new_op;
3112
                }
3113
            }
3114
 
3115
          if (new_tree)
3116
            {
3117
              new_tree = fold (new_tree);
3118
              if (TREE_CODE (new_tree) == CALL_EXPR)
3119
                process_call_operands (new_tree);
3120
            }
3121
          else
3122
            return exp;
3123
        }
3124
        break;
3125
 
3126
      default:
3127
        gcc_unreachable ();
3128
      }
3129
 
3130
  TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3131
  return new_tree;
3132
}
3133
 
3134
/* Similar, but look for a PLACEHOLDER_EXPR in EXP and find a replacement
3135
   for it within OBJ, a tree that is an object or a chain of references.  */
3136
 
3137
tree
3138
substitute_placeholder_in_expr (tree exp, tree obj)
3139
{
3140
  enum tree_code code = TREE_CODE (exp);
3141
  tree op0, op1, op2, op3;
3142
  tree new_tree;
3143
 
3144
  /* If this is a PLACEHOLDER_EXPR, see if we find a corresponding type
3145
     in the chain of OBJ.  */
3146
  if (code == PLACEHOLDER_EXPR)
3147
    {
3148
      tree need_type = TYPE_MAIN_VARIANT (TREE_TYPE (exp));
3149
      tree elt;
3150
 
3151
      for (elt = obj; elt != 0;
3152
           elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3153
                   || TREE_CODE (elt) == COND_EXPR)
3154
                  ? TREE_OPERAND (elt, 1)
3155
                  : (REFERENCE_CLASS_P (elt)
3156
                     || UNARY_CLASS_P (elt)
3157
                     || BINARY_CLASS_P (elt)
3158
                     || VL_EXP_CLASS_P (elt)
3159
                     || EXPRESSION_CLASS_P (elt))
3160
                  ? TREE_OPERAND (elt, 0) : 0))
3161
        if (TYPE_MAIN_VARIANT (TREE_TYPE (elt)) == need_type)
3162
          return elt;
3163
 
3164
      for (elt = obj; elt != 0;
3165
           elt = ((TREE_CODE (elt) == COMPOUND_EXPR
3166
                   || TREE_CODE (elt) == COND_EXPR)
3167
                  ? TREE_OPERAND (elt, 1)
3168
                  : (REFERENCE_CLASS_P (elt)
3169
                     || UNARY_CLASS_P (elt)
3170
                     || BINARY_CLASS_P (elt)
3171
                     || VL_EXP_CLASS_P (elt)
3172
                     || EXPRESSION_CLASS_P (elt))
3173
                  ? TREE_OPERAND (elt, 0) : 0))
3174
        if (POINTER_TYPE_P (TREE_TYPE (elt))
3175
            && (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (elt)))
3176
                == need_type))
3177
          return fold_build1 (INDIRECT_REF, need_type, elt);
3178
 
3179
      /* If we didn't find it, return the original PLACEHOLDER_EXPR.  If it
3180
         survives until RTL generation, there will be an error.  */
3181
      return exp;
3182
    }
3183
 
3184
  /* TREE_LIST is special because we need to look at TREE_VALUE
3185
     and TREE_CHAIN, not TREE_OPERANDS.  */
3186
  else if (code == TREE_LIST)
3187
    {
3188
      op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_CHAIN (exp), obj);
3189
      op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_VALUE (exp), obj);
3190
      if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
3191
        return exp;
3192
 
3193
      return tree_cons (TREE_PURPOSE (exp), op1, op0);
3194
    }
3195
  else
3196
    switch (TREE_CODE_CLASS (code))
3197
      {
3198
      case tcc_constant:
3199
      case tcc_declaration:
3200
        return exp;
3201
 
3202
      case tcc_exceptional:
3203
      case tcc_unary:
3204
      case tcc_binary:
3205
      case tcc_comparison:
3206
      case tcc_expression:
3207
      case tcc_reference:
3208
      case tcc_statement:
3209
        switch (TREE_CODE_LENGTH (code))
3210
          {
3211
          case 0:
3212
            return exp;
3213
 
3214
          case 1:
3215
            op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3216
            if (op0 == TREE_OPERAND (exp, 0))
3217
              return exp;
3218
 
3219
            new_tree = fold_build1 (code, TREE_TYPE (exp), op0);
3220
            break;
3221
 
3222
          case 2:
3223
            op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3224
            op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3225
 
3226
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
3227
              return exp;
3228
 
3229
            new_tree = fold_build2 (code, TREE_TYPE (exp), op0, op1);
3230
            break;
3231
 
3232
          case 3:
3233
            op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3234
            op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3235
            op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3236
 
3237
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3238
                && op2 == TREE_OPERAND (exp, 2))
3239
              return exp;
3240
 
3241
            new_tree = fold_build3 (code, TREE_TYPE (exp), op0, op1, op2);
3242
            break;
3243
 
3244
          case 4:
3245
            op0 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 0), obj);
3246
            op1 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 1), obj);
3247
            op2 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 2), obj);
3248
            op3 = SUBSTITUTE_PLACEHOLDER_IN_EXPR (TREE_OPERAND (exp, 3), obj);
3249
 
3250
            if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
3251
                && op2 == TREE_OPERAND (exp, 2)
3252
                && op3 == TREE_OPERAND (exp, 3))
3253
              return exp;
3254
 
3255
            new_tree
3256
              = fold (build4 (code, TREE_TYPE (exp), op0, op1, op2, op3));
3257
            break;
3258
 
3259
          default:
3260
            gcc_unreachable ();
3261
          }
3262
        break;
3263
 
3264
      case tcc_vl_exp:
3265
        {
3266
          int i;
3267
 
3268
          new_tree = NULL_TREE;
3269
 
3270
          for (i = 1; i < TREE_OPERAND_LENGTH (exp); i++)
3271
            {
3272
              tree op = TREE_OPERAND (exp, i);
3273
              tree new_op = SUBSTITUTE_PLACEHOLDER_IN_EXPR (op, obj);
3274
              if (new_op != op)
3275
                {
3276
                  if (!new_tree)
3277
                    new_tree = copy_node (exp);
3278
                  TREE_OPERAND (new_tree, i) = new_op;
3279
                }
3280
            }
3281
 
3282
          if (new_tree)
3283
            {
3284
              new_tree = fold (new_tree);
3285
              if (TREE_CODE (new_tree) == CALL_EXPR)
3286
                process_call_operands (new_tree);
3287
            }
3288
          else
3289
            return exp;
3290
        }
3291
        break;
3292
 
3293
      default:
3294
        gcc_unreachable ();
3295
      }
3296
 
3297
  TREE_READONLY (new_tree) |= TREE_READONLY (exp);
3298
  return new_tree;
3299
}
3300
 
3301
/* Stabilize a reference so that we can use it any number of times
3302
   without causing its operands to be evaluated more than once.
3303
   Returns the stabilized reference.  This works by means of save_expr,
3304
   so see the caveats in the comments about save_expr.
3305
 
3306
   Also allows conversion expressions whose operands are references.
3307
   Any other kind of expression is returned unchanged.  */
3308
 
3309
tree
3310
stabilize_reference (tree ref)
3311
{
3312
  tree result;
3313
  enum tree_code code = TREE_CODE (ref);
3314
 
3315
  switch (code)
3316
    {
3317
    case VAR_DECL:
3318
    case PARM_DECL:
3319
    case RESULT_DECL:
3320
      /* No action is needed in this case.  */
3321
      return ref;
3322
 
3323
    CASE_CONVERT:
3324
    case FLOAT_EXPR:
3325
    case FIX_TRUNC_EXPR:
3326
      result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
3327
      break;
3328
 
3329
    case INDIRECT_REF:
3330
      result = build_nt (INDIRECT_REF,
3331
                         stabilize_reference_1 (TREE_OPERAND (ref, 0)));
3332
      break;
3333
 
3334
    case COMPONENT_REF:
3335
      result = build_nt (COMPONENT_REF,
3336
                         stabilize_reference (TREE_OPERAND (ref, 0)),
3337
                         TREE_OPERAND (ref, 1), NULL_TREE);
3338
      break;
3339
 
3340
    case BIT_FIELD_REF:
3341
      result = build_nt (BIT_FIELD_REF,
3342
                         stabilize_reference (TREE_OPERAND (ref, 0)),
3343
                         stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3344
                         stabilize_reference_1 (TREE_OPERAND (ref, 2)));
3345
      break;
3346
 
3347
    case ARRAY_REF:
3348
      result = build_nt (ARRAY_REF,
3349
                         stabilize_reference (TREE_OPERAND (ref, 0)),
3350
                         stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3351
                         TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3352
      break;
3353
 
3354
    case ARRAY_RANGE_REF:
3355
      result = build_nt (ARRAY_RANGE_REF,
3356
                         stabilize_reference (TREE_OPERAND (ref, 0)),
3357
                         stabilize_reference_1 (TREE_OPERAND (ref, 1)),
3358
                         TREE_OPERAND (ref, 2), TREE_OPERAND (ref, 3));
3359
      break;
3360
 
3361
    case COMPOUND_EXPR:
3362
      /* We cannot wrap the first expression in a SAVE_EXPR, as then
3363
         it wouldn't be ignored.  This matters when dealing with
3364
         volatiles.  */
3365
      return stabilize_reference_1 (ref);
3366
 
3367
      /* If arg isn't a kind of lvalue we recognize, make no change.
3368
         Caller should recognize the error for an invalid lvalue.  */
3369
    default:
3370
      return ref;
3371
 
3372
    case ERROR_MARK:
3373
      return error_mark_node;
3374
    }
3375
 
3376
  TREE_TYPE (result) = TREE_TYPE (ref);
3377
  TREE_READONLY (result) = TREE_READONLY (ref);
3378
  TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
3379
  TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
3380
 
3381
  return result;
3382
}
3383
 
3384
/* Subroutine of stabilize_reference; this is called for subtrees of
3385
   references.  Any expression with side-effects must be put in a SAVE_EXPR
3386
   to ensure that it is only evaluated once.
3387
 
3388
   We don't put SAVE_EXPR nodes around everything, because assigning very
3389
   simple expressions to temporaries causes us to miss good opportunities
3390
   for optimizations.  Among other things, the opportunity to fold in the
3391
   addition of a constant into an addressing mode often gets lost, e.g.
3392
   "y[i+1] += x;".  In general, we take the approach that we should not make
3393
   an assignment unless we are forced into it - i.e., that any non-side effect
3394
   operator should be allowed, and that cse should take care of coalescing
3395
   multiple utterances of the same expression should that prove fruitful.  */
3396
 
3397
tree
3398
stabilize_reference_1 (tree e)
3399
{
3400
  tree result;
3401
  enum tree_code code = TREE_CODE (e);
3402
 
3403
  /* We cannot ignore const expressions because it might be a reference
3404
     to a const array but whose index contains side-effects.  But we can
3405
     ignore things that are actual constant or that already have been
3406
     handled by this function.  */
3407
 
3408
  if (tree_invariant_p (e))
3409
    return e;
3410
 
3411
  switch (TREE_CODE_CLASS (code))
3412
    {
3413
    case tcc_exceptional:
3414
    case tcc_type:
3415
    case tcc_declaration:
3416
    case tcc_comparison:
3417
    case tcc_statement:
3418
    case tcc_expression:
3419
    case tcc_reference:
3420
    case tcc_vl_exp:
3421
      /* If the expression has side-effects, then encase it in a SAVE_EXPR
3422
         so that it will only be evaluated once.  */
3423
      /* The reference (r) and comparison (<) classes could be handled as
3424
         below, but it is generally faster to only evaluate them once.  */
3425
      if (TREE_SIDE_EFFECTS (e))
3426
        return save_expr (e);
3427
      return e;
3428
 
3429
    case tcc_constant:
3430
      /* Constants need no processing.  In fact, we should never reach
3431
         here.  */
3432
      return e;
3433
 
3434
    case tcc_binary:
3435
      /* Division is slow and tends to be compiled with jumps,
3436
         especially the division by powers of 2 that is often
3437
         found inside of an array reference.  So do it just once.  */
3438
      if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
3439
          || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
3440
          || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
3441
          || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
3442
        return save_expr (e);
3443
      /* Recursively stabilize each operand.  */
3444
      result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
3445
                         stabilize_reference_1 (TREE_OPERAND (e, 1)));
3446
      break;
3447
 
3448
    case tcc_unary:
3449
      /* Recursively stabilize each operand.  */
3450
      result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
3451
      break;
3452
 
3453
    default:
3454
      gcc_unreachable ();
3455
    }
3456
 
3457
  TREE_TYPE (result) = TREE_TYPE (e);
3458
  TREE_READONLY (result) = TREE_READONLY (e);
3459
  TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
3460
  TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
3461
 
3462
  return result;
3463
}
3464
 
3465
/* Low-level constructors for expressions.  */
3466
 
3467
/* A helper function for build1 and constant folders.  Set TREE_CONSTANT,
3468
   and TREE_SIDE_EFFECTS for an ADDR_EXPR.  */
3469
 
3470
void
3471
recompute_tree_invariant_for_addr_expr (tree t)
3472
{
3473
  tree node;
3474
  bool tc = true, se = false;
3475
 
3476
  /* We started out assuming this address is both invariant and constant, but
3477
     does not have side effects.  Now go down any handled components and see if
3478
     any of them involve offsets that are either non-constant or non-invariant.
3479
     Also check for side-effects.
3480
 
3481
     ??? Note that this code makes no attempt to deal with the case where
3482
     taking the address of something causes a copy due to misalignment.  */
3483
 
3484
#define UPDATE_FLAGS(NODE)  \
3485
do { tree _node = (NODE); \
3486
     if (_node && !TREE_CONSTANT (_node)) tc = false; \
3487
     if (_node && TREE_SIDE_EFFECTS (_node)) se = true; } while (0)
3488
 
3489
  for (node = TREE_OPERAND (t, 0); handled_component_p (node);
3490
       node = TREE_OPERAND (node, 0))
3491
    {
3492
      /* If the first operand doesn't have an ARRAY_TYPE, this is a bogus
3493
         array reference (probably made temporarily by the G++ front end),
3494
         so ignore all the operands.  */
3495
      if ((TREE_CODE (node) == ARRAY_REF
3496
           || TREE_CODE (node) == ARRAY_RANGE_REF)
3497
          && TREE_CODE (TREE_TYPE (TREE_OPERAND (node, 0))) == ARRAY_TYPE)
3498
        {
3499
          UPDATE_FLAGS (TREE_OPERAND (node, 1));
3500
          if (TREE_OPERAND (node, 2))
3501
            UPDATE_FLAGS (TREE_OPERAND (node, 2));
3502
          if (TREE_OPERAND (node, 3))
3503
            UPDATE_FLAGS (TREE_OPERAND (node, 3));
3504
        }
3505
      /* Likewise, just because this is a COMPONENT_REF doesn't mean we have a
3506
         FIELD_DECL, apparently.  The G++ front end can put something else
3507
         there, at least temporarily.  */
3508
      else if (TREE_CODE (node) == COMPONENT_REF
3509
               && TREE_CODE (TREE_OPERAND (node, 1)) == FIELD_DECL)
3510
        {
3511
          if (TREE_OPERAND (node, 2))
3512
            UPDATE_FLAGS (TREE_OPERAND (node, 2));
3513
        }
3514
      else if (TREE_CODE (node) == BIT_FIELD_REF)
3515
        UPDATE_FLAGS (TREE_OPERAND (node, 2));
3516
    }
3517
 
3518
  node = lang_hooks.expr_to_decl (node, &tc, &se);
3519
 
3520
  /* Now see what's inside.  If it's an INDIRECT_REF, copy our properties from
3521
     the address, since &(*a)->b is a form of addition.  If it's a constant, the
3522
     address is constant too.  If it's a decl, its address is constant if the
3523
     decl is static.  Everything else is not constant and, furthermore,
3524
     taking the address of a volatile variable is not volatile.  */
3525
  if (TREE_CODE (node) == INDIRECT_REF)
3526
    UPDATE_FLAGS (TREE_OPERAND (node, 0));
3527
  else if (CONSTANT_CLASS_P (node))
3528
    ;
3529
  else if (DECL_P (node))
3530
    tc &= (staticp (node) != NULL_TREE);
3531
  else
3532
    {
3533
      tc = false;
3534
      se |= TREE_SIDE_EFFECTS (node);
3535
    }
3536
 
3537
 
3538
  TREE_CONSTANT (t) = tc;
3539
  TREE_SIDE_EFFECTS (t) = se;
3540
#undef UPDATE_FLAGS
3541
}
3542
 
3543
/* Build an expression of code CODE, data type TYPE, and operands as
3544
   specified.  Expressions and reference nodes can be created this way.
3545
   Constants, decls, types and misc nodes cannot be.
3546
 
3547
   We define 5 non-variadic functions, from 0 to 4 arguments.  This is
3548
   enough for all extant tree codes.  */
3549
 
3550
tree
3551
build0_stat (enum tree_code code, tree tt MEM_STAT_DECL)
3552
{
3553
  tree t;
3554
 
3555
  gcc_assert (TREE_CODE_LENGTH (code) == 0);
3556
 
3557
  t = make_node_stat (code PASS_MEM_STAT);
3558
  TREE_TYPE (t) = tt;
3559
 
3560
  return t;
3561
}
3562
 
3563
tree
3564
build1_stat (enum tree_code code, tree type, tree node MEM_STAT_DECL)
3565
{
3566
  int length = sizeof (struct tree_exp);
3567
#ifdef GATHER_STATISTICS
3568
  tree_node_kind kind;
3569
#endif
3570
  tree t;
3571
 
3572
#ifdef GATHER_STATISTICS
3573
  switch (TREE_CODE_CLASS (code))
3574
    {
3575
    case tcc_statement:  /* an expression with side effects */
3576
      kind = s_kind;
3577
      break;
3578
    case tcc_reference:  /* a reference */
3579
      kind = r_kind;
3580
      break;
3581
    default:
3582
      kind = e_kind;
3583
      break;
3584
    }
3585
 
3586
  tree_node_counts[(int) kind]++;
3587
  tree_node_sizes[(int) kind] += length;
3588
#endif
3589
 
3590
  gcc_assert (TREE_CODE_LENGTH (code) == 1);
3591
 
3592
  t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
3593
 
3594
  memset (t, 0, sizeof (struct tree_common));
3595
 
3596
  TREE_SET_CODE (t, code);
3597
 
3598
  TREE_TYPE (t) = type;
3599
  SET_EXPR_LOCATION (t, UNKNOWN_LOCATION);
3600
  TREE_OPERAND (t, 0) = node;
3601
  TREE_BLOCK (t) = NULL_TREE;
3602
  if (node && !TYPE_P (node))
3603
    {
3604
      TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
3605
      TREE_READONLY (t) = TREE_READONLY (node);
3606
    }
3607
 
3608
  if (TREE_CODE_CLASS (code) == tcc_statement)
3609
    TREE_SIDE_EFFECTS (t) = 1;
3610
  else switch (code)
3611
    {
3612
    case VA_ARG_EXPR:
3613
      /* All of these have side-effects, no matter what their
3614
         operands are.  */
3615
      TREE_SIDE_EFFECTS (t) = 1;
3616
      TREE_READONLY (t) = 0;
3617
      break;
3618
 
3619
    case MISALIGNED_INDIRECT_REF:
3620
    case ALIGN_INDIRECT_REF:
3621
    case INDIRECT_REF:
3622
      /* Whether a dereference is readonly has nothing to do with whether
3623
         its operand is readonly.  */
3624
      TREE_READONLY (t) = 0;
3625
      break;
3626
 
3627
    case ADDR_EXPR:
3628
      if (node)
3629
        recompute_tree_invariant_for_addr_expr (t);
3630
      break;
3631
 
3632
    default:
3633
      if ((TREE_CODE_CLASS (code) == tcc_unary || code == VIEW_CONVERT_EXPR)
3634
          && node && !TYPE_P (node)
3635
          && TREE_CONSTANT (node))
3636
        TREE_CONSTANT (t) = 1;
3637
      if (TREE_CODE_CLASS (code) == tcc_reference
3638
          && node && TREE_THIS_VOLATILE (node))
3639
        TREE_THIS_VOLATILE (t) = 1;
3640
      break;
3641
    }
3642
 
3643
  return t;
3644
}
3645
 
3646
#define PROCESS_ARG(N)                          \
3647
  do {                                          \
3648
    TREE_OPERAND (t, N) = arg##N;               \
3649
    if (arg##N &&!TYPE_P (arg##N))              \
3650
      {                                         \
3651
        if (TREE_SIDE_EFFECTS (arg##N))         \
3652
          side_effects = 1;                     \
3653
        if (!TREE_READONLY (arg##N)             \
3654
            && !CONSTANT_CLASS_P (arg##N))      \
3655
          read_only = 0;                 \
3656
        if (!TREE_CONSTANT (arg##N))            \
3657
          constant = 0;                          \
3658
      }                                         \
3659
  } while (0)
3660
 
3661
tree
3662
build2_stat (enum tree_code code, tree tt, tree arg0, tree arg1 MEM_STAT_DECL)
3663
{
3664
  bool constant, read_only, side_effects;
3665
  tree t;
3666
 
3667
  gcc_assert (TREE_CODE_LENGTH (code) == 2);
3668
 
3669
  if ((code == MINUS_EXPR || code == PLUS_EXPR || code == MULT_EXPR)
3670
      && arg0 && arg1 && tt && POINTER_TYPE_P (tt)
3671
      /* When sizetype precision doesn't match that of pointers
3672
         we need to be able to build explicit extensions or truncations
3673
         of the offset argument.  */
3674
      && TYPE_PRECISION (sizetype) == TYPE_PRECISION (tt))
3675
    gcc_assert (TREE_CODE (arg0) == INTEGER_CST
3676
                && TREE_CODE (arg1) == INTEGER_CST);
3677
 
3678
  if (code == POINTER_PLUS_EXPR && arg0 && arg1 && tt)
3679
    gcc_assert (POINTER_TYPE_P (tt) && POINTER_TYPE_P (TREE_TYPE (arg0))
3680
                && INTEGRAL_TYPE_P (TREE_TYPE (arg1))
3681
                && useless_type_conversion_p (sizetype, TREE_TYPE (arg1)));
3682
 
3683
  t = make_node_stat (code PASS_MEM_STAT);
3684
  TREE_TYPE (t) = tt;
3685
 
3686
  /* Below, we automatically set TREE_SIDE_EFFECTS and TREE_READONLY for the
3687
     result based on those same flags for the arguments.  But if the
3688
     arguments aren't really even `tree' expressions, we shouldn't be trying
3689
     to do this.  */
3690
 
3691
  /* Expressions without side effects may be constant if their
3692
     arguments are as well.  */
3693
  constant = (TREE_CODE_CLASS (code) == tcc_comparison
3694
              || TREE_CODE_CLASS (code) == tcc_binary);
3695
  read_only = 1;
3696
  side_effects = TREE_SIDE_EFFECTS (t);
3697
 
3698
  PROCESS_ARG(0);
3699
  PROCESS_ARG(1);
3700
 
3701
  TREE_READONLY (t) = read_only;
3702
  TREE_CONSTANT (t) = constant;
3703
  TREE_SIDE_EFFECTS (t) = side_effects;
3704
  TREE_THIS_VOLATILE (t)
3705
    = (TREE_CODE_CLASS (code) == tcc_reference
3706
       && arg0 && TREE_THIS_VOLATILE (arg0));
3707
 
3708
  return t;
3709
}
3710
 
3711
 
3712
tree
3713
build3_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3714
             tree arg2 MEM_STAT_DECL)
3715
{
3716
  bool constant, read_only, side_effects;
3717
  tree t;
3718
 
3719
  gcc_assert (TREE_CODE_LENGTH (code) == 3);
3720
  gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3721
 
3722
  t = make_node_stat (code PASS_MEM_STAT);
3723
  TREE_TYPE (t) = tt;
3724
 
3725
  read_only = 1;
3726
 
3727
  /* As a special exception, if COND_EXPR has NULL branches, we
3728
     assume that it is a gimple statement and always consider
3729
     it to have side effects.  */
3730
  if (code == COND_EXPR
3731
      && tt == void_type_node
3732
      && arg1 == NULL_TREE
3733
      && arg2 == NULL_TREE)
3734
    side_effects = true;
3735
  else
3736
    side_effects = TREE_SIDE_EFFECTS (t);
3737
 
3738
  PROCESS_ARG(0);
3739
  PROCESS_ARG(1);
3740
  PROCESS_ARG(2);
3741
 
3742
  if (code == COND_EXPR)
3743
    TREE_READONLY (t) = read_only;
3744
 
3745
  TREE_SIDE_EFFECTS (t) = side_effects;
3746
  TREE_THIS_VOLATILE (t)
3747
    = (TREE_CODE_CLASS (code) == tcc_reference
3748
       && arg0 && TREE_THIS_VOLATILE (arg0));
3749
 
3750
  return t;
3751
}
3752
 
3753
tree
3754
build4_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3755
             tree arg2, tree arg3 MEM_STAT_DECL)
3756
{
3757
  bool constant, read_only, side_effects;
3758
  tree t;
3759
 
3760
  gcc_assert (TREE_CODE_LENGTH (code) == 4);
3761
 
3762
  t = make_node_stat (code PASS_MEM_STAT);
3763
  TREE_TYPE (t) = tt;
3764
 
3765
  side_effects = TREE_SIDE_EFFECTS (t);
3766
 
3767
  PROCESS_ARG(0);
3768
  PROCESS_ARG(1);
3769
  PROCESS_ARG(2);
3770
  PROCESS_ARG(3);
3771
 
3772
  TREE_SIDE_EFFECTS (t) = side_effects;
3773
  TREE_THIS_VOLATILE (t)
3774
    = (TREE_CODE_CLASS (code) == tcc_reference
3775
       && arg0 && TREE_THIS_VOLATILE (arg0));
3776
 
3777
  return t;
3778
}
3779
 
3780
tree
3781
build5_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3782
             tree arg2, tree arg3, tree arg4 MEM_STAT_DECL)
3783
{
3784
  bool constant, read_only, side_effects;
3785
  tree t;
3786
 
3787
  gcc_assert (TREE_CODE_LENGTH (code) == 5);
3788
 
3789
  t = make_node_stat (code PASS_MEM_STAT);
3790
  TREE_TYPE (t) = tt;
3791
 
3792
  side_effects = TREE_SIDE_EFFECTS (t);
3793
 
3794
  PROCESS_ARG(0);
3795
  PROCESS_ARG(1);
3796
  PROCESS_ARG(2);
3797
  PROCESS_ARG(3);
3798
  PROCESS_ARG(4);
3799
 
3800
  TREE_SIDE_EFFECTS (t) = side_effects;
3801
  TREE_THIS_VOLATILE (t)
3802
    = (TREE_CODE_CLASS (code) == tcc_reference
3803
       && arg0 && TREE_THIS_VOLATILE (arg0));
3804
 
3805
  return t;
3806
}
3807
 
3808
tree
3809
build6_stat (enum tree_code code, tree tt, tree arg0, tree arg1,
3810
             tree arg2, tree arg3, tree arg4, tree arg5 MEM_STAT_DECL)
3811
{
3812
  bool constant, read_only, side_effects;
3813
  tree t;
3814
 
3815
  gcc_assert (code == TARGET_MEM_REF);
3816
 
3817
  t = make_node_stat (code PASS_MEM_STAT);
3818
  TREE_TYPE (t) = tt;
3819
 
3820
  side_effects = TREE_SIDE_EFFECTS (t);
3821
 
3822
  PROCESS_ARG(0);
3823
  PROCESS_ARG(1);
3824
  PROCESS_ARG(2);
3825
  PROCESS_ARG(3);
3826
  PROCESS_ARG(4);
3827
  if (code == TARGET_MEM_REF)
3828
    side_effects = 0;
3829
  PROCESS_ARG(5);
3830
 
3831
  TREE_SIDE_EFFECTS (t) = side_effects;
3832
  TREE_THIS_VOLATILE (t)
3833
    = (code == TARGET_MEM_REF
3834
       && arg5 && TREE_THIS_VOLATILE (arg5));
3835
 
3836
  return t;
3837
}
3838
 
3839
/* Similar except don't specify the TREE_TYPE
3840
   and leave the TREE_SIDE_EFFECTS as 0.
3841
   It is permissible for arguments to be null,
3842
   or even garbage if their values do not matter.  */
3843
 
3844
tree
3845
build_nt (enum tree_code code, ...)
3846
{
3847
  tree t;
3848
  int length;
3849
  int i;
3850
  va_list p;
3851
 
3852
  gcc_assert (TREE_CODE_CLASS (code) != tcc_vl_exp);
3853
 
3854
  va_start (p, code);
3855
 
3856
  t = make_node (code);
3857
  length = TREE_CODE_LENGTH (code);
3858
 
3859
  for (i = 0; i < length; i++)
3860
    TREE_OPERAND (t, i) = va_arg (p, tree);
3861
 
3862
  va_end (p);
3863
  return t;
3864
}
3865
 
3866
/* Similar to build_nt, but for creating a CALL_EXPR object with
3867
   ARGLIST passed as a list.  */
3868
 
3869
tree
3870
build_nt_call_list (tree fn, tree arglist)
3871
{
3872
  tree t;
3873
  int i;
3874
 
3875
  t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
3876
  CALL_EXPR_FN (t) = fn;
3877
  CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
3878
  for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
3879
    CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
3880
  return t;
3881
}
3882
 
3883
/* Similar to build_nt, but for creating a CALL_EXPR object with a
3884
   tree VEC.  */
3885
 
3886
tree
3887
build_nt_call_vec (tree fn, VEC(tree,gc) *args)
3888
{
3889
  tree ret, t;
3890
  unsigned int ix;
3891
 
3892
  ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
3893
  CALL_EXPR_FN (ret) = fn;
3894
  CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
3895
  for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
3896
    CALL_EXPR_ARG (ret, ix) = t;
3897
  return ret;
3898
}
3899
 
3900
/* Create a DECL_... node of code CODE, name NAME and data type TYPE.
3901
   We do NOT enter this node in any sort of symbol table.
3902
 
3903
   LOC is the location of the decl.
3904
 
3905
   layout_decl is used to set up the decl's storage layout.
3906
   Other slots are initialized to 0 or null pointers.  */
3907
 
3908
tree
3909
build_decl_stat (location_t loc, enum tree_code code, tree name,
3910
                 tree type MEM_STAT_DECL)
3911
{
3912
  tree t;
3913
 
3914
  t = make_node_stat (code PASS_MEM_STAT);
3915
  DECL_SOURCE_LOCATION (t) = loc;
3916
 
3917
/*  if (type == error_mark_node)
3918
    type = integer_type_node; */
3919
/* That is not done, deliberately, so that having error_mark_node
3920
   as the type can suppress useless errors in the use of this variable.  */
3921
 
3922
  DECL_NAME (t) = name;
3923
  TREE_TYPE (t) = type;
3924
 
3925
  if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
3926
    layout_decl (t, 0);
3927
 
3928
  return t;
3929
}
3930
 
3931
/* Builds and returns function declaration with NAME and TYPE.  */
3932
 
3933
tree
3934
build_fn_decl (const char *name, tree type)
3935
{
3936
  tree id = get_identifier (name);
3937
  tree decl = build_decl (input_location, FUNCTION_DECL, id, type);
3938
 
3939
  DECL_EXTERNAL (decl) = 1;
3940
  TREE_PUBLIC (decl) = 1;
3941
  DECL_ARTIFICIAL (decl) = 1;
3942
  TREE_NOTHROW (decl) = 1;
3943
 
3944
  return decl;
3945
}
3946
 
3947
 
3948
/* BLOCK nodes are used to represent the structure of binding contours
3949
   and declarations, once those contours have been exited and their contents
3950
   compiled.  This information is used for outputting debugging info.  */
3951
 
3952
tree
3953
build_block (tree vars, tree subblocks, tree supercontext, tree chain)
3954
{
3955
  tree block = make_node (BLOCK);
3956
 
3957
  BLOCK_VARS (block) = vars;
3958
  BLOCK_SUBBLOCKS (block) = subblocks;
3959
  BLOCK_SUPERCONTEXT (block) = supercontext;
3960
  BLOCK_CHAIN (block) = chain;
3961
  return block;
3962
}
3963
 
3964
expanded_location
3965
expand_location (source_location loc)
3966
{
3967
  expanded_location xloc;
3968
  if (loc <= BUILTINS_LOCATION)
3969
    {
3970
      xloc.file = loc == UNKNOWN_LOCATION ? NULL : _("<built-in>");
3971
      xloc.line = 0;
3972
      xloc.column = 0;
3973
      xloc.sysp = 0;
3974
    }
3975
  else
3976
    {
3977
      const struct line_map *map = linemap_lookup (line_table, loc);
3978
      xloc.file = map->to_file;
3979
      xloc.line = SOURCE_LINE (map, loc);
3980
      xloc.column = SOURCE_COLUMN (map, loc);
3981
      xloc.sysp = map->sysp != 0;
3982
    };
3983
  return xloc;
3984
}
3985
 
3986
 
3987
/* Like SET_EXPR_LOCATION, but make sure the tree can have a location.
3988
 
3989
   LOC is the location to use in tree T.  */
3990
 
3991
void
3992
protected_set_expr_location (tree t, location_t loc)
3993
{
3994
  if (t && CAN_HAVE_LOCATION_P (t))
3995
    SET_EXPR_LOCATION (t, loc);
3996
}
3997
 
3998
/* Return a declaration like DDECL except that its DECL_ATTRIBUTES
3999
   is ATTRIBUTE.  */
4000
 
4001
tree
4002
build_decl_attribute_variant (tree ddecl, tree attribute)
4003
{
4004
  DECL_ATTRIBUTES (ddecl) = attribute;
4005
  return ddecl;
4006
}
4007
 
4008
/* Borrowed from hashtab.c iterative_hash implementation.  */
4009
#define mix(a,b,c) \
4010
{ \
4011
  a -= b; a -= c; a ^= (c>>13); \
4012
  b -= c; b -= a; b ^= (a<< 8); \
4013
  c -= a; c -= b; c ^= ((b&0xffffffff)>>13); \
4014
  a -= b; a -= c; a ^= ((c&0xffffffff)>>12); \
4015
  b -= c; b -= a; b = (b ^ (a<<16)) & 0xffffffff; \
4016
  c -= a; c -= b; c = (c ^ (b>> 5)) & 0xffffffff; \
4017
  a -= b; a -= c; a = (a ^ (c>> 3)) & 0xffffffff; \
4018
  b -= c; b -= a; b = (b ^ (a<<10)) & 0xffffffff; \
4019
  c -= a; c -= b; c = (c ^ (b>>15)) & 0xffffffff; \
4020
}
4021
 
4022
 
4023
/* Produce good hash value combining VAL and VAL2.  */
4024
hashval_t
4025
iterative_hash_hashval_t (hashval_t val, hashval_t val2)
4026
{
4027
  /* the golden ratio; an arbitrary value.  */
4028
  hashval_t a = 0x9e3779b9;
4029
 
4030
  mix (a, val, val2);
4031
  return val2;
4032
}
4033
 
4034
/* Produce good hash value combining VAL and VAL2.  */
4035
hashval_t
4036
iterative_hash_host_wide_int (HOST_WIDE_INT val, hashval_t val2)
4037
{
4038
  if (sizeof (HOST_WIDE_INT) == sizeof (hashval_t))
4039
    return iterative_hash_hashval_t (val, val2);
4040
  else
4041
    {
4042
      hashval_t a = (hashval_t) val;
4043
      /* Avoid warnings about shifting of more than the width of the type on
4044
         hosts that won't execute this path.  */
4045
      int zero = 0;
4046
      hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 8 + zero));
4047
      mix (a, b, val2);
4048
      if (sizeof (HOST_WIDE_INT) > 2 * sizeof (hashval_t))
4049
        {
4050
          hashval_t a = (hashval_t) (val >> (sizeof (hashval_t) * 16 + zero));
4051
          hashval_t b = (hashval_t) (val >> (sizeof (hashval_t) * 24 + zero));
4052
          mix (a, b, val2);
4053
        }
4054
      return val2;
4055
    }
4056
}
4057
 
4058
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4059
   is ATTRIBUTE and its qualifiers are QUALS.
4060
 
4061
   Record such modified types already made so we don't make duplicates.  */
4062
 
4063
tree
4064
build_type_attribute_qual_variant (tree ttype, tree attribute, int quals)
4065
{
4066
  if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
4067
    {
4068
      hashval_t hashcode = 0;
4069
      tree ntype;
4070
      enum tree_code code = TREE_CODE (ttype);
4071
 
4072
      /* Building a distinct copy of a tagged type is inappropriate; it
4073
         causes breakage in code that expects there to be a one-to-one
4074
         relationship between a struct and its fields.
4075
         build_duplicate_type is another solution (as used in
4076
         handle_transparent_union_attribute), but that doesn't play well
4077
         with the stronger C++ type identity model.  */
4078
      if (TREE_CODE (ttype) == RECORD_TYPE
4079
          || TREE_CODE (ttype) == UNION_TYPE
4080
          || TREE_CODE (ttype) == QUAL_UNION_TYPE
4081
          || TREE_CODE (ttype) == ENUMERAL_TYPE)
4082
        {
4083
          warning (OPT_Wattributes,
4084
                   "ignoring attributes applied to %qT after definition",
4085
                   TYPE_MAIN_VARIANT (ttype));
4086
          return build_qualified_type (ttype, quals);
4087
        }
4088
 
4089
      ttype = build_qualified_type (ttype, TYPE_UNQUALIFIED);
4090
      ntype = build_distinct_type_copy (ttype);
4091
 
4092
      TYPE_ATTRIBUTES (ntype) = attribute;
4093
 
4094
      hashcode = iterative_hash_object (code, hashcode);
4095
      if (TREE_TYPE (ntype))
4096
        hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (ntype)),
4097
                                          hashcode);
4098
      hashcode = attribute_hash_list (attribute, hashcode);
4099
 
4100
      switch (TREE_CODE (ntype))
4101
        {
4102
        case FUNCTION_TYPE:
4103
          hashcode = type_hash_list (TYPE_ARG_TYPES (ntype), hashcode);
4104
          break;
4105
        case ARRAY_TYPE:
4106
          if (TYPE_DOMAIN (ntype))
4107
            hashcode = iterative_hash_object (TYPE_HASH (TYPE_DOMAIN (ntype)),
4108
                                              hashcode);
4109
          break;
4110
        case INTEGER_TYPE:
4111
          hashcode = iterative_hash_object
4112
            (TREE_INT_CST_LOW (TYPE_MAX_VALUE (ntype)), hashcode);
4113
          hashcode = iterative_hash_object
4114
            (TREE_INT_CST_HIGH (TYPE_MAX_VALUE (ntype)), hashcode);
4115
          break;
4116
        case REAL_TYPE:
4117
        case FIXED_POINT_TYPE:
4118
          {
4119
            unsigned int precision = TYPE_PRECISION (ntype);
4120
            hashcode = iterative_hash_object (precision, hashcode);
4121
          }
4122
          break;
4123
        default:
4124
          break;
4125
        }
4126
 
4127
      ntype = type_hash_canon (hashcode, ntype);
4128
 
4129
      /* If the target-dependent attributes make NTYPE different from
4130
         its canonical type, we will need to use structural equality
4131
         checks for this type. */
4132
      if (TYPE_STRUCTURAL_EQUALITY_P (ttype)
4133
          || !targetm.comp_type_attributes (ntype, ttype))
4134
        SET_TYPE_STRUCTURAL_EQUALITY (ntype);
4135
      else if (TYPE_CANONICAL (ntype) == ntype)
4136
        TYPE_CANONICAL (ntype) = TYPE_CANONICAL (ttype);
4137
 
4138
      ttype = build_qualified_type (ntype, quals);
4139
    }
4140
  else if (TYPE_QUALS (ttype) != quals)
4141
    ttype = build_qualified_type (ttype, quals);
4142
 
4143
  return ttype;
4144
}
4145
 
4146
 
4147
/* Return a type like TTYPE except that its TYPE_ATTRIBUTE
4148
   is ATTRIBUTE.
4149
 
4150
   Record such modified types already made so we don't make duplicates.  */
4151
 
4152
tree
4153
build_type_attribute_variant (tree ttype, tree attribute)
4154
{
4155
  return build_type_attribute_qual_variant (ttype, attribute,
4156
                                            TYPE_QUALS (ttype));
4157
}
4158
 
4159
 
4160
/* Reset all the fields in a binfo node BINFO.  We only keep
4161
   BINFO_VIRTUALS, which is used by gimple_fold_obj_type_ref.  */
4162
 
4163
static void
4164
free_lang_data_in_binfo (tree binfo)
4165
{
4166
  unsigned i;
4167
  tree t;
4168
 
4169
  gcc_assert (TREE_CODE (binfo) == TREE_BINFO);
4170
 
4171
  BINFO_VTABLE (binfo) = NULL_TREE;
4172
  BINFO_BASE_ACCESSES (binfo) = NULL;
4173
  BINFO_INHERITANCE_CHAIN (binfo) = NULL_TREE;
4174
  BINFO_SUBVTT_INDEX (binfo) = NULL_TREE;
4175
 
4176
  for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (binfo), i, t); i++)
4177
    free_lang_data_in_binfo (t);
4178
}
4179
 
4180
 
4181
/* Reset all language specific information still present in TYPE.  */
4182
 
4183
static void
4184
free_lang_data_in_type (tree type)
4185
{
4186
  gcc_assert (TYPE_P (type));
4187
 
4188
  /* Give the FE a chance to remove its own data first.  */
4189
  lang_hooks.free_lang_data (type);
4190
 
4191
  TREE_LANG_FLAG_0 (type) = 0;
4192
  TREE_LANG_FLAG_1 (type) = 0;
4193
  TREE_LANG_FLAG_2 (type) = 0;
4194
  TREE_LANG_FLAG_3 (type) = 0;
4195
  TREE_LANG_FLAG_4 (type) = 0;
4196
  TREE_LANG_FLAG_5 (type) = 0;
4197
  TREE_LANG_FLAG_6 (type) = 0;
4198
 
4199
  if (TREE_CODE (type) == FUNCTION_TYPE)
4200
    {
4201
      /* Remove the const and volatile qualifiers from arguments.  The
4202
         C++ front end removes them, but the C front end does not,
4203
         leading to false ODR violation errors when merging two
4204
         instances of the same function signature compiled by
4205
         different front ends.  */
4206
      tree p;
4207
 
4208
      for (p = TYPE_ARG_TYPES (type); p; p = TREE_CHAIN (p))
4209
        {
4210
          tree arg_type = TREE_VALUE (p);
4211
 
4212
          if (TYPE_READONLY (arg_type) || TYPE_VOLATILE (arg_type))
4213
            {
4214
              int quals = TYPE_QUALS (arg_type)
4215
                          & ~TYPE_QUAL_CONST
4216
                          & ~TYPE_QUAL_VOLATILE;
4217
              TREE_VALUE (p) = build_qualified_type (arg_type, quals);
4218
              free_lang_data_in_type (TREE_VALUE (p));
4219
            }
4220
        }
4221
    }
4222
 
4223
  /* Remove members that are not actually FIELD_DECLs from the field
4224
     list of an aggregate.  These occur in C++.  */
4225
  if (RECORD_OR_UNION_TYPE_P (type))
4226
    {
4227
      tree prev, member;
4228
 
4229
      /* Note that TYPE_FIELDS can be shared across distinct
4230
         TREE_TYPEs.  Therefore, if the first field of TYPE_FIELDS is
4231
         to be removed, we cannot set its TREE_CHAIN to NULL.
4232
         Otherwise, we would not be able to find all the other fields
4233
         in the other instances of this TREE_TYPE.
4234
 
4235
         This was causing an ICE in testsuite/g++.dg/lto/20080915.C.  */
4236
      prev = NULL_TREE;
4237
      member = TYPE_FIELDS (type);
4238
      while (member)
4239
        {
4240
          if (TREE_CODE (member) == FIELD_DECL)
4241
            {
4242
              if (prev)
4243
                TREE_CHAIN (prev) = member;
4244
              else
4245
                TYPE_FIELDS (type) = member;
4246
              prev = member;
4247
            }
4248
 
4249
          member = TREE_CHAIN (member);
4250
        }
4251
 
4252
      if (prev)
4253
        TREE_CHAIN (prev) = NULL_TREE;
4254
      else
4255
        TYPE_FIELDS (type) = NULL_TREE;
4256
 
4257
      TYPE_METHODS (type) = NULL_TREE;
4258
      if (TYPE_BINFO (type))
4259
        free_lang_data_in_binfo (TYPE_BINFO (type));
4260
    }
4261
  else
4262
    {
4263
      /* For non-aggregate types, clear out the language slot (which
4264
         overloads TYPE_BINFO).  */
4265
      TYPE_LANG_SLOT_1 (type) = NULL_TREE;
4266
    }
4267
 
4268
  if (debug_info_level < DINFO_LEVEL_TERSE
4269
      || (TYPE_CONTEXT (type)
4270
          && TREE_CODE (TYPE_CONTEXT (type)) != FUNCTION_DECL
4271
          && TREE_CODE (TYPE_CONTEXT (type)) != NAMESPACE_DECL))
4272
    TYPE_CONTEXT (type) = NULL_TREE;
4273
 
4274
  if (debug_info_level < DINFO_LEVEL_TERSE)
4275
    TYPE_STUB_DECL (type) = NULL_TREE;
4276
}
4277
 
4278
 
4279
/* Return true if DECL may need an assembler name to be set.  */
4280
 
4281
static inline bool
4282
need_assembler_name_p (tree decl)
4283
{
4284
  /* Only FUNCTION_DECLs and VAR_DECLs are considered.  */
4285
  if (TREE_CODE (decl) != FUNCTION_DECL
4286
      && TREE_CODE (decl) != VAR_DECL)
4287
    return false;
4288
 
4289
  /* If DECL already has its assembler name set, it does not need a
4290
     new one.  */
4291
  if (!HAS_DECL_ASSEMBLER_NAME_P (decl)
4292
      || DECL_ASSEMBLER_NAME_SET_P (decl))
4293
    return false;
4294
 
4295
  /* Abstract decls do not need an assembler name.  */
4296
  if (DECL_ABSTRACT (decl))
4297
    return false;
4298
 
4299
  /* For VAR_DECLs, only static, public and external symbols need an
4300
     assembler name.  */
4301
  if (TREE_CODE (decl) == VAR_DECL
4302
      && !TREE_STATIC (decl)
4303
      && !TREE_PUBLIC (decl)
4304
      && !DECL_EXTERNAL (decl))
4305
    return false;
4306
 
4307
  if (TREE_CODE (decl) == FUNCTION_DECL)
4308
    {
4309
      /* Do not set assembler name on builtins.  Allow RTL expansion to
4310
         decide whether to expand inline or via a regular call.  */
4311
      if (DECL_BUILT_IN (decl)
4312
          && DECL_BUILT_IN_CLASS (decl) != BUILT_IN_FRONTEND)
4313
        return false;
4314
 
4315
      /* Functions represented in the callgraph need an assembler name.  */
4316
      if (cgraph_get_node (decl) != NULL)
4317
        return true;
4318
 
4319
      /* Unused and not public functions don't need an assembler name.  */
4320
      if (!TREE_USED (decl) && !TREE_PUBLIC (decl))
4321
        return false;
4322
    }
4323
 
4324
  return true;
4325
}
4326
 
4327
 
4328
/* Remove all the non-variable decls from BLOCK.  LOCALS is the set of
4329
   variables in DECL_STRUCT_FUNCTION (FN)->local_decls.  Every decl
4330
   in BLOCK that is not in LOCALS is removed.  */
4331
 
4332
static void
4333
free_lang_data_in_block (tree fn, tree block, struct pointer_set_t *locals)
4334
{
4335
  tree *tp, t;
4336
 
4337
  tp = &BLOCK_VARS (block);
4338
  while (*tp)
4339
    {
4340
      if (!pointer_set_contains (locals, *tp))
4341
        *tp = TREE_CHAIN (*tp);
4342
      else
4343
        tp = &TREE_CHAIN (*tp);
4344
    }
4345
 
4346
  for (t = BLOCK_SUBBLOCKS (block); t; t = BLOCK_CHAIN (t))
4347
    free_lang_data_in_block (fn, t, locals);
4348
}
4349
 
4350
 
4351
/* Reset all language specific information still present in symbol
4352
   DECL.  */
4353
 
4354
static void
4355
free_lang_data_in_decl (tree decl)
4356
{
4357
  gcc_assert (DECL_P (decl));
4358
 
4359
  /* Give the FE a chance to remove its own data first.  */
4360
  lang_hooks.free_lang_data (decl);
4361
 
4362
  TREE_LANG_FLAG_0 (decl) = 0;
4363
  TREE_LANG_FLAG_1 (decl) = 0;
4364
  TREE_LANG_FLAG_2 (decl) = 0;
4365
  TREE_LANG_FLAG_3 (decl) = 0;
4366
  TREE_LANG_FLAG_4 (decl) = 0;
4367
  TREE_LANG_FLAG_5 (decl) = 0;
4368
  TREE_LANG_FLAG_6 (decl) = 0;
4369
 
4370
  /* Identifiers need not have a type.  */
4371
  if (DECL_NAME (decl))
4372
    TREE_TYPE (DECL_NAME (decl)) = NULL_TREE;
4373
 
4374
  /* Ignore any intervening types, because we are going to clear their
4375
     TYPE_CONTEXT fields.  */
4376
  if (TREE_CODE (decl) != FIELD_DECL
4377
      && TREE_CODE (decl) != FUNCTION_DECL)
4378
    DECL_CONTEXT (decl) = decl_function_context (decl);
4379
 
4380
  if (DECL_CONTEXT (decl)
4381
      && TREE_CODE (DECL_CONTEXT (decl)) == NAMESPACE_DECL)
4382
    DECL_CONTEXT (decl) = NULL_TREE;
4383
 
4384
 if (TREE_CODE (decl) == VAR_DECL)
4385
   {
4386
     tree context = DECL_CONTEXT (decl);
4387
 
4388
     if (context)
4389
       {
4390
         enum tree_code code = TREE_CODE (context);
4391
         if (code == FUNCTION_DECL && DECL_ABSTRACT (context))
4392
           {
4393
             /* Do not clear the decl context here, that will promote
4394
                all vars to global ones.  */
4395
             DECL_INITIAL (decl) = NULL_TREE;
4396
           }
4397
 
4398
         if (TREE_STATIC (decl))
4399
           DECL_CONTEXT (decl) = NULL_TREE;
4400
       }
4401
   }
4402
 
4403
 /* ???  We could free non-constant DECL_SIZE, DECL_SIZE_UNIT
4404
    and DECL_FIELD_OFFSET.  But it's cheap enough to not do
4405
    that and refrain from adding workarounds to dwarf2out.c  */
4406
 
4407
 /* DECL_FCONTEXT is only used for debug info generation.  */
4408
 if (TREE_CODE (decl) == FIELD_DECL
4409
     && debug_info_level < DINFO_LEVEL_TERSE)
4410
   DECL_FCONTEXT (decl) = NULL_TREE;
4411
 
4412
 if (TREE_CODE (decl) == FUNCTION_DECL)
4413
    {
4414
      if (gimple_has_body_p (decl))
4415
        {
4416
          tree t;
4417
          struct pointer_set_t *locals;
4418
 
4419
          /* If DECL has a gimple body, then the context for its
4420
             arguments must be DECL.  Otherwise, it doesn't really
4421
             matter, as we will not be emitting any code for DECL.  In
4422
             general, there may be other instances of DECL created by
4423
             the front end and since PARM_DECLs are generally shared,
4424
             their DECL_CONTEXT changes as the replicas of DECL are
4425
             created.  The only time where DECL_CONTEXT is important
4426
             is for the FUNCTION_DECLs that have a gimple body (since
4427
             the PARM_DECL will be used in the function's body).  */
4428
          for (t = DECL_ARGUMENTS (decl); t; t = TREE_CHAIN (t))
4429
            DECL_CONTEXT (t) = decl;
4430
 
4431
          /* Collect all the symbols declared in DECL.  */
4432
          locals = pointer_set_create ();
4433
          t = DECL_STRUCT_FUNCTION (decl)->local_decls;
4434
          for (; t; t = TREE_CHAIN (t))
4435
            {
4436
              pointer_set_insert (locals, TREE_VALUE (t));
4437
 
4438
              /* All the local symbols should have DECL as their
4439
                 context.  */
4440
              DECL_CONTEXT (TREE_VALUE (t)) = decl;
4441
            }
4442
 
4443
          /* Get rid of any decl not in local_decls.  */
4444
          free_lang_data_in_block (decl, DECL_INITIAL (decl), locals);
4445
 
4446
          pointer_set_destroy (locals);
4447
        }
4448
 
4449
      /* DECL_SAVED_TREE holds the GENERIC representation for DECL.
4450
         At this point, it is not needed anymore.  */
4451
      DECL_SAVED_TREE (decl) = NULL_TREE;
4452
    }
4453
  else if (TREE_CODE (decl) == VAR_DECL)
4454
    {
4455
      tree expr = DECL_DEBUG_EXPR (decl);
4456
      if (expr
4457
          && TREE_CODE (expr) == VAR_DECL
4458
          && !TREE_STATIC (expr) && !DECL_EXTERNAL (expr))
4459
        SET_DECL_DEBUG_EXPR (decl, NULL_TREE);
4460
 
4461
      if (DECL_EXTERNAL (decl)
4462
          && (!TREE_STATIC (decl) || !TREE_READONLY (decl)))
4463
        DECL_INITIAL (decl) = NULL_TREE;
4464
    }
4465
  else if (TREE_CODE (decl) == TYPE_DECL)
4466
    {
4467
      DECL_INITIAL (decl) = NULL_TREE;
4468
 
4469
      /* DECL_CONTEXT is overloaded as DECL_FIELD_CONTEXT for
4470
         FIELD_DECLs, which should be preserved.  Otherwise,
4471
         we shouldn't be concerned with source-level lexical
4472
         nesting beyond this point. */
4473
      DECL_CONTEXT (decl) = NULL_TREE;
4474
    }
4475
}
4476
 
4477
 
4478
/* Data used when collecting DECLs and TYPEs for language data removal.  */
4479
 
4480
struct free_lang_data_d
4481
{
4482
  /* Worklist to avoid excessive recursion.  */
4483
  VEC(tree,heap) *worklist;
4484
 
4485
  /* Set of traversed objects.  Used to avoid duplicate visits.  */
4486
  struct pointer_set_t *pset;
4487
 
4488
  /* Array of symbols to process with free_lang_data_in_decl.  */
4489
  VEC(tree,heap) *decls;
4490
 
4491
  /* Array of types to process with free_lang_data_in_type.  */
4492
  VEC(tree,heap) *types;
4493
};
4494
 
4495
 
4496
/* Save all language fields needed to generate proper debug information
4497
   for DECL.  This saves most fields cleared out by free_lang_data_in_decl.  */
4498
 
4499
static void
4500
save_debug_info_for_decl (tree t)
4501
{
4502
  /*struct saved_debug_info_d *sdi;*/
4503
 
4504
  gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && DECL_P (t));
4505
 
4506
  /* FIXME.  Partial implementation for saving debug info removed.  */
4507
}
4508
 
4509
 
4510
/* Save all language fields needed to generate proper debug information
4511
   for TYPE.  This saves most fields cleared out by free_lang_data_in_type.  */
4512
 
4513
static void
4514
save_debug_info_for_type (tree t)
4515
{
4516
  /*struct saved_debug_info_d *sdi;*/
4517
 
4518
  gcc_assert (debug_info_level > DINFO_LEVEL_TERSE && t && TYPE_P (t));
4519
 
4520
  /* FIXME.  Partial implementation for saving debug info removed.  */
4521
}
4522
 
4523
 
4524
/* Add type or decl T to one of the list of tree nodes that need their
4525
   language data removed.  The lists are held inside FLD.  */
4526
 
4527
static void
4528
add_tree_to_fld_list (tree t, struct free_lang_data_d *fld)
4529
{
4530
  if (DECL_P (t))
4531
    {
4532
      VEC_safe_push (tree, heap, fld->decls, t);
4533
      if (debug_info_level > DINFO_LEVEL_TERSE)
4534
        save_debug_info_for_decl (t);
4535
    }
4536
  else if (TYPE_P (t))
4537
    {
4538
      VEC_safe_push (tree, heap, fld->types, t);
4539
      if (debug_info_level > DINFO_LEVEL_TERSE)
4540
        save_debug_info_for_type (t);
4541
    }
4542
  else
4543
    gcc_unreachable ();
4544
}
4545
 
4546
/* Push tree node T into FLD->WORKLIST.  */
4547
 
4548
static inline void
4549
fld_worklist_push (tree t, struct free_lang_data_d *fld)
4550
{
4551
  if (t && !is_lang_specific (t) && !pointer_set_contains (fld->pset, t))
4552
    VEC_safe_push (tree, heap, fld->worklist, (t));
4553
}
4554
 
4555
 
4556
/* Operand callback helper for free_lang_data_in_node.  *TP is the
4557
   subtree operand being considered.  */
4558
 
4559
static tree
4560
find_decls_types_r (tree *tp, int *ws, void *data)
4561
{
4562
  tree t = *tp;
4563
  struct free_lang_data_d *fld = (struct free_lang_data_d *) data;
4564
 
4565
  if (TREE_CODE (t) == TREE_LIST)
4566
    return NULL_TREE;
4567
 
4568
  /* Language specific nodes will be removed, so there is no need
4569
     to gather anything under them.  */
4570
  if (is_lang_specific (t))
4571
    {
4572
      *ws = 0;
4573
      return NULL_TREE;
4574
    }
4575
 
4576
  if (DECL_P (t))
4577
    {
4578
      /* Note that walk_tree does not traverse every possible field in
4579
         decls, so we have to do our own traversals here.  */
4580
      add_tree_to_fld_list (t, fld);
4581
 
4582
      fld_worklist_push (DECL_NAME (t), fld);
4583
      fld_worklist_push (DECL_CONTEXT (t), fld);
4584
      fld_worklist_push (DECL_SIZE (t), fld);
4585
      fld_worklist_push (DECL_SIZE_UNIT (t), fld);
4586
 
4587
      /* We are going to remove everything under DECL_INITIAL for
4588
         TYPE_DECLs.  No point walking them.  */
4589
      if (TREE_CODE (t) != TYPE_DECL)
4590
        fld_worklist_push (DECL_INITIAL (t), fld);
4591
 
4592
      fld_worklist_push (DECL_ATTRIBUTES (t), fld);
4593
      fld_worklist_push (DECL_ABSTRACT_ORIGIN (t), fld);
4594
 
4595
      if (TREE_CODE (t) == FUNCTION_DECL)
4596
        {
4597
          fld_worklist_push (DECL_ARGUMENTS (t), fld);
4598
          fld_worklist_push (DECL_RESULT (t), fld);
4599
        }
4600
      else if (TREE_CODE (t) == TYPE_DECL)
4601
        {
4602
          fld_worklist_push (DECL_ARGUMENT_FLD (t), fld);
4603
          fld_worklist_push (DECL_VINDEX (t), fld);
4604
        }
4605
      else if (TREE_CODE (t) == FIELD_DECL)
4606
        {
4607
          fld_worklist_push (DECL_FIELD_OFFSET (t), fld);
4608
          fld_worklist_push (DECL_BIT_FIELD_TYPE (t), fld);
4609
          fld_worklist_push (DECL_QUALIFIER (t), fld);
4610
          fld_worklist_push (DECL_FIELD_BIT_OFFSET (t), fld);
4611
          fld_worklist_push (DECL_FCONTEXT (t), fld);
4612
        }
4613
      else if (TREE_CODE (t) == VAR_DECL)
4614
        {
4615
          fld_worklist_push (DECL_SECTION_NAME (t), fld);
4616
          fld_worklist_push (DECL_COMDAT_GROUP (t), fld);
4617
        }
4618
 
4619
      if (TREE_CODE (t) != FIELD_DECL)
4620
        fld_worklist_push (TREE_CHAIN (t), fld);
4621
      *ws = 0;
4622
    }
4623
  else if (TYPE_P (t))
4624
    {
4625
      /* Note that walk_tree does not traverse every possible field in
4626
         types, so we have to do our own traversals here.  */
4627
      add_tree_to_fld_list (t, fld);
4628
 
4629
      if (!RECORD_OR_UNION_TYPE_P (t))
4630
        fld_worklist_push (TYPE_CACHED_VALUES (t), fld);
4631
      fld_worklist_push (TYPE_SIZE (t), fld);
4632
      fld_worklist_push (TYPE_SIZE_UNIT (t), fld);
4633
      fld_worklist_push (TYPE_ATTRIBUTES (t), fld);
4634
      fld_worklist_push (TYPE_POINTER_TO (t), fld);
4635
      fld_worklist_push (TYPE_REFERENCE_TO (t), fld);
4636
      fld_worklist_push (TYPE_NAME (t), fld);
4637
      fld_worklist_push (TYPE_MINVAL (t), fld);
4638
      if (!RECORD_OR_UNION_TYPE_P (t))
4639
        fld_worklist_push (TYPE_MAXVAL (t), fld);
4640
      fld_worklist_push (TYPE_MAIN_VARIANT (t), fld);
4641
      fld_worklist_push (TYPE_NEXT_VARIANT (t), fld);
4642
      fld_worklist_push (TYPE_CONTEXT (t), fld);
4643
      fld_worklist_push (TYPE_CANONICAL (t), fld);
4644
 
4645
      if (RECORD_OR_UNION_TYPE_P (t) && TYPE_BINFO (t))
4646
        {
4647
          unsigned i;
4648
          tree tem;
4649
          for (i = 0; VEC_iterate (tree, BINFO_BASE_BINFOS (TYPE_BINFO (t)),
4650
                                   i, tem); ++i)
4651
            fld_worklist_push (TREE_TYPE (tem), fld);
4652
          tem = BINFO_VIRTUALS (TYPE_BINFO (t));
4653
          if (tem
4654
              /* The Java FE overloads BINFO_VIRTUALS for its own purpose.  */
4655
              && TREE_CODE (tem) == TREE_LIST)
4656
            do
4657
              {
4658
                fld_worklist_push (TREE_VALUE (tem), fld);
4659
                tem = TREE_CHAIN (tem);
4660
              }
4661
            while (tem);
4662
        }
4663
      if (RECORD_OR_UNION_TYPE_P (t))
4664
        {
4665
          tree tem;
4666
          /* Push all TYPE_FIELDS - there can be interleaving interesting
4667
             and non-interesting things.  */
4668
          tem = TYPE_FIELDS (t);
4669
          while (tem)
4670
            {
4671
              if (TREE_CODE (tem) == FIELD_DECL)
4672
                fld_worklist_push (tem, fld);
4673
              tem = TREE_CHAIN (tem);
4674
            }
4675
        }
4676
 
4677
      fld_worklist_push (TREE_CHAIN (t), fld);
4678
      *ws = 0;
4679
    }
4680
  else if (TREE_CODE (t) == BLOCK)
4681
    {
4682
      tree tem;
4683
      for (tem = BLOCK_VARS (t); tem; tem = TREE_CHAIN (tem))
4684
        fld_worklist_push (tem, fld);
4685
      for (tem = BLOCK_SUBBLOCKS (t); tem; tem = BLOCK_CHAIN (tem))
4686
        fld_worklist_push (tem, fld);
4687
      fld_worklist_push (BLOCK_ABSTRACT_ORIGIN (t), fld);
4688
    }
4689
 
4690
  fld_worklist_push (TREE_TYPE (t), fld);
4691
 
4692
  return NULL_TREE;
4693
}
4694
 
4695
 
4696
/* Find decls and types in T.  */
4697
 
4698
static void
4699
find_decls_types (tree t, struct free_lang_data_d *fld)
4700
{
4701
  while (1)
4702
    {
4703
      if (!pointer_set_contains (fld->pset, t))
4704
        walk_tree (&t, find_decls_types_r, fld, fld->pset);
4705
      if (VEC_empty (tree, fld->worklist))
4706
        break;
4707
      t = VEC_pop (tree, fld->worklist);
4708
    }
4709
}
4710
 
4711
/* Translate all the types in LIST with the corresponding runtime
4712
   types.  */
4713
 
4714
static tree
4715
get_eh_types_for_runtime (tree list)
4716
{
4717
  tree head, prev;
4718
 
4719
  if (list == NULL_TREE)
4720
    return NULL_TREE;
4721
 
4722
  head = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4723
  prev = head;
4724
  list = TREE_CHAIN (list);
4725
  while (list)
4726
    {
4727
      tree n = build_tree_list (0, lookup_type_for_runtime (TREE_VALUE (list)));
4728
      TREE_CHAIN (prev) = n;
4729
      prev = TREE_CHAIN (prev);
4730
      list = TREE_CHAIN (list);
4731
    }
4732
 
4733
  return head;
4734
}
4735
 
4736
 
4737
/* Find decls and types referenced in EH region R and store them in
4738
   FLD->DECLS and FLD->TYPES.  */
4739
 
4740
static void
4741
find_decls_types_in_eh_region (eh_region r, struct free_lang_data_d *fld)
4742
{
4743
  switch (r->type)
4744
    {
4745
    case ERT_CLEANUP:
4746
      break;
4747
 
4748
    case ERT_TRY:
4749
      {
4750
        eh_catch c;
4751
 
4752
        /* The types referenced in each catch must first be changed to the
4753
           EH types used at runtime.  This removes references to FE types
4754
           in the region.  */
4755
        for (c = r->u.eh_try.first_catch; c ; c = c->next_catch)
4756
          {
4757
            c->type_list = get_eh_types_for_runtime (c->type_list);
4758
            walk_tree (&c->type_list, find_decls_types_r, fld, fld->pset);
4759
          }
4760
      }
4761
      break;
4762
 
4763
    case ERT_ALLOWED_EXCEPTIONS:
4764
      r->u.allowed.type_list
4765
        = get_eh_types_for_runtime (r->u.allowed.type_list);
4766
      walk_tree (&r->u.allowed.type_list, find_decls_types_r, fld, fld->pset);
4767
      break;
4768
 
4769
    case ERT_MUST_NOT_THROW:
4770
      walk_tree (&r->u.must_not_throw.failure_decl,
4771
                 find_decls_types_r, fld, fld->pset);
4772
      break;
4773
    }
4774
}
4775
 
4776
 
4777
/* Find decls and types referenced in cgraph node N and store them in
4778
   FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4779
   look for *every* kind of DECL and TYPE node reachable from N,
4780
   including those embedded inside types and decls (i.e,, TYPE_DECLs,
4781
   NAMESPACE_DECLs, etc).  */
4782
 
4783
static void
4784
find_decls_types_in_node (struct cgraph_node *n, struct free_lang_data_d *fld)
4785
{
4786
  basic_block bb;
4787
  struct function *fn;
4788
  tree t;
4789
 
4790
  find_decls_types (n->decl, fld);
4791
 
4792
  if (!gimple_has_body_p (n->decl))
4793
    return;
4794
 
4795
  gcc_assert (current_function_decl == NULL_TREE && cfun == NULL);
4796
 
4797
  fn = DECL_STRUCT_FUNCTION (n->decl);
4798
 
4799
  /* Traverse locals. */
4800
  for (t = fn->local_decls; t; t = TREE_CHAIN (t))
4801
    find_decls_types (TREE_VALUE (t), fld);
4802
 
4803
  /* Traverse EH regions in FN.  */
4804
  {
4805
    eh_region r;
4806
    FOR_ALL_EH_REGION_FN (r, fn)
4807
      find_decls_types_in_eh_region (r, fld);
4808
  }
4809
 
4810
  /* Traverse every statement in FN.  */
4811
  FOR_EACH_BB_FN (bb, fn)
4812
    {
4813
      gimple_stmt_iterator si;
4814
      unsigned i;
4815
 
4816
      for (si = gsi_start_phis (bb); !gsi_end_p (si); gsi_next (&si))
4817
        {
4818
          gimple phi = gsi_stmt (si);
4819
 
4820
          for (i = 0; i < gimple_phi_num_args (phi); i++)
4821
            {
4822
              tree *arg_p = gimple_phi_arg_def_ptr (phi, i);
4823
              find_decls_types (*arg_p, fld);
4824
            }
4825
        }
4826
 
4827
      for (si = gsi_start_bb (bb); !gsi_end_p (si); gsi_next (&si))
4828
        {
4829
          gimple stmt = gsi_stmt (si);
4830
 
4831
          for (i = 0; i < gimple_num_ops (stmt); i++)
4832
            {
4833
              tree arg = gimple_op (stmt, i);
4834
              find_decls_types (arg, fld);
4835
            }
4836
        }
4837
    }
4838
}
4839
 
4840
 
4841
/* Find decls and types referenced in varpool node N and store them in
4842
   FLD->DECLS and FLD->TYPES.  Unlike pass_referenced_vars, this will
4843
   look for *every* kind of DECL and TYPE node reachable from N,
4844
   including those embedded inside types and decls (i.e,, TYPE_DECLs,
4845
   NAMESPACE_DECLs, etc).  */
4846
 
4847
static void
4848
find_decls_types_in_var (struct varpool_node *v, struct free_lang_data_d *fld)
4849
{
4850
  find_decls_types (v->decl, fld);
4851
}
4852
 
4853
/* If T needs an assembler name, have one created for it.  */
4854
 
4855
void
4856
assign_assembler_name_if_neeeded (tree t)
4857
{
4858
  if (need_assembler_name_p (t))
4859
    {
4860
      /* When setting DECL_ASSEMBLER_NAME, the C++ mangler may emit
4861
         diagnostics that use input_location to show locus
4862
         information.  The problem here is that, at this point,
4863
         input_location is generally anchored to the end of the file
4864
         (since the parser is long gone), so we don't have a good
4865
         position to pin it to.
4866
 
4867
         To alleviate this problem, this uses the location of T's
4868
         declaration.  Examples of this are
4869
         testsuite/g++.dg/template/cond2.C and
4870
         testsuite/g++.dg/template/pr35240.C.  */
4871
      location_t saved_location = input_location;
4872
      input_location = DECL_SOURCE_LOCATION (t);
4873
 
4874
      decl_assembler_name (t);
4875
 
4876
      input_location = saved_location;
4877
    }
4878
}
4879
 
4880
 
4881
/* Free language specific information for every operand and expression
4882
   in every node of the call graph.  This process operates in three stages:
4883
 
4884
   1- Every callgraph node and varpool node is traversed looking for
4885
      decls and types embedded in them.  This is a more exhaustive
4886
      search than that done by find_referenced_vars, because it will
4887
      also collect individual fields, decls embedded in types, etc.
4888
 
4889
   2- All the decls found are sent to free_lang_data_in_decl.
4890
 
4891
   3- All the types found are sent to free_lang_data_in_type.
4892
 
4893
   The ordering between decls and types is important because
4894
   free_lang_data_in_decl sets assembler names, which includes
4895
   mangling.  So types cannot be freed up until assembler names have
4896
   been set up.  */
4897
 
4898
static void
4899
free_lang_data_in_cgraph (void)
4900
{
4901
  struct cgraph_node *n;
4902
  struct varpool_node *v;
4903
  struct free_lang_data_d fld;
4904
  tree t;
4905
  unsigned i;
4906
  alias_pair *p;
4907
 
4908
  /* Initialize sets and arrays to store referenced decls and types.  */
4909
  fld.pset = pointer_set_create ();
4910
  fld.worklist = NULL;
4911
  fld.decls = VEC_alloc (tree, heap, 100);
4912
  fld.types = VEC_alloc (tree, heap, 100);
4913
 
4914
  /* Find decls and types in the body of every function in the callgraph.  */
4915
  for (n = cgraph_nodes; n; n = n->next)
4916
    find_decls_types_in_node (n, &fld);
4917
 
4918
  for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
4919
    find_decls_types (p->decl, &fld);
4920
 
4921
  /* Find decls and types in every varpool symbol.  */
4922
  for (v = varpool_nodes_queue; v; v = v->next_needed)
4923
    find_decls_types_in_var (v, &fld);
4924
 
4925
  /* Set the assembler name on every decl found.  We need to do this
4926
     now because free_lang_data_in_decl will invalidate data needed
4927
     for mangling.  This breaks mangling on interdependent decls.  */
4928
  for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4929
    assign_assembler_name_if_neeeded (t);
4930
 
4931
  /* Traverse every decl found freeing its language data.  */
4932
  for (i = 0; VEC_iterate (tree, fld.decls, i, t); i++)
4933
    free_lang_data_in_decl (t);
4934
 
4935
  /* Traverse every type found freeing its language data.  */
4936
  for (i = 0; VEC_iterate (tree, fld.types, i, t); i++)
4937
    free_lang_data_in_type (t);
4938
 
4939
  pointer_set_destroy (fld.pset);
4940
  VEC_free (tree, heap, fld.worklist);
4941
  VEC_free (tree, heap, fld.decls);
4942
  VEC_free (tree, heap, fld.types);
4943
}
4944
 
4945
 
4946
/* Free resources that are used by FE but are not needed once they are done. */
4947
 
4948
static unsigned
4949
free_lang_data (void)
4950
{
4951
  unsigned i;
4952
 
4953
  /* If we are the LTO frontend we have freed lang-specific data already.  */
4954
  if (in_lto_p
4955
      || !flag_generate_lto)
4956
    return 0;
4957
 
4958
  /* Allocate and assign alias sets to the standard integer types
4959
     while the slots are still in the way the frontends generated them.  */
4960
  for (i = 0; i < itk_none; ++i)
4961
    if (integer_types[i])
4962
      TYPE_ALIAS_SET (integer_types[i]) = get_alias_set (integer_types[i]);
4963
 
4964
  /* Traverse the IL resetting language specific information for
4965
     operands, expressions, etc.  */
4966
  free_lang_data_in_cgraph ();
4967
 
4968
  /* Create gimple variants for common types.  */
4969
  ptrdiff_type_node = integer_type_node;
4970
  fileptr_type_node = ptr_type_node;
4971
  if (TREE_CODE (boolean_type_node) != BOOLEAN_TYPE
4972
      || (TYPE_MODE (boolean_type_node)
4973
          != mode_for_size (BOOL_TYPE_SIZE, MODE_INT, 0))
4974
      || TYPE_PRECISION (boolean_type_node) != 1
4975
      || !TYPE_UNSIGNED (boolean_type_node))
4976
    {
4977
      boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
4978
      TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
4979
      TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
4980
      TYPE_PRECISION (boolean_type_node) = 1;
4981
      boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
4982
      boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
4983
    }
4984
 
4985
  /* Unify char_type_node with its properly signed variant.  */
4986
  if (TYPE_UNSIGNED (char_type_node))
4987
    unsigned_char_type_node = char_type_node;
4988
  else
4989
    signed_char_type_node = char_type_node;
4990
 
4991
  /* Reset some langhooks.  Do not reset types_compatible_p, it may
4992
     still be used indirectly via the get_alias_set langhook.  */
4993
  lang_hooks.callgraph.analyze_expr = NULL;
4994
  lang_hooks.dwarf_name = lhd_dwarf_name;
4995
  lang_hooks.decl_printable_name = gimple_decl_printable_name;
4996
  lang_hooks.set_decl_assembler_name = lhd_set_decl_assembler_name;
4997
  lang_hooks.fold_obj_type_ref = gimple_fold_obj_type_ref;
4998
 
4999
  /* Reset diagnostic machinery.  */
5000
  diagnostic_starter (global_dc) = default_diagnostic_starter;
5001
  diagnostic_finalizer (global_dc) = default_diagnostic_finalizer;
5002
  diagnostic_format_decoder (global_dc) = default_tree_printer;
5003
 
5004
  return 0;
5005
}
5006
 
5007
 
5008
struct simple_ipa_opt_pass pass_ipa_free_lang_data =
5009
{
5010
 {
5011
  SIMPLE_IPA_PASS,
5012
  "*free_lang_data",                    /* name */
5013
  NULL,                                 /* gate */
5014
  free_lang_data,                       /* execute */
5015
  NULL,                                 /* sub */
5016
  NULL,                                 /* next */
5017
  0,                                     /* static_pass_number */
5018
  TV_IPA_FREE_LANG_DATA,                /* tv_id */
5019
  0,                                     /* properties_required */
5020
  0,                                     /* properties_provided */
5021
  0,                                     /* properties_destroyed */
5022
  0,                                     /* todo_flags_start */
5023
  TODO_ggc_collect                      /* todo_flags_finish */
5024
 }
5025
};
5026
 
5027
/* Return nonzero if IDENT is a valid name for attribute ATTR,
5028
   or zero if not.
5029
 
5030
   We try both `text' and `__text__', ATTR may be either one.  */
5031
/* ??? It might be a reasonable simplification to require ATTR to be only
5032
   `text'.  One might then also require attribute lists to be stored in
5033
   their canonicalized form.  */
5034
 
5035
static int
5036
is_attribute_with_length_p (const char *attr, int attr_len, const_tree ident)
5037
{
5038
  int ident_len;
5039
  const char *p;
5040
 
5041
  if (TREE_CODE (ident) != IDENTIFIER_NODE)
5042
    return 0;
5043
 
5044
  p = IDENTIFIER_POINTER (ident);
5045
  ident_len = IDENTIFIER_LENGTH (ident);
5046
 
5047
  if (ident_len == attr_len
5048
      && strcmp (attr, p) == 0)
5049
    return 1;
5050
 
5051
  /* If ATTR is `__text__', IDENT must be `text'; and vice versa.  */
5052
  if (attr[0] == '_')
5053
    {
5054
      gcc_assert (attr[1] == '_');
5055
      gcc_assert (attr[attr_len - 2] == '_');
5056
      gcc_assert (attr[attr_len - 1] == '_');
5057
      if (ident_len == attr_len - 4
5058
          && strncmp (attr + 2, p, attr_len - 4) == 0)
5059
        return 1;
5060
    }
5061
  else
5062
    {
5063
      if (ident_len == attr_len + 4
5064
          && p[0] == '_' && p[1] == '_'
5065
          && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
5066
          && strncmp (attr, p + 2, attr_len) == 0)
5067
        return 1;
5068
    }
5069
 
5070
  return 0;
5071
}
5072
 
5073
/* Return nonzero if IDENT is a valid name for attribute ATTR,
5074
   or zero if not.
5075
 
5076
   We try both `text' and `__text__', ATTR may be either one.  */
5077
 
5078
int
5079
is_attribute_p (const char *attr, const_tree ident)
5080
{
5081
  return is_attribute_with_length_p (attr, strlen (attr), ident);
5082
}
5083
 
5084
/* Given an attribute name and a list of attributes, return a pointer to the
5085
   attribute's list element if the attribute is part of the list, or NULL_TREE
5086
   if not found.  If the attribute appears more than once, this only
5087
   returns the first occurrence; the TREE_CHAIN of the return value should
5088
   be passed back in if further occurrences are wanted.  */
5089
 
5090
tree
5091
lookup_attribute (const char *attr_name, tree list)
5092
{
5093
  tree l;
5094
  size_t attr_len = strlen (attr_name);
5095
 
5096
  for (l = list; l; l = TREE_CHAIN (l))
5097
    {
5098
      gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5099
      if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5100
        return l;
5101
    }
5102
  return NULL_TREE;
5103
}
5104
 
5105
/* Remove any instances of attribute ATTR_NAME in LIST and return the
5106
   modified list.  */
5107
 
5108
tree
5109
remove_attribute (const char *attr_name, tree list)
5110
{
5111
  tree *p;
5112
  size_t attr_len = strlen (attr_name);
5113
 
5114
  for (p = &list; *p; )
5115
    {
5116
      tree l = *p;
5117
      gcc_assert (TREE_CODE (TREE_PURPOSE (l)) == IDENTIFIER_NODE);
5118
      if (is_attribute_with_length_p (attr_name, attr_len, TREE_PURPOSE (l)))
5119
        *p = TREE_CHAIN (l);
5120
      else
5121
        p = &TREE_CHAIN (l);
5122
    }
5123
 
5124
  return list;
5125
}
5126
 
5127
/* Return an attribute list that is the union of a1 and a2.  */
5128
 
5129
tree
5130
merge_attributes (tree a1, tree a2)
5131
{
5132
  tree attributes;
5133
 
5134
  /* Either one unset?  Take the set one.  */
5135
 
5136
  if ((attributes = a1) == 0)
5137
    attributes = a2;
5138
 
5139
  /* One that completely contains the other?  Take it.  */
5140
 
5141
  else if (a2 != 0 && ! attribute_list_contained (a1, a2))
5142
    {
5143
      if (attribute_list_contained (a2, a1))
5144
        attributes = a2;
5145
      else
5146
        {
5147
          /* Pick the longest list, and hang on the other list.  */
5148
 
5149
          if (list_length (a1) < list_length (a2))
5150
            attributes = a2, a2 = a1;
5151
 
5152
          for (; a2 != 0; a2 = TREE_CHAIN (a2))
5153
            {
5154
              tree a;
5155
              for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5156
                                         attributes);
5157
                   a != NULL_TREE;
5158
                   a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
5159
                                         TREE_CHAIN (a)))
5160
                {
5161
                  if (TREE_VALUE (a) != NULL
5162
                      && TREE_CODE (TREE_VALUE (a)) == TREE_LIST
5163
                      && TREE_VALUE (a2) != NULL
5164
                      && TREE_CODE (TREE_VALUE (a2)) == TREE_LIST)
5165
                    {
5166
                      if (simple_cst_list_equal (TREE_VALUE (a),
5167
                                                 TREE_VALUE (a2)) == 1)
5168
                        break;
5169
                    }
5170
                  else if (simple_cst_equal (TREE_VALUE (a),
5171
                                             TREE_VALUE (a2)) == 1)
5172
                    break;
5173
                }
5174
              if (a == NULL_TREE)
5175
                {
5176
                  a1 = copy_node (a2);
5177
                  TREE_CHAIN (a1) = attributes;
5178
                  attributes = a1;
5179
                }
5180
            }
5181
        }
5182
    }
5183
  return attributes;
5184
}
5185
 
5186
/* Given types T1 and T2, merge their attributes and return
5187
  the result.  */
5188
 
5189
tree
5190
merge_type_attributes (tree t1, tree t2)
5191
{
5192
  return merge_attributes (TYPE_ATTRIBUTES (t1),
5193
                           TYPE_ATTRIBUTES (t2));
5194
}
5195
 
5196
/* Given decls OLDDECL and NEWDECL, merge their attributes and return
5197
   the result.  */
5198
 
5199
tree
5200
merge_decl_attributes (tree olddecl, tree newdecl)
5201
{
5202
  return merge_attributes (DECL_ATTRIBUTES (olddecl),
5203
                           DECL_ATTRIBUTES (newdecl));
5204
}
5205
 
5206
#if TARGET_DLLIMPORT_DECL_ATTRIBUTES
5207
 
5208
/* Specialization of merge_decl_attributes for various Windows targets.
5209
 
5210
   This handles the following situation:
5211
 
5212
     __declspec (dllimport) int foo;
5213
     int foo;
5214
 
5215
   The second instance of `foo' nullifies the dllimport.  */
5216
 
5217
tree
5218
merge_dllimport_decl_attributes (tree old, tree new_tree)
5219
{
5220
  tree a;
5221
  int delete_dllimport_p = 1;
5222
 
5223
  /* What we need to do here is remove from `old' dllimport if it doesn't
5224
     appear in `new'.  dllimport behaves like extern: if a declaration is
5225
     marked dllimport and a definition appears later, then the object
5226
     is not dllimport'd.  We also remove a `new' dllimport if the old list
5227
     contains dllexport:  dllexport always overrides dllimport, regardless
5228
     of the order of declaration.  */
5229
  if (!VAR_OR_FUNCTION_DECL_P (new_tree))
5230
    delete_dllimport_p = 0;
5231
  else if (DECL_DLLIMPORT_P (new_tree)
5232
           && lookup_attribute ("dllexport", DECL_ATTRIBUTES (old)))
5233
    {
5234
      DECL_DLLIMPORT_P (new_tree) = 0;
5235
      warning (OPT_Wattributes, "%q+D already declared with dllexport attribute: "
5236
              "dllimport ignored", new_tree);
5237
    }
5238
  else if (DECL_DLLIMPORT_P (old) && !DECL_DLLIMPORT_P (new_tree))
5239
    {
5240
      /* Warn about overriding a symbol that has already been used, e.g.:
5241
           extern int __attribute__ ((dllimport)) foo;
5242
           int* bar () {return &foo;}
5243
           int foo;
5244
      */
5245
      if (TREE_USED (old))
5246
        {
5247
          warning (0, "%q+D redeclared without dllimport attribute "
5248
                   "after being referenced with dll linkage", new_tree);
5249
          /* If we have used a variable's address with dllimport linkage,
5250
              keep the old DECL_DLLIMPORT_P flag: the ADDR_EXPR using the
5251
              decl may already have had TREE_CONSTANT computed.
5252
              We still remove the attribute so that assembler code refers
5253
              to '&foo rather than '_imp__foo'.  */
5254
          if (TREE_CODE (old) == VAR_DECL && TREE_ADDRESSABLE (old))
5255
            DECL_DLLIMPORT_P (new_tree) = 1;
5256
        }
5257
 
5258
      /* Let an inline definition silently override the external reference,
5259
         but otherwise warn about attribute inconsistency.  */
5260
      else if (TREE_CODE (new_tree) == VAR_DECL
5261
               || !DECL_DECLARED_INLINE_P (new_tree))
5262
        warning (OPT_Wattributes, "%q+D redeclared without dllimport attribute: "
5263
                  "previous dllimport ignored", new_tree);
5264
    }
5265
  else
5266
    delete_dllimport_p = 0;
5267
 
5268
  a = merge_attributes (DECL_ATTRIBUTES (old), DECL_ATTRIBUTES (new_tree));
5269
 
5270
  if (delete_dllimport_p)
5271
    {
5272
      tree prev, t;
5273
      const size_t attr_len = strlen ("dllimport");
5274
 
5275
      /* Scan the list for dllimport and delete it.  */
5276
      for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
5277
        {
5278
          if (is_attribute_with_length_p ("dllimport", attr_len,
5279
                                          TREE_PURPOSE (t)))
5280
            {
5281
              if (prev == NULL_TREE)
5282
                a = TREE_CHAIN (a);
5283
              else
5284
                TREE_CHAIN (prev) = TREE_CHAIN (t);
5285
              break;
5286
            }
5287
        }
5288
    }
5289
 
5290
  return a;
5291
}
5292
 
5293
/* Handle a "dllimport" or "dllexport" attribute; arguments as in
5294
   struct attribute_spec.handler.  */
5295
 
5296
tree
5297
handle_dll_attribute (tree * pnode, tree name, tree args, int flags,
5298
                      bool *no_add_attrs)
5299
{
5300
  tree node = *pnode;
5301
  bool is_dllimport;
5302
 
5303
  /* These attributes may apply to structure and union types being created,
5304
     but otherwise should pass to the declaration involved.  */
5305
  if (!DECL_P (node))
5306
    {
5307
      if (flags & ((int) ATTR_FLAG_DECL_NEXT | (int) ATTR_FLAG_FUNCTION_NEXT
5308
                   | (int) ATTR_FLAG_ARRAY_NEXT))
5309
        {
5310
          *no_add_attrs = true;
5311
          return tree_cons (name, args, NULL_TREE);
5312
        }
5313
      if (TREE_CODE (node) == RECORD_TYPE
5314
          || TREE_CODE (node) == UNION_TYPE)
5315
        {
5316
          node = TYPE_NAME (node);
5317
          if (!node)
5318
            return NULL_TREE;
5319
        }
5320
      else
5321
        {
5322
          warning (OPT_Wattributes, "%qE attribute ignored",
5323
                   name);
5324
          *no_add_attrs = true;
5325
          return NULL_TREE;
5326
        }
5327
    }
5328
 
5329
  if (TREE_CODE (node) != FUNCTION_DECL
5330
      && TREE_CODE (node) != VAR_DECL
5331
      && TREE_CODE (node) != TYPE_DECL)
5332
    {
5333
      *no_add_attrs = true;
5334
      warning (OPT_Wattributes, "%qE attribute ignored",
5335
               name);
5336
      return NULL_TREE;
5337
    }
5338
 
5339
  if (TREE_CODE (node) == TYPE_DECL
5340
      && TREE_CODE (TREE_TYPE (node)) != RECORD_TYPE
5341
      && TREE_CODE (TREE_TYPE (node)) != UNION_TYPE)
5342
    {
5343
      *no_add_attrs = true;
5344
      warning (OPT_Wattributes, "%qE attribute ignored",
5345
               name);
5346
      return NULL_TREE;
5347
    }
5348
 
5349
  is_dllimport = is_attribute_p ("dllimport", name);
5350
 
5351
  /* Report error on dllimport ambiguities seen now before they cause
5352
     any damage.  */
5353
  if (is_dllimport)
5354
    {
5355
      /* Honor any target-specific overrides. */
5356
      if (!targetm.valid_dllimport_attribute_p (node))
5357
        *no_add_attrs = true;
5358
 
5359
     else if (TREE_CODE (node) == FUNCTION_DECL
5360
                && DECL_DECLARED_INLINE_P (node))
5361
        {
5362
          warning (OPT_Wattributes, "inline function %q+D declared as "
5363
                  " dllimport: attribute ignored", node);
5364
          *no_add_attrs = true;
5365
        }
5366
      /* Like MS, treat definition of dllimported variables and
5367
         non-inlined functions on declaration as syntax errors. */
5368
     else if (TREE_CODE (node) == FUNCTION_DECL && DECL_INITIAL (node))
5369
        {
5370
          error ("function %q+D definition is marked dllimport", node);
5371
          *no_add_attrs = true;
5372
        }
5373
 
5374
     else if (TREE_CODE (node) == VAR_DECL)
5375
        {
5376
          if (DECL_INITIAL (node))
5377
            {
5378
              error ("variable %q+D definition is marked dllimport",
5379
                     node);
5380
              *no_add_attrs = true;
5381
            }
5382
 
5383
          /* `extern' needn't be specified with dllimport.
5384
             Specify `extern' now and hope for the best.  Sigh.  */
5385
          DECL_EXTERNAL (node) = 1;
5386
          /* Also, implicitly give dllimport'd variables declared within
5387
             a function global scope, unless declared static.  */
5388
          if (current_function_decl != NULL_TREE && !TREE_STATIC (node))
5389
            TREE_PUBLIC (node) = 1;
5390
        }
5391
 
5392
      if (*no_add_attrs == false)
5393
        DECL_DLLIMPORT_P (node) = 1;
5394
    }
5395
  else if (TREE_CODE (node) == FUNCTION_DECL
5396
           && DECL_DECLARED_INLINE_P (node))
5397
    /* An exported function, even if inline, must be emitted.  */
5398
    DECL_EXTERNAL (node) = 0;
5399
 
5400
  /*  Report error if symbol is not accessible at global scope.  */
5401
  if (!TREE_PUBLIC (node)
5402
      && (TREE_CODE (node) == VAR_DECL
5403
          || TREE_CODE (node) == FUNCTION_DECL))
5404
    {
5405
      error ("external linkage required for symbol %q+D because of "
5406
             "%qE attribute", node, name);
5407
      *no_add_attrs = true;
5408
    }
5409
 
5410
  /* A dllexport'd entity must have default visibility so that other
5411
     program units (shared libraries or the main executable) can see
5412
     it.  A dllimport'd entity must have default visibility so that
5413
     the linker knows that undefined references within this program
5414
     unit can be resolved by the dynamic linker.  */
5415
  if (!*no_add_attrs)
5416
    {
5417
      if (DECL_VISIBILITY_SPECIFIED (node)
5418
          && DECL_VISIBILITY (node) != VISIBILITY_DEFAULT)
5419
        error ("%qE implies default visibility, but %qD has already "
5420
               "been declared with a different visibility",
5421
               name, node);
5422
      DECL_VISIBILITY (node) = VISIBILITY_DEFAULT;
5423
      DECL_VISIBILITY_SPECIFIED (node) = 1;
5424
    }
5425
 
5426
  return NULL_TREE;
5427
}
5428
 
5429
#endif /* TARGET_DLLIMPORT_DECL_ATTRIBUTES  */
5430
 
5431
/* Set the type qualifiers for TYPE to TYPE_QUALS, which is a bitmask
5432
   of the various TYPE_QUAL values.  */
5433
 
5434
static void
5435
set_type_quals (tree type, int type_quals)
5436
{
5437
  TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
5438
  TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
5439
  TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
5440
  TYPE_ADDR_SPACE (type) = DECODE_QUAL_ADDR_SPACE (type_quals);
5441
}
5442
 
5443
/* Returns true iff CAND is equivalent to BASE with TYPE_QUALS.  */
5444
 
5445
bool
5446
check_qualified_type (const_tree cand, const_tree base, int type_quals)
5447
{
5448
  return (TYPE_QUALS (cand) == type_quals
5449
          && TYPE_NAME (cand) == TYPE_NAME (base)
5450
          /* Apparently this is needed for Objective-C.  */
5451
          && TYPE_CONTEXT (cand) == TYPE_CONTEXT (base)
5452
          && attribute_list_equal (TYPE_ATTRIBUTES (cand),
5453
                                   TYPE_ATTRIBUTES (base)));
5454
}
5455
 
5456
/* Return a version of the TYPE, qualified as indicated by the
5457
   TYPE_QUALS, if one exists.  If no qualified version exists yet,
5458
   return NULL_TREE.  */
5459
 
5460
tree
5461
get_qualified_type (tree type, int type_quals)
5462
{
5463
  tree t;
5464
 
5465
  if (TYPE_QUALS (type) == type_quals)
5466
    return type;
5467
 
5468
  /* Search the chain of variants to see if there is already one there just
5469
     like the one we need to have.  If so, use that existing one.  We must
5470
     preserve the TYPE_NAME, since there is code that depends on this.  */
5471
  for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
5472
    if (check_qualified_type (t, type, type_quals))
5473
      return t;
5474
 
5475
  return NULL_TREE;
5476
}
5477
 
5478
/* Like get_qualified_type, but creates the type if it does not
5479
   exist.  This function never returns NULL_TREE.  */
5480
 
5481
tree
5482
build_qualified_type (tree type, int type_quals)
5483
{
5484
  tree t;
5485
 
5486
  /* See if we already have the appropriate qualified variant.  */
5487
  t = get_qualified_type (type, type_quals);
5488
 
5489
  /* If not, build it.  */
5490
  if (!t)
5491
    {
5492
      t = build_variant_type_copy (type);
5493
      set_type_quals (t, type_quals);
5494
 
5495
      if (TYPE_STRUCTURAL_EQUALITY_P (type))
5496
        /* Propagate structural equality. */
5497
        SET_TYPE_STRUCTURAL_EQUALITY (t);
5498
      else if (TYPE_CANONICAL (type) != type)
5499
        /* Build the underlying canonical type, since it is different
5500
           from TYPE. */
5501
        TYPE_CANONICAL (t) = build_qualified_type (TYPE_CANONICAL (type),
5502
                                                   type_quals);
5503
      else
5504
        /* T is its own canonical type. */
5505
        TYPE_CANONICAL (t) = t;
5506
 
5507
    }
5508
 
5509
  return t;
5510
}
5511
 
5512
/* Create a new distinct copy of TYPE.  The new type is made its own
5513
   MAIN_VARIANT. If TYPE requires structural equality checks, the
5514
   resulting type requires structural equality checks; otherwise, its
5515
   TYPE_CANONICAL points to itself. */
5516
 
5517
tree
5518
build_distinct_type_copy (tree type)
5519
{
5520
  tree t = copy_node (type);
5521
 
5522
  TYPE_POINTER_TO (t) = 0;
5523
  TYPE_REFERENCE_TO (t) = 0;
5524
 
5525
  /* Set the canonical type either to a new equivalence class, or
5526
     propagate the need for structural equality checks. */
5527
  if (TYPE_STRUCTURAL_EQUALITY_P (type))
5528
    SET_TYPE_STRUCTURAL_EQUALITY (t);
5529
  else
5530
    TYPE_CANONICAL (t) = t;
5531
 
5532
  /* Make it its own variant.  */
5533
  TYPE_MAIN_VARIANT (t) = t;
5534
  TYPE_NEXT_VARIANT (t) = 0;
5535
 
5536
  /* Note that it is now possible for TYPE_MIN_VALUE to be a value
5537
     whose TREE_TYPE is not t.  This can also happen in the Ada
5538
     frontend when using subtypes.  */
5539
 
5540
  return t;
5541
}
5542
 
5543
/* Create a new variant of TYPE, equivalent but distinct.  This is so
5544
   the caller can modify it. TYPE_CANONICAL for the return type will
5545
   be equivalent to TYPE_CANONICAL of TYPE, indicating that the types
5546
   are considered equal by the language itself (or that both types
5547
   require structural equality checks). */
5548
 
5549
tree
5550
build_variant_type_copy (tree type)
5551
{
5552
  tree t, m = TYPE_MAIN_VARIANT (type);
5553
 
5554
  t = build_distinct_type_copy (type);
5555
 
5556
  /* Since we're building a variant, assume that it is a non-semantic
5557
     variant. This also propagates TYPE_STRUCTURAL_EQUALITY_P. */
5558
  TYPE_CANONICAL (t) = TYPE_CANONICAL (type);
5559
 
5560
  /* Add the new type to the chain of variants of TYPE.  */
5561
  TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
5562
  TYPE_NEXT_VARIANT (m) = t;
5563
  TYPE_MAIN_VARIANT (t) = m;
5564
 
5565
  return t;
5566
}
5567
 
5568
/* Return true if the from tree in both tree maps are equal.  */
5569
 
5570
int
5571
tree_map_base_eq (const void *va, const void *vb)
5572
{
5573
  const struct tree_map_base  *const a = (const struct tree_map_base *) va,
5574
    *const b = (const struct tree_map_base *) vb;
5575
  return (a->from == b->from);
5576
}
5577
 
5578
/* Hash a from tree in a tree_map.  */
5579
 
5580
unsigned int
5581
tree_map_base_hash (const void *item)
5582
{
5583
  return htab_hash_pointer (((const struct tree_map_base *)item)->from);
5584
}
5585
 
5586
/* Return true if this tree map structure is marked for garbage collection
5587
   purposes.  We simply return true if the from tree is marked, so that this
5588
   structure goes away when the from tree goes away.  */
5589
 
5590
int
5591
tree_map_base_marked_p (const void *p)
5592
{
5593
  return ggc_marked_p (((const struct tree_map_base *) p)->from);
5594
}
5595
 
5596
unsigned int
5597
tree_map_hash (const void *item)
5598
{
5599
  return (((const struct tree_map *) item)->hash);
5600
}
5601
 
5602
/* Return the initialization priority for DECL.  */
5603
 
5604
priority_type
5605
decl_init_priority_lookup (tree decl)
5606
{
5607
  struct tree_priority_map *h;
5608
  struct tree_map_base in;
5609
 
5610
  gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5611
  in.from = decl;
5612
  h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5613
  return h ? h->init : DEFAULT_INIT_PRIORITY;
5614
}
5615
 
5616
/* Return the finalization priority for DECL.  */
5617
 
5618
priority_type
5619
decl_fini_priority_lookup (tree decl)
5620
{
5621
  struct tree_priority_map *h;
5622
  struct tree_map_base in;
5623
 
5624
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5625
  in.from = decl;
5626
  h = (struct tree_priority_map *) htab_find (init_priority_for_decl, &in);
5627
  return h ? h->fini : DEFAULT_INIT_PRIORITY;
5628
}
5629
 
5630
/* Return the initialization and finalization priority information for
5631
   DECL.  If there is no previous priority information, a freshly
5632
   allocated structure is returned.  */
5633
 
5634
static struct tree_priority_map *
5635
decl_priority_info (tree decl)
5636
{
5637
  struct tree_priority_map in;
5638
  struct tree_priority_map *h;
5639
  void **loc;
5640
 
5641
  in.base.from = decl;
5642
  loc = htab_find_slot (init_priority_for_decl, &in, INSERT);
5643
  h = (struct tree_priority_map *) *loc;
5644
  if (!h)
5645
    {
5646
      h = GGC_CNEW (struct tree_priority_map);
5647
      *loc = h;
5648
      h->base.from = decl;
5649
      h->init = DEFAULT_INIT_PRIORITY;
5650
      h->fini = DEFAULT_INIT_PRIORITY;
5651
    }
5652
 
5653
  return h;
5654
}
5655
 
5656
/* Set the initialization priority for DECL to PRIORITY.  */
5657
 
5658
void
5659
decl_init_priority_insert (tree decl, priority_type priority)
5660
{
5661
  struct tree_priority_map *h;
5662
 
5663
  gcc_assert (VAR_OR_FUNCTION_DECL_P (decl));
5664
  h = decl_priority_info (decl);
5665
  h->init = priority;
5666
}
5667
 
5668
/* Set the finalization priority for DECL to PRIORITY.  */
5669
 
5670
void
5671
decl_fini_priority_insert (tree decl, priority_type priority)
5672
{
5673
  struct tree_priority_map *h;
5674
 
5675
  gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
5676
  h = decl_priority_info (decl);
5677
  h->fini = priority;
5678
}
5679
 
5680
/* Print out the statistics for the DECL_DEBUG_EXPR hash table.  */
5681
 
5682
static void
5683
print_debug_expr_statistics (void)
5684
{
5685
  fprintf (stderr, "DECL_DEBUG_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5686
           (long) htab_size (debug_expr_for_decl),
5687
           (long) htab_elements (debug_expr_for_decl),
5688
           htab_collisions (debug_expr_for_decl));
5689
}
5690
 
5691
/* Print out the statistics for the DECL_VALUE_EXPR hash table.  */
5692
 
5693
static void
5694
print_value_expr_statistics (void)
5695
{
5696
  fprintf (stderr, "DECL_VALUE_EXPR  hash: size %ld, %ld elements, %f collisions\n",
5697
           (long) htab_size (value_expr_for_decl),
5698
           (long) htab_elements (value_expr_for_decl),
5699
           htab_collisions (value_expr_for_decl));
5700
}
5701
 
5702
/* Lookup a debug expression for FROM, and return it if we find one.  */
5703
 
5704
tree
5705
decl_debug_expr_lookup (tree from)
5706
{
5707
  struct tree_map *h, in;
5708
  in.base.from = from;
5709
 
5710
  h = (struct tree_map *) htab_find_with_hash (debug_expr_for_decl, &in,
5711
                                               htab_hash_pointer (from));
5712
  if (h)
5713
    return h->to;
5714
  return NULL_TREE;
5715
}
5716
 
5717
/* Insert a mapping FROM->TO in the debug expression hashtable.  */
5718
 
5719
void
5720
decl_debug_expr_insert (tree from, tree to)
5721
{
5722
  struct tree_map *h;
5723
  void **loc;
5724
 
5725
  h = GGC_NEW (struct tree_map);
5726
  h->hash = htab_hash_pointer (from);
5727
  h->base.from = from;
5728
  h->to = to;
5729
  loc = htab_find_slot_with_hash (debug_expr_for_decl, h, h->hash, INSERT);
5730
  *(struct tree_map **) loc = h;
5731
}
5732
 
5733
/* Lookup a value expression for FROM, and return it if we find one.  */
5734
 
5735
tree
5736
decl_value_expr_lookup (tree from)
5737
{
5738
  struct tree_map *h, in;
5739
  in.base.from = from;
5740
 
5741
  h = (struct tree_map *) htab_find_with_hash (value_expr_for_decl, &in,
5742
                                               htab_hash_pointer (from));
5743
  if (h)
5744
    return h->to;
5745
  return NULL_TREE;
5746
}
5747
 
5748
/* Insert a mapping FROM->TO in the value expression hashtable.  */
5749
 
5750
void
5751
decl_value_expr_insert (tree from, tree to)
5752
{
5753
  struct tree_map *h;
5754
  void **loc;
5755
 
5756
  h = GGC_NEW (struct tree_map);
5757
  h->hash = htab_hash_pointer (from);
5758
  h->base.from = from;
5759
  h->to = to;
5760
  loc = htab_find_slot_with_hash (value_expr_for_decl, h, h->hash, INSERT);
5761
  *(struct tree_map **) loc = h;
5762
}
5763
 
5764
/* Hashing of types so that we don't make duplicates.
5765
   The entry point is `type_hash_canon'.  */
5766
 
5767
/* Compute a hash code for a list of types (chain of TREE_LIST nodes
5768
   with types in the TREE_VALUE slots), by adding the hash codes
5769
   of the individual types.  */
5770
 
5771
static unsigned int
5772
type_hash_list (const_tree list, hashval_t hashcode)
5773
{
5774
  const_tree tail;
5775
 
5776
  for (tail = list; tail; tail = TREE_CHAIN (tail))
5777
    if (TREE_VALUE (tail) != error_mark_node)
5778
      hashcode = iterative_hash_object (TYPE_HASH (TREE_VALUE (tail)),
5779
                                        hashcode);
5780
 
5781
  return hashcode;
5782
}
5783
 
5784
/* These are the Hashtable callback functions.  */
5785
 
5786
/* Returns true iff the types are equivalent.  */
5787
 
5788
static int
5789
type_hash_eq (const void *va, const void *vb)
5790
{
5791
  const struct type_hash *const a = (const struct type_hash *) va,
5792
    *const b = (const struct type_hash *) vb;
5793
 
5794
  /* First test the things that are the same for all types.  */
5795
  if (a->hash != b->hash
5796
      || TREE_CODE (a->type) != TREE_CODE (b->type)
5797
      || TREE_TYPE (a->type) != TREE_TYPE (b->type)
5798
      || !attribute_list_equal (TYPE_ATTRIBUTES (a->type),
5799
                                 TYPE_ATTRIBUTES (b->type))
5800
      || TYPE_ALIGN (a->type) != TYPE_ALIGN (b->type)
5801
      || TYPE_MODE (a->type) != TYPE_MODE (b->type)
5802
      || (TREE_CODE (a->type) != COMPLEX_TYPE
5803
          && TYPE_NAME (a->type) != TYPE_NAME (b->type)))
5804
    return 0;
5805
 
5806
  switch (TREE_CODE (a->type))
5807
    {
5808
    case VOID_TYPE:
5809
    case COMPLEX_TYPE:
5810
    case POINTER_TYPE:
5811
    case REFERENCE_TYPE:
5812
      return 1;
5813
 
5814
    case VECTOR_TYPE:
5815
      return TYPE_VECTOR_SUBPARTS (a->type) == TYPE_VECTOR_SUBPARTS (b->type);
5816
 
5817
    case ENUMERAL_TYPE:
5818
      if (TYPE_VALUES (a->type) != TYPE_VALUES (b->type)
5819
          && !(TYPE_VALUES (a->type)
5820
               && TREE_CODE (TYPE_VALUES (a->type)) == TREE_LIST
5821
               && TYPE_VALUES (b->type)
5822
               && TREE_CODE (TYPE_VALUES (b->type)) == TREE_LIST
5823
               && type_list_equal (TYPE_VALUES (a->type),
5824
                                   TYPE_VALUES (b->type))))
5825
        return 0;
5826
 
5827
      /* ... fall through ... */
5828
 
5829
    case INTEGER_TYPE:
5830
    case REAL_TYPE:
5831
    case BOOLEAN_TYPE:
5832
      return ((TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
5833
               || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
5834
                                      TYPE_MAX_VALUE (b->type)))
5835
              && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
5836
                  || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
5837
                                         TYPE_MIN_VALUE (b->type))));
5838
 
5839
    case FIXED_POINT_TYPE:
5840
      return TYPE_SATURATING (a->type) == TYPE_SATURATING (b->type);
5841
 
5842
    case OFFSET_TYPE:
5843
      return TYPE_OFFSET_BASETYPE (a->type) == TYPE_OFFSET_BASETYPE (b->type);
5844
 
5845
    case METHOD_TYPE:
5846
      return (TYPE_METHOD_BASETYPE (a->type) == TYPE_METHOD_BASETYPE (b->type)
5847
              && (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5848
                  || (TYPE_ARG_TYPES (a->type)
5849
                      && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5850
                      && TYPE_ARG_TYPES (b->type)
5851
                      && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5852
                      && type_list_equal (TYPE_ARG_TYPES (a->type),
5853
                                          TYPE_ARG_TYPES (b->type)))));
5854
 
5855
    case ARRAY_TYPE:
5856
      return TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type);
5857
 
5858
    case RECORD_TYPE:
5859
    case UNION_TYPE:
5860
    case QUAL_UNION_TYPE:
5861
      return (TYPE_FIELDS (a->type) == TYPE_FIELDS (b->type)
5862
              || (TYPE_FIELDS (a->type)
5863
                  && TREE_CODE (TYPE_FIELDS (a->type)) == TREE_LIST
5864
                  && TYPE_FIELDS (b->type)
5865
                  && TREE_CODE (TYPE_FIELDS (b->type)) == TREE_LIST
5866
                  && type_list_equal (TYPE_FIELDS (a->type),
5867
                                      TYPE_FIELDS (b->type))));
5868
 
5869
    case FUNCTION_TYPE:
5870
      if (TYPE_ARG_TYPES (a->type) == TYPE_ARG_TYPES (b->type)
5871
          || (TYPE_ARG_TYPES (a->type)
5872
              && TREE_CODE (TYPE_ARG_TYPES (a->type)) == TREE_LIST
5873
              && TYPE_ARG_TYPES (b->type)
5874
              && TREE_CODE (TYPE_ARG_TYPES (b->type)) == TREE_LIST
5875
              && type_list_equal (TYPE_ARG_TYPES (a->type),
5876
                                  TYPE_ARG_TYPES (b->type))))
5877
        break;
5878
      return 0;
5879
 
5880
    default:
5881
      return 0;
5882
    }
5883
 
5884
  if (lang_hooks.types.type_hash_eq != NULL)
5885
    return lang_hooks.types.type_hash_eq (a->type, b->type);
5886
 
5887
  return 1;
5888
}
5889
 
5890
/* Return the cached hash value.  */
5891
 
5892
static hashval_t
5893
type_hash_hash (const void *item)
5894
{
5895
  return ((const struct type_hash *) item)->hash;
5896
}
5897
 
5898
/* Look in the type hash table for a type isomorphic to TYPE.
5899
   If one is found, return it.  Otherwise return 0.  */
5900
 
5901
tree
5902
type_hash_lookup (hashval_t hashcode, tree type)
5903
{
5904
  struct type_hash *h, in;
5905
 
5906
  /* The TYPE_ALIGN field of a type is set by layout_type(), so we
5907
     must call that routine before comparing TYPE_ALIGNs.  */
5908
  layout_type (type);
5909
 
5910
  in.hash = hashcode;
5911
  in.type = type;
5912
 
5913
  h = (struct type_hash *) htab_find_with_hash (type_hash_table, &in,
5914
                                                hashcode);
5915
  if (h)
5916
    return h->type;
5917
  return NULL_TREE;
5918
}
5919
 
5920
/* Add an entry to the type-hash-table
5921
   for a type TYPE whose hash code is HASHCODE.  */
5922
 
5923
void
5924
type_hash_add (hashval_t hashcode, tree type)
5925
{
5926
  struct type_hash *h;
5927
  void **loc;
5928
 
5929
  h = GGC_NEW (struct type_hash);
5930
  h->hash = hashcode;
5931
  h->type = type;
5932
  loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
5933
  *loc = (void *)h;
5934
}
5935
 
5936
/* Given TYPE, and HASHCODE its hash code, return the canonical
5937
   object for an identical type if one already exists.
5938
   Otherwise, return TYPE, and record it as the canonical object.
5939
 
5940
   To use this function, first create a type of the sort you want.
5941
   Then compute its hash code from the fields of the type that
5942
   make it different from other similar types.
5943
   Then call this function and use the value.  */
5944
 
5945
tree
5946
type_hash_canon (unsigned int hashcode, tree type)
5947
{
5948
  tree t1;
5949
 
5950
  /* The hash table only contains main variants, so ensure that's what we're
5951
     being passed.  */
5952
  gcc_assert (TYPE_MAIN_VARIANT (type) == type);
5953
 
5954
  if (!lang_hooks.types.hash_types)
5955
    return type;
5956
 
5957
  /* See if the type is in the hash table already.  If so, return it.
5958
     Otherwise, add the type.  */
5959
  t1 = type_hash_lookup (hashcode, type);
5960
  if (t1 != 0)
5961
    {
5962
#ifdef GATHER_STATISTICS
5963
      tree_node_counts[(int) t_kind]--;
5964
      tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
5965
#endif
5966
      return t1;
5967
    }
5968
  else
5969
    {
5970
      type_hash_add (hashcode, type);
5971
      return type;
5972
    }
5973
}
5974
 
5975
/* See if the data pointed to by the type hash table is marked.  We consider
5976
   it marked if the type is marked or if a debug type number or symbol
5977
   table entry has been made for the type.  This reduces the amount of
5978
   debugging output and eliminates that dependency of the debug output on
5979
   the number of garbage collections.  */
5980
 
5981
static int
5982
type_hash_marked_p (const void *p)
5983
{
5984
  const_tree const type = ((const struct type_hash *) p)->type;
5985
 
5986
  return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
5987
}
5988
 
5989
static void
5990
print_type_hash_statistics (void)
5991
{
5992
  fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
5993
           (long) htab_size (type_hash_table),
5994
           (long) htab_elements (type_hash_table),
5995
           htab_collisions (type_hash_table));
5996
}
5997
 
5998
/* Compute a hash code for a list of attributes (chain of TREE_LIST nodes
5999
   with names in the TREE_PURPOSE slots and args in the TREE_VALUE slots),
6000
   by adding the hash codes of the individual attributes.  */
6001
 
6002
static unsigned int
6003
attribute_hash_list (const_tree list, hashval_t hashcode)
6004
{
6005
  const_tree tail;
6006
 
6007
  for (tail = list; tail; tail = TREE_CHAIN (tail))
6008
    /* ??? Do we want to add in TREE_VALUE too? */
6009
    hashcode = iterative_hash_object
6010
      (IDENTIFIER_HASH_VALUE (TREE_PURPOSE (tail)), hashcode);
6011
  return hashcode;
6012
}
6013
 
6014
/* Given two lists of attributes, return true if list l2 is
6015
   equivalent to l1.  */
6016
 
6017
int
6018
attribute_list_equal (const_tree l1, const_tree l2)
6019
{
6020
  return attribute_list_contained (l1, l2)
6021
         && attribute_list_contained (l2, l1);
6022
}
6023
 
6024
/* Given two lists of attributes, return true if list L2 is
6025
   completely contained within L1.  */
6026
/* ??? This would be faster if attribute names were stored in a canonicalized
6027
   form.  Otherwise, if L1 uses `foo' and L2 uses `__foo__', the long method
6028
   must be used to show these elements are equivalent (which they are).  */
6029
/* ??? It's not clear that attributes with arguments will always be handled
6030
   correctly.  */
6031
 
6032
int
6033
attribute_list_contained (const_tree l1, const_tree l2)
6034
{
6035
  const_tree t1, t2;
6036
 
6037
  /* First check the obvious, maybe the lists are identical.  */
6038
  if (l1 == l2)
6039
    return 1;
6040
 
6041
  /* Maybe the lists are similar.  */
6042
  for (t1 = l1, t2 = l2;
6043
       t1 != 0 && t2 != 0
6044
        && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
6045
        && TREE_VALUE (t1) == TREE_VALUE (t2);
6046
       t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
6047
 
6048
  /* Maybe the lists are equal.  */
6049
  if (t1 == 0 && t2 == 0)
6050
    return 1;
6051
 
6052
  for (; t2 != 0; t2 = TREE_CHAIN (t2))
6053
    {
6054
      const_tree attr;
6055
      /* This CONST_CAST is okay because lookup_attribute does not
6056
         modify its argument and the return value is assigned to a
6057
         const_tree.  */
6058
      for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6059
                                    CONST_CAST_TREE(l1));
6060
           attr != NULL_TREE;
6061
           attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
6062
                                    TREE_CHAIN (attr)))
6063
        {
6064
          if (TREE_VALUE (t2) != NULL
6065
              && TREE_CODE (TREE_VALUE (t2)) == TREE_LIST
6066
              && TREE_VALUE (attr) != NULL
6067
              && TREE_CODE (TREE_VALUE (attr)) == TREE_LIST)
6068
            {
6069
              if (simple_cst_list_equal (TREE_VALUE (t2),
6070
                                         TREE_VALUE (attr)) == 1)
6071
                break;
6072
            }
6073
          else if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
6074
            break;
6075
        }
6076
 
6077
      if (attr == 0)
6078
        return 0;
6079
    }
6080
 
6081
  return 1;
6082
}
6083
 
6084
/* Given two lists of types
6085
   (chains of TREE_LIST nodes with types in the TREE_VALUE slots)
6086
   return 1 if the lists contain the same types in the same order.
6087
   Also, the TREE_PURPOSEs must match.  */
6088
 
6089
int
6090
type_list_equal (const_tree l1, const_tree l2)
6091
{
6092
  const_tree t1, t2;
6093
 
6094
  for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
6095
    if (TREE_VALUE (t1) != TREE_VALUE (t2)
6096
        || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
6097
            && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
6098
                  && (TREE_TYPE (TREE_PURPOSE (t1))
6099
                      == TREE_TYPE (TREE_PURPOSE (t2))))))
6100
      return 0;
6101
 
6102
  return t1 == t2;
6103
}
6104
 
6105
/* Returns the number of arguments to the FUNCTION_TYPE or METHOD_TYPE
6106
   given by TYPE.  If the argument list accepts variable arguments,
6107
   then this function counts only the ordinary arguments.  */
6108
 
6109
int
6110
type_num_arguments (const_tree type)
6111
{
6112
  int i = 0;
6113
  tree t;
6114
 
6115
  for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
6116
    /* If the function does not take a variable number of arguments,
6117
       the last element in the list will have type `void'.  */
6118
    if (VOID_TYPE_P (TREE_VALUE (t)))
6119
      break;
6120
    else
6121
      ++i;
6122
 
6123
  return i;
6124
}
6125
 
6126
/* Nonzero if integer constants T1 and T2
6127
   represent the same constant value.  */
6128
 
6129
int
6130
tree_int_cst_equal (const_tree t1, const_tree t2)
6131
{
6132
  if (t1 == t2)
6133
    return 1;
6134
 
6135
  if (t1 == 0 || t2 == 0)
6136
    return 0;
6137
 
6138
  if (TREE_CODE (t1) == INTEGER_CST
6139
      && TREE_CODE (t2) == INTEGER_CST
6140
      && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6141
      && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
6142
    return 1;
6143
 
6144
  return 0;
6145
}
6146
 
6147
/* Nonzero if integer constants T1 and T2 represent values that satisfy <.
6148
   The precise way of comparison depends on their data type.  */
6149
 
6150
int
6151
tree_int_cst_lt (const_tree t1, const_tree t2)
6152
{
6153
  if (t1 == t2)
6154
    return 0;
6155
 
6156
  if (TYPE_UNSIGNED (TREE_TYPE (t1)) != TYPE_UNSIGNED (TREE_TYPE (t2)))
6157
    {
6158
      int t1_sgn = tree_int_cst_sgn (t1);
6159
      int t2_sgn = tree_int_cst_sgn (t2);
6160
 
6161
      if (t1_sgn < t2_sgn)
6162
        return 1;
6163
      else if (t1_sgn > t2_sgn)
6164
        return 0;
6165
      /* Otherwise, both are non-negative, so we compare them as
6166
         unsigned just in case one of them would overflow a signed
6167
         type.  */
6168
    }
6169
  else if (!TYPE_UNSIGNED (TREE_TYPE (t1)))
6170
    return INT_CST_LT (t1, t2);
6171
 
6172
  return INT_CST_LT_UNSIGNED (t1, t2);
6173
}
6174
 
6175
/* Returns -1 if T1 < T2, 0 if T1 == T2, and 1 if T1 > T2.  */
6176
 
6177
int
6178
tree_int_cst_compare (const_tree t1, const_tree t2)
6179
{
6180
  if (tree_int_cst_lt (t1, t2))
6181
    return -1;
6182
  else if (tree_int_cst_lt (t2, t1))
6183
    return 1;
6184
  else
6185
    return 0;
6186
}
6187
 
6188
/* Return 1 if T is an INTEGER_CST that can be manipulated efficiently on
6189
   the host.  If POS is zero, the value can be represented in a single
6190
   HOST_WIDE_INT.  If POS is nonzero, the value must be non-negative and can
6191
   be represented in a single unsigned HOST_WIDE_INT.  */
6192
 
6193
int
6194
host_integerp (const_tree t, int pos)
6195
{
6196
  if (t == NULL_TREE)
6197
    return 0;
6198
 
6199
  return (TREE_CODE (t) == INTEGER_CST
6200
          && ((TREE_INT_CST_HIGH (t) == 0
6201
               && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
6202
              || (! pos && TREE_INT_CST_HIGH (t) == -1
6203
                  && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
6204
                  && (!TYPE_UNSIGNED (TREE_TYPE (t))
6205
                      || (TREE_CODE (TREE_TYPE (t)) == INTEGER_TYPE
6206
                          && TYPE_IS_SIZETYPE (TREE_TYPE (t)))))
6207
              || (pos && TREE_INT_CST_HIGH (t) == 0)));
6208
}
6209
 
6210
/* Return the HOST_WIDE_INT least significant bits of T if it is an
6211
   INTEGER_CST and there is no overflow.  POS is nonzero if the result must
6212
   be non-negative.  We must be able to satisfy the above conditions.  */
6213
 
6214
HOST_WIDE_INT
6215
tree_low_cst (const_tree t, int pos)
6216
{
6217
  gcc_assert (host_integerp (t, pos));
6218
  return TREE_INT_CST_LOW (t);
6219
}
6220
 
6221
/* Return the most significant bit of the integer constant T.  */
6222
 
6223
int
6224
tree_int_cst_msb (const_tree t)
6225
{
6226
  int prec;
6227
  HOST_WIDE_INT h;
6228
  unsigned HOST_WIDE_INT l;
6229
 
6230
  /* Note that using TYPE_PRECISION here is wrong.  We care about the
6231
     actual bits, not the (arbitrary) range of the type.  */
6232
  prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
6233
  rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
6234
                 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
6235
  return (l & 1) == 1;
6236
}
6237
 
6238
/* Return an indication of the sign of the integer constant T.
6239
   The return value is -1 if T < 0, 0 if T == 0, and 1 if T > 0.
6240
   Note that -1 will never be returned if T's type is unsigned.  */
6241
 
6242
int
6243
tree_int_cst_sgn (const_tree t)
6244
{
6245
  if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
6246
    return 0;
6247
  else if (TYPE_UNSIGNED (TREE_TYPE (t)))
6248
    return 1;
6249
  else if (TREE_INT_CST_HIGH (t) < 0)
6250
    return -1;
6251
  else
6252
    return 1;
6253
}
6254
 
6255
/* Return the minimum number of bits needed to represent VALUE in a
6256
   signed or unsigned type, UNSIGNEDP says which.  */
6257
 
6258
unsigned int
6259
tree_int_cst_min_precision (tree value, bool unsignedp)
6260
{
6261
  int log;
6262
 
6263
  /* If the value is negative, compute its negative minus 1.  The latter
6264
     adjustment is because the absolute value of the largest negative value
6265
     is one larger than the largest positive value.  This is equivalent to
6266
     a bit-wise negation, so use that operation instead.  */
6267
 
6268
  if (tree_int_cst_sgn (value) < 0)
6269
    value = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (value), value);
6270
 
6271
  /* Return the number of bits needed, taking into account the fact
6272
     that we need one more bit for a signed than unsigned type.  */
6273
 
6274
  if (integer_zerop (value))
6275
    log = 0;
6276
  else
6277
    log = tree_floor_log2 (value);
6278
 
6279
  return log + 1 + !unsignedp;
6280
}
6281
 
6282
/* Compare two constructor-element-type constants.  Return 1 if the lists
6283
   are known to be equal; otherwise return 0.  */
6284
 
6285
int
6286
simple_cst_list_equal (const_tree l1, const_tree l2)
6287
{
6288
  while (l1 != NULL_TREE && l2 != NULL_TREE)
6289
    {
6290
      if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
6291
        return 0;
6292
 
6293
      l1 = TREE_CHAIN (l1);
6294
      l2 = TREE_CHAIN (l2);
6295
    }
6296
 
6297
  return l1 == l2;
6298
}
6299
 
6300
/* Return truthvalue of whether T1 is the same tree structure as T2.
6301
   Return 1 if they are the same.
6302
   Return 0 if they are understandably different.
6303
   Return -1 if either contains tree structure not understood by
6304
   this function.  */
6305
 
6306
int
6307
simple_cst_equal (const_tree t1, const_tree t2)
6308
{
6309
  enum tree_code code1, code2;
6310
  int cmp;
6311
  int i;
6312
 
6313
  if (t1 == t2)
6314
    return 1;
6315
  if (t1 == 0 || t2 == 0)
6316
    return 0;
6317
 
6318
  code1 = TREE_CODE (t1);
6319
  code2 = TREE_CODE (t2);
6320
 
6321
  if (CONVERT_EXPR_CODE_P (code1) || code1 == NON_LVALUE_EXPR)
6322
    {
6323
      if (CONVERT_EXPR_CODE_P (code2)
6324
          || code2 == NON_LVALUE_EXPR)
6325
        return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6326
      else
6327
        return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
6328
    }
6329
 
6330
  else if (CONVERT_EXPR_CODE_P (code2)
6331
           || code2 == NON_LVALUE_EXPR)
6332
    return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
6333
 
6334
  if (code1 != code2)
6335
    return 0;
6336
 
6337
  switch (code1)
6338
    {
6339
    case INTEGER_CST:
6340
      return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
6341
              && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
6342
 
6343
    case REAL_CST:
6344
      return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
6345
 
6346
    case FIXED_CST:
6347
      return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
6348
 
6349
    case STRING_CST:
6350
      return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
6351
              && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
6352
                         TREE_STRING_LENGTH (t1)));
6353
 
6354
    case CONSTRUCTOR:
6355
      {
6356
        unsigned HOST_WIDE_INT idx;
6357
        VEC(constructor_elt, gc) *v1 = CONSTRUCTOR_ELTS (t1);
6358
        VEC(constructor_elt, gc) *v2 = CONSTRUCTOR_ELTS (t2);
6359
 
6360
        if (VEC_length (constructor_elt, v1) != VEC_length (constructor_elt, v2))
6361
          return false;
6362
 
6363
        for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
6364
          /* ??? Should we handle also fields here? */
6365
          if (!simple_cst_equal (VEC_index (constructor_elt, v1, idx)->value,
6366
                                 VEC_index (constructor_elt, v2, idx)->value))
6367
            return false;
6368
        return true;
6369
      }
6370
 
6371
    case SAVE_EXPR:
6372
      return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6373
 
6374
    case CALL_EXPR:
6375
      cmp = simple_cst_equal (CALL_EXPR_FN (t1), CALL_EXPR_FN (t2));
6376
      if (cmp <= 0)
6377
        return cmp;
6378
      if (call_expr_nargs (t1) != call_expr_nargs (t2))
6379
        return 0;
6380
      {
6381
        const_tree arg1, arg2;
6382
        const_call_expr_arg_iterator iter1, iter2;
6383
        for (arg1 = first_const_call_expr_arg (t1, &iter1),
6384
               arg2 = first_const_call_expr_arg (t2, &iter2);
6385
             arg1 && arg2;
6386
             arg1 = next_const_call_expr_arg (&iter1),
6387
               arg2 = next_const_call_expr_arg (&iter2))
6388
          {
6389
            cmp = simple_cst_equal (arg1, arg2);
6390
            if (cmp <= 0)
6391
              return cmp;
6392
          }
6393
        return arg1 == arg2;
6394
      }
6395
 
6396
    case TARGET_EXPR:
6397
      /* Special case: if either target is an unallocated VAR_DECL,
6398
         it means that it's going to be unified with whatever the
6399
         TARGET_EXPR is really supposed to initialize, so treat it
6400
         as being equivalent to anything.  */
6401
      if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
6402
           && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
6403
           && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
6404
          || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
6405
              && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
6406
              && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
6407
        cmp = 1;
6408
      else
6409
        cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6410
 
6411
      if (cmp <= 0)
6412
        return cmp;
6413
 
6414
      return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
6415
 
6416
    case WITH_CLEANUP_EXPR:
6417
      cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6418
      if (cmp <= 0)
6419
        return cmp;
6420
 
6421
      return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
6422
 
6423
    case COMPONENT_REF:
6424
      if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
6425
        return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
6426
 
6427
      return 0;
6428
 
6429
    case VAR_DECL:
6430
    case PARM_DECL:
6431
    case CONST_DECL:
6432
    case FUNCTION_DECL:
6433
      return 0;
6434
 
6435
    default:
6436
      break;
6437
    }
6438
 
6439
  /* This general rule works for most tree codes.  All exceptions should be
6440
     handled above.  If this is a language-specific tree code, we can't
6441
     trust what might be in the operand, so say we don't know
6442
     the situation.  */
6443
  if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
6444
    return -1;
6445
 
6446
  switch (TREE_CODE_CLASS (code1))
6447
    {
6448
    case tcc_unary:
6449
    case tcc_binary:
6450
    case tcc_comparison:
6451
    case tcc_expression:
6452
    case tcc_reference:
6453
    case tcc_statement:
6454
      cmp = 1;
6455
      for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
6456
        {
6457
          cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
6458
          if (cmp <= 0)
6459
            return cmp;
6460
        }
6461
 
6462
      return cmp;
6463
 
6464
    default:
6465
      return -1;
6466
    }
6467
}
6468
 
6469
/* Compare the value of T, an INTEGER_CST, with U, an unsigned integer value.
6470
   Return -1, 0, or 1 if the value of T is less than, equal to, or greater
6471
   than U, respectively.  */
6472
 
6473
int
6474
compare_tree_int (const_tree t, unsigned HOST_WIDE_INT u)
6475
{
6476
  if (tree_int_cst_sgn (t) < 0)
6477
    return -1;
6478
  else if (TREE_INT_CST_HIGH (t) != 0)
6479
    return 1;
6480
  else if (TREE_INT_CST_LOW (t) == u)
6481
    return 0;
6482
  else if (TREE_INT_CST_LOW (t) < u)
6483
    return -1;
6484
  else
6485
    return 1;
6486
}
6487
 
6488
/* Return true if CODE represents an associative tree code.  Otherwise
6489
   return false.  */
6490
bool
6491
associative_tree_code (enum tree_code code)
6492
{
6493
  switch (code)
6494
    {
6495
    case BIT_IOR_EXPR:
6496
    case BIT_AND_EXPR:
6497
    case BIT_XOR_EXPR:
6498
    case PLUS_EXPR:
6499
    case MULT_EXPR:
6500
    case MIN_EXPR:
6501
    case MAX_EXPR:
6502
      return true;
6503
 
6504
    default:
6505
      break;
6506
    }
6507
  return false;
6508
}
6509
 
6510
/* Return true if CODE represents a commutative tree code.  Otherwise
6511
   return false.  */
6512
bool
6513
commutative_tree_code (enum tree_code code)
6514
{
6515
  switch (code)
6516
    {
6517
    case PLUS_EXPR:
6518
    case MULT_EXPR:
6519
    case MIN_EXPR:
6520
    case MAX_EXPR:
6521
    case BIT_IOR_EXPR:
6522
    case BIT_XOR_EXPR:
6523
    case BIT_AND_EXPR:
6524
    case NE_EXPR:
6525
    case EQ_EXPR:
6526
    case UNORDERED_EXPR:
6527
    case ORDERED_EXPR:
6528
    case UNEQ_EXPR:
6529
    case LTGT_EXPR:
6530
    case TRUTH_AND_EXPR:
6531
    case TRUTH_XOR_EXPR:
6532
    case TRUTH_OR_EXPR:
6533
      return true;
6534
 
6535
    default:
6536
      break;
6537
    }
6538
  return false;
6539
}
6540
 
6541
/* Generate a hash value for an expression.  This can be used iteratively
6542
   by passing a previous result as the VAL argument.
6543
 
6544
   This function is intended to produce the same hash for expressions which
6545
   would compare equal using operand_equal_p.  */
6546
 
6547
hashval_t
6548
iterative_hash_expr (const_tree t, hashval_t val)
6549
{
6550
  int i;
6551
  enum tree_code code;
6552
  char tclass;
6553
 
6554
  if (t == NULL_TREE)
6555
    return iterative_hash_hashval_t (0, val);
6556
 
6557
  code = TREE_CODE (t);
6558
 
6559
  switch (code)
6560
    {
6561
    /* Alas, constants aren't shared, so we can't rely on pointer
6562
       identity.  */
6563
    case INTEGER_CST:
6564
      val = iterative_hash_host_wide_int (TREE_INT_CST_LOW (t), val);
6565
      return iterative_hash_host_wide_int (TREE_INT_CST_HIGH (t), val);
6566
    case REAL_CST:
6567
      {
6568
        unsigned int val2 = real_hash (TREE_REAL_CST_PTR (t));
6569
 
6570
        return iterative_hash_hashval_t (val2, val);
6571
      }
6572
    case FIXED_CST:
6573
      {
6574
        unsigned int val2 = fixed_hash (TREE_FIXED_CST_PTR (t));
6575
 
6576
        return iterative_hash_hashval_t (val2, val);
6577
      }
6578
    case STRING_CST:
6579
      return iterative_hash (TREE_STRING_POINTER (t),
6580
                             TREE_STRING_LENGTH (t), val);
6581
    case COMPLEX_CST:
6582
      val = iterative_hash_expr (TREE_REALPART (t), val);
6583
      return iterative_hash_expr (TREE_IMAGPART (t), val);
6584
    case VECTOR_CST:
6585
      return iterative_hash_expr (TREE_VECTOR_CST_ELTS (t), val);
6586
 
6587
    case SSA_NAME:
6588
      /* we can just compare by pointer.  */
6589
      return iterative_hash_host_wide_int (SSA_NAME_VERSION (t), val);
6590
 
6591
    case TREE_LIST:
6592
      /* A list of expressions, for a CALL_EXPR or as the elements of a
6593
         VECTOR_CST.  */
6594
      for (; t; t = TREE_CHAIN (t))
6595
        val = iterative_hash_expr (TREE_VALUE (t), val);
6596
      return val;
6597
    case CONSTRUCTOR:
6598
      {
6599
        unsigned HOST_WIDE_INT idx;
6600
        tree field, value;
6601
        FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), idx, field, value)
6602
          {
6603
            val = iterative_hash_expr (field, val);
6604
            val = iterative_hash_expr (value, val);
6605
          }
6606
        return val;
6607
      }
6608
    case FUNCTION_DECL:
6609
      /* When referring to a built-in FUNCTION_DECL, use the __builtin__ form.
6610
         Otherwise nodes that compare equal according to operand_equal_p might
6611
         get different hash codes.  However, don't do this for machine specific
6612
         or front end builtins, since the function code is overloaded in those
6613
         cases.  */
6614
      if (DECL_BUILT_IN_CLASS (t) == BUILT_IN_NORMAL
6615
          && built_in_decls[DECL_FUNCTION_CODE (t)])
6616
        {
6617
          t = built_in_decls[DECL_FUNCTION_CODE (t)];
6618
          code = TREE_CODE (t);
6619
        }
6620
      /* FALL THROUGH */
6621
    default:
6622
      tclass = TREE_CODE_CLASS (code);
6623
 
6624
      if (tclass == tcc_declaration)
6625
        {
6626
          /* DECL's have a unique ID */
6627
          val = iterative_hash_host_wide_int (DECL_UID (t), val);
6628
        }
6629
      else
6630
        {
6631
          gcc_assert (IS_EXPR_CODE_CLASS (tclass));
6632
 
6633
          val = iterative_hash_object (code, val);
6634
 
6635
          /* Don't hash the type, that can lead to having nodes which
6636
             compare equal according to operand_equal_p, but which
6637
             have different hash codes.  */
6638
          if (CONVERT_EXPR_CODE_P (code)
6639
              || code == NON_LVALUE_EXPR)
6640
            {
6641
              /* Make sure to include signness in the hash computation.  */
6642
              val += TYPE_UNSIGNED (TREE_TYPE (t));
6643
              val = iterative_hash_expr (TREE_OPERAND (t, 0), val);
6644
            }
6645
 
6646
          else if (commutative_tree_code (code))
6647
            {
6648
              /* It's a commutative expression.  We want to hash it the same
6649
                 however it appears.  We do this by first hashing both operands
6650
                 and then rehashing based on the order of their independent
6651
                 hashes.  */
6652
              hashval_t one = iterative_hash_expr (TREE_OPERAND (t, 0), 0);
6653
              hashval_t two = iterative_hash_expr (TREE_OPERAND (t, 1), 0);
6654
              hashval_t t;
6655
 
6656
              if (one > two)
6657
                t = one, one = two, two = t;
6658
 
6659
              val = iterative_hash_hashval_t (one, val);
6660
              val = iterative_hash_hashval_t (two, val);
6661
            }
6662
          else
6663
            for (i = TREE_OPERAND_LENGTH (t) - 1; i >= 0; --i)
6664
              val = iterative_hash_expr (TREE_OPERAND (t, i), val);
6665
        }
6666
      return val;
6667
      break;
6668
    }
6669
}
6670
 
6671
/* Generate a hash value for a pair of expressions.  This can be used
6672
   iteratively by passing a previous result as the VAL argument.
6673
 
6674
   The same hash value is always returned for a given pair of expressions,
6675
   regardless of the order in which they are presented.  This is useful in
6676
   hashing the operands of commutative functions.  */
6677
 
6678
hashval_t
6679
iterative_hash_exprs_commutative (const_tree t1,
6680
                                  const_tree t2, hashval_t val)
6681
{
6682
  hashval_t one = iterative_hash_expr (t1, 0);
6683
  hashval_t two = iterative_hash_expr (t2, 0);
6684
  hashval_t t;
6685
 
6686
  if (one > two)
6687
    t = one, one = two, two = t;
6688
  val = iterative_hash_hashval_t (one, val);
6689
  val = iterative_hash_hashval_t (two, val);
6690
 
6691
  return val;
6692
}
6693
 
6694
/* Constructors for pointer, array and function types.
6695
   (RECORD_TYPE, UNION_TYPE and ENUMERAL_TYPE nodes are
6696
   constructed by language-dependent code, not here.)  */
6697
 
6698
/* Construct, lay out and return the type of pointers to TO_TYPE with
6699
   mode MODE.  If CAN_ALIAS_ALL is TRUE, indicate this type can
6700
   reference all of memory. If such a type has already been
6701
   constructed, reuse it.  */
6702
 
6703
tree
6704
build_pointer_type_for_mode (tree to_type, enum machine_mode mode,
6705
                             bool can_alias_all)
6706
{
6707
  tree t;
6708
 
6709
  if (to_type == error_mark_node)
6710
    return error_mark_node;
6711
 
6712
  /* If the pointed-to type has the may_alias attribute set, force
6713
     a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6714
  if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6715
    can_alias_all = true;
6716
 
6717
  /* In some cases, languages will have things that aren't a POINTER_TYPE
6718
     (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_POINTER_TO.
6719
     In that case, return that type without regard to the rest of our
6720
     operands.
6721
 
6722
     ??? This is a kludge, but consistent with the way this function has
6723
     always operated and there doesn't seem to be a good way to avoid this
6724
     at the moment.  */
6725
  if (TYPE_POINTER_TO (to_type) != 0
6726
      && TREE_CODE (TYPE_POINTER_TO (to_type)) != POINTER_TYPE)
6727
    return TYPE_POINTER_TO (to_type);
6728
 
6729
  /* First, if we already have a type for pointers to TO_TYPE and it's
6730
     the proper mode, use it.  */
6731
  for (t = TYPE_POINTER_TO (to_type); t; t = TYPE_NEXT_PTR_TO (t))
6732
    if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6733
      return t;
6734
 
6735
  t = make_node (POINTER_TYPE);
6736
 
6737
  TREE_TYPE (t) = to_type;
6738
  SET_TYPE_MODE (t, mode);
6739
  TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6740
  TYPE_NEXT_PTR_TO (t) = TYPE_POINTER_TO (to_type);
6741
  TYPE_POINTER_TO (to_type) = t;
6742
 
6743
  if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6744
    SET_TYPE_STRUCTURAL_EQUALITY (t);
6745
  else if (TYPE_CANONICAL (to_type) != to_type)
6746
    TYPE_CANONICAL (t)
6747
      = build_pointer_type_for_mode (TYPE_CANONICAL (to_type),
6748
                                     mode, can_alias_all);
6749
 
6750
  /* Lay out the type.  This function has many callers that are concerned
6751
     with expression-construction, and this simplifies them all.  */
6752
  layout_type (t);
6753
 
6754
  return t;
6755
}
6756
 
6757
/* By default build pointers in ptr_mode.  */
6758
 
6759
tree
6760
build_pointer_type (tree to_type)
6761
{
6762
  addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6763
                                              : TYPE_ADDR_SPACE (to_type);
6764
  enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6765
  return build_pointer_type_for_mode (to_type, pointer_mode, false);
6766
}
6767
 
6768
/* Same as build_pointer_type_for_mode, but for REFERENCE_TYPE.  */
6769
 
6770
tree
6771
build_reference_type_for_mode (tree to_type, enum machine_mode mode,
6772
                               bool can_alias_all)
6773
{
6774
  tree t;
6775
 
6776
  if (to_type == error_mark_node)
6777
    return error_mark_node;
6778
 
6779
  /* If the pointed-to type has the may_alias attribute set, force
6780
     a TYPE_REF_CAN_ALIAS_ALL pointer to be generated.  */
6781
  if (lookup_attribute ("may_alias", TYPE_ATTRIBUTES (to_type)))
6782
    can_alias_all = true;
6783
 
6784
  /* In some cases, languages will have things that aren't a REFERENCE_TYPE
6785
     (such as a RECORD_TYPE for fat pointers in Ada) as TYPE_REFERENCE_TO.
6786
     In that case, return that type without regard to the rest of our
6787
     operands.
6788
 
6789
     ??? This is a kludge, but consistent with the way this function has
6790
     always operated and there doesn't seem to be a good way to avoid this
6791
     at the moment.  */
6792
  if (TYPE_REFERENCE_TO (to_type) != 0
6793
      && TREE_CODE (TYPE_REFERENCE_TO (to_type)) != REFERENCE_TYPE)
6794
    return TYPE_REFERENCE_TO (to_type);
6795
 
6796
  /* First, if we already have a type for pointers to TO_TYPE and it's
6797
     the proper mode, use it.  */
6798
  for (t = TYPE_REFERENCE_TO (to_type); t; t = TYPE_NEXT_REF_TO (t))
6799
    if (TYPE_MODE (t) == mode && TYPE_REF_CAN_ALIAS_ALL (t) == can_alias_all)
6800
      return t;
6801
 
6802
  t = make_node (REFERENCE_TYPE);
6803
 
6804
  TREE_TYPE (t) = to_type;
6805
  SET_TYPE_MODE (t, mode);
6806
  TYPE_REF_CAN_ALIAS_ALL (t) = can_alias_all;
6807
  TYPE_NEXT_REF_TO (t) = TYPE_REFERENCE_TO (to_type);
6808
  TYPE_REFERENCE_TO (to_type) = t;
6809
 
6810
  if (TYPE_STRUCTURAL_EQUALITY_P (to_type))
6811
    SET_TYPE_STRUCTURAL_EQUALITY (t);
6812
  else if (TYPE_CANONICAL (to_type) != to_type)
6813
    TYPE_CANONICAL (t)
6814
      = build_reference_type_for_mode (TYPE_CANONICAL (to_type),
6815
                                       mode, can_alias_all);
6816
 
6817
  layout_type (t);
6818
 
6819
  return t;
6820
}
6821
 
6822
 
6823
/* Build the node for the type of references-to-TO_TYPE by default
6824
   in ptr_mode.  */
6825
 
6826
tree
6827
build_reference_type (tree to_type)
6828
{
6829
  addr_space_t as = to_type == error_mark_node? ADDR_SPACE_GENERIC
6830
                                              : TYPE_ADDR_SPACE (to_type);
6831
  enum machine_mode pointer_mode = targetm.addr_space.pointer_mode (as);
6832
  return build_reference_type_for_mode (to_type, pointer_mode, false);
6833
}
6834
 
6835
/* Build a type that is compatible with t but has no cv quals anywhere
6836
   in its type, thus
6837
 
6838
   const char *const *const *  ->  char ***.  */
6839
 
6840
tree
6841
build_type_no_quals (tree t)
6842
{
6843
  switch (TREE_CODE (t))
6844
    {
6845
    case POINTER_TYPE:
6846
      return build_pointer_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6847
                                          TYPE_MODE (t),
6848
                                          TYPE_REF_CAN_ALIAS_ALL (t));
6849
    case REFERENCE_TYPE:
6850
      return
6851
        build_reference_type_for_mode (build_type_no_quals (TREE_TYPE (t)),
6852
                                       TYPE_MODE (t),
6853
                                       TYPE_REF_CAN_ALIAS_ALL (t));
6854
    default:
6855
      return TYPE_MAIN_VARIANT (t);
6856
    }
6857
}
6858
 
6859
/* Create a type of integers to be the TYPE_DOMAIN of an ARRAY_TYPE.
6860
   MAXVAL should be the maximum value in the domain
6861
   (one less than the length of the array).
6862
 
6863
   The maximum value that MAXVAL can have is INT_MAX for a HOST_WIDE_INT.
6864
   We don't enforce this limit, that is up to caller (e.g. language front end).
6865
   The limit exists because the result is a signed type and we don't handle
6866
   sizes that use more than one HOST_WIDE_INT.  */
6867
 
6868
tree
6869
build_index_type (tree maxval)
6870
{
6871
  tree itype = make_node (INTEGER_TYPE);
6872
 
6873
  TREE_TYPE (itype) = sizetype;
6874
  TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
6875
  TYPE_MIN_VALUE (itype) = size_zero_node;
6876
  TYPE_MAX_VALUE (itype) = fold_convert (sizetype, maxval);
6877
  SET_TYPE_MODE (itype, TYPE_MODE (sizetype));
6878
  TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
6879
  TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
6880
  TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
6881
  TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
6882
 
6883
  if (host_integerp (maxval, 1))
6884
    return type_hash_canon (tree_low_cst (maxval, 1), itype);
6885
  else
6886
    {
6887
      /* Since we cannot hash this type, we need to compare it using
6888
         structural equality checks. */
6889
      SET_TYPE_STRUCTURAL_EQUALITY (itype);
6890
      return itype;
6891
    }
6892
}
6893
 
6894
/* Builds a signed or unsigned integer type of precision PRECISION.
6895
   Used for C bitfields whose precision does not match that of
6896
   built-in target types.  */
6897
tree
6898
build_nonstandard_integer_type (unsigned HOST_WIDE_INT precision,
6899
                                int unsignedp)
6900
{
6901
  tree itype = make_node (INTEGER_TYPE);
6902
 
6903
  TYPE_PRECISION (itype) = precision;
6904
 
6905
  if (unsignedp)
6906
    fixup_unsigned_type (itype);
6907
  else
6908
    fixup_signed_type (itype);
6909
 
6910
  if (host_integerp (TYPE_MAX_VALUE (itype), 1))
6911
    return type_hash_canon (tree_low_cst (TYPE_MAX_VALUE (itype), 1), itype);
6912
 
6913
  return itype;
6914
}
6915
 
6916
/* Create a range of some discrete type TYPE (an INTEGER_TYPE,
6917
   ENUMERAL_TYPE or BOOLEAN_TYPE), with low bound LOWVAL and
6918
   high bound HIGHVAL.  If TYPE is NULL, sizetype is used.  */
6919
 
6920
tree
6921
build_range_type (tree type, tree lowval, tree highval)
6922
{
6923
  tree itype = make_node (INTEGER_TYPE);
6924
 
6925
  TREE_TYPE (itype) = type;
6926
  if (type == NULL_TREE)
6927
    type = sizetype;
6928
 
6929
  TYPE_MIN_VALUE (itype) = fold_convert (type, lowval);
6930
  TYPE_MAX_VALUE (itype) = highval ? fold_convert (type, highval) : NULL;
6931
 
6932
  TYPE_PRECISION (itype) = TYPE_PRECISION (type);
6933
  SET_TYPE_MODE (itype, TYPE_MODE (type));
6934
  TYPE_SIZE (itype) = TYPE_SIZE (type);
6935
  TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
6936
  TYPE_ALIGN (itype) = TYPE_ALIGN (type);
6937
  TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
6938
 
6939
  if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
6940
    return type_hash_canon (tree_low_cst (highval, 0)
6941
                            - tree_low_cst (lowval, 0),
6942
                            itype);
6943
  else
6944
    return itype;
6945
}
6946
 
6947
/* Return true if the debug information for TYPE, a subtype, should be emitted
6948
   as a subrange type.  If so, set LOWVAL to the low bound and HIGHVAL to the
6949
   high bound, respectively.  Sometimes doing so unnecessarily obfuscates the
6950
   debug info and doesn't reflect the source code.  */
6951
 
6952
bool
6953
subrange_type_for_debug_p (const_tree type, tree *lowval, tree *highval)
6954
{
6955
  tree base_type = TREE_TYPE (type), low, high;
6956
 
6957
  /* Subrange types have a base type which is an integral type.  */
6958
  if (!INTEGRAL_TYPE_P (base_type))
6959
    return false;
6960
 
6961
  /* Get the real bounds of the subtype.  */
6962
  if (lang_hooks.types.get_subrange_bounds)
6963
    lang_hooks.types.get_subrange_bounds (type, &low, &high);
6964
  else
6965
    {
6966
      low = TYPE_MIN_VALUE (type);
6967
      high = TYPE_MAX_VALUE (type);
6968
    }
6969
 
6970
  /* If the type and its base type have the same representation and the same
6971
     name, then the type is not a subrange but a copy of the base type.  */
6972
  if ((TREE_CODE (base_type) == INTEGER_TYPE
6973
       || TREE_CODE (base_type) == BOOLEAN_TYPE)
6974
      && int_size_in_bytes (type) == int_size_in_bytes (base_type)
6975
      && tree_int_cst_equal (low, TYPE_MIN_VALUE (base_type))
6976
      && tree_int_cst_equal (high, TYPE_MAX_VALUE (base_type)))
6977
    {
6978
      tree type_name = TYPE_NAME (type);
6979
      tree base_type_name = TYPE_NAME (base_type);
6980
 
6981
      if (type_name && TREE_CODE (type_name) == TYPE_DECL)
6982
        type_name = DECL_NAME (type_name);
6983
 
6984
      if (base_type_name && TREE_CODE (base_type_name) == TYPE_DECL)
6985
        base_type_name = DECL_NAME (base_type_name);
6986
 
6987
      if (type_name == base_type_name)
6988
        return false;
6989
    }
6990
 
6991
  if (lowval)
6992
    *lowval = low;
6993
  if (highval)
6994
    *highval = high;
6995
  return true;
6996
}
6997
 
6998
/* Just like build_index_type, but takes lowval and highval instead
6999
   of just highval (maxval).  */
7000
 
7001
tree
7002
build_index_2_type (tree lowval, tree highval)
7003
{
7004
  return build_range_type (sizetype, lowval, highval);
7005
}
7006
 
7007
/* Construct, lay out and return the type of arrays of elements with ELT_TYPE
7008
   and number of elements specified by the range of values of INDEX_TYPE.
7009
   If such a type has already been constructed, reuse it.  */
7010
 
7011
tree
7012
build_array_type (tree elt_type, tree index_type)
7013
{
7014
  tree t;
7015
  hashval_t hashcode = 0;
7016
 
7017
  if (TREE_CODE (elt_type) == FUNCTION_TYPE)
7018
    {
7019
      error ("arrays of functions are not meaningful");
7020
      elt_type = integer_type_node;
7021
    }
7022
 
7023
  t = make_node (ARRAY_TYPE);
7024
  TREE_TYPE (t) = elt_type;
7025
  TYPE_DOMAIN (t) = index_type;
7026
  TYPE_ADDR_SPACE (t) = TYPE_ADDR_SPACE (elt_type);
7027
  layout_type (t);
7028
 
7029
  /* If the element type is incomplete at this point we get marked for
7030
     structural equality.  Do not record these types in the canonical
7031
     type hashtable.  */
7032
  if (TYPE_STRUCTURAL_EQUALITY_P (t))
7033
    return t;
7034
 
7035
  hashcode = iterative_hash_object (TYPE_HASH (elt_type), hashcode);
7036
  if (index_type)
7037
    hashcode = iterative_hash_object (TYPE_HASH (index_type), hashcode);
7038
  t = type_hash_canon (hashcode, t);
7039
 
7040
  if (TYPE_CANONICAL (t) == t)
7041
    {
7042
      if (TYPE_STRUCTURAL_EQUALITY_P (elt_type)
7043
          || (index_type && TYPE_STRUCTURAL_EQUALITY_P (index_type)))
7044
        SET_TYPE_STRUCTURAL_EQUALITY (t);
7045
      else if (TYPE_CANONICAL (elt_type) != elt_type
7046
               || (index_type && TYPE_CANONICAL (index_type) != index_type))
7047
        TYPE_CANONICAL (t)
7048
          = build_array_type (TYPE_CANONICAL (elt_type),
7049
                              index_type ? TYPE_CANONICAL (index_type) : NULL);
7050
    }
7051
 
7052
  return t;
7053
}
7054
 
7055
/* Recursively examines the array elements of TYPE, until a non-array
7056
   element type is found.  */
7057
 
7058
tree
7059
strip_array_types (tree type)
7060
{
7061
  while (TREE_CODE (type) == ARRAY_TYPE)
7062
    type = TREE_TYPE (type);
7063
 
7064
  return type;
7065
}
7066
 
7067
/* Computes the canonical argument types from the argument type list
7068
   ARGTYPES.
7069
 
7070
   Upon return, *ANY_STRUCTURAL_P will be true iff either it was true
7071
   on entry to this function, or if any of the ARGTYPES are
7072
   structural.
7073
 
7074
   Upon return, *ANY_NONCANONICAL_P will be true iff either it was
7075
   true on entry to this function, or if any of the ARGTYPES are
7076
   non-canonical.
7077
 
7078
   Returns a canonical argument list, which may be ARGTYPES when the
7079
   canonical argument list is unneeded (i.e., *ANY_STRUCTURAL_P is
7080
   true) or would not differ from ARGTYPES.  */
7081
 
7082
static tree
7083
maybe_canonicalize_argtypes(tree argtypes,
7084
                            bool *any_structural_p,
7085
                            bool *any_noncanonical_p)
7086
{
7087
  tree arg;
7088
  bool any_noncanonical_argtypes_p = false;
7089
 
7090
  for (arg = argtypes; arg && !(*any_structural_p); arg = TREE_CHAIN (arg))
7091
    {
7092
      if (!TREE_VALUE (arg) || TREE_VALUE (arg) == error_mark_node)
7093
        /* Fail gracefully by stating that the type is structural.  */
7094
        *any_structural_p = true;
7095
      else if (TYPE_STRUCTURAL_EQUALITY_P (TREE_VALUE (arg)))
7096
        *any_structural_p = true;
7097
      else if (TYPE_CANONICAL (TREE_VALUE (arg)) != TREE_VALUE (arg)
7098
               || TREE_PURPOSE (arg))
7099
        /* If the argument has a default argument, we consider it
7100
           non-canonical even though the type itself is canonical.
7101
           That way, different variants of function and method types
7102
           with default arguments will all point to the variant with
7103
           no defaults as their canonical type.  */
7104
        any_noncanonical_argtypes_p = true;
7105
    }
7106
 
7107
  if (*any_structural_p)
7108
    return argtypes;
7109
 
7110
  if (any_noncanonical_argtypes_p)
7111
    {
7112
      /* Build the canonical list of argument types.  */
7113
      tree canon_argtypes = NULL_TREE;
7114
      bool is_void = false;
7115
 
7116
      for (arg = argtypes; arg; arg = TREE_CHAIN (arg))
7117
        {
7118
          if (arg == void_list_node)
7119
            is_void = true;
7120
          else
7121
            canon_argtypes = tree_cons (NULL_TREE,
7122
                                        TYPE_CANONICAL (TREE_VALUE (arg)),
7123
                                        canon_argtypes);
7124
        }
7125
 
7126
      canon_argtypes = nreverse (canon_argtypes);
7127
      if (is_void)
7128
        canon_argtypes = chainon (canon_argtypes, void_list_node);
7129
 
7130
      /* There is a non-canonical type.  */
7131
      *any_noncanonical_p = true;
7132
      return canon_argtypes;
7133
    }
7134
 
7135
  /* The canonical argument types are the same as ARGTYPES.  */
7136
  return argtypes;
7137
}
7138
 
7139
/* Construct, lay out and return
7140
   the type of functions returning type VALUE_TYPE
7141
   given arguments of types ARG_TYPES.
7142
   ARG_TYPES is a chain of TREE_LIST nodes whose TREE_VALUEs
7143
   are data type nodes for the arguments of the function.
7144
   If such a type has already been constructed, reuse it.  */
7145
 
7146
tree
7147
build_function_type (tree value_type, tree arg_types)
7148
{
7149
  tree t;
7150
  hashval_t hashcode = 0;
7151
  bool any_structural_p, any_noncanonical_p;
7152
  tree canon_argtypes;
7153
 
7154
  if (TREE_CODE (value_type) == FUNCTION_TYPE)
7155
    {
7156
      error ("function return type cannot be function");
7157
      value_type = integer_type_node;
7158
    }
7159
 
7160
  /* Make a node of the sort we want.  */
7161
  t = make_node (FUNCTION_TYPE);
7162
  TREE_TYPE (t) = value_type;
7163
  TYPE_ARG_TYPES (t) = arg_types;
7164
 
7165
  /* If we already have such a type, use the old one.  */
7166
  hashcode = iterative_hash_object (TYPE_HASH (value_type), hashcode);
7167
  hashcode = type_hash_list (arg_types, hashcode);
7168
  t = type_hash_canon (hashcode, t);
7169
 
7170
  /* Set up the canonical type. */
7171
  any_structural_p   = TYPE_STRUCTURAL_EQUALITY_P (value_type);
7172
  any_noncanonical_p = TYPE_CANONICAL (value_type) != value_type;
7173
  canon_argtypes = maybe_canonicalize_argtypes (arg_types,
7174
                                                &any_structural_p,
7175
                                                &any_noncanonical_p);
7176
  if (any_structural_p)
7177
    SET_TYPE_STRUCTURAL_EQUALITY (t);
7178
  else if (any_noncanonical_p)
7179
    TYPE_CANONICAL (t) = build_function_type (TYPE_CANONICAL (value_type),
7180
                                              canon_argtypes);
7181
 
7182
  if (!COMPLETE_TYPE_P (t))
7183
    layout_type (t);
7184
  return t;
7185
}
7186
 
7187
/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.  */
7188
 
7189
tree
7190
build_function_type_skip_args (tree orig_type, bitmap args_to_skip)
7191
{
7192
  tree new_type = NULL;
7193
  tree args, new_args = NULL, t;
7194
  tree new_reversed;
7195
  int i = 0;
7196
 
7197
  for (args = TYPE_ARG_TYPES (orig_type); args && args != void_list_node;
7198
       args = TREE_CHAIN (args), i++)
7199
    if (!bitmap_bit_p (args_to_skip, i))
7200
      new_args = tree_cons (NULL_TREE, TREE_VALUE (args), new_args);
7201
 
7202
  new_reversed = nreverse (new_args);
7203
  if (args)
7204
    {
7205
      if (new_reversed)
7206
        TREE_CHAIN (new_args) = void_list_node;
7207
      else
7208
        new_reversed = void_list_node;
7209
    }
7210
 
7211
  /* Use copy_node to preserve as much as possible from original type
7212
     (debug info, attribute lists etc.)
7213
     Exception is METHOD_TYPEs must have THIS argument.
7214
     When we are asked to remove it, we need to build new FUNCTION_TYPE
7215
     instead.  */
7216
  if (TREE_CODE (orig_type) != METHOD_TYPE
7217
      || !bitmap_bit_p (args_to_skip, 0))
7218
    {
7219
      new_type = build_distinct_type_copy (orig_type);
7220
      TYPE_ARG_TYPES (new_type) = new_reversed;
7221
    }
7222
  else
7223
    {
7224
      new_type
7225
        = build_distinct_type_copy (build_function_type (TREE_TYPE (orig_type),
7226
                                                         new_reversed));
7227
      TYPE_CONTEXT (new_type) = TYPE_CONTEXT (orig_type);
7228
    }
7229
 
7230
  /* This is a new type, not a copy of an old type.  Need to reassociate
7231
     variants.  We can handle everything except the main variant lazily.  */
7232
  t = TYPE_MAIN_VARIANT (orig_type);
7233
  if (orig_type != t)
7234
    {
7235
      TYPE_MAIN_VARIANT (new_type) = t;
7236
      TYPE_NEXT_VARIANT (new_type) = TYPE_NEXT_VARIANT (t);
7237
      TYPE_NEXT_VARIANT (t) = new_type;
7238
    }
7239
  else
7240
    {
7241
      TYPE_MAIN_VARIANT (new_type) = new_type;
7242
      TYPE_NEXT_VARIANT (new_type) = NULL;
7243
    }
7244
  return new_type;
7245
}
7246
 
7247
/* Build variant of function type ORIG_TYPE skipping ARGS_TO_SKIP.
7248
 
7249
   Arguments from DECL_ARGUMENTS list can't be removed now, since they are
7250
   linked by TREE_CHAIN directly.  It is caller responsibility to eliminate
7251
   them when they are being duplicated (i.e. copy_arguments_for_versioning).  */
7252
 
7253
tree
7254
build_function_decl_skip_args (tree orig_decl, bitmap args_to_skip)
7255
{
7256
  tree new_decl = copy_node (orig_decl);
7257
  tree new_type;
7258
 
7259
  new_type = TREE_TYPE (orig_decl);
7260
  if (prototype_p (new_type))
7261
    new_type = build_function_type_skip_args (new_type, args_to_skip);
7262
  TREE_TYPE (new_decl) = new_type;
7263
 
7264
  /* For declarations setting DECL_VINDEX (i.e. methods)
7265
     we expect first argument to be THIS pointer.   */
7266
  if (bitmap_bit_p (args_to_skip, 0))
7267
    DECL_VINDEX (new_decl) = NULL_TREE;
7268
 
7269
  /* When signature changes, we need to clear builtin info.  */
7270
  if (DECL_BUILT_IN (new_decl) && !bitmap_empty_p (args_to_skip))
7271
    {
7272
      DECL_BUILT_IN_CLASS (new_decl) = NOT_BUILT_IN;
7273
      DECL_FUNCTION_CODE (new_decl) = (enum built_in_function) 0;
7274
    }
7275
  return new_decl;
7276
}
7277
 
7278
/* Build a function type.  The RETURN_TYPE is the type returned by the
7279
   function. If VAARGS is set, no void_type_node is appended to the
7280
   the list. ARGP muse be alway be terminated be a NULL_TREE.  */
7281
 
7282
static tree
7283
build_function_type_list_1 (bool vaargs, tree return_type, va_list argp)
7284
{
7285
  tree t, args, last;
7286
 
7287
  t = va_arg (argp, tree);
7288
  for (args = NULL_TREE; t != NULL_TREE; t = va_arg (argp, tree))
7289
    args = tree_cons (NULL_TREE, t, args);
7290
 
7291
  if (vaargs)
7292
    {
7293
      last = args;
7294
      if (args != NULL_TREE)
7295
        args = nreverse (args);
7296
      gcc_assert (args != NULL_TREE && last != void_list_node);
7297
    }
7298
  else if (args == NULL_TREE)
7299
    args = void_list_node;
7300
  else
7301
    {
7302
      last = args;
7303
      args = nreverse (args);
7304
      TREE_CHAIN (last) = void_list_node;
7305
    }
7306
  args = build_function_type (return_type, args);
7307
 
7308
  return args;
7309
}
7310
 
7311
/* Build a function type.  The RETURN_TYPE is the type returned by the
7312
   function.  If additional arguments are provided, they are
7313
   additional argument types.  The list of argument types must always
7314
   be terminated by NULL_TREE.  */
7315
 
7316
tree
7317
build_function_type_list (tree return_type, ...)
7318
{
7319
  tree args;
7320
  va_list p;
7321
 
7322
  va_start (p, return_type);
7323
  args = build_function_type_list_1 (false, return_type, p);
7324
  va_end (p);
7325
  return args;
7326
}
7327
 
7328
/* Build a variable argument function type.  The RETURN_TYPE is the
7329
   type returned by the function.  If additional arguments are provided,
7330
   they are additional argument types.  The list of argument types must
7331
   always be terminated by NULL_TREE.  */
7332
 
7333
tree
7334
build_varargs_function_type_list (tree return_type, ...)
7335
{
7336
  tree args;
7337
  va_list p;
7338
 
7339
  va_start (p, return_type);
7340
  args = build_function_type_list_1 (true, return_type, p);
7341
  va_end (p);
7342
 
7343
  return args;
7344
}
7345
 
7346
/* Build a METHOD_TYPE for a member of BASETYPE.  The RETTYPE (a TYPE)
7347
   and ARGTYPES (a TREE_LIST) are the return type and arguments types
7348
   for the method.  An implicit additional parameter (of type
7349
   pointer-to-BASETYPE) is added to the ARGTYPES.  */
7350
 
7351
tree
7352
build_method_type_directly (tree basetype,
7353
                            tree rettype,
7354
                            tree argtypes)
7355
{
7356
  tree t;
7357
  tree ptype;
7358
  int hashcode = 0;
7359
  bool any_structural_p, any_noncanonical_p;
7360
  tree canon_argtypes;
7361
 
7362
  /* Make a node of the sort we want.  */
7363
  t = make_node (METHOD_TYPE);
7364
 
7365
  TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7366
  TREE_TYPE (t) = rettype;
7367
  ptype = build_pointer_type (basetype);
7368
 
7369
  /* The actual arglist for this function includes a "hidden" argument
7370
     which is "this".  Put it into the list of argument types.  */
7371
  argtypes = tree_cons (NULL_TREE, ptype, argtypes);
7372
  TYPE_ARG_TYPES (t) = argtypes;
7373
 
7374
  /* If we already have such a type, use the old one.  */
7375
  hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7376
  hashcode = iterative_hash_object (TYPE_HASH (rettype), hashcode);
7377
  hashcode = type_hash_list (argtypes, hashcode);
7378
  t = type_hash_canon (hashcode, t);
7379
 
7380
  /* Set up the canonical type. */
7381
  any_structural_p
7382
    = (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7383
       || TYPE_STRUCTURAL_EQUALITY_P (rettype));
7384
  any_noncanonical_p
7385
    = (TYPE_CANONICAL (basetype) != basetype
7386
       || TYPE_CANONICAL (rettype) != rettype);
7387
  canon_argtypes = maybe_canonicalize_argtypes (TREE_CHAIN (argtypes),
7388
                                                &any_structural_p,
7389
                                                &any_noncanonical_p);
7390
  if (any_structural_p)
7391
    SET_TYPE_STRUCTURAL_EQUALITY (t);
7392
  else if (any_noncanonical_p)
7393
    TYPE_CANONICAL (t)
7394
      = build_method_type_directly (TYPE_CANONICAL (basetype),
7395
                                    TYPE_CANONICAL (rettype),
7396
                                    canon_argtypes);
7397
  if (!COMPLETE_TYPE_P (t))
7398
    layout_type (t);
7399
 
7400
  return t;
7401
}
7402
 
7403
/* Construct, lay out and return the type of methods belonging to class
7404
   BASETYPE and whose arguments and values are described by TYPE.
7405
   If that type exists already, reuse it.
7406
   TYPE must be a FUNCTION_TYPE node.  */
7407
 
7408
tree
7409
build_method_type (tree basetype, tree type)
7410
{
7411
  gcc_assert (TREE_CODE (type) == FUNCTION_TYPE);
7412
 
7413
  return build_method_type_directly (basetype,
7414
                                     TREE_TYPE (type),
7415
                                     TYPE_ARG_TYPES (type));
7416
}
7417
 
7418
/* Construct, lay out and return the type of offsets to a value
7419
   of type TYPE, within an object of type BASETYPE.
7420
   If a suitable offset type exists already, reuse it.  */
7421
 
7422
tree
7423
build_offset_type (tree basetype, tree type)
7424
{
7425
  tree t;
7426
  hashval_t hashcode = 0;
7427
 
7428
  /* Make a node of the sort we want.  */
7429
  t = make_node (OFFSET_TYPE);
7430
 
7431
  TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
7432
  TREE_TYPE (t) = type;
7433
 
7434
  /* If we already have such a type, use the old one.  */
7435
  hashcode = iterative_hash_object (TYPE_HASH (basetype), hashcode);
7436
  hashcode = iterative_hash_object (TYPE_HASH (type), hashcode);
7437
  t = type_hash_canon (hashcode, t);
7438
 
7439
  if (!COMPLETE_TYPE_P (t))
7440
    layout_type (t);
7441
 
7442
  if (TYPE_CANONICAL (t) == t)
7443
    {
7444
      if (TYPE_STRUCTURAL_EQUALITY_P (basetype)
7445
          || TYPE_STRUCTURAL_EQUALITY_P (type))
7446
        SET_TYPE_STRUCTURAL_EQUALITY (t);
7447
      else if (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)) != basetype
7448
               || TYPE_CANONICAL (type) != type)
7449
        TYPE_CANONICAL (t)
7450
          = build_offset_type (TYPE_CANONICAL (TYPE_MAIN_VARIANT (basetype)),
7451
                               TYPE_CANONICAL (type));
7452
    }
7453
 
7454
  return t;
7455
}
7456
 
7457
/* Create a complex type whose components are COMPONENT_TYPE.  */
7458
 
7459
tree
7460
build_complex_type (tree component_type)
7461
{
7462
  tree t;
7463
  hashval_t hashcode;
7464
 
7465
  gcc_assert (INTEGRAL_TYPE_P (component_type)
7466
              || SCALAR_FLOAT_TYPE_P (component_type)
7467
              || FIXED_POINT_TYPE_P (component_type));
7468
 
7469
  /* Make a node of the sort we want.  */
7470
  t = make_node (COMPLEX_TYPE);
7471
 
7472
  TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
7473
 
7474
  /* If we already have such a type, use the old one.  */
7475
  hashcode = iterative_hash_object (TYPE_HASH (component_type), 0);
7476
  t = type_hash_canon (hashcode, t);
7477
 
7478
  if (!COMPLETE_TYPE_P (t))
7479
    layout_type (t);
7480
 
7481
  if (TYPE_CANONICAL (t) == t)
7482
    {
7483
      if (TYPE_STRUCTURAL_EQUALITY_P (component_type))
7484
        SET_TYPE_STRUCTURAL_EQUALITY (t);
7485
      else if (TYPE_CANONICAL (component_type) != component_type)
7486
        TYPE_CANONICAL (t)
7487
          = build_complex_type (TYPE_CANONICAL (component_type));
7488
    }
7489
 
7490
  /* We need to create a name, since complex is a fundamental type.  */
7491
  if (! TYPE_NAME (t))
7492
    {
7493
      const char *name;
7494
      if (component_type == char_type_node)
7495
        name = "complex char";
7496
      else if (component_type == signed_char_type_node)
7497
        name = "complex signed char";
7498
      else if (component_type == unsigned_char_type_node)
7499
        name = "complex unsigned char";
7500
      else if (component_type == short_integer_type_node)
7501
        name = "complex short int";
7502
      else if (component_type == short_unsigned_type_node)
7503
        name = "complex short unsigned int";
7504
      else if (component_type == integer_type_node)
7505
        name = "complex int";
7506
      else if (component_type == unsigned_type_node)
7507
        name = "complex unsigned int";
7508
      else if (component_type == long_integer_type_node)
7509
        name = "complex long int";
7510
      else if (component_type == long_unsigned_type_node)
7511
        name = "complex long unsigned int";
7512
      else if (component_type == long_long_integer_type_node)
7513
        name = "complex long long int";
7514
      else if (component_type == long_long_unsigned_type_node)
7515
        name = "complex long long unsigned int";
7516
      else
7517
        name = 0;
7518
 
7519
      if (name != 0)
7520
        TYPE_NAME (t) = build_decl (UNKNOWN_LOCATION, TYPE_DECL,
7521
                                    get_identifier (name), t);
7522
    }
7523
 
7524
  return build_qualified_type (t, TYPE_QUALS (component_type));
7525
}
7526
 
7527
/* If TYPE is a real or complex floating-point type and the target
7528
   does not directly support arithmetic on TYPE then return the wider
7529
   type to be used for arithmetic on TYPE.  Otherwise, return
7530
   NULL_TREE.  */
7531
 
7532
tree
7533
excess_precision_type (tree type)
7534
{
7535
  if (flag_excess_precision != EXCESS_PRECISION_FAST)
7536
    {
7537
      int flt_eval_method = TARGET_FLT_EVAL_METHOD;
7538
      switch (TREE_CODE (type))
7539
        {
7540
        case REAL_TYPE:
7541
          switch (flt_eval_method)
7542
            {
7543
            case 1:
7544
              if (TYPE_MODE (type) == TYPE_MODE (float_type_node))
7545
                return double_type_node;
7546
              break;
7547
            case 2:
7548
              if (TYPE_MODE (type) == TYPE_MODE (float_type_node)
7549
                  || TYPE_MODE (type) == TYPE_MODE (double_type_node))
7550
                return long_double_type_node;
7551
              break;
7552
            default:
7553
              gcc_unreachable ();
7554
            }
7555
          break;
7556
        case COMPLEX_TYPE:
7557
          if (TREE_CODE (TREE_TYPE (type)) != REAL_TYPE)
7558
            return NULL_TREE;
7559
          switch (flt_eval_method)
7560
            {
7561
            case 1:
7562
              if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node))
7563
                return complex_double_type_node;
7564
              break;
7565
            case 2:
7566
              if (TYPE_MODE (TREE_TYPE (type)) == TYPE_MODE (float_type_node)
7567
                  || (TYPE_MODE (TREE_TYPE (type))
7568
                      == TYPE_MODE (double_type_node)))
7569
                return complex_long_double_type_node;
7570
              break;
7571
            default:
7572
              gcc_unreachable ();
7573
            }
7574
          break;
7575
        default:
7576
          break;
7577
        }
7578
    }
7579
  return NULL_TREE;
7580
}
7581
 
7582
/* Return OP, stripped of any conversions to wider types as much as is safe.
7583
   Converting the value back to OP's type makes a value equivalent to OP.
7584
 
7585
   If FOR_TYPE is nonzero, we return a value which, if converted to
7586
   type FOR_TYPE, would be equivalent to converting OP to type FOR_TYPE.
7587
 
7588
   OP must have integer, real or enumeral type.  Pointers are not allowed!
7589
 
7590
   There are some cases where the obvious value we could return
7591
   would regenerate to OP if converted to OP's type,
7592
   but would not extend like OP to wider types.
7593
   If FOR_TYPE indicates such extension is contemplated, we eschew such values.
7594
   For example, if OP is (unsigned short)(signed char)-1,
7595
   we avoid returning (signed char)-1 if FOR_TYPE is int,
7596
   even though extending that to an unsigned short would regenerate OP,
7597
   since the result of extending (signed char)-1 to (int)
7598
   is different from (int) OP.  */
7599
 
7600
tree
7601
get_unwidened (tree op, tree for_type)
7602
{
7603
  /* Set UNS initially if converting OP to FOR_TYPE is a zero-extension.  */
7604
  tree type = TREE_TYPE (op);
7605
  unsigned final_prec
7606
    = TYPE_PRECISION (for_type != 0 ? for_type : type);
7607
  int uns
7608
    = (for_type != 0 && for_type != type
7609
       && final_prec > TYPE_PRECISION (type)
7610
       && TYPE_UNSIGNED (type));
7611
  tree win = op;
7612
 
7613
  while (CONVERT_EXPR_P (op))
7614
    {
7615
      int bitschange;
7616
 
7617
      /* TYPE_PRECISION on vector types has different meaning
7618
         (TYPE_VECTOR_SUBPARTS) and casts from vectors are view conversions,
7619
         so avoid them here.  */
7620
      if (TREE_CODE (TREE_TYPE (TREE_OPERAND (op, 0))) == VECTOR_TYPE)
7621
        break;
7622
 
7623
      bitschange = TYPE_PRECISION (TREE_TYPE (op))
7624
                   - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
7625
 
7626
      /* Truncations are many-one so cannot be removed.
7627
         Unless we are later going to truncate down even farther.  */
7628
      if (bitschange < 0
7629
          && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
7630
        break;
7631
 
7632
      /* See what's inside this conversion.  If we decide to strip it,
7633
         we will set WIN.  */
7634
      op = TREE_OPERAND (op, 0);
7635
 
7636
      /* If we have not stripped any zero-extensions (uns is 0),
7637
         we can strip any kind of extension.
7638
         If we have previously stripped a zero-extension,
7639
         only zero-extensions can safely be stripped.
7640
         Any extension can be stripped if the bits it would produce
7641
         are all going to be discarded later by truncating to FOR_TYPE.  */
7642
 
7643
      if (bitschange > 0)
7644
        {
7645
          if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
7646
            win = op;
7647
          /* TYPE_UNSIGNED says whether this is a zero-extension.
7648
             Let's avoid computing it if it does not affect WIN
7649
             and if UNS will not be needed again.  */
7650
          if ((uns
7651
               || CONVERT_EXPR_P (op))
7652
              && TYPE_UNSIGNED (TREE_TYPE (op)))
7653
            {
7654
              uns = 1;
7655
              win = op;
7656
            }
7657
        }
7658
    }
7659
 
7660
  /* If we finally reach a constant see if it fits in for_type and
7661
     in that case convert it.  */
7662
  if (for_type
7663
      && TREE_CODE (win) == INTEGER_CST
7664
      && TREE_TYPE (win) != for_type
7665
      && int_fits_type_p (win, for_type))
7666
    win = fold_convert (for_type, win);
7667
 
7668
  return win;
7669
}
7670
 
7671
/* Return OP or a simpler expression for a narrower value
7672
   which can be sign-extended or zero-extended to give back OP.
7673
   Store in *UNSIGNEDP_PTR either 1 if the value should be zero-extended
7674
   or 0 if the value should be sign-extended.  */
7675
 
7676
tree
7677
get_narrower (tree op, int *unsignedp_ptr)
7678
{
7679
  int uns = 0;
7680
  int first = 1;
7681
  tree win = op;
7682
  bool integral_p = INTEGRAL_TYPE_P (TREE_TYPE (op));
7683
 
7684
  while (TREE_CODE (op) == NOP_EXPR)
7685
    {
7686
      int bitschange
7687
        = (TYPE_PRECISION (TREE_TYPE (op))
7688
           - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
7689
 
7690
      /* Truncations are many-one so cannot be removed.  */
7691
      if (bitschange < 0)
7692
        break;
7693
 
7694
      /* See what's inside this conversion.  If we decide to strip it,
7695
         we will set WIN.  */
7696
 
7697
      if (bitschange > 0)
7698
        {
7699
          op = TREE_OPERAND (op, 0);
7700
          /* An extension: the outermost one can be stripped,
7701
             but remember whether it is zero or sign extension.  */
7702
          if (first)
7703
            uns = TYPE_UNSIGNED (TREE_TYPE (op));
7704
          /* Otherwise, if a sign extension has been stripped,
7705
             only sign extensions can now be stripped;
7706
             if a zero extension has been stripped, only zero-extensions.  */
7707
          else if (uns != TYPE_UNSIGNED (TREE_TYPE (op)))
7708
            break;
7709
          first = 0;
7710
        }
7711
      else /* bitschange == 0 */
7712
        {
7713
          /* A change in nominal type can always be stripped, but we must
7714
             preserve the unsignedness.  */
7715
          if (first)
7716
            uns = TYPE_UNSIGNED (TREE_TYPE (op));
7717
          first = 0;
7718
          op = TREE_OPERAND (op, 0);
7719
          /* Keep trying to narrow, but don't assign op to win if it
7720
             would turn an integral type into something else.  */
7721
          if (INTEGRAL_TYPE_P (TREE_TYPE (op)) != integral_p)
7722
            continue;
7723
        }
7724
 
7725
      win = op;
7726
    }
7727
 
7728
  if (TREE_CODE (op) == COMPONENT_REF
7729
      /* Since type_for_size always gives an integer type.  */
7730
      && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
7731
      && TREE_CODE (TREE_TYPE (op)) != FIXED_POINT_TYPE
7732
      /* Ensure field is laid out already.  */
7733
      && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
7734
      && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
7735
    {
7736
      unsigned HOST_WIDE_INT innerprec
7737
        = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
7738
      int unsignedp = (DECL_UNSIGNED (TREE_OPERAND (op, 1))
7739
                       || TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (op, 1))));
7740
      tree type = lang_hooks.types.type_for_size (innerprec, unsignedp);
7741
 
7742
      /* We can get this structure field in a narrower type that fits it,
7743
         but the resulting extension to its nominal type (a fullword type)
7744
         must satisfy the same conditions as for other extensions.
7745
 
7746
         Do this only for fields that are aligned (not bit-fields),
7747
         because when bit-field insns will be used there is no
7748
         advantage in doing this.  */
7749
 
7750
      if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
7751
          && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
7752
          && (first || uns == DECL_UNSIGNED (TREE_OPERAND (op, 1)))
7753
          && type != 0)
7754
        {
7755
          if (first)
7756
            uns = DECL_UNSIGNED (TREE_OPERAND (op, 1));
7757
          win = fold_convert (type, op);
7758
        }
7759
    }
7760
 
7761
  *unsignedp_ptr = uns;
7762
  return win;
7763
}
7764
 
7765
/* Nonzero if integer constant C has a value that is permissible
7766
   for type TYPE (an INTEGER_TYPE).  */
7767
 
7768
int
7769
int_fits_type_p (const_tree c, const_tree type)
7770
{
7771
  tree type_low_bound, type_high_bound;
7772
  bool ok_for_low_bound, ok_for_high_bound, unsc;
7773
  double_int dc, dd;
7774
 
7775
  dc = tree_to_double_int (c);
7776
  unsc = TYPE_UNSIGNED (TREE_TYPE (c));
7777
 
7778
  if (TREE_CODE (TREE_TYPE (c)) == INTEGER_TYPE
7779
      && TYPE_IS_SIZETYPE (TREE_TYPE (c))
7780
      && unsc)
7781
    /* So c is an unsigned integer whose type is sizetype and type is not.
7782
       sizetype'd integers are sign extended even though they are
7783
       unsigned. If the integer value fits in the lower end word of c,
7784
       and if the higher end word has all its bits set to 1, that
7785
       means the higher end bits are set to 1 only for sign extension.
7786
       So let's convert c into an equivalent zero extended unsigned
7787
       integer.  */
7788
    dc = double_int_zext (dc, TYPE_PRECISION (TREE_TYPE (c)));
7789
 
7790
retry:
7791
  type_low_bound = TYPE_MIN_VALUE (type);
7792
  type_high_bound = TYPE_MAX_VALUE (type);
7793
 
7794
  /* If at least one bound of the type is a constant integer, we can check
7795
     ourselves and maybe make a decision. If no such decision is possible, but
7796
     this type is a subtype, try checking against that.  Otherwise, use
7797
     fit_double_type, which checks against the precision.
7798
 
7799
     Compute the status for each possibly constant bound, and return if we see
7800
     one does not match. Use ok_for_xxx_bound for this purpose, assigning -1
7801
     for "unknown if constant fits", 0 for "constant known *not* to fit" and 1
7802
     for "constant known to fit".  */
7803
 
7804
  /* Check if c >= type_low_bound.  */
7805
  if (type_low_bound && TREE_CODE (type_low_bound) == INTEGER_CST)
7806
    {
7807
      dd = tree_to_double_int (type_low_bound);
7808
      if (TREE_CODE (type) == INTEGER_TYPE
7809
          && TYPE_IS_SIZETYPE (type)
7810
          && TYPE_UNSIGNED (type))
7811
        dd = double_int_zext (dd, TYPE_PRECISION (type));
7812
      if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_low_bound)))
7813
        {
7814
          int c_neg = (!unsc && double_int_negative_p (dc));
7815
          int t_neg = (unsc && double_int_negative_p (dd));
7816
 
7817
          if (c_neg && !t_neg)
7818
            return 0;
7819
          if ((c_neg || !t_neg) && double_int_ucmp (dc, dd) < 0)
7820
            return 0;
7821
        }
7822
      else if (double_int_cmp (dc, dd, unsc) < 0)
7823
        return 0;
7824
      ok_for_low_bound = true;
7825
    }
7826
  else
7827
    ok_for_low_bound = false;
7828
 
7829
  /* Check if c <= type_high_bound.  */
7830
  if (type_high_bound && TREE_CODE (type_high_bound) == INTEGER_CST)
7831
    {
7832
      dd = tree_to_double_int (type_high_bound);
7833
      if (TREE_CODE (type) == INTEGER_TYPE
7834
          && TYPE_IS_SIZETYPE (type)
7835
          && TYPE_UNSIGNED (type))
7836
        dd = double_int_zext (dd, TYPE_PRECISION (type));
7837
      if (unsc != TYPE_UNSIGNED (TREE_TYPE (type_high_bound)))
7838
        {
7839
          int c_neg = (!unsc && double_int_negative_p (dc));
7840
          int t_neg = (unsc && double_int_negative_p (dd));
7841
 
7842
          if (t_neg && !c_neg)
7843
            return 0;
7844
          if ((t_neg || !c_neg) && double_int_ucmp (dc, dd) > 0)
7845
            return 0;
7846
        }
7847
      else if (double_int_cmp (dc, dd, unsc) > 0)
7848
        return 0;
7849
      ok_for_high_bound = true;
7850
    }
7851
  else
7852
    ok_for_high_bound = false;
7853
 
7854
  /* If the constant fits both bounds, the result is known.  */
7855
  if (ok_for_low_bound && ok_for_high_bound)
7856
    return 1;
7857
 
7858
  /* Perform some generic filtering which may allow making a decision
7859
     even if the bounds are not constant.  First, negative integers
7860
     never fit in unsigned types, */
7861
  if (TYPE_UNSIGNED (type) && !unsc && double_int_negative_p (dc))
7862
    return 0;
7863
 
7864
  /* Second, narrower types always fit in wider ones.  */
7865
  if (TYPE_PRECISION (type) > TYPE_PRECISION (TREE_TYPE (c)))
7866
    return 1;
7867
 
7868
  /* Third, unsigned integers with top bit set never fit signed types.  */
7869
  if (! TYPE_UNSIGNED (type) && unsc)
7870
    {
7871
      int prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (c))) - 1;
7872
      if (prec < HOST_BITS_PER_WIDE_INT)
7873
        {
7874
          if (((((unsigned HOST_WIDE_INT) 1) << prec) & dc.low) != 0)
7875
            return 0;
7876
        }
7877
      else if (((((unsigned HOST_WIDE_INT) 1)
7878
                 << (prec - HOST_BITS_PER_WIDE_INT)) & dc.high) != 0)
7879
        return 0;
7880
    }
7881
 
7882
  /* If we haven't been able to decide at this point, there nothing more we
7883
     can check ourselves here.  Look at the base type if we have one and it
7884
     has the same precision.  */
7885
  if (TREE_CODE (type) == INTEGER_TYPE
7886
      && TREE_TYPE (type) != 0
7887
      && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (type)))
7888
    {
7889
      type = TREE_TYPE (type);
7890
      goto retry;
7891
    }
7892
 
7893
  /* Or to fit_double_type, if nothing else.  */
7894
  return !fit_double_type (dc.low, dc.high, &dc.low, &dc.high, type);
7895
}
7896
 
7897
/* Stores bounds of an integer TYPE in MIN and MAX.  If TYPE has non-constant
7898
   bounds or is a POINTER_TYPE, the maximum and/or minimum values that can be
7899
   represented (assuming two's-complement arithmetic) within the bit
7900
   precision of the type are returned instead.  */
7901
 
7902
void
7903
get_type_static_bounds (const_tree type, mpz_t min, mpz_t max)
7904
{
7905
  if (!POINTER_TYPE_P (type) && TYPE_MIN_VALUE (type)
7906
      && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
7907
    mpz_set_double_int (min, tree_to_double_int (TYPE_MIN_VALUE (type)),
7908
                        TYPE_UNSIGNED (type));
7909
  else
7910
    {
7911
      if (TYPE_UNSIGNED (type))
7912
        mpz_set_ui (min, 0);
7913
      else
7914
        {
7915
          double_int mn;
7916
          mn = double_int_mask (TYPE_PRECISION (type) - 1);
7917
          mn = double_int_sext (double_int_add (mn, double_int_one),
7918
                                TYPE_PRECISION (type));
7919
          mpz_set_double_int (min, mn, false);
7920
        }
7921
    }
7922
 
7923
  if (!POINTER_TYPE_P (type) && TYPE_MAX_VALUE (type)
7924
      && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST)
7925
    mpz_set_double_int (max, tree_to_double_int (TYPE_MAX_VALUE (type)),
7926
                        TYPE_UNSIGNED (type));
7927
  else
7928
    {
7929
      if (TYPE_UNSIGNED (type))
7930
        mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type)),
7931
                            true);
7932
      else
7933
        mpz_set_double_int (max, double_int_mask (TYPE_PRECISION (type) - 1),
7934
                            true);
7935
    }
7936
}
7937
 
7938
/* Return true if VAR is an automatic variable defined in function FN.  */
7939
 
7940
bool
7941
auto_var_in_fn_p (const_tree var, const_tree fn)
7942
{
7943
  return (DECL_P (var) && DECL_CONTEXT (var) == fn
7944
          && ((((TREE_CODE (var) == VAR_DECL && ! DECL_EXTERNAL (var))
7945
                || TREE_CODE (var) == PARM_DECL)
7946
               && ! TREE_STATIC (var))
7947
              || TREE_CODE (var) == LABEL_DECL
7948
              || TREE_CODE (var) == RESULT_DECL));
7949
}
7950
 
7951
/* Subprogram of following function.  Called by walk_tree.
7952
 
7953
   Return *TP if it is an automatic variable or parameter of the
7954
   function passed in as DATA.  */
7955
 
7956
static tree
7957
find_var_from_fn (tree *tp, int *walk_subtrees, void *data)
7958
{
7959
  tree fn = (tree) data;
7960
 
7961
  if (TYPE_P (*tp))
7962
    *walk_subtrees = 0;
7963
 
7964
  else if (DECL_P (*tp)
7965
           && auto_var_in_fn_p (*tp, fn))
7966
    return *tp;
7967
 
7968
  return NULL_TREE;
7969
}
7970
 
7971
/* Returns true if T is, contains, or refers to a type with variable
7972
   size.  For METHOD_TYPEs and FUNCTION_TYPEs we exclude the
7973
   arguments, but not the return type.  If FN is nonzero, only return
7974
   true if a modifier of the type or position of FN is a variable or
7975
   parameter inside FN.
7976
 
7977
   This concept is more general than that of C99 'variably modified types':
7978
   in C99, a struct type is never variably modified because a VLA may not
7979
   appear as a structure member.  However, in GNU C code like:
7980
 
7981
     struct S { int i[f()]; };
7982
 
7983
   is valid, and other languages may define similar constructs.  */
7984
 
7985
bool
7986
variably_modified_type_p (tree type, tree fn)
7987
{
7988
  tree t;
7989
 
7990
/* Test if T is either variable (if FN is zero) or an expression containing
7991
   a variable in FN.  */
7992
#define RETURN_TRUE_IF_VAR(T)                                           \
7993
  do { tree _t = (T);                                                   \
7994
    if (_t && _t != error_mark_node && TREE_CODE (_t) != INTEGER_CST    \
7995
        && (!fn || walk_tree (&_t, find_var_from_fn, fn, NULL)))        \
7996
      return true;  } while (0)
7997
 
7998
  if (type == error_mark_node)
7999
    return false;
8000
 
8001
  /* If TYPE itself has variable size, it is variably modified.  */
8002
  RETURN_TRUE_IF_VAR (TYPE_SIZE (type));
8003
  RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (type));
8004
 
8005
  switch (TREE_CODE (type))
8006
    {
8007
    case POINTER_TYPE:
8008
    case REFERENCE_TYPE:
8009
    case VECTOR_TYPE:
8010
      if (variably_modified_type_p (TREE_TYPE (type), fn))
8011
        return true;
8012
      break;
8013
 
8014
    case FUNCTION_TYPE:
8015
    case METHOD_TYPE:
8016
      /* If TYPE is a function type, it is variably modified if the
8017
         return type is variably modified.  */
8018
      if (variably_modified_type_p (TREE_TYPE (type), fn))
8019
          return true;
8020
      break;
8021
 
8022
    case INTEGER_TYPE:
8023
    case REAL_TYPE:
8024
    case FIXED_POINT_TYPE:
8025
    case ENUMERAL_TYPE:
8026
    case BOOLEAN_TYPE:
8027
      /* Scalar types are variably modified if their end points
8028
         aren't constant.  */
8029
      RETURN_TRUE_IF_VAR (TYPE_MIN_VALUE (type));
8030
      RETURN_TRUE_IF_VAR (TYPE_MAX_VALUE (type));
8031
      break;
8032
 
8033
    case RECORD_TYPE:
8034
    case UNION_TYPE:
8035
    case QUAL_UNION_TYPE:
8036
      /* We can't see if any of the fields are variably-modified by the
8037
         definition we normally use, since that would produce infinite
8038
         recursion via pointers.  */
8039
      /* This is variably modified if some field's type is.  */
8040
      for (t = TYPE_FIELDS (type); t; t = TREE_CHAIN (t))
8041
        if (TREE_CODE (t) == FIELD_DECL)
8042
          {
8043
            RETURN_TRUE_IF_VAR (DECL_FIELD_OFFSET (t));
8044
            RETURN_TRUE_IF_VAR (DECL_SIZE (t));
8045
            RETURN_TRUE_IF_VAR (DECL_SIZE_UNIT (t));
8046
 
8047
            if (TREE_CODE (type) == QUAL_UNION_TYPE)
8048
              RETURN_TRUE_IF_VAR (DECL_QUALIFIER (t));
8049
          }
8050
        break;
8051
 
8052
    case ARRAY_TYPE:
8053
      /* Do not call ourselves to avoid infinite recursion.  This is
8054
         variably modified if the element type is.  */
8055
      RETURN_TRUE_IF_VAR (TYPE_SIZE (TREE_TYPE (type)));
8056
      RETURN_TRUE_IF_VAR (TYPE_SIZE_UNIT (TREE_TYPE (type)));
8057
      break;
8058
 
8059
    default:
8060
      break;
8061
    }
8062
 
8063
  /* The current language may have other cases to check, but in general,
8064
     all other types are not variably modified.  */
8065
  return lang_hooks.tree_inlining.var_mod_type_p (type, fn);
8066
 
8067
#undef RETURN_TRUE_IF_VAR
8068
}
8069
 
8070
/* Given a DECL or TYPE, return the scope in which it was declared, or
8071
   NULL_TREE if there is no containing scope.  */
8072
 
8073
tree
8074
get_containing_scope (const_tree t)
8075
{
8076
  return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
8077
}
8078
 
8079
/* Return the innermost context enclosing DECL that is
8080
   a FUNCTION_DECL, or zero if none.  */
8081
 
8082
tree
8083
decl_function_context (const_tree decl)
8084
{
8085
  tree context;
8086
 
8087
  if (TREE_CODE (decl) == ERROR_MARK)
8088
    return 0;
8089
 
8090
  /* C++ virtual functions use DECL_CONTEXT for the class of the vtable
8091
     where we look up the function at runtime.  Such functions always take
8092
     a first argument of type 'pointer to real context'.
8093
 
8094
     C++ should really be fixed to use DECL_CONTEXT for the real context,
8095
     and use something else for the "virtual context".  */
8096
  else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
8097
    context
8098
      = TYPE_MAIN_VARIANT
8099
        (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
8100
  else
8101
    context = DECL_CONTEXT (decl);
8102
 
8103
  while (context && TREE_CODE (context) != FUNCTION_DECL)
8104
    {
8105
      if (TREE_CODE (context) == BLOCK)
8106
        context = BLOCK_SUPERCONTEXT (context);
8107
      else
8108
        context = get_containing_scope (context);
8109
    }
8110
 
8111
  return context;
8112
}
8113
 
8114
/* Return the innermost context enclosing DECL that is
8115
   a RECORD_TYPE, UNION_TYPE or QUAL_UNION_TYPE, or zero if none.
8116
   TYPE_DECLs and FUNCTION_DECLs are transparent to this function.  */
8117
 
8118
tree
8119
decl_type_context (const_tree decl)
8120
{
8121
  tree context = DECL_CONTEXT (decl);
8122
 
8123
  while (context)
8124
    switch (TREE_CODE (context))
8125
      {
8126
      case NAMESPACE_DECL:
8127
      case TRANSLATION_UNIT_DECL:
8128
        return NULL_TREE;
8129
 
8130
      case RECORD_TYPE:
8131
      case UNION_TYPE:
8132
      case QUAL_UNION_TYPE:
8133
        return context;
8134
 
8135
      case TYPE_DECL:
8136
      case FUNCTION_DECL:
8137
        context = DECL_CONTEXT (context);
8138
        break;
8139
 
8140
      case BLOCK:
8141
        context = BLOCK_SUPERCONTEXT (context);
8142
        break;
8143
 
8144
      default:
8145
        gcc_unreachable ();
8146
      }
8147
 
8148
  return NULL_TREE;
8149
}
8150
 
8151
/* CALL is a CALL_EXPR.  Return the declaration for the function
8152
   called, or NULL_TREE if the called function cannot be
8153
   determined.  */
8154
 
8155
tree
8156
get_callee_fndecl (const_tree call)
8157
{
8158
  tree addr;
8159
 
8160
  if (call == error_mark_node)
8161
    return error_mark_node;
8162
 
8163
  /* It's invalid to call this function with anything but a
8164
     CALL_EXPR.  */
8165
  gcc_assert (TREE_CODE (call) == CALL_EXPR);
8166
 
8167
  /* The first operand to the CALL is the address of the function
8168
     called.  */
8169
  addr = CALL_EXPR_FN (call);
8170
 
8171
  STRIP_NOPS (addr);
8172
 
8173
  /* If this is a readonly function pointer, extract its initial value.  */
8174
  if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
8175
      && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
8176
      && DECL_INITIAL (addr))
8177
    addr = DECL_INITIAL (addr);
8178
 
8179
  /* If the address is just `&f' for some function `f', then we know
8180
     that `f' is being called.  */
8181
  if (TREE_CODE (addr) == ADDR_EXPR
8182
      && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
8183
    return TREE_OPERAND (addr, 0);
8184
 
8185
  /* We couldn't figure out what was being called.  */
8186
  return NULL_TREE;
8187
}
8188
 
8189
/* Print debugging information about tree nodes generated during the compile,
8190
   and any language-specific information.  */
8191
 
8192
void
8193
dump_tree_statistics (void)
8194
{
8195
#ifdef GATHER_STATISTICS
8196
  int i;
8197
  int total_nodes, total_bytes;
8198
#endif
8199
 
8200
  fprintf (stderr, "\n??? tree nodes created\n\n");
8201
#ifdef GATHER_STATISTICS
8202
  fprintf (stderr, "Kind                   Nodes      Bytes\n");
8203
  fprintf (stderr, "---------------------------------------\n");
8204
  total_nodes = total_bytes = 0;
8205
  for (i = 0; i < (int) all_kinds; i++)
8206
    {
8207
      fprintf (stderr, "%-20s %7d %10d\n", tree_node_kind_names[i],
8208
               tree_node_counts[i], tree_node_sizes[i]);
8209
      total_nodes += tree_node_counts[i];
8210
      total_bytes += tree_node_sizes[i];
8211
    }
8212
  fprintf (stderr, "---------------------------------------\n");
8213
  fprintf (stderr, "%-20s %7d %10d\n", "Total", total_nodes, total_bytes);
8214
  fprintf (stderr, "---------------------------------------\n");
8215
  ssanames_print_statistics ();
8216
  phinodes_print_statistics ();
8217
#else
8218
  fprintf (stderr, "(No per-node statistics)\n");
8219
#endif
8220
  print_type_hash_statistics ();
8221
  print_debug_expr_statistics ();
8222
  print_value_expr_statistics ();
8223
  lang_hooks.print_statistics ();
8224
}
8225
 
8226
#define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
8227
 
8228
/* Generate a crc32 of a string.  */
8229
 
8230
unsigned
8231
crc32_string (unsigned chksum, const char *string)
8232
{
8233
  do
8234
    {
8235
      unsigned value = *string << 24;
8236
      unsigned ix;
8237
 
8238
      for (ix = 8; ix--; value <<= 1)
8239
        {
8240
          unsigned feedback;
8241
 
8242
          feedback = (value ^ chksum) & 0x80000000 ? 0x04c11db7 : 0;
8243
          chksum <<= 1;
8244
          chksum ^= feedback;
8245
        }
8246
    }
8247
  while (*string++);
8248
  return chksum;
8249
}
8250
 
8251
/* P is a string that will be used in a symbol.  Mask out any characters
8252
   that are not valid in that context.  */
8253
 
8254
void
8255
clean_symbol_name (char *p)
8256
{
8257
  for (; *p; p++)
8258
    if (! (ISALNUM (*p)
8259
#ifndef NO_DOLLAR_IN_LABEL      /* this for `$'; unlikely, but... -- kr */
8260
            || *p == '$'
8261
#endif
8262
#ifndef NO_DOT_IN_LABEL         /* this for `.'; unlikely, but...  */
8263
            || *p == '.'
8264
#endif
8265
           ))
8266
      *p = '_';
8267
}
8268
 
8269
/* Generate a name for a special-purpose function function.
8270
   The generated name may need to be unique across the whole link.
8271
   TYPE is some string to identify the purpose of this function to the
8272
   linker or collect2; it must start with an uppercase letter,
8273
   one of:
8274
   I - for constructors
8275
   D - for destructors
8276
   N - for C++ anonymous namespaces
8277
   F - for DWARF unwind frame information.  */
8278
 
8279
tree
8280
get_file_function_name (const char *type)
8281
{
8282
  char *buf;
8283
  const char *p;
8284
  char *q;
8285
 
8286
  /* If we already have a name we know to be unique, just use that.  */
8287
  if (first_global_object_name)
8288
    p = q = ASTRDUP (first_global_object_name);
8289
  /* If the target is handling the constructors/destructors, they
8290
     will be local to this file and the name is only necessary for
8291
     debugging purposes.  */
8292
  else if ((type[0] == 'I' || type[0] == 'D') && targetm.have_ctors_dtors)
8293
    {
8294
      const char *file = main_input_filename;
8295
      if (! file)
8296
        file = input_filename;
8297
      /* Just use the file's basename, because the full pathname
8298
         might be quite long.  */
8299
      p = strrchr (file, '/');
8300
      if (p)
8301
        p++;
8302
      else
8303
        p = file;
8304
      p = q = ASTRDUP (p);
8305
    }
8306
  else
8307
    {
8308
      /* Otherwise, the name must be unique across the entire link.
8309
         We don't have anything that we know to be unique to this translation
8310
         unit, so use what we do have and throw in some randomness.  */
8311
      unsigned len;
8312
      const char *name = weak_global_object_name;
8313
      const char *file = main_input_filename;
8314
 
8315
      if (! name)
8316
        name = "";
8317
      if (! file)
8318
        file = input_filename;
8319
 
8320
      len = strlen (file);
8321
      q = (char *) alloca (9 * 2 + len + 1);
8322
      memcpy (q, file, len + 1);
8323
 
8324
      sprintf (q + len, "_%08X_%08X", crc32_string (0, name),
8325
               crc32_string (0, get_random_seed (false)));
8326
 
8327
      p = q;
8328
    }
8329
 
8330
  clean_symbol_name (q);
8331
  buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
8332
                         + strlen (type));
8333
 
8334
  /* Set up the name of the file-level functions we may need.
8335
     Use a global object (which is already required to be unique over
8336
     the program) rather than the file name (which imposes extra
8337
     constraints).  */
8338
  sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
8339
 
8340
  return get_identifier (buf);
8341
}
8342
 
8343
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
8344
 
8345
/* Complain that the tree code of NODE does not match the expected 0
8346
   terminated list of trailing codes. The trailing code list can be
8347
   empty, for a more vague error message.  FILE, LINE, and FUNCTION
8348
   are of the caller.  */
8349
 
8350
void
8351
tree_check_failed (const_tree node, const char *file,
8352
                   int line, const char *function, ...)
8353
{
8354
  va_list args;
8355
  const char *buffer;
8356
  unsigned length = 0;
8357
  int code;
8358
 
8359
  va_start (args, function);
8360
  while ((code = va_arg (args, int)))
8361
    length += 4 + strlen (tree_code_name[code]);
8362
  va_end (args);
8363
  if (length)
8364
    {
8365
      char *tmp;
8366
      va_start (args, function);
8367
      length += strlen ("expected ");
8368
      buffer = tmp = (char *) alloca (length);
8369
      length = 0;
8370
      while ((code = va_arg (args, int)))
8371
        {
8372
          const char *prefix = length ? " or " : "expected ";
8373
 
8374
          strcpy (tmp + length, prefix);
8375
          length += strlen (prefix);
8376
          strcpy (tmp + length, tree_code_name[code]);
8377
          length += strlen (tree_code_name[code]);
8378
        }
8379
      va_end (args);
8380
    }
8381
  else
8382
    buffer = "unexpected node";
8383
 
8384
  internal_error ("tree check: %s, have %s in %s, at %s:%d",
8385
                  buffer, tree_code_name[TREE_CODE (node)],
8386
                  function, trim_filename (file), line);
8387
}
8388
 
8389
/* Complain that the tree code of NODE does match the expected 0
8390
   terminated list of trailing codes. FILE, LINE, and FUNCTION are of
8391
   the caller.  */
8392
 
8393
void
8394
tree_not_check_failed (const_tree node, const char *file,
8395
                       int line, const char *function, ...)
8396
{
8397
  va_list args;
8398
  char *buffer;
8399
  unsigned length = 0;
8400
  int code;
8401
 
8402
  va_start (args, function);
8403
  while ((code = va_arg (args, int)))
8404
    length += 4 + strlen (tree_code_name[code]);
8405
  va_end (args);
8406
  va_start (args, function);
8407
  buffer = (char *) alloca (length);
8408
  length = 0;
8409
  while ((code = va_arg (args, int)))
8410
    {
8411
      if (length)
8412
        {
8413
          strcpy (buffer + length, " or ");
8414
          length += 4;
8415
        }
8416
      strcpy (buffer + length, tree_code_name[code]);
8417
      length += strlen (tree_code_name[code]);
8418
    }
8419
  va_end (args);
8420
 
8421
  internal_error ("tree check: expected none of %s, have %s in %s, at %s:%d",
8422
                  buffer, tree_code_name[TREE_CODE (node)],
8423
                  function, trim_filename (file), line);
8424
}
8425
 
8426
/* Similar to tree_check_failed, except that we check for a class of tree
8427
   code, given in CL.  */
8428
 
8429
void
8430
tree_class_check_failed (const_tree node, const enum tree_code_class cl,
8431
                         const char *file, int line, const char *function)
8432
{
8433
  internal_error
8434
    ("tree check: expected class %qs, have %qs (%s) in %s, at %s:%d",
8435
     TREE_CODE_CLASS_STRING (cl),
8436
     TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8437
     tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8438
}
8439
 
8440
/* Similar to tree_check_failed, except that instead of specifying a
8441
   dozen codes, use the knowledge that they're all sequential.  */
8442
 
8443
void
8444
tree_range_check_failed (const_tree node, const char *file, int line,
8445
                         const char *function, enum tree_code c1,
8446
                         enum tree_code c2)
8447
{
8448
  char *buffer;
8449
  unsigned length = 0;
8450
  unsigned int c;
8451
 
8452
  for (c = c1; c <= c2; ++c)
8453
    length += 4 + strlen (tree_code_name[c]);
8454
 
8455
  length += strlen ("expected ");
8456
  buffer = (char *) alloca (length);
8457
  length = 0;
8458
 
8459
  for (c = c1; c <= c2; ++c)
8460
    {
8461
      const char *prefix = length ? " or " : "expected ";
8462
 
8463
      strcpy (buffer + length, prefix);
8464
      length += strlen (prefix);
8465
      strcpy (buffer + length, tree_code_name[c]);
8466
      length += strlen (tree_code_name[c]);
8467
    }
8468
 
8469
  internal_error ("tree check: %s, have %s in %s, at %s:%d",
8470
                  buffer, tree_code_name[TREE_CODE (node)],
8471
                  function, trim_filename (file), line);
8472
}
8473
 
8474
 
8475
/* Similar to tree_check_failed, except that we check that a tree does
8476
   not have the specified code, given in CL.  */
8477
 
8478
void
8479
tree_not_class_check_failed (const_tree node, const enum tree_code_class cl,
8480
                             const char *file, int line, const char *function)
8481
{
8482
  internal_error
8483
    ("tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d",
8484
     TREE_CODE_CLASS_STRING (cl),
8485
     TREE_CODE_CLASS_STRING (TREE_CODE_CLASS (TREE_CODE (node))),
8486
     tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8487
}
8488
 
8489
 
8490
/* Similar to tree_check_failed but applied to OMP_CLAUSE codes.  */
8491
 
8492
void
8493
omp_clause_check_failed (const_tree node, const char *file, int line,
8494
                         const char *function, enum omp_clause_code code)
8495
{
8496
  internal_error ("tree check: expected omp_clause %s, have %s in %s, at %s:%d",
8497
                  omp_clause_code_name[code], tree_code_name[TREE_CODE (node)],
8498
                  function, trim_filename (file), line);
8499
}
8500
 
8501
 
8502
/* Similar to tree_range_check_failed but applied to OMP_CLAUSE codes.  */
8503
 
8504
void
8505
omp_clause_range_check_failed (const_tree node, const char *file, int line,
8506
                               const char *function, enum omp_clause_code c1,
8507
                               enum omp_clause_code c2)
8508
{
8509
  char *buffer;
8510
  unsigned length = 0;
8511
  unsigned int c;
8512
 
8513
  for (c = c1; c <= c2; ++c)
8514
    length += 4 + strlen (omp_clause_code_name[c]);
8515
 
8516
  length += strlen ("expected ");
8517
  buffer = (char *) alloca (length);
8518
  length = 0;
8519
 
8520
  for (c = c1; c <= c2; ++c)
8521
    {
8522
      const char *prefix = length ? " or " : "expected ";
8523
 
8524
      strcpy (buffer + length, prefix);
8525
      length += strlen (prefix);
8526
      strcpy (buffer + length, omp_clause_code_name[c]);
8527
      length += strlen (omp_clause_code_name[c]);
8528
    }
8529
 
8530
  internal_error ("tree check: %s, have %s in %s, at %s:%d",
8531
                  buffer, omp_clause_code_name[TREE_CODE (node)],
8532
                  function, trim_filename (file), line);
8533
}
8534
 
8535
 
8536
#undef DEFTREESTRUCT
8537
#define DEFTREESTRUCT(VAL, NAME) NAME,
8538
 
8539
static const char *ts_enum_names[] = {
8540
#include "treestruct.def"
8541
};
8542
#undef DEFTREESTRUCT
8543
 
8544
#define TS_ENUM_NAME(EN) (ts_enum_names[(EN)])
8545
 
8546
/* Similar to tree_class_check_failed, except that we check for
8547
   whether CODE contains the tree structure identified by EN.  */
8548
 
8549
void
8550
tree_contains_struct_check_failed (const_tree node,
8551
                                   const enum tree_node_structure_enum en,
8552
                                   const char *file, int line,
8553
                                   const char *function)
8554
{
8555
  internal_error
8556
    ("tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d",
8557
     TS_ENUM_NAME(en),
8558
     tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
8559
}
8560
 
8561
 
8562
/* Similar to above, except that the check is for the bounds of a TREE_VEC's
8563
   (dynamically sized) vector.  */
8564
 
8565
void
8566
tree_vec_elt_check_failed (int idx, int len, const char *file, int line,
8567
                           const char *function)
8568
{
8569
  internal_error
8570
    ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
8571
     idx + 1, len, function, trim_filename (file), line);
8572
}
8573
 
8574
/* Similar to above, except that the check is for the bounds of the operand
8575
   vector of an expression node EXP.  */
8576
 
8577
void
8578
tree_operand_check_failed (int idx, const_tree exp, const char *file,
8579
                           int line, const char *function)
8580
{
8581
  int code = TREE_CODE (exp);
8582
  internal_error
8583
    ("tree check: accessed operand %d of %s with %d operands in %s, at %s:%d",
8584
     idx + 1, tree_code_name[code], TREE_OPERAND_LENGTH (exp),
8585
     function, trim_filename (file), line);
8586
}
8587
 
8588
/* Similar to above, except that the check is for the number of
8589
   operands of an OMP_CLAUSE node.  */
8590
 
8591
void
8592
omp_clause_operand_check_failed (int idx, const_tree t, const char *file,
8593
                                 int line, const char *function)
8594
{
8595
  internal_error
8596
    ("tree check: accessed operand %d of omp_clause %s with %d operands "
8597
     "in %s, at %s:%d", idx + 1, omp_clause_code_name[OMP_CLAUSE_CODE (t)],
8598
     omp_clause_num_ops [OMP_CLAUSE_CODE (t)], function,
8599
     trim_filename (file), line);
8600
}
8601
#endif /* ENABLE_TREE_CHECKING */
8602
 
8603
/* Create a new vector type node holding SUBPARTS units of type INNERTYPE,
8604
   and mapped to the machine mode MODE.  Initialize its fields and build
8605
   the information necessary for debugging output.  */
8606
 
8607
static tree
8608
make_vector_type (tree innertype, int nunits, enum machine_mode mode)
8609
{
8610
  tree t;
8611
  hashval_t hashcode = 0;
8612
 
8613
  t = make_node (VECTOR_TYPE);
8614
  TREE_TYPE (t) = TYPE_MAIN_VARIANT (innertype);
8615
  SET_TYPE_VECTOR_SUBPARTS (t, nunits);
8616
  SET_TYPE_MODE (t, mode);
8617
 
8618
  if (TYPE_STRUCTURAL_EQUALITY_P (innertype))
8619
    SET_TYPE_STRUCTURAL_EQUALITY (t);
8620
  else if (TYPE_CANONICAL (innertype) != innertype
8621
           || mode != VOIDmode)
8622
    TYPE_CANONICAL (t)
8623
      = make_vector_type (TYPE_CANONICAL (innertype), nunits, VOIDmode);
8624
 
8625
  layout_type (t);
8626
 
8627
  {
8628
    tree index = build_int_cst (NULL_TREE, nunits - 1);
8629
    tree array = build_array_type (TYPE_MAIN_VARIANT (innertype),
8630
                                   build_index_type (index));
8631
    tree rt = make_node (RECORD_TYPE);
8632
 
8633
    TYPE_FIELDS (rt) = build_decl (UNKNOWN_LOCATION, FIELD_DECL,
8634
                                   get_identifier ("f"), array);
8635
    DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
8636
    layout_type (rt);
8637
    TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
8638
    /* In dwarfout.c, type lookup uses TYPE_UID numbers.  We want to output
8639
       the representation type, and we want to find that die when looking up
8640
       the vector type.  This is most easily achieved by making the TYPE_UID
8641
       numbers equal.  */
8642
    TYPE_UID (rt) = TYPE_UID (t);
8643
  }
8644
 
8645
  hashcode = iterative_hash_host_wide_int (VECTOR_TYPE, hashcode);
8646
  hashcode = iterative_hash_host_wide_int (nunits, hashcode);
8647
  hashcode = iterative_hash_host_wide_int (mode, hashcode);
8648
  hashcode = iterative_hash_object (TYPE_HASH (TREE_TYPE (t)), hashcode);
8649
  t = type_hash_canon (hashcode, t);
8650
 
8651
  /* We have built a main variant, based on the main variant of the
8652
     inner type. Use it to build the variant we return.  */
8653
  if ((TYPE_ATTRIBUTES (innertype) || TYPE_QUALS (innertype))
8654
      && TREE_TYPE (t) != innertype)
8655
    return build_type_attribute_qual_variant (t,
8656
                                              TYPE_ATTRIBUTES (innertype),
8657
                                              TYPE_QUALS (innertype));
8658
 
8659
  return t;
8660
}
8661
 
8662
static tree
8663
make_or_reuse_type (unsigned size, int unsignedp)
8664
{
8665
  if (size == INT_TYPE_SIZE)
8666
    return unsignedp ? unsigned_type_node : integer_type_node;
8667
  if (size == CHAR_TYPE_SIZE)
8668
    return unsignedp ? unsigned_char_type_node : signed_char_type_node;
8669
  if (size == SHORT_TYPE_SIZE)
8670
    return unsignedp ? short_unsigned_type_node : short_integer_type_node;
8671
  if (size == LONG_TYPE_SIZE)
8672
    return unsignedp ? long_unsigned_type_node : long_integer_type_node;
8673
  if (size == LONG_LONG_TYPE_SIZE)
8674
    return (unsignedp ? long_long_unsigned_type_node
8675
            : long_long_integer_type_node);
8676
 
8677
  if (unsignedp)
8678
    return make_unsigned_type (size);
8679
  else
8680
    return make_signed_type (size);
8681
}
8682
 
8683
/* Create or reuse a fract type by SIZE, UNSIGNEDP, and SATP.  */
8684
 
8685
static tree
8686
make_or_reuse_fract_type (unsigned size, int unsignedp, int satp)
8687
{
8688
  if (satp)
8689
    {
8690
      if (size == SHORT_FRACT_TYPE_SIZE)
8691
        return unsignedp ? sat_unsigned_short_fract_type_node
8692
                         : sat_short_fract_type_node;
8693
      if (size == FRACT_TYPE_SIZE)
8694
        return unsignedp ? sat_unsigned_fract_type_node : sat_fract_type_node;
8695
      if (size == LONG_FRACT_TYPE_SIZE)
8696
        return unsignedp ? sat_unsigned_long_fract_type_node
8697
                         : sat_long_fract_type_node;
8698
      if (size == LONG_LONG_FRACT_TYPE_SIZE)
8699
        return unsignedp ? sat_unsigned_long_long_fract_type_node
8700
                         : sat_long_long_fract_type_node;
8701
    }
8702
  else
8703
    {
8704
      if (size == SHORT_FRACT_TYPE_SIZE)
8705
        return unsignedp ? unsigned_short_fract_type_node
8706
                         : short_fract_type_node;
8707
      if (size == FRACT_TYPE_SIZE)
8708
        return unsignedp ? unsigned_fract_type_node : fract_type_node;
8709
      if (size == LONG_FRACT_TYPE_SIZE)
8710
        return unsignedp ? unsigned_long_fract_type_node
8711
                         : long_fract_type_node;
8712
      if (size == LONG_LONG_FRACT_TYPE_SIZE)
8713
        return unsignedp ? unsigned_long_long_fract_type_node
8714
                         : long_long_fract_type_node;
8715
    }
8716
 
8717
  return make_fract_type (size, unsignedp, satp);
8718
}
8719
 
8720
/* Create or reuse an accum type by SIZE, UNSIGNEDP, and SATP.  */
8721
 
8722
static tree
8723
make_or_reuse_accum_type (unsigned size, int unsignedp, int satp)
8724
{
8725
  if (satp)
8726
    {
8727
      if (size == SHORT_ACCUM_TYPE_SIZE)
8728
        return unsignedp ? sat_unsigned_short_accum_type_node
8729
                         : sat_short_accum_type_node;
8730
      if (size == ACCUM_TYPE_SIZE)
8731
        return unsignedp ? sat_unsigned_accum_type_node : sat_accum_type_node;
8732
      if (size == LONG_ACCUM_TYPE_SIZE)
8733
        return unsignedp ? sat_unsigned_long_accum_type_node
8734
                         : sat_long_accum_type_node;
8735
      if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8736
        return unsignedp ? sat_unsigned_long_long_accum_type_node
8737
                         : sat_long_long_accum_type_node;
8738
    }
8739
  else
8740
    {
8741
      if (size == SHORT_ACCUM_TYPE_SIZE)
8742
        return unsignedp ? unsigned_short_accum_type_node
8743
                         : short_accum_type_node;
8744
      if (size == ACCUM_TYPE_SIZE)
8745
        return unsignedp ? unsigned_accum_type_node : accum_type_node;
8746
      if (size == LONG_ACCUM_TYPE_SIZE)
8747
        return unsignedp ? unsigned_long_accum_type_node
8748
                         : long_accum_type_node;
8749
      if (size == LONG_LONG_ACCUM_TYPE_SIZE)
8750
        return unsignedp ? unsigned_long_long_accum_type_node
8751
                         : long_long_accum_type_node;
8752
    }
8753
 
8754
  return make_accum_type (size, unsignedp, satp);
8755
}
8756
 
8757
/* Create nodes for all integer types (and error_mark_node) using the sizes
8758
   of C datatypes.  The caller should call set_sizetype soon after calling
8759
   this function to select one of the types as sizetype.  */
8760
 
8761
void
8762
build_common_tree_nodes (bool signed_char, bool signed_sizetype)
8763
{
8764
  error_mark_node = make_node (ERROR_MARK);
8765
  TREE_TYPE (error_mark_node) = error_mark_node;
8766
 
8767
  initialize_sizetypes (signed_sizetype);
8768
 
8769
  /* Define both `signed char' and `unsigned char'.  */
8770
  signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
8771
  TYPE_STRING_FLAG (signed_char_type_node) = 1;
8772
  unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
8773
  TYPE_STRING_FLAG (unsigned_char_type_node) = 1;
8774
 
8775
  /* Define `char', which is like either `signed char' or `unsigned char'
8776
     but not the same as either.  */
8777
  char_type_node
8778
    = (signed_char
8779
       ? make_signed_type (CHAR_TYPE_SIZE)
8780
       : make_unsigned_type (CHAR_TYPE_SIZE));
8781
  TYPE_STRING_FLAG (char_type_node) = 1;
8782
 
8783
  short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
8784
  short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
8785
  integer_type_node = make_signed_type (INT_TYPE_SIZE);
8786
  unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
8787
  long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
8788
  long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
8789
  long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
8790
  long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
8791
 
8792
  /* Define a boolean type.  This type only represents boolean values but
8793
     may be larger than char depending on the value of BOOL_TYPE_SIZE.
8794
     Front ends which want to override this size (i.e. Java) can redefine
8795
     boolean_type_node before calling build_common_tree_nodes_2.  */
8796
  boolean_type_node = make_unsigned_type (BOOL_TYPE_SIZE);
8797
  TREE_SET_CODE (boolean_type_node, BOOLEAN_TYPE);
8798
  TYPE_MAX_VALUE (boolean_type_node) = build_int_cst (boolean_type_node, 1);
8799
  TYPE_PRECISION (boolean_type_node) = 1;
8800
 
8801
  /* Fill in the rest of the sized types.  Reuse existing type nodes
8802
     when possible.  */
8803
  intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 0);
8804
  intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 0);
8805
  intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 0);
8806
  intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 0);
8807
  intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 0);
8808
 
8809
  unsigned_intQI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (QImode), 1);
8810
  unsigned_intHI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (HImode), 1);
8811
  unsigned_intSI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (SImode), 1);
8812
  unsigned_intDI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (DImode), 1);
8813
  unsigned_intTI_type_node = make_or_reuse_type (GET_MODE_BITSIZE (TImode), 1);
8814
 
8815
  access_public_node = get_identifier ("public");
8816
  access_protected_node = get_identifier ("protected");
8817
  access_private_node = get_identifier ("private");
8818
}
8819
 
8820
/* Call this function after calling build_common_tree_nodes and set_sizetype.
8821
   It will create several other common tree nodes.  */
8822
 
8823
void
8824
build_common_tree_nodes_2 (int short_double)
8825
{
8826
  /* Define these next since types below may used them.  */
8827
  integer_zero_node = build_int_cst (NULL_TREE, 0);
8828
  integer_one_node = build_int_cst (NULL_TREE, 1);
8829
  integer_minus_one_node = build_int_cst (NULL_TREE, -1);
8830
 
8831
  size_zero_node = size_int (0);
8832
  size_one_node = size_int (1);
8833
  bitsize_zero_node = bitsize_int (0);
8834
  bitsize_one_node = bitsize_int (1);
8835
  bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
8836
 
8837
  boolean_false_node = TYPE_MIN_VALUE (boolean_type_node);
8838
  boolean_true_node = TYPE_MAX_VALUE (boolean_type_node);
8839
 
8840
  void_type_node = make_node (VOID_TYPE);
8841
  layout_type (void_type_node);
8842
 
8843
  /* We are not going to have real types in C with less than byte alignment,
8844
     so we might as well not have any types that claim to have it.  */
8845
  TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
8846
  TYPE_USER_ALIGN (void_type_node) = 0;
8847
 
8848
  null_pointer_node = build_int_cst (build_pointer_type (void_type_node), 0);
8849
  layout_type (TREE_TYPE (null_pointer_node));
8850
 
8851
  ptr_type_node = build_pointer_type (void_type_node);
8852
  const_ptr_type_node
8853
    = build_pointer_type (build_type_variant (void_type_node, 1, 0));
8854
  fileptr_type_node = ptr_type_node;
8855
 
8856
  float_type_node = make_node (REAL_TYPE);
8857
  TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
8858
  layout_type (float_type_node);
8859
 
8860
  double_type_node = make_node (REAL_TYPE);
8861
  if (short_double)
8862
    TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
8863
  else
8864
    TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
8865
  layout_type (double_type_node);
8866
 
8867
  long_double_type_node = make_node (REAL_TYPE);
8868
  TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
8869
  layout_type (long_double_type_node);
8870
 
8871
  float_ptr_type_node = build_pointer_type (float_type_node);
8872
  double_ptr_type_node = build_pointer_type (double_type_node);
8873
  long_double_ptr_type_node = build_pointer_type (long_double_type_node);
8874
  integer_ptr_type_node = build_pointer_type (integer_type_node);
8875
 
8876
  /* Fixed size integer types.  */
8877
  uint32_type_node = build_nonstandard_integer_type (32, true);
8878
  uint64_type_node = build_nonstandard_integer_type (64, true);
8879
 
8880
  /* Decimal float types. */
8881
  dfloat32_type_node = make_node (REAL_TYPE);
8882
  TYPE_PRECISION (dfloat32_type_node) = DECIMAL32_TYPE_SIZE;
8883
  layout_type (dfloat32_type_node);
8884
  SET_TYPE_MODE (dfloat32_type_node, SDmode);
8885
  dfloat32_ptr_type_node = build_pointer_type (dfloat32_type_node);
8886
 
8887
  dfloat64_type_node = make_node (REAL_TYPE);
8888
  TYPE_PRECISION (dfloat64_type_node) = DECIMAL64_TYPE_SIZE;
8889
  layout_type (dfloat64_type_node);
8890
  SET_TYPE_MODE (dfloat64_type_node, DDmode);
8891
  dfloat64_ptr_type_node = build_pointer_type (dfloat64_type_node);
8892
 
8893
  dfloat128_type_node = make_node (REAL_TYPE);
8894
  TYPE_PRECISION (dfloat128_type_node) = DECIMAL128_TYPE_SIZE;
8895
  layout_type (dfloat128_type_node);
8896
  SET_TYPE_MODE (dfloat128_type_node, TDmode);
8897
  dfloat128_ptr_type_node = build_pointer_type (dfloat128_type_node);
8898
 
8899
  complex_integer_type_node = build_complex_type (integer_type_node);
8900
  complex_float_type_node = build_complex_type (float_type_node);
8901
  complex_double_type_node = build_complex_type (double_type_node);
8902
  complex_long_double_type_node = build_complex_type (long_double_type_node);
8903
 
8904
/* Make fixed-point nodes based on sat/non-sat and signed/unsigned.  */
8905
#define MAKE_FIXED_TYPE_NODE(KIND,SIZE) \
8906
  sat_ ## KIND ## _type_node = \
8907
    make_sat_signed_ ## KIND ## _type (SIZE); \
8908
  sat_unsigned_ ## KIND ## _type_node = \
8909
    make_sat_unsigned_ ## KIND ## _type (SIZE); \
8910
  KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8911
  unsigned_ ## KIND ## _type_node = \
8912
    make_unsigned_ ## KIND ## _type (SIZE);
8913
 
8914
#define MAKE_FIXED_TYPE_NODE_WIDTH(KIND,WIDTH,SIZE) \
8915
  sat_ ## WIDTH ## KIND ## _type_node = \
8916
    make_sat_signed_ ## KIND ## _type (SIZE); \
8917
  sat_unsigned_ ## WIDTH ## KIND ## _type_node = \
8918
    make_sat_unsigned_ ## KIND ## _type (SIZE); \
8919
  WIDTH ## KIND ## _type_node = make_signed_ ## KIND ## _type (SIZE); \
8920
  unsigned_ ## WIDTH ## KIND ## _type_node = \
8921
    make_unsigned_ ## KIND ## _type (SIZE);
8922
 
8923
/* Make fixed-point type nodes based on four different widths.  */
8924
#define MAKE_FIXED_TYPE_NODE_FAMILY(N1,N2) \
8925
  MAKE_FIXED_TYPE_NODE_WIDTH (N1, short_, SHORT_ ## N2 ## _TYPE_SIZE) \
8926
  MAKE_FIXED_TYPE_NODE (N1, N2 ## _TYPE_SIZE) \
8927
  MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_, LONG_ ## N2 ## _TYPE_SIZE) \
8928
  MAKE_FIXED_TYPE_NODE_WIDTH (N1, long_long_, LONG_LONG_ ## N2 ## _TYPE_SIZE)
8929
 
8930
/* Make fixed-point mode nodes based on sat/non-sat and signed/unsigned.  */
8931
#define MAKE_FIXED_MODE_NODE(KIND,NAME,MODE) \
8932
  NAME ## _type_node = \
8933
    make_or_reuse_signed_ ## KIND ## _type (GET_MODE_BITSIZE (MODE ## mode)); \
8934
  u ## NAME ## _type_node = \
8935
    make_or_reuse_unsigned_ ## KIND ## _type \
8936
      (GET_MODE_BITSIZE (U ## MODE ## mode)); \
8937
  sat_ ## NAME ## _type_node = \
8938
    make_or_reuse_sat_signed_ ## KIND ## _type \
8939
      (GET_MODE_BITSIZE (MODE ## mode)); \
8940
  sat_u ## NAME ## _type_node = \
8941
    make_or_reuse_sat_unsigned_ ## KIND ## _type \
8942
      (GET_MODE_BITSIZE (U ## MODE ## mode));
8943
 
8944
  /* Fixed-point type and mode nodes.  */
8945
  MAKE_FIXED_TYPE_NODE_FAMILY (fract, FRACT)
8946
  MAKE_FIXED_TYPE_NODE_FAMILY (accum, ACCUM)
8947
  MAKE_FIXED_MODE_NODE (fract, qq, QQ)
8948
  MAKE_FIXED_MODE_NODE (fract, hq, HQ)
8949
  MAKE_FIXED_MODE_NODE (fract, sq, SQ)
8950
  MAKE_FIXED_MODE_NODE (fract, dq, DQ)
8951
  MAKE_FIXED_MODE_NODE (fract, tq, TQ)
8952
  MAKE_FIXED_MODE_NODE (accum, ha, HA)
8953
  MAKE_FIXED_MODE_NODE (accum, sa, SA)
8954
  MAKE_FIXED_MODE_NODE (accum, da, DA)
8955
  MAKE_FIXED_MODE_NODE (accum, ta, TA)
8956
 
8957
  {
8958
    tree t = targetm.build_builtin_va_list ();
8959
 
8960
    /* Many back-ends define record types without setting TYPE_NAME.
8961
       If we copied the record type here, we'd keep the original
8962
       record type without a name.  This breaks name mangling.  So,
8963
       don't copy record types and let c_common_nodes_and_builtins()
8964
       declare the type to be __builtin_va_list.  */
8965
    if (TREE_CODE (t) != RECORD_TYPE)
8966
      t = build_variant_type_copy (t);
8967
 
8968
    va_list_type_node = t;
8969
  }
8970
}
8971
 
8972
/* A subroutine of build_common_builtin_nodes.  Define a builtin function.  */
8973
 
8974
static void
8975
local_define_builtin (const char *name, tree type, enum built_in_function code,
8976
                      const char *library_name, int ecf_flags)
8977
{
8978
  tree decl;
8979
 
8980
  decl = add_builtin_function (name, type, code, BUILT_IN_NORMAL,
8981
                               library_name, NULL_TREE);
8982
  if (ecf_flags & ECF_CONST)
8983
    TREE_READONLY (decl) = 1;
8984
  if (ecf_flags & ECF_PURE)
8985
    DECL_PURE_P (decl) = 1;
8986
  if (ecf_flags & ECF_LOOPING_CONST_OR_PURE)
8987
    DECL_LOOPING_CONST_OR_PURE_P (decl) = 1;
8988
  if (ecf_flags & ECF_NORETURN)
8989
    TREE_THIS_VOLATILE (decl) = 1;
8990
  if (ecf_flags & ECF_NOTHROW)
8991
    TREE_NOTHROW (decl) = 1;
8992
  if (ecf_flags & ECF_MALLOC)
8993
    DECL_IS_MALLOC (decl) = 1;
8994
 
8995
  built_in_decls[code] = decl;
8996
  implicit_built_in_decls[code] = decl;
8997
}
8998
 
8999
/* Call this function after instantiating all builtins that the language
9000
   front end cares about.  This will build the rest of the builtins that
9001
   are relied upon by the tree optimizers and the middle-end.  */
9002
 
9003
void
9004
build_common_builtin_nodes (void)
9005
{
9006
  tree tmp, tmp2, ftype;
9007
 
9008
  if (built_in_decls[BUILT_IN_MEMCPY] == NULL
9009
      || built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9010
    {
9011
      tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9012
      tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9013
      tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9014
      ftype = build_function_type (ptr_type_node, tmp);
9015
 
9016
      if (built_in_decls[BUILT_IN_MEMCPY] == NULL)
9017
        local_define_builtin ("__builtin_memcpy", ftype, BUILT_IN_MEMCPY,
9018
                              "memcpy", ECF_NOTHROW);
9019
      if (built_in_decls[BUILT_IN_MEMMOVE] == NULL)
9020
        local_define_builtin ("__builtin_memmove", ftype, BUILT_IN_MEMMOVE,
9021
                              "memmove", ECF_NOTHROW);
9022
    }
9023
 
9024
  if (built_in_decls[BUILT_IN_MEMCMP] == NULL)
9025
    {
9026
      tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9027
      tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9028
      tmp = tree_cons (NULL_TREE, const_ptr_type_node, tmp);
9029
      ftype = build_function_type (integer_type_node, tmp);
9030
      local_define_builtin ("__builtin_memcmp", ftype, BUILT_IN_MEMCMP,
9031
                            "memcmp", ECF_PURE | ECF_NOTHROW);
9032
    }
9033
 
9034
  if (built_in_decls[BUILT_IN_MEMSET] == NULL)
9035
    {
9036
      tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9037
      tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9038
      tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9039
      ftype = build_function_type (ptr_type_node, tmp);
9040
      local_define_builtin ("__builtin_memset", ftype, BUILT_IN_MEMSET,
9041
                            "memset", ECF_NOTHROW);
9042
    }
9043
 
9044
  if (built_in_decls[BUILT_IN_ALLOCA] == NULL)
9045
    {
9046
      tmp = tree_cons (NULL_TREE, size_type_node, void_list_node);
9047
      ftype = build_function_type (ptr_type_node, tmp);
9048
      local_define_builtin ("__builtin_alloca", ftype, BUILT_IN_ALLOCA,
9049
                            "alloca",
9050
                            ECF_MALLOC | (flag_stack_check ? 0 : ECF_NOTHROW));
9051
    }
9052
 
9053
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9054
  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9055
  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9056
  ftype = build_function_type (void_type_node, tmp);
9057
  local_define_builtin ("__builtin_init_trampoline", ftype,
9058
                        BUILT_IN_INIT_TRAMPOLINE,
9059
                        "__builtin_init_trampoline", ECF_NOTHROW);
9060
 
9061
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9062
  ftype = build_function_type (ptr_type_node, tmp);
9063
  local_define_builtin ("__builtin_adjust_trampoline", ftype,
9064
                        BUILT_IN_ADJUST_TRAMPOLINE,
9065
                        "__builtin_adjust_trampoline",
9066
                        ECF_CONST | ECF_NOTHROW);
9067
 
9068
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9069
  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9070
  ftype = build_function_type (void_type_node, tmp);
9071
  local_define_builtin ("__builtin_nonlocal_goto", ftype,
9072
                        BUILT_IN_NONLOCAL_GOTO,
9073
                        "__builtin_nonlocal_goto",
9074
                        ECF_NORETURN | ECF_NOTHROW);
9075
 
9076
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9077
  tmp = tree_cons (NULL_TREE, ptr_type_node, tmp);
9078
  ftype = build_function_type (void_type_node, tmp);
9079
  local_define_builtin ("__builtin_setjmp_setup", ftype,
9080
                        BUILT_IN_SETJMP_SETUP,
9081
                        "__builtin_setjmp_setup", ECF_NOTHROW);
9082
 
9083
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9084
  ftype = build_function_type (ptr_type_node, tmp);
9085
  local_define_builtin ("__builtin_setjmp_dispatcher", ftype,
9086
                        BUILT_IN_SETJMP_DISPATCHER,
9087
                        "__builtin_setjmp_dispatcher",
9088
                        ECF_PURE | ECF_NOTHROW);
9089
 
9090
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9091
  ftype = build_function_type (void_type_node, tmp);
9092
  local_define_builtin ("__builtin_setjmp_receiver", ftype,
9093
                        BUILT_IN_SETJMP_RECEIVER,
9094
                        "__builtin_setjmp_receiver", ECF_NOTHROW);
9095
 
9096
  ftype = build_function_type (ptr_type_node, void_list_node);
9097
  local_define_builtin ("__builtin_stack_save", ftype, BUILT_IN_STACK_SAVE,
9098
                        "__builtin_stack_save", ECF_NOTHROW);
9099
 
9100
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9101
  ftype = build_function_type (void_type_node, tmp);
9102
  local_define_builtin ("__builtin_stack_restore", ftype,
9103
                        BUILT_IN_STACK_RESTORE,
9104
                        "__builtin_stack_restore", ECF_NOTHROW);
9105
 
9106
  ftype = build_function_type (void_type_node, void_list_node);
9107
  local_define_builtin ("__builtin_profile_func_enter", ftype,
9108
                        BUILT_IN_PROFILE_FUNC_ENTER, "profile_func_enter", 0);
9109
  local_define_builtin ("__builtin_profile_func_exit", ftype,
9110
                        BUILT_IN_PROFILE_FUNC_EXIT, "profile_func_exit", 0);
9111
 
9112
  /* If there's a possibility that we might use the ARM EABI, build the
9113
    alternate __cxa_end_cleanup node used to resume from C++ and Java.  */
9114
  if (targetm.arm_eabi_unwinder)
9115
    {
9116
      ftype = build_function_type (void_type_node, void_list_node);
9117
      local_define_builtin ("__builtin_cxa_end_cleanup", ftype,
9118
                            BUILT_IN_CXA_END_CLEANUP,
9119
                            "__cxa_end_cleanup", ECF_NORETURN);
9120
    }
9121
 
9122
  tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
9123
  ftype = build_function_type (void_type_node, tmp);
9124
  local_define_builtin ("__builtin_unwind_resume", ftype,
9125
                        BUILT_IN_UNWIND_RESUME,
9126
                        (USING_SJLJ_EXCEPTIONS
9127
                         ? "_Unwind_SjLj_Resume" : "_Unwind_Resume"),
9128
                        ECF_NORETURN);
9129
 
9130
  /* The exception object and filter values from the runtime.  The argument
9131
     must be zero before exception lowering, i.e. from the front end.  After
9132
     exception lowering, it will be the region number for the exception
9133
     landing pad.  These functions are PURE instead of CONST to prevent
9134
     them from being hoisted past the exception edge that will initialize
9135
     its value in the landing pad.  */
9136
  tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9137
  ftype = build_function_type (ptr_type_node, tmp);
9138
  local_define_builtin ("__builtin_eh_pointer", ftype, BUILT_IN_EH_POINTER,
9139
                        "__builtin_eh_pointer", ECF_PURE | ECF_NOTHROW);
9140
 
9141
  tmp2 = lang_hooks.types.type_for_mode (targetm.eh_return_filter_mode (), 0);
9142
  ftype = build_function_type (tmp2, tmp);
9143
  local_define_builtin ("__builtin_eh_filter", ftype, BUILT_IN_EH_FILTER,
9144
                        "__builtin_eh_filter", ECF_PURE | ECF_NOTHROW);
9145
 
9146
  tmp = tree_cons (NULL_TREE, integer_type_node, void_list_node);
9147
  tmp = tree_cons (NULL_TREE, integer_type_node, tmp);
9148
  ftype = build_function_type (void_type_node, tmp);
9149
  local_define_builtin ("__builtin_eh_copy_values", ftype,
9150
                        BUILT_IN_EH_COPY_VALUES,
9151
                        "__builtin_eh_copy_values", ECF_NOTHROW);
9152
 
9153
  /* Complex multiplication and division.  These are handled as builtins
9154
     rather than optabs because emit_library_call_value doesn't support
9155
     complex.  Further, we can do slightly better with folding these
9156
     beasties if the real and complex parts of the arguments are separate.  */
9157
  {
9158
    int mode;
9159
 
9160
    for (mode = MIN_MODE_COMPLEX_FLOAT; mode <= MAX_MODE_COMPLEX_FLOAT; ++mode)
9161
      {
9162
        char mode_name_buf[4], *q;
9163
        const char *p;
9164
        enum built_in_function mcode, dcode;
9165
        tree type, inner_type;
9166
 
9167
        type = lang_hooks.types.type_for_mode ((enum machine_mode) mode, 0);
9168
        if (type == NULL)
9169
          continue;
9170
        inner_type = TREE_TYPE (type);
9171
 
9172
        tmp = tree_cons (NULL_TREE, inner_type, void_list_node);
9173
        tmp = tree_cons (NULL_TREE, inner_type, tmp);
9174
        tmp = tree_cons (NULL_TREE, inner_type, tmp);
9175
        tmp = tree_cons (NULL_TREE, inner_type, tmp);
9176
        ftype = build_function_type (type, tmp);
9177
 
9178
        mcode = ((enum built_in_function)
9179
                 (BUILT_IN_COMPLEX_MUL_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9180
        dcode = ((enum built_in_function)
9181
                 (BUILT_IN_COMPLEX_DIV_MIN + mode - MIN_MODE_COMPLEX_FLOAT));
9182
 
9183
        for (p = GET_MODE_NAME (mode), q = mode_name_buf; *p; p++, q++)
9184
          *q = TOLOWER (*p);
9185
        *q = '\0';
9186
 
9187
        built_in_names[mcode] = concat ("__mul", mode_name_buf, "3", NULL);
9188
        local_define_builtin (built_in_names[mcode], ftype, mcode,
9189
                              built_in_names[mcode], ECF_CONST | ECF_NOTHROW);
9190
 
9191
        built_in_names[dcode] = concat ("__div", mode_name_buf, "3", NULL);
9192
        local_define_builtin (built_in_names[dcode], ftype, dcode,
9193
                              built_in_names[dcode], ECF_CONST | ECF_NOTHROW);
9194
      }
9195
  }
9196
}
9197
 
9198
/* HACK.  GROSS.  This is absolutely disgusting.  I wish there was a
9199
   better way.
9200
 
9201
   If we requested a pointer to a vector, build up the pointers that
9202
   we stripped off while looking for the inner type.  Similarly for
9203
   return values from functions.
9204
 
9205
   The argument TYPE is the top of the chain, and BOTTOM is the
9206
   new type which we will point to.  */
9207
 
9208
tree
9209
reconstruct_complex_type (tree type, tree bottom)
9210
{
9211
  tree inner, outer;
9212
 
9213
  if (TREE_CODE (type) == POINTER_TYPE)
9214
    {
9215
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9216
      outer = build_pointer_type_for_mode (inner, TYPE_MODE (type),
9217
                                           TYPE_REF_CAN_ALIAS_ALL (type));
9218
    }
9219
  else if (TREE_CODE (type) == REFERENCE_TYPE)
9220
    {
9221
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9222
      outer = build_reference_type_for_mode (inner, TYPE_MODE (type),
9223
                                             TYPE_REF_CAN_ALIAS_ALL (type));
9224
    }
9225
  else if (TREE_CODE (type) == ARRAY_TYPE)
9226
    {
9227
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9228
      outer = build_array_type (inner, TYPE_DOMAIN (type));
9229
    }
9230
  else if (TREE_CODE (type) == FUNCTION_TYPE)
9231
    {
9232
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9233
      outer = build_function_type (inner, TYPE_ARG_TYPES (type));
9234
    }
9235
  else if (TREE_CODE (type) == METHOD_TYPE)
9236
    {
9237
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9238
      /* The build_method_type_directly() routine prepends 'this' to argument list,
9239
         so we must compensate by getting rid of it.  */
9240
      outer
9241
        = build_method_type_directly
9242
            (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (type))),
9243
             inner,
9244
             TREE_CHAIN (TYPE_ARG_TYPES (type)));
9245
    }
9246
  else if (TREE_CODE (type) == OFFSET_TYPE)
9247
    {
9248
      inner = reconstruct_complex_type (TREE_TYPE (type), bottom);
9249
      outer = build_offset_type (TYPE_OFFSET_BASETYPE (type), inner);
9250
    }
9251
  else
9252
    return bottom;
9253
 
9254
  return build_type_attribute_qual_variant (outer, TYPE_ATTRIBUTES (type),
9255
                                            TYPE_QUALS (type));
9256
}
9257
 
9258
/* Returns a vector tree node given a mode (integer, vector, or BLKmode) and
9259
   the inner type.  */
9260
tree
9261
build_vector_type_for_mode (tree innertype, enum machine_mode mode)
9262
{
9263
  int nunits;
9264
 
9265
  switch (GET_MODE_CLASS (mode))
9266
    {
9267
    case MODE_VECTOR_INT:
9268
    case MODE_VECTOR_FLOAT:
9269
    case MODE_VECTOR_FRACT:
9270
    case MODE_VECTOR_UFRACT:
9271
    case MODE_VECTOR_ACCUM:
9272
    case MODE_VECTOR_UACCUM:
9273
      nunits = GET_MODE_NUNITS (mode);
9274
      break;
9275
 
9276
    case MODE_INT:
9277
      /* Check that there are no leftover bits.  */
9278
      gcc_assert (GET_MODE_BITSIZE (mode)
9279
                  % TREE_INT_CST_LOW (TYPE_SIZE (innertype)) == 0);
9280
 
9281
      nunits = GET_MODE_BITSIZE (mode)
9282
               / TREE_INT_CST_LOW (TYPE_SIZE (innertype));
9283
      break;
9284
 
9285
    default:
9286
      gcc_unreachable ();
9287
    }
9288
 
9289
  return make_vector_type (innertype, nunits, mode);
9290
}
9291
 
9292
/* Similarly, but takes the inner type and number of units, which must be
9293
   a power of two.  */
9294
 
9295
tree
9296
build_vector_type (tree innertype, int nunits)
9297
{
9298
  return make_vector_type (innertype, nunits, VOIDmode);
9299
}
9300
 
9301
/* Similarly, but takes the inner type and number of units, which must be
9302
   a power of two.  */
9303
 
9304
tree
9305
build_opaque_vector_type (tree innertype, int nunits)
9306
{
9307
  tree t;
9308
  innertype = build_distinct_type_copy (innertype);
9309
  t = make_vector_type (innertype, nunits, VOIDmode);
9310
  TYPE_VECTOR_OPAQUE (t) = true;
9311
  return t;
9312
}
9313
 
9314
 
9315
/* Given an initializer INIT, return TRUE if INIT is zero or some
9316
   aggregate of zeros.  Otherwise return FALSE.  */
9317
bool
9318
initializer_zerop (const_tree init)
9319
{
9320
  tree elt;
9321
 
9322
  STRIP_NOPS (init);
9323
 
9324
  switch (TREE_CODE (init))
9325
    {
9326
    case INTEGER_CST:
9327
      return integer_zerop (init);
9328
 
9329
    case REAL_CST:
9330
      /* ??? Note that this is not correct for C4X float formats.  There,
9331
         a bit pattern of all zeros is 1.0; 0.0 is encoded with the most
9332
         negative exponent.  */
9333
      return real_zerop (init)
9334
        && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
9335
 
9336
    case FIXED_CST:
9337
      return fixed_zerop (init);
9338
 
9339
    case COMPLEX_CST:
9340
      return integer_zerop (init)
9341
        || (real_zerop (init)
9342
            && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
9343
            && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
9344
 
9345
    case VECTOR_CST:
9346
      for (elt = TREE_VECTOR_CST_ELTS (init); elt; elt = TREE_CHAIN (elt))
9347
        if (!initializer_zerop (TREE_VALUE (elt)))
9348
          return false;
9349
      return true;
9350
 
9351
    case CONSTRUCTOR:
9352
      {
9353
        unsigned HOST_WIDE_INT idx;
9354
 
9355
        FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (init), idx, elt)
9356
          if (!initializer_zerop (elt))
9357
            return false;
9358
        return true;
9359
      }
9360
 
9361
    default:
9362
      return false;
9363
    }
9364
}
9365
 
9366
/* Build an empty statement at location LOC.  */
9367
 
9368
tree
9369
build_empty_stmt (location_t loc)
9370
{
9371
  tree t = build1 (NOP_EXPR, void_type_node, size_zero_node);
9372
  SET_EXPR_LOCATION (t, loc);
9373
  return t;
9374
}
9375
 
9376
 
9377
/* Build an OpenMP clause with code CODE.  LOC is the location of the
9378
   clause.  */
9379
 
9380
tree
9381
build_omp_clause (location_t loc, enum omp_clause_code code)
9382
{
9383
  tree t;
9384
  int size, length;
9385
 
9386
  length = omp_clause_num_ops[code];
9387
  size = (sizeof (struct tree_omp_clause) + (length - 1) * sizeof (tree));
9388
 
9389
  t = GGC_NEWVAR (union tree_node, size);
9390
  memset (t, 0, size);
9391
  TREE_SET_CODE (t, OMP_CLAUSE);
9392
  OMP_CLAUSE_SET_CODE (t, code);
9393
  OMP_CLAUSE_LOCATION (t) = loc;
9394
 
9395
#ifdef GATHER_STATISTICS
9396
  tree_node_counts[(int) omp_clause_kind]++;
9397
  tree_node_sizes[(int) omp_clause_kind] += size;
9398
#endif
9399
 
9400
  return t;
9401
}
9402
 
9403
/* Build a tcc_vl_exp object with code CODE and room for LEN operands.  LEN
9404
   includes the implicit operand count in TREE_OPERAND 0, and so must be >= 1.
9405
   Except for the CODE and operand count field, other storage for the
9406
   object is initialized to zeros.  */
9407
 
9408
tree
9409
build_vl_exp_stat (enum tree_code code, int len MEM_STAT_DECL)
9410
{
9411
  tree t;
9412
  int length = (len - 1) * sizeof (tree) + sizeof (struct tree_exp);
9413
 
9414
  gcc_assert (TREE_CODE_CLASS (code) == tcc_vl_exp);
9415
  gcc_assert (len >= 1);
9416
 
9417
#ifdef GATHER_STATISTICS
9418
  tree_node_counts[(int) e_kind]++;
9419
  tree_node_sizes[(int) e_kind] += length;
9420
#endif
9421
 
9422
  t = (tree) ggc_alloc_zone_pass_stat (length, &tree_zone);
9423
 
9424
  memset (t, 0, length);
9425
 
9426
  TREE_SET_CODE (t, code);
9427
 
9428
  /* Can't use TREE_OPERAND to store the length because if checking is
9429
     enabled, it will try to check the length before we store it.  :-P  */
9430
  t->exp.operands[0] = build_int_cst (sizetype, len);
9431
 
9432
  return t;
9433
}
9434
 
9435
 
9436
/* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE
9437
   and FN and a null static chain slot.  ARGLIST is a TREE_LIST of the
9438
   arguments.  */
9439
 
9440
tree
9441
build_call_list (tree return_type, tree fn, tree arglist)
9442
{
9443
  tree t;
9444
  int i;
9445
 
9446
  t = build_vl_exp (CALL_EXPR, list_length (arglist) + 3);
9447
  TREE_TYPE (t) = return_type;
9448
  CALL_EXPR_FN (t) = fn;
9449
  CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9450
  for (i = 0; arglist; arglist = TREE_CHAIN (arglist), i++)
9451
    CALL_EXPR_ARG (t, i) = TREE_VALUE (arglist);
9452
  process_call_operands (t);
9453
  return t;
9454
}
9455
 
9456
/* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9457
   FN and a null static chain slot.  NARGS is the number of call arguments
9458
   which are specified as "..." arguments.  */
9459
 
9460
tree
9461
build_call_nary (tree return_type, tree fn, int nargs, ...)
9462
{
9463
  tree ret;
9464
  va_list args;
9465
  va_start (args, nargs);
9466
  ret = build_call_valist (return_type, fn, nargs, args);
9467
  va_end (args);
9468
  return ret;
9469
}
9470
 
9471
/* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9472
   FN and a null static chain slot.  NARGS is the number of call arguments
9473
   which are specified as a va_list ARGS.  */
9474
 
9475
tree
9476
build_call_valist (tree return_type, tree fn, int nargs, va_list args)
9477
{
9478
  tree t;
9479
  int i;
9480
 
9481
  t = build_vl_exp (CALL_EXPR, nargs + 3);
9482
  TREE_TYPE (t) = return_type;
9483
  CALL_EXPR_FN (t) = fn;
9484
  CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9485
  for (i = 0; i < nargs; i++)
9486
    CALL_EXPR_ARG (t, i) = va_arg (args, tree);
9487
  process_call_operands (t);
9488
  return t;
9489
}
9490
 
9491
/* Build a CALL_EXPR of class tcc_vl_exp with the indicated RETURN_TYPE and
9492
   FN and a null static chain slot.  NARGS is the number of call arguments
9493
   which are specified as a tree array ARGS.  */
9494
 
9495
tree
9496
build_call_array_loc (location_t loc, tree return_type, tree fn,
9497
                      int nargs, const tree *args)
9498
{
9499
  tree t;
9500
  int i;
9501
 
9502
  t = build_vl_exp (CALL_EXPR, nargs + 3);
9503
  TREE_TYPE (t) = return_type;
9504
  CALL_EXPR_FN (t) = fn;
9505
  CALL_EXPR_STATIC_CHAIN (t) = NULL_TREE;
9506
  for (i = 0; i < nargs; i++)
9507
    CALL_EXPR_ARG (t, i) = args[i];
9508
  process_call_operands (t);
9509
  SET_EXPR_LOCATION (t, loc);
9510
  return t;
9511
}
9512
 
9513
/* Like build_call_array, but takes a VEC.  */
9514
 
9515
tree
9516
build_call_vec (tree return_type, tree fn, VEC(tree,gc) *args)
9517
{
9518
  tree ret, t;
9519
  unsigned int ix;
9520
 
9521
  ret = build_vl_exp (CALL_EXPR, VEC_length (tree, args) + 3);
9522
  TREE_TYPE (ret) = return_type;
9523
  CALL_EXPR_FN (ret) = fn;
9524
  CALL_EXPR_STATIC_CHAIN (ret) = NULL_TREE;
9525
  for (ix = 0; VEC_iterate (tree, args, ix, t); ++ix)
9526
    CALL_EXPR_ARG (ret, ix) = t;
9527
  process_call_operands (ret);
9528
  return ret;
9529
}
9530
 
9531
 
9532
/* Returns true if it is possible to prove that the index of
9533
   an array access REF (an ARRAY_REF expression) falls into the
9534
   array bounds.  */
9535
 
9536
bool
9537
in_array_bounds_p (tree ref)
9538
{
9539
  tree idx = TREE_OPERAND (ref, 1);
9540
  tree min, max;
9541
 
9542
  if (TREE_CODE (idx) != INTEGER_CST)
9543
    return false;
9544
 
9545
  min = array_ref_low_bound (ref);
9546
  max = array_ref_up_bound (ref);
9547
  if (!min
9548
      || !max
9549
      || TREE_CODE (min) != INTEGER_CST
9550
      || TREE_CODE (max) != INTEGER_CST)
9551
    return false;
9552
 
9553
  if (tree_int_cst_lt (idx, min)
9554
      || tree_int_cst_lt (max, idx))
9555
    return false;
9556
 
9557
  return true;
9558
}
9559
 
9560
/* Returns true if it is possible to prove that the range of
9561
   an array access REF (an ARRAY_RANGE_REF expression) falls
9562
   into the array bounds.  */
9563
 
9564
bool
9565
range_in_array_bounds_p (tree ref)
9566
{
9567
  tree domain_type = TYPE_DOMAIN (TREE_TYPE (ref));
9568
  tree range_min, range_max, min, max;
9569
 
9570
  range_min = TYPE_MIN_VALUE (domain_type);
9571
  range_max = TYPE_MAX_VALUE (domain_type);
9572
  if (!range_min
9573
      || !range_max
9574
      || TREE_CODE (range_min) != INTEGER_CST
9575
      || TREE_CODE (range_max) != INTEGER_CST)
9576
    return false;
9577
 
9578
  min = array_ref_low_bound (ref);
9579
  max = array_ref_up_bound (ref);
9580
  if (!min
9581
      || !max
9582
      || TREE_CODE (min) != INTEGER_CST
9583
      || TREE_CODE (max) != INTEGER_CST)
9584
    return false;
9585
 
9586
  if (tree_int_cst_lt (range_min, min)
9587
      || tree_int_cst_lt (max, range_max))
9588
    return false;
9589
 
9590
  return true;
9591
}
9592
 
9593
/* Return true if T (assumed to be a DECL) must be assigned a memory
9594
   location.  */
9595
 
9596
bool
9597
needs_to_live_in_memory (const_tree t)
9598
{
9599
  if (TREE_CODE (t) == SSA_NAME)
9600
    t = SSA_NAME_VAR (t);
9601
 
9602
  return (TREE_ADDRESSABLE (t)
9603
          || is_global_var (t)
9604
          || (TREE_CODE (t) == RESULT_DECL
9605
              && aggregate_value_p (t, current_function_decl)));
9606
}
9607
 
9608
/* There are situations in which a language considers record types
9609
   compatible which have different field lists.  Decide if two fields
9610
   are compatible.  It is assumed that the parent records are compatible.  */
9611
 
9612
bool
9613
fields_compatible_p (const_tree f1, const_tree f2)
9614
{
9615
  if (!operand_equal_p (DECL_FIELD_BIT_OFFSET (f1),
9616
                        DECL_FIELD_BIT_OFFSET (f2), OEP_ONLY_CONST))
9617
    return false;
9618
 
9619
  if (!operand_equal_p (DECL_FIELD_OFFSET (f1),
9620
                        DECL_FIELD_OFFSET (f2), OEP_ONLY_CONST))
9621
    return false;
9622
 
9623
  if (!types_compatible_p (TREE_TYPE (f1), TREE_TYPE (f2)))
9624
    return false;
9625
 
9626
  return true;
9627
}
9628
 
9629
/* Locate within RECORD a field that is compatible with ORIG_FIELD.  */
9630
 
9631
tree
9632
find_compatible_field (tree record, tree orig_field)
9633
{
9634
  tree f;
9635
 
9636
  for (f = TYPE_FIELDS (record); f ; f = TREE_CHAIN (f))
9637
    if (TREE_CODE (f) == FIELD_DECL
9638
        && fields_compatible_p (f, orig_field))
9639
      return f;
9640
 
9641
  /* ??? Why isn't this on the main fields list?  */
9642
  f = TYPE_VFIELD (record);
9643
  if (f && TREE_CODE (f) == FIELD_DECL
9644
      && fields_compatible_p (f, orig_field))
9645
    return f;
9646
 
9647
  /* ??? We should abort here, but Java appears to do Bad Things
9648
     with inherited fields.  */
9649
  return orig_field;
9650
}
9651
 
9652
/* Return value of a constant X and sign-extend it.  */
9653
 
9654
HOST_WIDE_INT
9655
int_cst_value (const_tree x)
9656
{
9657
  unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9658
  unsigned HOST_WIDE_INT val = TREE_INT_CST_LOW (x);
9659
 
9660
  /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9661
  gcc_assert (TREE_INT_CST_HIGH (x) == 0
9662
              || TREE_INT_CST_HIGH (x) == -1);
9663
 
9664
  if (bits < HOST_BITS_PER_WIDE_INT)
9665
    {
9666
      bool negative = ((val >> (bits - 1)) & 1) != 0;
9667
      if (negative)
9668
        val |= (~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1;
9669
      else
9670
        val &= ~((~(unsigned HOST_WIDE_INT) 0) << (bits - 1) << 1);
9671
    }
9672
 
9673
  return val;
9674
}
9675
 
9676
/* Return value of a constant X and sign-extend it.  */
9677
 
9678
HOST_WIDEST_INT
9679
widest_int_cst_value (const_tree x)
9680
{
9681
  unsigned bits = TYPE_PRECISION (TREE_TYPE (x));
9682
  unsigned HOST_WIDEST_INT val = TREE_INT_CST_LOW (x);
9683
 
9684
#if HOST_BITS_PER_WIDEST_INT > HOST_BITS_PER_WIDE_INT
9685
  gcc_assert (HOST_BITS_PER_WIDEST_INT >= 2 * HOST_BITS_PER_WIDE_INT);
9686
  val |= (((unsigned HOST_WIDEST_INT) TREE_INT_CST_HIGH (x))
9687
          << HOST_BITS_PER_WIDE_INT);
9688
#else
9689
  /* Make sure the sign-extended value will fit in a HOST_WIDE_INT.  */
9690
  gcc_assert (TREE_INT_CST_HIGH (x) == 0
9691
              || TREE_INT_CST_HIGH (x) == -1);
9692
#endif
9693
 
9694
  if (bits < HOST_BITS_PER_WIDEST_INT)
9695
    {
9696
      bool negative = ((val >> (bits - 1)) & 1) != 0;
9697
      if (negative)
9698
        val |= (~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1;
9699
      else
9700
        val &= ~((~(unsigned HOST_WIDEST_INT) 0) << (bits - 1) << 1);
9701
    }
9702
 
9703
  return val;
9704
}
9705
 
9706
/* If TYPE is an integral type, return an equivalent type which is
9707
    unsigned iff UNSIGNEDP is true.  If TYPE is not an integral type,
9708
    return TYPE itself.  */
9709
 
9710
tree
9711
signed_or_unsigned_type_for (int unsignedp, tree type)
9712
{
9713
  tree t = type;
9714
  if (POINTER_TYPE_P (type))
9715
    {
9716
      /* If the pointer points to the normal address space, use the
9717
         size_type_node.  Otherwise use an appropriate size for the pointer
9718
         based on the named address space it points to.  */
9719
      if (!TYPE_ADDR_SPACE (TREE_TYPE (t)))
9720
        t = size_type_node;
9721
      else
9722
        return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9723
    }
9724
 
9725
  if (!INTEGRAL_TYPE_P (t) || TYPE_UNSIGNED (t) == unsignedp)
9726
    return t;
9727
 
9728
  return lang_hooks.types.type_for_size (TYPE_PRECISION (t), unsignedp);
9729
}
9730
 
9731
/* Returns unsigned variant of TYPE.  */
9732
 
9733
tree
9734
unsigned_type_for (tree type)
9735
{
9736
  return signed_or_unsigned_type_for (1, type);
9737
}
9738
 
9739
/* Returns signed variant of TYPE.  */
9740
 
9741
tree
9742
signed_type_for (tree type)
9743
{
9744
  return signed_or_unsigned_type_for (0, type);
9745
}
9746
 
9747
/* Returns the largest value obtainable by casting something in INNER type to
9748
   OUTER type.  */
9749
 
9750
tree
9751
upper_bound_in_type (tree outer, tree inner)
9752
{
9753
  unsigned HOST_WIDE_INT lo, hi;
9754
  unsigned int det = 0;
9755
  unsigned oprec = TYPE_PRECISION (outer);
9756
  unsigned iprec = TYPE_PRECISION (inner);
9757
  unsigned prec;
9758
 
9759
  /* Compute a unique number for every combination.  */
9760
  det |= (oprec > iprec) ? 4 : 0;
9761
  det |= TYPE_UNSIGNED (outer) ? 2 : 0;
9762
  det |= TYPE_UNSIGNED (inner) ? 1 : 0;
9763
 
9764
  /* Determine the exponent to use.  */
9765
  switch (det)
9766
    {
9767
    case 0:
9768
    case 1:
9769
      /* oprec <= iprec, outer: signed, inner: don't care.  */
9770
      prec = oprec - 1;
9771
      break;
9772
    case 2:
9773
    case 3:
9774
      /* oprec <= iprec, outer: unsigned, inner: don't care.  */
9775
      prec = oprec;
9776
      break;
9777
    case 4:
9778
      /* oprec > iprec, outer: signed, inner: signed.  */
9779
      prec = iprec - 1;
9780
      break;
9781
    case 5:
9782
      /* oprec > iprec, outer: signed, inner: unsigned.  */
9783
      prec = iprec;
9784
      break;
9785
    case 6:
9786
      /* oprec > iprec, outer: unsigned, inner: signed.  */
9787
      prec = oprec;
9788
      break;
9789
    case 7:
9790
      /* oprec > iprec, outer: unsigned, inner: unsigned.  */
9791
      prec = iprec;
9792
      break;
9793
    default:
9794
      gcc_unreachable ();
9795
    }
9796
 
9797
  /* Compute 2^^prec - 1.  */
9798
  if (prec <= HOST_BITS_PER_WIDE_INT)
9799
    {
9800
      hi = 0;
9801
      lo = ((~(unsigned HOST_WIDE_INT) 0)
9802
            >> (HOST_BITS_PER_WIDE_INT - prec));
9803
    }
9804
  else
9805
    {
9806
      hi = ((~(unsigned HOST_WIDE_INT) 0)
9807
            >> (2 * HOST_BITS_PER_WIDE_INT - prec));
9808
      lo = ~(unsigned HOST_WIDE_INT) 0;
9809
    }
9810
 
9811
  return build_int_cst_wide (outer, lo, hi);
9812
}
9813
 
9814
/* Returns the smallest value obtainable by casting something in INNER type to
9815
   OUTER type.  */
9816
 
9817
tree
9818
lower_bound_in_type (tree outer, tree inner)
9819
{
9820
  unsigned HOST_WIDE_INT lo, hi;
9821
  unsigned oprec = TYPE_PRECISION (outer);
9822
  unsigned iprec = TYPE_PRECISION (inner);
9823
 
9824
  /* If OUTER type is unsigned, we can definitely cast 0 to OUTER type
9825
     and obtain 0.  */
9826
  if (TYPE_UNSIGNED (outer)
9827
      /* If we are widening something of an unsigned type, OUTER type
9828
         contains all values of INNER type.  In particular, both INNER
9829
         and OUTER types have zero in common.  */
9830
      || (oprec > iprec && TYPE_UNSIGNED (inner)))
9831
    lo = hi = 0;
9832
  else
9833
    {
9834
      /* If we are widening a signed type to another signed type, we
9835
         want to obtain -2^^(iprec-1).  If we are keeping the
9836
         precision or narrowing to a signed type, we want to obtain
9837
         -2^(oprec-1).  */
9838
      unsigned prec = oprec > iprec ? iprec : oprec;
9839
 
9840
      if (prec <= HOST_BITS_PER_WIDE_INT)
9841
        {
9842
          hi = ~(unsigned HOST_WIDE_INT) 0;
9843
          lo = (~(unsigned HOST_WIDE_INT) 0) << (prec - 1);
9844
        }
9845
      else
9846
        {
9847
          hi = ((~(unsigned HOST_WIDE_INT) 0)
9848
                << (prec - HOST_BITS_PER_WIDE_INT - 1));
9849
          lo = 0;
9850
        }
9851
    }
9852
 
9853
  return build_int_cst_wide (outer, lo, hi);
9854
}
9855
 
9856
/* Return nonzero if two operands that are suitable for PHI nodes are
9857
   necessarily equal.  Specifically, both ARG0 and ARG1 must be either
9858
   SSA_NAME or invariant.  Note that this is strictly an optimization.
9859
   That is, callers of this function can directly call operand_equal_p
9860
   and get the same result, only slower.  */
9861
 
9862
int
9863
operand_equal_for_phi_arg_p (const_tree arg0, const_tree arg1)
9864
{
9865
  if (arg0 == arg1)
9866
    return 1;
9867
  if (TREE_CODE (arg0) == SSA_NAME || TREE_CODE (arg1) == SSA_NAME)
9868
    return 0;
9869
  return operand_equal_p (arg0, arg1, 0);
9870
}
9871
 
9872
/* Returns number of zeros at the end of binary representation of X.
9873
 
9874
   ??? Use ffs if available?  */
9875
 
9876
tree
9877
num_ending_zeros (const_tree x)
9878
{
9879
  unsigned HOST_WIDE_INT fr, nfr;
9880
  unsigned num, abits;
9881
  tree type = TREE_TYPE (x);
9882
 
9883
  if (TREE_INT_CST_LOW (x) == 0)
9884
    {
9885
      num = HOST_BITS_PER_WIDE_INT;
9886
      fr = TREE_INT_CST_HIGH (x);
9887
    }
9888
  else
9889
    {
9890
      num = 0;
9891
      fr = TREE_INT_CST_LOW (x);
9892
    }
9893
 
9894
  for (abits = HOST_BITS_PER_WIDE_INT / 2; abits; abits /= 2)
9895
    {
9896
      nfr = fr >> abits;
9897
      if (nfr << abits == fr)
9898
        {
9899
          num += abits;
9900
          fr = nfr;
9901
        }
9902
    }
9903
 
9904
  if (num > TYPE_PRECISION (type))
9905
    num = TYPE_PRECISION (type);
9906
 
9907
  return build_int_cst_type (type, num);
9908
}
9909
 
9910
 
9911
#define WALK_SUBTREE(NODE)                              \
9912
  do                                                    \
9913
    {                                                   \
9914
      result = walk_tree_1 (&(NODE), func, data, pset, lh);     \
9915
      if (result)                                       \
9916
        return result;                                  \
9917
    }                                                   \
9918
  while (0)
9919
 
9920
/* This is a subroutine of walk_tree that walks field of TYPE that are to
9921
   be walked whenever a type is seen in the tree.  Rest of operands and return
9922
   value are as for walk_tree.  */
9923
 
9924
static tree
9925
walk_type_fields (tree type, walk_tree_fn func, void *data,
9926
                  struct pointer_set_t *pset, walk_tree_lh lh)
9927
{
9928
  tree result = NULL_TREE;
9929
 
9930
  switch (TREE_CODE (type))
9931
    {
9932
    case POINTER_TYPE:
9933
    case REFERENCE_TYPE:
9934
      /* We have to worry about mutually recursive pointers.  These can't
9935
         be written in C.  They can in Ada.  It's pathological, but
9936
         there's an ACATS test (c38102a) that checks it.  Deal with this
9937
         by checking if we're pointing to another pointer, that one
9938
         points to another pointer, that one does too, and we have no htab.
9939
         If so, get a hash table.  We check three levels deep to avoid
9940
         the cost of the hash table if we don't need one.  */
9941
      if (POINTER_TYPE_P (TREE_TYPE (type))
9942
          && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (type)))
9943
          && POINTER_TYPE_P (TREE_TYPE (TREE_TYPE (TREE_TYPE (type))))
9944
          && !pset)
9945
        {
9946
          result = walk_tree_without_duplicates (&TREE_TYPE (type),
9947
                                                 func, data);
9948
          if (result)
9949
            return result;
9950
 
9951
          break;
9952
        }
9953
 
9954
      /* ... fall through ... */
9955
 
9956
    case COMPLEX_TYPE:
9957
      WALK_SUBTREE (TREE_TYPE (type));
9958
      break;
9959
 
9960
    case METHOD_TYPE:
9961
      WALK_SUBTREE (TYPE_METHOD_BASETYPE (type));
9962
 
9963
      /* Fall through.  */
9964
 
9965
    case FUNCTION_TYPE:
9966
      WALK_SUBTREE (TREE_TYPE (type));
9967
      {
9968
        tree arg;
9969
 
9970
        /* We never want to walk into default arguments.  */
9971
        for (arg = TYPE_ARG_TYPES (type); arg; arg = TREE_CHAIN (arg))
9972
          WALK_SUBTREE (TREE_VALUE (arg));
9973
      }
9974
      break;
9975
 
9976
    case ARRAY_TYPE:
9977
      /* Don't follow this nodes's type if a pointer for fear that
9978
         we'll have infinite recursion.  If we have a PSET, then we
9979
         need not fear.  */
9980
      if (pset
9981
          || (!POINTER_TYPE_P (TREE_TYPE (type))
9982
              && TREE_CODE (TREE_TYPE (type)) != OFFSET_TYPE))
9983
        WALK_SUBTREE (TREE_TYPE (type));
9984
      WALK_SUBTREE (TYPE_DOMAIN (type));
9985
      break;
9986
 
9987
    case OFFSET_TYPE:
9988
      WALK_SUBTREE (TREE_TYPE (type));
9989
      WALK_SUBTREE (TYPE_OFFSET_BASETYPE (type));
9990
      break;
9991
 
9992
    default:
9993
      break;
9994
    }
9995
 
9996
  return NULL_TREE;
9997
}
9998
 
9999
/* Apply FUNC to all the sub-trees of TP in a pre-order traversal.  FUNC is
10000
   called with the DATA and the address of each sub-tree.  If FUNC returns a
10001
   non-NULL value, the traversal is stopped, and the value returned by FUNC
10002
   is returned.  If PSET is non-NULL it is used to record the nodes visited,
10003
   and to avoid visiting a node more than once.  */
10004
 
10005
tree
10006
walk_tree_1 (tree *tp, walk_tree_fn func, void *data,
10007
             struct pointer_set_t *pset, walk_tree_lh lh)
10008
{
10009
  enum tree_code code;
10010
  int walk_subtrees;
10011
  tree result;
10012
 
10013
#define WALK_SUBTREE_TAIL(NODE)                         \
10014
  do                                                    \
10015
    {                                                   \
10016
       tp = & (NODE);                                   \
10017
       goto tail_recurse;                               \
10018
    }                                                   \
10019
  while (0)
10020
 
10021
 tail_recurse:
10022
  /* Skip empty subtrees.  */
10023
  if (!*tp)
10024
    return NULL_TREE;
10025
 
10026
  /* Don't walk the same tree twice, if the user has requested
10027
     that we avoid doing so.  */
10028
  if (pset && pointer_set_insert (pset, *tp))
10029
    return NULL_TREE;
10030
 
10031
  /* Call the function.  */
10032
  walk_subtrees = 1;
10033
  result = (*func) (tp, &walk_subtrees, data);
10034
 
10035
  /* If we found something, return it.  */
10036
  if (result)
10037
    return result;
10038
 
10039
  code = TREE_CODE (*tp);
10040
 
10041
  /* Even if we didn't, FUNC may have decided that there was nothing
10042
     interesting below this point in the tree.  */
10043
  if (!walk_subtrees)
10044
    {
10045
      /* But we still need to check our siblings.  */
10046
      if (code == TREE_LIST)
10047
        WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10048
      else if (code == OMP_CLAUSE)
10049
        WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10050
      else
10051
        return NULL_TREE;
10052
    }
10053
 
10054
  if (lh)
10055
    {
10056
      result = (*lh) (tp, &walk_subtrees, func, data, pset);
10057
      if (result || !walk_subtrees)
10058
        return result;
10059
    }
10060
 
10061
  switch (code)
10062
    {
10063
    case ERROR_MARK:
10064
    case IDENTIFIER_NODE:
10065
    case INTEGER_CST:
10066
    case REAL_CST:
10067
    case FIXED_CST:
10068
    case VECTOR_CST:
10069
    case STRING_CST:
10070
    case BLOCK:
10071
    case PLACEHOLDER_EXPR:
10072
    case SSA_NAME:
10073
    case FIELD_DECL:
10074
    case RESULT_DECL:
10075
      /* None of these have subtrees other than those already walked
10076
         above.  */
10077
      break;
10078
 
10079
    case TREE_LIST:
10080
      WALK_SUBTREE (TREE_VALUE (*tp));
10081
      WALK_SUBTREE_TAIL (TREE_CHAIN (*tp));
10082
      break;
10083
 
10084
    case TREE_VEC:
10085
      {
10086
        int len = TREE_VEC_LENGTH (*tp);
10087
 
10088
        if (len == 0)
10089
          break;
10090
 
10091
        /* Walk all elements but the first.  */
10092
        while (--len)
10093
          WALK_SUBTREE (TREE_VEC_ELT (*tp, len));
10094
 
10095
        /* Now walk the first one as a tail call.  */
10096
        WALK_SUBTREE_TAIL (TREE_VEC_ELT (*tp, 0));
10097
      }
10098
 
10099
    case COMPLEX_CST:
10100
      WALK_SUBTREE (TREE_REALPART (*tp));
10101
      WALK_SUBTREE_TAIL (TREE_IMAGPART (*tp));
10102
 
10103
    case CONSTRUCTOR:
10104
      {
10105
        unsigned HOST_WIDE_INT idx;
10106
        constructor_elt *ce;
10107
 
10108
        for (idx = 0;
10109
             VEC_iterate(constructor_elt, CONSTRUCTOR_ELTS (*tp), idx, ce);
10110
             idx++)
10111
          WALK_SUBTREE (ce->value);
10112
      }
10113
      break;
10114
 
10115
    case SAVE_EXPR:
10116
      WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, 0));
10117
 
10118
    case BIND_EXPR:
10119
      {
10120
        tree decl;
10121
        for (decl = BIND_EXPR_VARS (*tp); decl; decl = TREE_CHAIN (decl))
10122
          {
10123
            /* Walk the DECL_INITIAL and DECL_SIZE.  We don't want to walk
10124
               into declarations that are just mentioned, rather than
10125
               declared; they don't really belong to this part of the tree.
10126
               And, we can see cycles: the initializer for a declaration
10127
               can refer to the declaration itself.  */
10128
            WALK_SUBTREE (DECL_INITIAL (decl));
10129
            WALK_SUBTREE (DECL_SIZE (decl));
10130
            WALK_SUBTREE (DECL_SIZE_UNIT (decl));
10131
          }
10132
        WALK_SUBTREE_TAIL (BIND_EXPR_BODY (*tp));
10133
      }
10134
 
10135
    case STATEMENT_LIST:
10136
      {
10137
        tree_stmt_iterator i;
10138
        for (i = tsi_start (*tp); !tsi_end_p (i); tsi_next (&i))
10139
          WALK_SUBTREE (*tsi_stmt_ptr (i));
10140
      }
10141
      break;
10142
 
10143
    case OMP_CLAUSE:
10144
      switch (OMP_CLAUSE_CODE (*tp))
10145
        {
10146
        case OMP_CLAUSE_PRIVATE:
10147
        case OMP_CLAUSE_SHARED:
10148
        case OMP_CLAUSE_FIRSTPRIVATE:
10149
        case OMP_CLAUSE_COPYIN:
10150
        case OMP_CLAUSE_COPYPRIVATE:
10151
        case OMP_CLAUSE_IF:
10152
        case OMP_CLAUSE_NUM_THREADS:
10153
        case OMP_CLAUSE_SCHEDULE:
10154
          WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, 0));
10155
          /* FALLTHRU */
10156
 
10157
        case OMP_CLAUSE_NOWAIT:
10158
        case OMP_CLAUSE_ORDERED:
10159
        case OMP_CLAUSE_DEFAULT:
10160
        case OMP_CLAUSE_UNTIED:
10161
          WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10162
 
10163
        case OMP_CLAUSE_LASTPRIVATE:
10164
          WALK_SUBTREE (OMP_CLAUSE_DECL (*tp));
10165
          WALK_SUBTREE (OMP_CLAUSE_LASTPRIVATE_STMT (*tp));
10166
          WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10167
 
10168
        case OMP_CLAUSE_COLLAPSE:
10169
          {
10170
            int i;
10171
            for (i = 0; i < 3; i++)
10172
              WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10173
            WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10174
          }
10175
 
10176
        case OMP_CLAUSE_REDUCTION:
10177
          {
10178
            int i;
10179
            for (i = 0; i < 4; i++)
10180
              WALK_SUBTREE (OMP_CLAUSE_OPERAND (*tp, i));
10181
            WALK_SUBTREE_TAIL (OMP_CLAUSE_CHAIN (*tp));
10182
          }
10183
 
10184
        default:
10185
          gcc_unreachable ();
10186
        }
10187
      break;
10188
 
10189
    case TARGET_EXPR:
10190
      {
10191
        int i, len;
10192
 
10193
        /* TARGET_EXPRs are peculiar: operands 1 and 3 can be the same.
10194
           But, we only want to walk once.  */
10195
        len = (TREE_OPERAND (*tp, 3) == TREE_OPERAND (*tp, 1)) ? 2 : 3;
10196
        for (i = 0; i < len; ++i)
10197
          WALK_SUBTREE (TREE_OPERAND (*tp, i));
10198
        WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len));
10199
      }
10200
 
10201
    case DECL_EXPR:
10202
      /* If this is a TYPE_DECL, walk into the fields of the type that it's
10203
         defining.  We only want to walk into these fields of a type in this
10204
         case and not in the general case of a mere reference to the type.
10205
 
10206
         The criterion is as follows: if the field can be an expression, it
10207
         must be walked only here.  This should be in keeping with the fields
10208
         that are directly gimplified in gimplify_type_sizes in order for the
10209
         mark/copy-if-shared/unmark machinery of the gimplifier to work with
10210
         variable-sized types.
10211
 
10212
         Note that DECLs get walked as part of processing the BIND_EXPR.  */
10213
      if (TREE_CODE (DECL_EXPR_DECL (*tp)) == TYPE_DECL)
10214
        {
10215
          tree *type_p = &TREE_TYPE (DECL_EXPR_DECL (*tp));
10216
          if (TREE_CODE (*type_p) == ERROR_MARK)
10217
            return NULL_TREE;
10218
 
10219
          /* Call the function for the type.  See if it returns anything or
10220
             doesn't want us to continue.  If we are to continue, walk both
10221
             the normal fields and those for the declaration case.  */
10222
          result = (*func) (type_p, &walk_subtrees, data);
10223
          if (result || !walk_subtrees)
10224
            return result;
10225
 
10226
          result = walk_type_fields (*type_p, func, data, pset, lh);
10227
          if (result)
10228
            return result;
10229
 
10230
          /* If this is a record type, also walk the fields.  */
10231
          if (RECORD_OR_UNION_TYPE_P (*type_p))
10232
            {
10233
              tree field;
10234
 
10235
              for (field = TYPE_FIELDS (*type_p); field;
10236
                   field = TREE_CHAIN (field))
10237
                {
10238
                  /* We'd like to look at the type of the field, but we can
10239
                     easily get infinite recursion.  So assume it's pointed
10240
                     to elsewhere in the tree.  Also, ignore things that
10241
                     aren't fields.  */
10242
                  if (TREE_CODE (field) != FIELD_DECL)
10243
                    continue;
10244
 
10245
                  WALK_SUBTREE (DECL_FIELD_OFFSET (field));
10246
                  WALK_SUBTREE (DECL_SIZE (field));
10247
                  WALK_SUBTREE (DECL_SIZE_UNIT (field));
10248
                  if (TREE_CODE (*type_p) == QUAL_UNION_TYPE)
10249
                    WALK_SUBTREE (DECL_QUALIFIER (field));
10250
                }
10251
            }
10252
 
10253
          /* Same for scalar types.  */
10254
          else if (TREE_CODE (*type_p) == BOOLEAN_TYPE
10255
                   || TREE_CODE (*type_p) == ENUMERAL_TYPE
10256
                   || TREE_CODE (*type_p) == INTEGER_TYPE
10257
                   || TREE_CODE (*type_p) == FIXED_POINT_TYPE
10258
                   || TREE_CODE (*type_p) == REAL_TYPE)
10259
            {
10260
              WALK_SUBTREE (TYPE_MIN_VALUE (*type_p));
10261
              WALK_SUBTREE (TYPE_MAX_VALUE (*type_p));
10262
            }
10263
 
10264
          WALK_SUBTREE (TYPE_SIZE (*type_p));
10265
          WALK_SUBTREE_TAIL (TYPE_SIZE_UNIT (*type_p));
10266
        }
10267
      /* FALLTHRU */
10268
 
10269
    default:
10270
      if (IS_EXPR_CODE_CLASS (TREE_CODE_CLASS (code)))
10271
        {
10272
          int i, len;
10273
 
10274
          /* Walk over all the sub-trees of this operand.  */
10275
          len = TREE_OPERAND_LENGTH (*tp);
10276
 
10277
          /* Go through the subtrees.  We need to do this in forward order so
10278
             that the scope of a FOR_EXPR is handled properly.  */
10279
          if (len)
10280
            {
10281
              for (i = 0; i < len - 1; ++i)
10282
                WALK_SUBTREE (TREE_OPERAND (*tp, i));
10283
              WALK_SUBTREE_TAIL (TREE_OPERAND (*tp, len - 1));
10284
            }
10285
        }
10286
      /* If this is a type, walk the needed fields in the type.  */
10287
      else if (TYPE_P (*tp))
10288
        return walk_type_fields (*tp, func, data, pset, lh);
10289
      break;
10290
    }
10291
 
10292
  /* We didn't find what we were looking for.  */
10293
  return NULL_TREE;
10294
 
10295
#undef WALK_SUBTREE_TAIL
10296
}
10297
#undef WALK_SUBTREE
10298
 
10299
/* Like walk_tree, but does not walk duplicate nodes more than once.  */
10300
 
10301
tree
10302
walk_tree_without_duplicates_1 (tree *tp, walk_tree_fn func, void *data,
10303
                                walk_tree_lh lh)
10304
{
10305
  tree result;
10306
  struct pointer_set_t *pset;
10307
 
10308
  pset = pointer_set_create ();
10309
  result = walk_tree_1 (tp, func, data, pset, lh);
10310
  pointer_set_destroy (pset);
10311
  return result;
10312
}
10313
 
10314
 
10315
tree *
10316
tree_block (tree t)
10317
{
10318
  char const c = TREE_CODE_CLASS (TREE_CODE (t));
10319
 
10320
  if (IS_EXPR_CODE_CLASS (c))
10321
    return &t->exp.block;
10322
  gcc_unreachable ();
10323
  return NULL;
10324
}
10325
 
10326
/* Build and return a TREE_LIST of arguments in the CALL_EXPR exp.
10327
   FIXME: don't use this function.  It exists for compatibility with
10328
   the old representation of CALL_EXPRs where a list was used to hold the
10329
   arguments.  Places that currently extract the arglist from a CALL_EXPR
10330
   ought to be rewritten to use the CALL_EXPR itself.  */
10331
tree
10332
call_expr_arglist (tree exp)
10333
{
10334
  tree arglist = NULL_TREE;
10335
  int i;
10336
  for (i = call_expr_nargs (exp) - 1; i >= 0; i--)
10337
    arglist = tree_cons (NULL_TREE, CALL_EXPR_ARG (exp, i), arglist);
10338
  return arglist;
10339
}
10340
 
10341
 
10342
/* Create a nameless artificial label and put it in the current
10343
   function context.  The label has a location of LOC.  Returns the
10344
   newly created label.  */
10345
 
10346
tree
10347
create_artificial_label (location_t loc)
10348
{
10349
  tree lab = build_decl (loc,
10350
                         LABEL_DECL, NULL_TREE, void_type_node);
10351
 
10352
  DECL_ARTIFICIAL (lab) = 1;
10353
  DECL_IGNORED_P (lab) = 1;
10354
  DECL_CONTEXT (lab) = current_function_decl;
10355
  return lab;
10356
}
10357
 
10358
/*  Given a tree, try to return a useful variable name that we can use
10359
    to prefix a temporary that is being assigned the value of the tree.
10360
    I.E. given  <temp> = &A, return A.  */
10361
 
10362
const char *
10363
get_name (tree t)
10364
{
10365
  tree stripped_decl;
10366
 
10367
  stripped_decl = t;
10368
  STRIP_NOPS (stripped_decl);
10369
  if (DECL_P (stripped_decl) && DECL_NAME (stripped_decl))
10370
    return IDENTIFIER_POINTER (DECL_NAME (stripped_decl));
10371
  else
10372
    {
10373
      switch (TREE_CODE (stripped_decl))
10374
        {
10375
        case ADDR_EXPR:
10376
          return get_name (TREE_OPERAND (stripped_decl, 0));
10377
        default:
10378
          return NULL;
10379
        }
10380
    }
10381
}
10382
 
10383
/* Return true if TYPE has a variable argument list.  */
10384
 
10385
bool
10386
stdarg_p (tree fntype)
10387
{
10388
  function_args_iterator args_iter;
10389
  tree n = NULL_TREE, t;
10390
 
10391
  if (!fntype)
10392
    return false;
10393
 
10394
  FOREACH_FUNCTION_ARGS(fntype, t, args_iter)
10395
    {
10396
      n = t;
10397
    }
10398
 
10399
  return n != NULL_TREE && n != void_type_node;
10400
}
10401
 
10402
/* Return true if TYPE has a prototype.  */
10403
 
10404
bool
10405
prototype_p (tree fntype)
10406
{
10407
  tree t;
10408
 
10409
  gcc_assert (fntype != NULL_TREE);
10410
 
10411
  t = TYPE_ARG_TYPES (fntype);
10412
  return (t != NULL_TREE);
10413
}
10414
 
10415
/* If BLOCK is inlined from an __attribute__((__artificial__))
10416
   routine, return pointer to location from where it has been
10417
   called.  */
10418
location_t *
10419
block_nonartificial_location (tree block)
10420
{
10421
  location_t *ret = NULL;
10422
 
10423
  while (block && TREE_CODE (block) == BLOCK
10424
         && BLOCK_ABSTRACT_ORIGIN (block))
10425
    {
10426
      tree ao = BLOCK_ABSTRACT_ORIGIN (block);
10427
 
10428
      while (TREE_CODE (ao) == BLOCK
10429
             && BLOCK_ABSTRACT_ORIGIN (ao)
10430
             && BLOCK_ABSTRACT_ORIGIN (ao) != ao)
10431
        ao = BLOCK_ABSTRACT_ORIGIN (ao);
10432
 
10433
      if (TREE_CODE (ao) == FUNCTION_DECL)
10434
        {
10435
          /* If AO is an artificial inline, point RET to the
10436
             call site locus at which it has been inlined and continue
10437
             the loop, in case AO's caller is also an artificial
10438
             inline.  */
10439
          if (DECL_DECLARED_INLINE_P (ao)
10440
              && lookup_attribute ("artificial", DECL_ATTRIBUTES (ao)))
10441
            ret = &BLOCK_SOURCE_LOCATION (block);
10442
          else
10443
            break;
10444
        }
10445
      else if (TREE_CODE (ao) != BLOCK)
10446
        break;
10447
 
10448
      block = BLOCK_SUPERCONTEXT (block);
10449
    }
10450
  return ret;
10451
}
10452
 
10453
 
10454
/* If EXP is inlined from an __attribute__((__artificial__))
10455
   function, return the location of the original call expression.  */
10456
 
10457
location_t
10458
tree_nonartificial_location (tree exp)
10459
{
10460
  location_t *loc = block_nonartificial_location (TREE_BLOCK (exp));
10461
 
10462
  if (loc)
10463
    return *loc;
10464
  else
10465
    return EXPR_LOCATION (exp);
10466
}
10467
 
10468
 
10469
/* These are the hash table functions for the hash table of OPTIMIZATION_NODEq
10470
   nodes.  */
10471
 
10472
/* Return the hash code code X, an OPTIMIZATION_NODE or TARGET_OPTION code.  */
10473
 
10474
static hashval_t
10475
cl_option_hash_hash (const void *x)
10476
{
10477
  const_tree const t = (const_tree) x;
10478
  const char *p;
10479
  size_t i;
10480
  size_t len = 0;
10481
  hashval_t hash = 0;
10482
 
10483
  if (TREE_CODE (t) == OPTIMIZATION_NODE)
10484
    {
10485
      p = (const char *)TREE_OPTIMIZATION (t);
10486
      len = sizeof (struct cl_optimization);
10487
    }
10488
 
10489
  else if (TREE_CODE (t) == TARGET_OPTION_NODE)
10490
    {
10491
      p = (const char *)TREE_TARGET_OPTION (t);
10492
      len = sizeof (struct cl_target_option);
10493
    }
10494
 
10495
  else
10496
    gcc_unreachable ();
10497
 
10498
  /* assume most opt flags are just 0/1, some are 2-3, and a few might be
10499
     something else.  */
10500
  for (i = 0; i < len; i++)
10501
    if (p[i])
10502
      hash = (hash << 4) ^ ((i << 2) | p[i]);
10503
 
10504
  return hash;
10505
}
10506
 
10507
/* Return nonzero if the value represented by *X (an OPTIMIZATION or
10508
   TARGET_OPTION tree node) is the same as that given by *Y, which is the
10509
   same.  */
10510
 
10511
static int
10512
cl_option_hash_eq (const void *x, const void *y)
10513
{
10514
  const_tree const xt = (const_tree) x;
10515
  const_tree const yt = (const_tree) y;
10516
  const char *xp;
10517
  const char *yp;
10518
  size_t len;
10519
 
10520
  if (TREE_CODE (xt) != TREE_CODE (yt))
10521
    return 0;
10522
 
10523
  if (TREE_CODE (xt) == OPTIMIZATION_NODE)
10524
    {
10525
      xp = (const char *)TREE_OPTIMIZATION (xt);
10526
      yp = (const char *)TREE_OPTIMIZATION (yt);
10527
      len = sizeof (struct cl_optimization);
10528
    }
10529
 
10530
  else if (TREE_CODE (xt) == TARGET_OPTION_NODE)
10531
    {
10532
      xp = (const char *)TREE_TARGET_OPTION (xt);
10533
      yp = (const char *)TREE_TARGET_OPTION (yt);
10534
      len = sizeof (struct cl_target_option);
10535
    }
10536
 
10537
  else
10538
    gcc_unreachable ();
10539
 
10540
  return (memcmp (xp, yp, len) == 0);
10541
}
10542
 
10543
/* Build an OPTIMIZATION_NODE based on the current options.  */
10544
 
10545
tree
10546
build_optimization_node (void)
10547
{
10548
  tree t;
10549
  void **slot;
10550
 
10551
  /* Use the cache of optimization nodes.  */
10552
 
10553
  cl_optimization_save (TREE_OPTIMIZATION (cl_optimization_node));
10554
 
10555
  slot = htab_find_slot (cl_option_hash_table, cl_optimization_node, INSERT);
10556
  t = (tree) *slot;
10557
  if (!t)
10558
    {
10559
      /* Insert this one into the hash table.  */
10560
      t = cl_optimization_node;
10561
      *slot = t;
10562
 
10563
      /* Make a new node for next time round.  */
10564
      cl_optimization_node = make_node (OPTIMIZATION_NODE);
10565
    }
10566
 
10567
  return t;
10568
}
10569
 
10570
/* Build a TARGET_OPTION_NODE based on the current options.  */
10571
 
10572
tree
10573
build_target_option_node (void)
10574
{
10575
  tree t;
10576
  void **slot;
10577
 
10578
  /* Use the cache of optimization nodes.  */
10579
 
10580
  cl_target_option_save (TREE_TARGET_OPTION (cl_target_option_node));
10581
 
10582
  slot = htab_find_slot (cl_option_hash_table, cl_target_option_node, INSERT);
10583
  t = (tree) *slot;
10584
  if (!t)
10585
    {
10586
      /* Insert this one into the hash table.  */
10587
      t = cl_target_option_node;
10588
      *slot = t;
10589
 
10590
      /* Make a new node for next time round.  */
10591
      cl_target_option_node = make_node (TARGET_OPTION_NODE);
10592
    }
10593
 
10594
  return t;
10595
}
10596
 
10597
/* Determine the "ultimate origin" of a block.  The block may be an inlined
10598
   instance of an inlined instance of a block which is local to an inline
10599
   function, so we have to trace all of the way back through the origin chain
10600
   to find out what sort of node actually served as the original seed for the
10601
   given block.  */
10602
 
10603
tree
10604
block_ultimate_origin (const_tree block)
10605
{
10606
  tree immediate_origin = BLOCK_ABSTRACT_ORIGIN (block);
10607
 
10608
  /* output_inline_function sets BLOCK_ABSTRACT_ORIGIN for all the
10609
     nodes in the function to point to themselves; ignore that if
10610
     we're trying to output the abstract instance of this function.  */
10611
  if (BLOCK_ABSTRACT (block) && immediate_origin == block)
10612
    return NULL_TREE;
10613
 
10614
  if (immediate_origin == NULL_TREE)
10615
    return NULL_TREE;
10616
  else
10617
    {
10618
      tree ret_val;
10619
      tree lookahead = immediate_origin;
10620
 
10621
      do
10622
        {
10623
          ret_val = lookahead;
10624
          lookahead = (TREE_CODE (ret_val) == BLOCK
10625
                       ? BLOCK_ABSTRACT_ORIGIN (ret_val) : NULL);
10626
        }
10627
      while (lookahead != NULL && lookahead != ret_val);
10628
 
10629
      /* The block's abstract origin chain may not be the *ultimate* origin of
10630
         the block. It could lead to a DECL that has an abstract origin set.
10631
         If so, we want that DECL's abstract origin (which is what DECL_ORIGIN
10632
         will give us if it has one).  Note that DECL's abstract origins are
10633
         supposed to be the most distant ancestor (or so decl_ultimate_origin
10634
         claims), so we don't need to loop following the DECL origins.  */
10635
      if (DECL_P (ret_val))
10636
        return DECL_ORIGIN (ret_val);
10637
 
10638
      return ret_val;
10639
    }
10640
}
10641
 
10642
/* Return true if T1 and T2 are equivalent lists.  */
10643
 
10644
bool
10645
list_equal_p (const_tree t1, const_tree t2)
10646
{
10647
  for (; t1 && t2; t1 = TREE_CHAIN (t1) , t2 = TREE_CHAIN (t2))
10648
    if (TREE_VALUE (t1) != TREE_VALUE (t2))
10649
      return false;
10650
  return !t1 && !t2;
10651
}
10652
 
10653
/* Return true iff conversion in EXP generates no instruction.  Mark
10654
   it inline so that we fully inline into the stripping functions even
10655
   though we have two uses of this function.  */
10656
 
10657
static inline bool
10658
tree_nop_conversion (const_tree exp)
10659
{
10660
  tree outer_type, inner_type;
10661
 
10662
  if (!CONVERT_EXPR_P (exp)
10663
      && TREE_CODE (exp) != NON_LVALUE_EXPR)
10664
    return false;
10665
  if (TREE_OPERAND (exp, 0) == error_mark_node)
10666
    return false;
10667
 
10668
  outer_type = TREE_TYPE (exp);
10669
  inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10670
 
10671
  /* Use precision rather then machine mode when we can, which gives
10672
     the correct answer even for submode (bit-field) types.  */
10673
  if ((INTEGRAL_TYPE_P (outer_type)
10674
       || POINTER_TYPE_P (outer_type)
10675
       || TREE_CODE (outer_type) == OFFSET_TYPE)
10676
      && (INTEGRAL_TYPE_P (inner_type)
10677
          || POINTER_TYPE_P (inner_type)
10678
          || TREE_CODE (inner_type) == OFFSET_TYPE))
10679
    return TYPE_PRECISION (outer_type) == TYPE_PRECISION (inner_type);
10680
 
10681
  /* Otherwise fall back on comparing machine modes (e.g. for
10682
     aggregate types, floats).  */
10683
  return TYPE_MODE (outer_type) == TYPE_MODE (inner_type);
10684
}
10685
 
10686
/* Return true iff conversion in EXP generates no instruction.  Don't
10687
   consider conversions changing the signedness.  */
10688
 
10689
static bool
10690
tree_sign_nop_conversion (const_tree exp)
10691
{
10692
  tree outer_type, inner_type;
10693
 
10694
  if (!tree_nop_conversion (exp))
10695
    return false;
10696
 
10697
  outer_type = TREE_TYPE (exp);
10698
  inner_type = TREE_TYPE (TREE_OPERAND (exp, 0));
10699
 
10700
  return (TYPE_UNSIGNED (outer_type) == TYPE_UNSIGNED (inner_type)
10701
          && POINTER_TYPE_P (outer_type) == POINTER_TYPE_P (inner_type));
10702
}
10703
 
10704
/* Strip conversions from EXP according to tree_nop_conversion and
10705
   return the resulting expression.  */
10706
 
10707
tree
10708
tree_strip_nop_conversions (tree exp)
10709
{
10710
  while (tree_nop_conversion (exp))
10711
    exp = TREE_OPERAND (exp, 0);
10712
  return exp;
10713
}
10714
 
10715
/* Strip conversions from EXP according to tree_sign_nop_conversion
10716
   and return the resulting expression.  */
10717
 
10718
tree
10719
tree_strip_sign_nop_conversions (tree exp)
10720
{
10721
  while (tree_sign_nop_conversion (exp))
10722
    exp = TREE_OPERAND (exp, 0);
10723
  return exp;
10724
}
10725
 
10726
static GTY(()) tree gcc_eh_personality_decl;
10727
 
10728
/* Return the GCC personality function decl.  */
10729
 
10730
tree
10731
lhd_gcc_personality (void)
10732
{
10733
  if (!gcc_eh_personality_decl)
10734
    gcc_eh_personality_decl
10735
      = build_personality_function (USING_SJLJ_EXCEPTIONS
10736
                                    ? "__gcc_personality_sj0"
10737
                                    : "__gcc_personality_v0");
10738
 
10739
  return gcc_eh_personality_decl;
10740
}
10741
 
10742
#include "gt-tree.h"

powered by: WebSVN 2.1.0

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