00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036 #include "config.h"
00037 #include "system.h"
00038 #include "flags.h"
00039 #ifdef SGI_MONGOOSE
00040
00041 #include "rtl.h"
00042 #endif
00043 #include "tree.h"
00044 #include "real.h"
00045 #include "tm_p.h"
00046 #include "function.h"
00047 #include "obstack.h"
00048 #include "toplev.h"
00049 #include "ggc.h"
00050 #include "hashtab.h"
00051 #include "output.h"
00052 #include "target.h"
00053 #include "langhooks.h"
00054
00055 #ifdef KEY
00056 #include "c-common.h"
00057 extern void erase_duplicates (tree);
00058 #endif
00059
00060
00061 extern int _obstack_allocated_p PARAMS ((struct obstack *h, PTR obj));
00062
00063 #ifdef GATHER_STATISTICS
00064
00065 typedef enum
00066 {
00067 d_kind,
00068 t_kind,
00069 b_kind,
00070 s_kind,
00071 r_kind,
00072 e_kind,
00073 c_kind,
00074 id_kind,
00075 perm_list_kind,
00076 temp_list_kind,
00077 vec_kind,
00078 x_kind,
00079 lang_decl,
00080 lang_type,
00081 all_kinds
00082 } tree_node_kind;
00083
00084 int tree_node_counts[(int) all_kinds];
00085 int tree_node_sizes[(int) all_kinds];
00086
00087 static const char * const tree_node_kind_names[] = {
00088 "decls",
00089 "types",
00090 "blocks",
00091 "stmts",
00092 "refs",
00093 "exprs",
00094 "constants",
00095 "identifiers",
00096 "perm_tree_lists",
00097 "temp_tree_lists",
00098 "vecs",
00099 "random kinds",
00100 "lang_decl kinds",
00101 "lang_type kinds"
00102 };
00103 #endif
00104
00105
00106 static int next_decl_uid;
00107
00108 static int next_type_uid = 1;
00109
00110
00111
00112
00113 struct type_hash GTY(())
00114 {
00115 unsigned long hash;
00116 tree type;
00117 };
00118
00119
00120 #define TYPE_HASH_INITIAL_SIZE 1000
00121
00122
00123
00124
00125
00126
00127
00128
00129 static GTY ((if_marked ("type_hash_marked_p"), param_is (struct type_hash)))
00130 htab_t type_hash_table;
00131
00132 static void set_type_quals PARAMS ((tree, int));
00133 static void append_random_chars PARAMS ((char *));
00134 static int type_hash_eq PARAMS ((const void *, const void *));
00135 static hashval_t type_hash_hash PARAMS ((const void *));
00136 static void print_type_hash_statistics PARAMS((void));
00137 static void finish_vector_type PARAMS((tree));
00138 static tree make_vector PARAMS ((enum machine_mode, tree, int));
00139 static int type_hash_marked_p PARAMS ((const void *));
00140
00141 tree global_trees[TI_MAX];
00142 tree integer_types[itk_none];
00143
00144
00145
00146 void
00147 init_ttree ()
00148 {
00149
00150 type_hash_table = htab_create (TYPE_HASH_INITIAL_SIZE, type_hash_hash,
00151 type_hash_eq, 0);
00152 }
00153
00154
00155
00156
00157
00158 tree
00159 decl_assembler_name (decl)
00160 tree decl;
00161 {
00162 if (!DECL_ASSEMBLER_NAME_SET_P (decl))
00163 (*lang_hooks.set_decl_assembler_name) (decl);
00164 return DECL_CHECK (decl)->decl.assembler_name;
00165 }
00166
00167
00168
00169 size_t
00170 tree_size (node)
00171 tree node;
00172 {
00173 enum tree_code code = TREE_CODE (node);
00174
00175 switch (TREE_CODE_CLASS (code))
00176 {
00177 case 'd':
00178 return sizeof (struct tree_decl);
00179
00180 case 't':
00181 return sizeof (struct tree_type);
00182
00183 case 'b':
00184 return sizeof (struct tree_block);
00185
00186 case 'r':
00187 case 'e':
00188 case 's':
00189 case '<':
00190 case '1':
00191 case '2':
00192 #ifdef KEY
00193 if (code == OMP_MARKER_STMT)
00194 return sizeof (struct tree_omp);
00195 #endif // KEY
00196 return (sizeof (struct tree_exp)
00197 + TREE_CODE_LENGTH (code) * sizeof (char *) - sizeof (char *));
00198
00199 case 'c':
00200
00201
00202
00203
00204
00205 if (code == INTEGER_CST)
00206 return sizeof (struct tree_int_cst);
00207 else if (code == REAL_CST)
00208 return sizeof (struct tree_real_cst);
00209 else
00210 return (sizeof (struct tree_common)
00211 + TREE_CODE_LENGTH (code) * sizeof (char *));
00212
00213 case 'x':
00214 {
00215 size_t length;
00216 length = (sizeof (struct tree_common)
00217 + TREE_CODE_LENGTH (code) * sizeof (char *));
00218 if (code == TREE_VEC)
00219 length += TREE_VEC_LENGTH (node) * sizeof (char *) - sizeof (char *);
00220 return length;
00221 }
00222
00223 default:
00224 abort ();
00225 }
00226 }
00227
00228
00229
00230
00231
00232
00233
00234 tree
00235 make_node (code)
00236 enum tree_code code;
00237 {
00238 tree t;
00239 int type = TREE_CODE_CLASS (code);
00240 size_t length;
00241 #ifdef GATHER_STATISTICS
00242 tree_node_kind kind;
00243 #endif
00244 struct tree_common ttmp;
00245
00246
00247
00248 if (code == TREE_VEC)
00249 abort ();
00250
00251 TREE_SET_CODE ((tree)&ttmp, code);
00252 length = tree_size ((tree)&ttmp);
00253
00254 #ifdef GATHER_STATISTICS
00255 switch (type)
00256 {
00257 case 'd':
00258 kind = d_kind;
00259 break;
00260
00261 case 't':
00262 kind = t_kind;
00263 break;
00264
00265 case 'b':
00266 kind = b_kind;
00267 break;
00268
00269 case 's':
00270 kind = s_kind;
00271 break;
00272
00273 case 'r':
00274 kind = r_kind;
00275 break;
00276
00277 case 'e':
00278 case '<':
00279 case '1':
00280 case '2':
00281 kind = e_kind;
00282 break;
00283
00284 case 'c':
00285 kind = c_kind;
00286 break;
00287
00288 case 'x':
00289 if (code == IDENTIFIER_NODE)
00290 kind = id_kind;
00291 else if (code == TREE_VEC)
00292 kind = vec_kind;
00293 else
00294 kind = x_kind;
00295 break;
00296
00297 default:
00298 abort ();
00299 }
00300
00301 tree_node_counts[(int) kind]++;
00302 tree_node_sizes[(int) kind] += length;
00303 #endif
00304
00305 t = ggc_alloc_tree (length);
00306
00307 memset ((PTR) t, 0, length);
00308
00309 TREE_SET_CODE (t, code);
00310
00311 switch (type)
00312 {
00313 case 's':
00314 TREE_SIDE_EFFECTS (t) = 1;
00315 TREE_TYPE (t) = void_type_node;
00316 break;
00317
00318 case 'd':
00319 if (code != FUNCTION_DECL)
00320 DECL_ALIGN (t) = 1;
00321 DECL_USER_ALIGN (t) = 0;
00322 DECL_IN_SYSTEM_HEADER (t) = in_system_header;
00323 DECL_SOURCE_LINE (t) = lineno;
00324 DECL_SOURCE_FILE (t) =
00325 (input_filename) ? input_filename : "<built-in>";
00326 DECL_UID (t) = next_decl_uid++;
00327
00328
00329 DECL_POINTER_ALIAS_SET (t) = -1;
00330 break;
00331
00332 case 't':
00333 TYPE_UID (t) = next_type_uid++;
00334 TYPE_ALIGN (t) = char_type_node ? TYPE_ALIGN (char_type_node) : 0;
00335 TYPE_USER_ALIGN (t) = 0;
00336 TYPE_MAIN_VARIANT (t) = t;
00337
00338
00339 TYPE_ATTRIBUTES (t) = NULL_TREE;
00340 (*targetm.set_default_type_attributes) (t);
00341
00342
00343 TYPE_ALIAS_SET (t) = -1;
00344 #ifdef SGI_MONGOOSE
00345 {
00346
00347 static struct mongoose_gcc_DST_IDX di = {-1,-1};
00348 TYPE_DST_IDX(t) = di;
00349 }
00350 #endif
00351 break;
00352
00353 case 'c':
00354 TREE_CONSTANT (t) = 1;
00355 break;
00356
00357 case 'e':
00358 switch (code)
00359 {
00360 case INIT_EXPR:
00361 case MODIFY_EXPR:
00362 case VA_ARG_EXPR:
00363 case RTL_EXPR:
00364 case PREDECREMENT_EXPR:
00365 case PREINCREMENT_EXPR:
00366 case POSTDECREMENT_EXPR:
00367 case POSTINCREMENT_EXPR:
00368
00369
00370 TREE_SIDE_EFFECTS (t) = 1;
00371 break;
00372
00373 default:
00374 break;
00375 }
00376 break;
00377 }
00378
00379 return t;
00380 }
00381
00382
00383
00384
00385 tree
00386 copy_node (node)
00387 tree node;
00388 {
00389 tree t;
00390 enum tree_code code = TREE_CODE (node);
00391 size_t length;
00392
00393 length = tree_size (node);
00394 t = ggc_alloc_tree (length);
00395 memcpy (t, node, length);
00396
00397 TREE_CHAIN (t) = 0;
00398 TREE_ASM_WRITTEN (t) = 0;
00399
00400 if (TREE_CODE_CLASS (code) == 'd')
00401 DECL_UID (t) = next_decl_uid++;
00402 else if (TREE_CODE_CLASS (code) == 't')
00403 {
00404 TYPE_UID (t) = next_type_uid++;
00405
00406
00407
00408
00409
00410 TYPE_SYMTAB_POINTER (t) = 0;
00411 TYPE_SYMTAB_ADDRESS (t) = 0;
00412 }
00413
00414 return t;
00415 }
00416
00417
00418
00419
00420 tree
00421 copy_list (list)
00422 tree list;
00423 {
00424 tree head;
00425 tree prev, next;
00426
00427 if (list == 0)
00428 return 0;
00429
00430 head = prev = copy_node (list);
00431 next = TREE_CHAIN (list);
00432 while (next)
00433 {
00434 TREE_CHAIN (prev) = copy_node (next);
00435 prev = TREE_CHAIN (prev);
00436 next = TREE_CHAIN (next);
00437 }
00438 return head;
00439 }
00440
00441
00442
00443
00444
00445
00446
00447
00448 tree
00449 build_int_2_wide (low, hi)
00450 unsigned HOST_WIDE_INT low;
00451 HOST_WIDE_INT hi;
00452 {
00453 tree t = make_node (INTEGER_CST);
00454
00455 TREE_INT_CST_LOW (t) = low;
00456 TREE_INT_CST_HIGH (t) = hi;
00457 TREE_TYPE (t) = integer_type_node;
00458 return t;
00459 }
00460
00461
00462
00463
00464 tree
00465 build_vector (type, vals)
00466 tree type, vals;
00467 {
00468 tree v = make_node (VECTOR_CST);
00469 int over1 = 0, over2 = 0;
00470 tree link;
00471
00472 TREE_VECTOR_CST_ELTS (v) = vals;
00473 TREE_TYPE (v) = type;
00474
00475
00476 for (link = vals; link; link = TREE_CHAIN (link))
00477 {
00478 tree value = TREE_VALUE (link);
00479
00480 over1 |= TREE_OVERFLOW (value);
00481 over2 |= TREE_CONSTANT_OVERFLOW (value);
00482 }
00483
00484 TREE_OVERFLOW (v) = over1;
00485 TREE_CONSTANT_OVERFLOW (v) = over2;
00486
00487 return v;
00488 }
00489
00490
00491
00492 tree
00493 build_real (type, d)
00494 tree type;
00495 REAL_VALUE_TYPE d;
00496 {
00497 tree v;
00498 REAL_VALUE_TYPE *dp;
00499 int overflow = 0;
00500
00501
00502
00503
00504 v = make_node (REAL_CST);
00505 dp = ggc_alloc (sizeof (REAL_VALUE_TYPE));
00506 memcpy (dp, &d, sizeof (REAL_VALUE_TYPE));
00507
00508 TREE_TYPE (v) = type;
00509 TREE_REAL_CST_PTR (v) = dp;
00510 TREE_OVERFLOW (v) = TREE_CONSTANT_OVERFLOW (v) = overflow;
00511 return v;
00512 }
00513
00514
00515
00516
00517 REAL_VALUE_TYPE
00518 real_value_from_int_cst (type, i)
00519 tree type ATTRIBUTE_UNUSED, i;
00520 {
00521 REAL_VALUE_TYPE d;
00522
00523
00524
00525 memset ((char *) &d, 0, sizeof d);
00526
00527 if (! TREE_UNSIGNED (TREE_TYPE (i)))
00528 REAL_VALUE_FROM_INT (d, TREE_INT_CST_LOW (i), TREE_INT_CST_HIGH (i),
00529 TYPE_MODE (type));
00530 else
00531 REAL_VALUE_FROM_UNSIGNED_INT (d, TREE_INT_CST_LOW (i),
00532 TREE_INT_CST_HIGH (i), TYPE_MODE (type));
00533 return d;
00534 }
00535
00536
00537
00538
00539 tree
00540 build_real_from_int_cst (type, i)
00541 tree type;
00542 tree i;
00543 {
00544 tree v;
00545 int overflow = TREE_OVERFLOW (i);
00546
00547 v = build_real (type, real_value_from_int_cst (type, i));
00548
00549 TREE_OVERFLOW (v) |= overflow;
00550 TREE_CONSTANT_OVERFLOW (v) |= overflow;
00551 return v;
00552 }
00553
00554
00555
00556
00557
00558 tree
00559 build_string (len, str)
00560 int len;
00561 const char *str;
00562 {
00563 tree s = make_node (STRING_CST);
00564
00565 TREE_STRING_LENGTH (s) = len;
00566 TREE_STRING_POINTER (s) = ggc_alloc_string (str, len);
00567
00568 return s;
00569 }
00570
00571
00572
00573
00574
00575
00576 tree
00577 build_complex (type, real, imag)
00578 tree type;
00579 tree real, imag;
00580 {
00581 tree t = make_node (COMPLEX_CST);
00582
00583 TREE_REALPART (t) = real;
00584 TREE_IMAGPART (t) = imag;
00585 TREE_TYPE (t) = type ? type : build_complex_type (TREE_TYPE (real));
00586 TREE_OVERFLOW (t) = TREE_OVERFLOW (real) | TREE_OVERFLOW (imag);
00587 TREE_CONSTANT_OVERFLOW (t)
00588 = TREE_CONSTANT_OVERFLOW (real) | TREE_CONSTANT_OVERFLOW (imag);
00589 return t;
00590 }
00591
00592
00593
00594 tree
00595 make_tree_vec (len)
00596 int len;
00597 {
00598 tree t;
00599 int length = (len - 1) * sizeof (tree) + sizeof (struct tree_vec);
00600
00601 #ifdef GATHER_STATISTICS
00602 tree_node_counts[(int) vec_kind]++;
00603 tree_node_sizes[(int) vec_kind] += length;
00604 #endif
00605
00606 t = ggc_alloc_tree (length);
00607
00608 memset ((PTR) t, 0, length);
00609 TREE_SET_CODE (t, TREE_VEC);
00610 TREE_VEC_LENGTH (t) = len;
00611
00612 return t;
00613 }
00614
00615
00616
00617
00618 int
00619 integer_zerop (expr)
00620 tree expr;
00621 {
00622 STRIP_NOPS (expr);
00623
00624 return ((TREE_CODE (expr) == INTEGER_CST
00625 && ! TREE_CONSTANT_OVERFLOW (expr)
00626 && TREE_INT_CST_LOW (expr) == 0
00627 && TREE_INT_CST_HIGH (expr) == 0)
00628 || (TREE_CODE (expr) == COMPLEX_CST
00629 && integer_zerop (TREE_REALPART (expr))
00630 && integer_zerop (TREE_IMAGPART (expr))));
00631 }
00632
00633
00634
00635
00636 int
00637 integer_onep (expr)
00638 tree expr;
00639 {
00640 STRIP_NOPS (expr);
00641
00642 return ((TREE_CODE (expr) == INTEGER_CST
00643 && ! TREE_CONSTANT_OVERFLOW (expr)
00644 && TREE_INT_CST_LOW (expr) == 1
00645 && TREE_INT_CST_HIGH (expr) == 0)
00646 || (TREE_CODE (expr) == COMPLEX_CST
00647 && integer_onep (TREE_REALPART (expr))
00648 && integer_zerop (TREE_IMAGPART (expr))));
00649 }
00650
00651
00652
00653
00654 int
00655 integer_all_onesp (expr)
00656 tree expr;
00657 {
00658 int prec;
00659 int uns;
00660
00661 STRIP_NOPS (expr);
00662
00663 if (TREE_CODE (expr) == COMPLEX_CST
00664 && integer_all_onesp (TREE_REALPART (expr))
00665 && integer_zerop (TREE_IMAGPART (expr)))
00666 return 1;
00667
00668 else if (TREE_CODE (expr) != INTEGER_CST
00669 || TREE_CONSTANT_OVERFLOW (expr))
00670 return 0;
00671
00672 uns = TREE_UNSIGNED (TREE_TYPE (expr));
00673 if (!uns)
00674 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
00675 && TREE_INT_CST_HIGH (expr) == -1);
00676
00677
00678
00679 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (expr)));
00680 if (prec >= HOST_BITS_PER_WIDE_INT)
00681 {
00682 HOST_WIDE_INT high_value;
00683 int shift_amount;
00684
00685 shift_amount = prec - HOST_BITS_PER_WIDE_INT;
00686
00687 if (shift_amount > HOST_BITS_PER_WIDE_INT)
00688
00689 abort ();
00690 else if (shift_amount == HOST_BITS_PER_WIDE_INT)
00691
00692
00693 high_value = -1;
00694 else
00695 high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
00696
00697 return (TREE_INT_CST_LOW (expr) == ~(unsigned HOST_WIDE_INT) 0
00698 && TREE_INT_CST_HIGH (expr) == high_value);
00699 }
00700 else
00701 return TREE_INT_CST_LOW (expr) == ((unsigned HOST_WIDE_INT) 1 << prec) - 1;
00702 }
00703
00704
00705
00706
00707 int
00708 integer_pow2p (expr)
00709 tree expr;
00710 {
00711 int prec;
00712 HOST_WIDE_INT high, low;
00713
00714 STRIP_NOPS (expr);
00715
00716 if (TREE_CODE (expr) == COMPLEX_CST
00717 && integer_pow2p (TREE_REALPART (expr))
00718 && integer_zerop (TREE_IMAGPART (expr)))
00719 return 1;
00720
00721 if (TREE_CODE (expr) != INTEGER_CST || TREE_CONSTANT_OVERFLOW (expr))
00722 return 0;
00723
00724 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
00725 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
00726 high = TREE_INT_CST_HIGH (expr);
00727 low = TREE_INT_CST_LOW (expr);
00728
00729
00730
00731
00732 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
00733 ;
00734 else if (prec > HOST_BITS_PER_WIDE_INT)
00735 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
00736 else
00737 {
00738 high = 0;
00739 if (prec < HOST_BITS_PER_WIDE_INT)
00740 low &= ~((HOST_WIDE_INT) (-1) << prec);
00741 }
00742
00743 if (high == 0 && low == 0)
00744 return 0;
00745
00746 return ((high == 0 && (low & (low - 1)) == 0)
00747 || (low == 0 && (high & (high - 1)) == 0));
00748 }
00749
00750
00751
00752
00753 int
00754 tree_log2 (expr)
00755 tree expr;
00756 {
00757 int prec;
00758 HOST_WIDE_INT high, low;
00759
00760 STRIP_NOPS (expr);
00761
00762 if (TREE_CODE (expr) == COMPLEX_CST)
00763 return tree_log2 (TREE_REALPART (expr));
00764
00765 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
00766 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
00767
00768 high = TREE_INT_CST_HIGH (expr);
00769 low = TREE_INT_CST_LOW (expr);
00770
00771
00772
00773
00774 if (prec == 2 * HOST_BITS_PER_WIDE_INT)
00775 ;
00776 else if (prec > HOST_BITS_PER_WIDE_INT)
00777 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
00778 else
00779 {
00780 high = 0;
00781 if (prec < HOST_BITS_PER_WIDE_INT)
00782 low &= ~((HOST_WIDE_INT) (-1) << prec);
00783 }
00784
00785 return (high != 0 ? HOST_BITS_PER_WIDE_INT + exact_log2 (high)
00786 : exact_log2 (low));
00787 }
00788
00789
00790
00791
00792 int
00793 tree_floor_log2 (expr)
00794 tree expr;
00795 {
00796 int prec;
00797 HOST_WIDE_INT high, low;
00798
00799 STRIP_NOPS (expr);
00800
00801 if (TREE_CODE (expr) == COMPLEX_CST)
00802 return tree_log2 (TREE_REALPART (expr));
00803
00804 prec = (POINTER_TYPE_P (TREE_TYPE (expr))
00805 ? POINTER_SIZE : TYPE_PRECISION (TREE_TYPE (expr)));
00806
00807 high = TREE_INT_CST_HIGH (expr);
00808 low = TREE_INT_CST_LOW (expr);
00809
00810
00811
00812
00813
00814 if (prec == 2 * HOST_BITS_PER_WIDE_INT || prec == 0)
00815 ;
00816 else if (prec > HOST_BITS_PER_WIDE_INT)
00817 high &= ~((HOST_WIDE_INT) (-1) << (prec - HOST_BITS_PER_WIDE_INT));
00818 else
00819 {
00820 high = 0;
00821 if (prec < HOST_BITS_PER_WIDE_INT)
00822 low &= ~((HOST_WIDE_INT) (-1) << prec);
00823 }
00824
00825 return (high != 0 ? HOST_BITS_PER_WIDE_INT + floor_log2 (high)
00826 : floor_log2 (low));
00827 }
00828
00829
00830
00831 int
00832 real_zerop (expr)
00833 tree expr;
00834 {
00835 STRIP_NOPS (expr);
00836
00837 return ((TREE_CODE (expr) == REAL_CST
00838 && ! TREE_CONSTANT_OVERFLOW (expr)
00839 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst0))
00840 || (TREE_CODE (expr) == COMPLEX_CST
00841 && real_zerop (TREE_REALPART (expr))
00842 && real_zerop (TREE_IMAGPART (expr))));
00843 }
00844
00845
00846
00847 int
00848 real_onep (expr)
00849 tree expr;
00850 {
00851 STRIP_NOPS (expr);
00852
00853 return ((TREE_CODE (expr) == REAL_CST
00854 && ! TREE_CONSTANT_OVERFLOW (expr)
00855 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst1))
00856 || (TREE_CODE (expr) == COMPLEX_CST
00857 && real_onep (TREE_REALPART (expr))
00858 && real_zerop (TREE_IMAGPART (expr))));
00859 }
00860
00861
00862
00863 int
00864 real_twop (expr)
00865 tree expr;
00866 {
00867 STRIP_NOPS (expr);
00868
00869 return ((TREE_CODE (expr) == REAL_CST
00870 && ! TREE_CONSTANT_OVERFLOW (expr)
00871 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconst2))
00872 || (TREE_CODE (expr) == COMPLEX_CST
00873 && real_twop (TREE_REALPART (expr))
00874 && real_zerop (TREE_IMAGPART (expr))));
00875 }
00876
00877
00878
00879 int
00880 real_minus_onep (expr)
00881 tree expr;
00882 {
00883 STRIP_NOPS (expr);
00884
00885 return ((TREE_CODE (expr) == REAL_CST
00886 && ! TREE_CONSTANT_OVERFLOW (expr)
00887 && REAL_VALUES_EQUAL (TREE_REAL_CST (expr), dconstm1))
00888 || (TREE_CODE (expr) == COMPLEX_CST
00889 && real_minus_onep (TREE_REALPART (expr))
00890 && real_zerop (TREE_IMAGPART (expr))));
00891 }
00892
00893
00894
00895 int
00896 really_constant_p (exp)
00897 tree exp;
00898 {
00899
00900 while (TREE_CODE (exp) == NOP_EXPR
00901 || TREE_CODE (exp) == CONVERT_EXPR
00902 || TREE_CODE (exp) == NON_LVALUE_EXPR)
00903 exp = TREE_OPERAND (exp, 0);
00904 return TREE_CONSTANT (exp);
00905 }
00906
00907
00908
00909
00910 tree
00911 value_member (elem, list)
00912 tree elem, list;
00913 {
00914 while (list)
00915 {
00916 if (elem == TREE_VALUE (list))
00917 return list;
00918 list = TREE_CHAIN (list);
00919 }
00920 return NULL_TREE;
00921 }
00922
00923
00924
00925
00926 tree
00927 purpose_member (elem, list)
00928 tree elem, list;
00929 {
00930 while (list)
00931 {
00932 if (elem == TREE_PURPOSE (list))
00933 return list;
00934 list = TREE_CHAIN (list);
00935 }
00936 return NULL_TREE;
00937 }
00938
00939
00940
00941
00942 tree
00943 binfo_member (elem, list)
00944 tree elem, list;
00945 {
00946 while (list)
00947 {
00948 if (elem == BINFO_TYPE (list))
00949 return list;
00950 list = TREE_CHAIN (list);
00951 }
00952 return NULL_TREE;
00953 }
00954
00955
00956
00957 int
00958 chain_member (elem, chain)
00959 tree elem, chain;
00960 {
00961 while (chain)
00962 {
00963 if (elem == chain)
00964 return 1;
00965 chain = TREE_CHAIN (chain);
00966 }
00967
00968 return 0;
00969 }
00970
00971
00972
00973
00974
00975 int
00976 chain_member_value (elem, chain)
00977 tree elem, chain;
00978 {
00979 while (chain)
00980 {
00981 if (elem == TREE_VALUE (chain))
00982 return 1;
00983 chain = TREE_CHAIN (chain);
00984 }
00985
00986 return 0;
00987 }
00988
00989
00990
00991
00992 int
00993 chain_member_purpose (elem, chain)
00994 tree elem, chain;
00995 {
00996 while (chain)
00997 {
00998 if (elem == TREE_PURPOSE (chain))
00999 return 1;
01000 chain = TREE_CHAIN (chain);
01001 }
01002
01003 return 0;
01004 }
01005
01006
01007
01008
01009
01010 int
01011 list_length (t)
01012 tree t;
01013 {
01014 tree tail;
01015 int len = 0;
01016
01017 for (tail = t; tail; tail = TREE_CHAIN (tail))
01018 len++;
01019
01020 return len;
01021 }
01022
01023
01024
01025 int
01026 fields_length (type)
01027 tree type;
01028 {
01029 tree t = TYPE_FIELDS (type);
01030 int count = 0;
01031
01032 for (; t; t = TREE_CHAIN (t))
01033 if (TREE_CODE (t) == FIELD_DECL)
01034 ++count;
01035
01036 return count;
01037 }
01038
01039
01040
01041
01042
01043 tree
01044 chainon (op1, op2)
01045 tree op1, op2;
01046 {
01047
01048 if (op1)
01049 {
01050 tree t1;
01051 #ifdef ENABLE_TREE_CHECKING
01052 tree t2;
01053 #endif
01054
01055 for (t1 = op1; TREE_CHAIN (t1); t1 = TREE_CHAIN (t1))
01056 ;
01057 TREE_CHAIN (t1) = op2;
01058 #ifdef ENABLE_TREE_CHECKING
01059 for (t2 = op2; t2; t2 = TREE_CHAIN (t2))
01060 if (t2 == t1)
01061 abort ();
01062 #endif
01063 return op1;
01064 }
01065 else
01066 return op2;
01067 }
01068
01069
01070
01071 tree
01072 tree_last (chain)
01073 tree chain;
01074 {
01075 tree next;
01076 if (chain)
01077 while ((next = TREE_CHAIN (chain)))
01078 chain = next;
01079 return chain;
01080 }
01081
01082
01083
01084
01085 tree
01086 nreverse (t)
01087 tree t;
01088 {
01089 tree prev = 0, decl, next;
01090 for (decl = t; decl; decl = next)
01091 {
01092 next = TREE_CHAIN (decl);
01093 TREE_CHAIN (decl) = prev;
01094 prev = decl;
01095 }
01096 return prev;
01097 }
01098
01099
01100
01101
01102 tree
01103 listify (chain)
01104 tree chain;
01105 {
01106 tree result = NULL_TREE;
01107 tree in_tail = chain;
01108 tree out_tail = NULL_TREE;
01109
01110 while (in_tail)
01111 {
01112 tree next = tree_cons (NULL_TREE, in_tail, NULL_TREE);
01113 if (out_tail)
01114 TREE_CHAIN (out_tail) = next;
01115 else
01116 result = next;
01117 out_tail = next;
01118 in_tail = TREE_CHAIN (in_tail);
01119 }
01120
01121 return result;
01122 }
01123
01124
01125
01126
01127 tree
01128 build_tree_list (parm, value)
01129 tree parm, value;
01130 {
01131 tree t = make_node (TREE_LIST);
01132 TREE_PURPOSE (t) = parm;
01133 TREE_VALUE (t) = value;
01134 return t;
01135 }
01136
01137
01138
01139
01140
01141 tree
01142 tree_cons (purpose, value, chain)
01143 tree purpose, value, chain;
01144 {
01145 tree node;
01146
01147 node = ggc_alloc_tree (sizeof (struct tree_list));
01148
01149 memset (node, 0, sizeof (struct tree_common));
01150
01151 #ifdef GATHER_STATISTICS
01152 tree_node_counts[(int) x_kind]++;
01153 tree_node_sizes[(int) x_kind] += sizeof (struct tree_list);
01154 #endif
01155
01156 TREE_SET_CODE (node, TREE_LIST);
01157 TREE_CHAIN (node) = chain;
01158 TREE_PURPOSE (node) = purpose;
01159 TREE_VALUE (node) = value;
01160 return node;
01161 }
01162
01163
01164
01165
01166
01167
01168
01169
01170 tree
01171 size_in_bytes (type)
01172 tree type;
01173 {
01174 tree t;
01175
01176 if (type == error_mark_node)
01177 return integer_zero_node;
01178
01179 type = TYPE_MAIN_VARIANT (type);
01180 t = TYPE_SIZE_UNIT (type);
01181
01182 if (t == 0)
01183 {
01184 (*lang_hooks.types.incomplete_type_error) (NULL_TREE, type);
01185 return size_zero_node;
01186 }
01187
01188 if (TREE_CODE (t) == INTEGER_CST)
01189 force_fit_type (t, 0);
01190
01191 return t;
01192 }
01193
01194
01195
01196
01197 HOST_WIDE_INT
01198 int_size_in_bytes (type)
01199 tree type;
01200 {
01201 tree t;
01202
01203 if (type == error_mark_node)
01204 return 0;
01205
01206 type = TYPE_MAIN_VARIANT (type);
01207 t = TYPE_SIZE_UNIT (type);
01208 if (t == 0
01209 || TREE_CODE (t) != INTEGER_CST
01210 || TREE_OVERFLOW (t)
01211 || TREE_INT_CST_HIGH (t) != 0
01212
01213 || (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0)
01214 return -1;
01215
01216 return TREE_INT_CST_LOW (t);
01217 }
01218
01219
01220
01221
01222 tree
01223 bit_position (field)
01224 tree field;
01225 {
01226
01227 return bit_from_pos (DECL_FIELD_OFFSET (field),
01228 DECL_FIELD_BIT_OFFSET (field));
01229 }
01230
01231
01232
01233
01234
01235 HOST_WIDE_INT
01236 int_bit_position (field)
01237 tree field;
01238 {
01239 return tree_low_cst (bit_position (field), 0);
01240 }
01241
01242
01243
01244
01245 tree
01246 byte_position (field)
01247 tree field;
01248 {
01249 return byte_from_pos (DECL_FIELD_OFFSET (field),
01250 DECL_FIELD_BIT_OFFSET (field));
01251 }
01252
01253
01254
01255
01256
01257 HOST_WIDE_INT
01258 int_byte_position (field)
01259 tree field;
01260 {
01261 return tree_low_cst (byte_position (field), 0);
01262 }
01263
01264
01265
01266 unsigned int
01267 expr_align (t)
01268 tree t;
01269 {
01270 unsigned int align0, align1;
01271
01272 switch (TREE_CODE (t))
01273 {
01274 case NOP_EXPR: case CONVERT_EXPR: case NON_LVALUE_EXPR:
01275
01276
01277 align0 = expr_align (TREE_OPERAND (t, 0));
01278 align1 = TYPE_ALIGN (TREE_TYPE (t));
01279 return MAX (align0, align1);
01280
01281 case SAVE_EXPR: case COMPOUND_EXPR: case MODIFY_EXPR:
01282 case INIT_EXPR: case TARGET_EXPR: case WITH_CLEANUP_EXPR:
01283 case WITH_RECORD_EXPR: case CLEANUP_POINT_EXPR: case UNSAVE_EXPR:
01284
01285 return expr_align (TREE_OPERAND (t, 0));
01286
01287 case COND_EXPR:
01288
01289
01290 align0 = expr_align (TREE_OPERAND (t, 1));
01291 align1 = expr_align (TREE_OPERAND (t, 2));
01292 return MIN (align0, align1);
01293
01294 case LABEL_DECL: case CONST_DECL:
01295 case VAR_DECL: case PARM_DECL: case RESULT_DECL:
01296 if (DECL_ALIGN (t) != 0)
01297 return DECL_ALIGN (t);
01298 break;
01299
01300 case FUNCTION_DECL:
01301 return FUNCTION_BOUNDARY;
01302
01303 default:
01304 break;
01305 }
01306
01307
01308 return TYPE_ALIGN (TREE_TYPE (t));
01309 }
01310
01311
01312
01313
01314 tree
01315 array_type_nelts (type)
01316 tree type;
01317 {
01318 tree index_type, min, max;
01319
01320
01321
01322 if (! TYPE_DOMAIN (type))
01323 return error_mark_node;
01324
01325 index_type = TYPE_DOMAIN (type);
01326 min = TYPE_MIN_VALUE (index_type);
01327 max = TYPE_MAX_VALUE (index_type);
01328
01329 return (integer_zerop (min)
01330 ? max
01331 : fold (build (MINUS_EXPR, TREE_TYPE (max), max, min)));
01332 }
01333
01334
01335
01336
01337 int
01338 staticp (arg)
01339 tree arg;
01340 {
01341 switch (TREE_CODE (arg))
01342 {
01343 case FUNCTION_DECL:
01344
01345
01346 return ((decl_function_context (arg) == 0 || DECL_NO_STATIC_CHAIN (arg))
01347 && ! DECL_NON_ADDR_CONST_P (arg));
01348
01349 case VAR_DECL:
01350 return ((TREE_STATIC (arg) || DECL_EXTERNAL (arg))
01351 && ! DECL_THREAD_LOCAL (arg)
01352 && ! DECL_NON_ADDR_CONST_P (arg));
01353
01354 case CONSTRUCTOR:
01355 return TREE_STATIC (arg);
01356
01357 case LABEL_DECL:
01358 case STRING_CST:
01359 return 1;
01360
01361
01362
01363 case COMPONENT_REF:
01364 return (! DECL_BIT_FIELD (TREE_OPERAND (arg, 1))
01365 && staticp (TREE_OPERAND (arg, 0)));
01366
01367 case BIT_FIELD_REF:
01368 return 0;
01369
01370 #if 0
01371
01372
01373
01374 case INDIRECT_REF:
01375 return TREE_CONSTANT (TREE_OPERAND (arg, 0));
01376 #endif
01377
01378 case ARRAY_REF:
01379 case ARRAY_RANGE_REF:
01380 if (TREE_CODE (TYPE_SIZE (TREE_TYPE (arg))) == INTEGER_CST
01381 && TREE_CODE (TREE_OPERAND (arg, 1)) == INTEGER_CST)
01382 return staticp (TREE_OPERAND (arg, 0));
01383
01384 default:
01385 if ((unsigned int) TREE_CODE (arg)
01386 >= (unsigned int) LAST_AND_UNUSED_TREE_CODE)
01387 return (*lang_hooks.staticp) (arg);
01388 else
01389 return 0;
01390 }
01391 }
01392
01393
01394
01395
01396
01397
01398
01399
01400
01401
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415 tree
01416 save_expr (expr)
01417 tree expr;
01418 {
01419 tree t = fold (expr);
01420 tree inner;
01421
01422
01423
01424 while (TREE_CODE (t) == NON_LVALUE_EXPR)
01425 t = TREE_OPERAND (t, 0);
01426
01427
01428
01429
01430
01431 for (inner = t;
01432 (TREE_CODE_CLASS (TREE_CODE (inner)) == '1'
01433 || (TREE_CODE_CLASS (TREE_CODE (inner)) == '2'
01434 && TREE_CONSTANT (TREE_OPERAND (inner, 1))));
01435 inner = TREE_OPERAND (inner, 0))
01436 ;
01437
01438
01439
01440
01441
01442
01443 if (TREE_CONSTANT (inner)
01444 || (TREE_READONLY (inner) && ! TREE_SIDE_EFFECTS (inner))
01445 || TREE_CODE (inner) == SAVE_EXPR || TREE_CODE (inner) == ERROR_MARK)
01446 return t;
01447
01448
01449
01450
01451
01452
01453
01454
01455
01456
01457 if (contains_placeholder_p (t))
01458 return t;
01459
01460 t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
01461
01462
01463
01464
01465 TREE_SIDE_EFFECTS (t) = 1;
01466 TREE_READONLY (t) = 1;
01467 return t;
01468 }
01469
01470
01471
01472
01473
01474 tree
01475 unsave_expr (expr)
01476 tree expr;
01477 {
01478 tree t;
01479
01480
01481 if (TREE_CODE (expr) == UNSAVE_EXPR)
01482 return expr;
01483
01484 t = build1 (UNSAVE_EXPR, TREE_TYPE (expr), expr);
01485 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (expr);
01486 return t;
01487 }
01488
01489
01490
01491
01492 int
01493 first_rtl_op (code)
01494 enum tree_code code;
01495 {
01496 switch (code)
01497 {
01498 case SAVE_EXPR:
01499 return 2;
01500 case GOTO_SUBROUTINE_EXPR:
01501 case RTL_EXPR:
01502 return 0;
01503 case WITH_CLEANUP_EXPR:
01504 return 2;
01505 case METHOD_CALL_EXPR:
01506 return 3;
01507 default:
01508 return TREE_CODE_LENGTH (code);
01509 }
01510 }
01511
01512
01513
01514 enum tree_node_structure_enum
01515 tree_node_structure (t)
01516 tree t;
01517 {
01518 enum tree_code code = TREE_CODE (t);
01519
01520 #ifdef KEY
01521 if (code == OMP_MARKER_STMT)
01522 return TS_OMP;
01523 #endif
01524
01525 switch (TREE_CODE_CLASS (code))
01526 {
01527 case 'd': return TS_DECL;
01528 case 't': return TS_TYPE;
01529 case 'b': return TS_BLOCK;
01530 case 'r': case '<': case '1': case '2': case 'e': case 's':
01531 return TS_EXP;
01532 default:
01533 break;
01534 }
01535 switch (code)
01536 {
01537
01538 case INTEGER_CST: return TS_INT_CST;
01539 case REAL_CST: return TS_REAL_CST;
01540 case COMPLEX_CST: return TS_COMPLEX;
01541 case VECTOR_CST: return TS_VECTOR;
01542 case STRING_CST: return TS_STRING;
01543
01544 case ERROR_MARK: return TS_COMMON;
01545 case IDENTIFIER_NODE: return TS_IDENTIFIER;
01546 case TREE_LIST: return TS_LIST;
01547 case TREE_VEC: return TS_VEC;
01548 case PLACEHOLDER_EXPR: return TS_COMMON;
01549
01550 default:
01551 abort ();
01552 }
01553 }
01554
01555
01556
01557
01558 void
01559 unsave_expr_1 (expr)
01560 tree expr;
01561 {
01562 switch (TREE_CODE (expr))
01563 {
01564 case SAVE_EXPR:
01565 if (! SAVE_EXPR_PERSISTENT_P (expr))
01566 SAVE_EXPR_RTL (expr) = 0;
01567 break;
01568
01569 case TARGET_EXPR:
01570
01571
01572
01573
01574 if (TREE_OPERAND (expr, 1))
01575 break;
01576
01577 TREE_OPERAND (expr, 1) = TREE_OPERAND (expr, 3);
01578 TREE_OPERAND (expr, 3) = NULL_TREE;
01579 break;
01580
01581 case RTL_EXPR:
01582
01583 if (RTL_EXPR_SEQUENCE (expr) != 0)
01584 abort ();
01585 break;
01586
01587 default:
01588 break;
01589 }
01590 }
01591
01592
01593
01594 tree
01595 lhd_unsave_expr_now (expr)
01596 tree expr;
01597 {
01598 enum tree_code code;
01599
01600
01601 if (expr == 0)
01602 return expr;
01603
01604 unsave_expr_1 (expr);
01605
01606 code = TREE_CODE (expr);
01607 switch (TREE_CODE_CLASS (code))
01608 {
01609 case 'c':
01610 case 't':
01611 case 'd':
01612 case 'b':
01613 break;
01614
01615 case 'x':
01616 if (code == TREE_LIST)
01617 {
01618 lhd_unsave_expr_now (TREE_VALUE (expr));
01619 lhd_unsave_expr_now (TREE_CHAIN (expr));
01620 }
01621 break;
01622
01623 case 'e':
01624 case 'r':
01625 case 's':
01626 case '<':
01627 case '2':
01628 case '1':
01629 {
01630 int i;
01631
01632 for (i = first_rtl_op (code) - 1; i >= 0; i--)
01633 lhd_unsave_expr_now (TREE_OPERAND (expr, i));
01634 }
01635 break;
01636
01637 default:
01638 abort ();
01639 }
01640
01641 return expr;
01642 }
01643
01644
01645
01646
01647
01648
01649
01650
01651
01652
01653
01654
01655
01656
01657
01658
01659
01660 int
01661 unsafe_for_reeval (expr)
01662 tree expr;
01663 {
01664 int unsafeness = 0;
01665 enum tree_code code;
01666 int i, tmp, tmp2;
01667 tree exp;
01668 int first_rtl;
01669
01670 if (expr == NULL_TREE)
01671 return 1;
01672
01673 code = TREE_CODE (expr);
01674 first_rtl = first_rtl_op (code);
01675
01676 switch (code)
01677 {
01678 case SAVE_EXPR:
01679 case RTL_EXPR:
01680 return 2;
01681
01682 case TREE_LIST:
01683 for (exp = expr; exp != 0; exp = TREE_CHAIN (exp))
01684 {
01685 tmp = unsafe_for_reeval (TREE_VALUE (exp));
01686 unsafeness = MAX (tmp, unsafeness);
01687 }
01688
01689 return unsafeness;
01690
01691 case CALL_EXPR:
01692 tmp2 = unsafe_for_reeval (TREE_OPERAND (expr, 0));
01693 tmp = unsafe_for_reeval (TREE_OPERAND (expr, 1));
01694 return MAX (MAX (tmp, 1), tmp2);
01695
01696 case TARGET_EXPR:
01697 unsafeness = 1;
01698 break;
01699
01700 default:
01701 tmp = (*lang_hooks.unsafe_for_reeval) (expr);
01702 if (tmp >= 0)
01703 return tmp;
01704 break;
01705 }
01706
01707 switch (TREE_CODE_CLASS (code))
01708 {
01709 case 'c':
01710 case 't':
01711 case 'x':
01712 case 'd':
01713 case 'b':
01714 return 0;
01715
01716 case 'e':
01717 case 'r':
01718 case 's':
01719 case '<':
01720 case '2':
01721 case '1':
01722 for (i = first_rtl - 1; i >= 0; i--)
01723 {
01724 tmp = unsafe_for_reeval (TREE_OPERAND (expr, i));
01725 unsafeness = MAX (tmp, unsafeness);
01726 }
01727
01728 return unsafeness;
01729
01730 default:
01731 return 2;
01732 }
01733 }
01734
01735
01736
01737
01738 int
01739 contains_placeholder_p (exp)
01740 tree exp;
01741 {
01742 enum tree_code code;
01743 int result;
01744
01745 if (!exp)
01746 return 0;
01747
01748
01749
01750 code = TREE_CODE (exp);
01751 if (code == WITH_RECORD_EXPR)
01752 return 0;
01753 else if (code == PLACEHOLDER_EXPR)
01754 return 1;
01755
01756 switch (TREE_CODE_CLASS (code))
01757 {
01758 case 'r':
01759
01760
01761
01762
01763 return contains_placeholder_p (TREE_OPERAND (exp, 0));
01764
01765 case 'x':
01766 if (code == TREE_LIST)
01767 return (contains_placeholder_p (TREE_VALUE (exp))
01768 || (TREE_CHAIN (exp) != 0
01769 && contains_placeholder_p (TREE_CHAIN (exp))));
01770 break;
01771
01772 case '1':
01773 case '2': case '<':
01774 case 'e':
01775 switch (code)
01776 {
01777 case COMPOUND_EXPR:
01778
01779 return contains_placeholder_p (TREE_OPERAND (exp, 1));
01780
01781 case RTL_EXPR:
01782 case CONSTRUCTOR:
01783 return 0;
01784
01785 case COND_EXPR:
01786 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
01787 || contains_placeholder_p (TREE_OPERAND (exp, 1))
01788 || contains_placeholder_p (TREE_OPERAND (exp, 2)));
01789
01790 case SAVE_EXPR:
01791
01792
01793 if (SAVE_EXPR_NOPLACEHOLDER (exp) || SAVE_EXPR_RTL (exp) != 0)
01794 return 0;
01795
01796 SAVE_EXPR_NOPLACEHOLDER (exp) = 1;
01797 result = contains_placeholder_p (TREE_OPERAND (exp, 0));
01798 if (result)
01799 SAVE_EXPR_NOPLACEHOLDER (exp) = 0;
01800
01801 return result;
01802
01803 case CALL_EXPR:
01804 return (TREE_OPERAND (exp, 1) != 0
01805 && contains_placeholder_p (TREE_OPERAND (exp, 1)));
01806
01807 default:
01808 break;
01809 }
01810
01811 switch (TREE_CODE_LENGTH (code))
01812 {
01813 case 1:
01814 return contains_placeholder_p (TREE_OPERAND (exp, 0));
01815 case 2:
01816 return (contains_placeholder_p (TREE_OPERAND (exp, 0))
01817 || contains_placeholder_p (TREE_OPERAND (exp, 1)));
01818 default:
01819 return 0;
01820 }
01821
01822 default:
01823 return 0;
01824 }
01825 return 0;
01826 }
01827
01828
01829
01830
01831 int
01832 has_cleanups (exp)
01833 tree exp;
01834 {
01835 int i, nops, cmp;
01836
01837 if (! TREE_SIDE_EFFECTS (exp))
01838 return 0;
01839
01840 switch (TREE_CODE (exp))
01841 {
01842 case TARGET_EXPR:
01843 case GOTO_SUBROUTINE_EXPR:
01844 case WITH_CLEANUP_EXPR:
01845 return 1;
01846
01847 case CLEANUP_POINT_EXPR:
01848 return 0;
01849
01850 case CALL_EXPR:
01851 for (exp = TREE_OPERAND (exp, 1); exp; exp = TREE_CHAIN (exp))
01852 {
01853 cmp = has_cleanups (TREE_VALUE (exp));
01854 if (cmp)
01855 return cmp;
01856 }
01857 return 0;
01858
01859 default:
01860 break;
01861 }
01862
01863
01864
01865
01866
01867 if ((int) TREE_CODE (exp) >= (int) LAST_AND_UNUSED_TREE_CODE)
01868 return -1;
01869
01870 nops = first_rtl_op (TREE_CODE (exp));
01871 for (i = 0; i < nops; i++)
01872 if (TREE_OPERAND (exp, i) != 0)
01873 {
01874 int type = TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, i)));
01875 if (type == 'e' || type == '<' || type == '1' || type == '2'
01876 || type == 'r' || type == 's')
01877 {
01878 cmp = has_cleanups (TREE_OPERAND (exp, i));
01879 if (cmp)
01880 return cmp;
01881 }
01882 }
01883
01884 return 0;
01885 }
01886
01887
01888
01889
01890
01891
01892
01893 tree
01894 substitute_in_expr (exp, f, r)
01895 tree exp;
01896 tree f;
01897 tree r;
01898 {
01899 enum tree_code code = TREE_CODE (exp);
01900 tree op0, op1, op2;
01901 tree new;
01902 tree inner;
01903
01904 switch (TREE_CODE_CLASS (code))
01905 {
01906 case 'c':
01907 case 'd':
01908 return exp;
01909
01910 case 'x':
01911 if (code == PLACEHOLDER_EXPR)
01912 return exp;
01913 else if (code == TREE_LIST)
01914 {
01915 op0 = (TREE_CHAIN (exp) == 0
01916 ? 0 : substitute_in_expr (TREE_CHAIN (exp), f, r));
01917 op1 = substitute_in_expr (TREE_VALUE (exp), f, r);
01918 if (op0 == TREE_CHAIN (exp) && op1 == TREE_VALUE (exp))
01919 return exp;
01920
01921 return tree_cons (TREE_PURPOSE (exp), op1, op0);
01922 }
01923
01924 abort ();
01925
01926 case '1':
01927 case '2':
01928 case '<':
01929 case 'e':
01930 switch (TREE_CODE_LENGTH (code))
01931 {
01932 case 1:
01933 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
01934 if (op0 == TREE_OPERAND (exp, 0))
01935 return exp;
01936
01937 if (code == NON_LVALUE_EXPR)
01938 return op0;
01939
01940 new = fold (build1 (code, TREE_TYPE (exp), op0));
01941 break;
01942
01943 case 2:
01944
01945
01946 if (code == RTL_EXPR)
01947 return exp;
01948 else if (code == CONSTRUCTOR)
01949 abort ();
01950
01951 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
01952 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
01953 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1))
01954 return exp;
01955
01956 new = fold (build (code, TREE_TYPE (exp), op0, op1));
01957 break;
01958
01959 case 3:
01960
01961
01962 if (code == SAVE_EXPR)
01963 return exp;
01964
01965 else if (code == CALL_EXPR)
01966 {
01967 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
01968 if (op1 == TREE_OPERAND (exp, 1))
01969 return exp;
01970
01971 return build (code, TREE_TYPE (exp),
01972 TREE_OPERAND (exp, 0), op1, NULL_TREE);
01973 }
01974
01975 else if (code != COND_EXPR)
01976 abort ();
01977
01978 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
01979 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
01980 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
01981 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
01982 && op2 == TREE_OPERAND (exp, 2))
01983 return exp;
01984
01985 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
01986 break;
01987
01988 default:
01989 abort ();
01990 }
01991
01992 break;
01993
01994 case 'r':
01995 switch (code)
01996 {
01997 case COMPONENT_REF:
01998
01999
02000 for (inner = TREE_OPERAND (exp, 0);
02001 TREE_CODE_CLASS (TREE_CODE (inner)) == 'r';
02002 inner = TREE_OPERAND (inner, 0))
02003 ;
02004 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
02005 && TREE_OPERAND (exp, 1) == f)
02006 return r;
02007
02008
02009
02010 if (TREE_CODE (inner) == PLACEHOLDER_EXPR
02011 && TREE_TYPE (inner) == 0)
02012 return exp;
02013
02014 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
02015 if (op0 == TREE_OPERAND (exp, 0))
02016 return exp;
02017
02018 new = fold (build (code, TREE_TYPE (exp), op0,
02019 TREE_OPERAND (exp, 1)));
02020 break;
02021
02022 case BIT_FIELD_REF:
02023 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
02024 op1 = substitute_in_expr (TREE_OPERAND (exp, 1), f, r);
02025 op2 = substitute_in_expr (TREE_OPERAND (exp, 2), f, r);
02026 if (op0 == TREE_OPERAND (exp, 0) && op1 == TREE_OPERAND (exp, 1)
02027 && op2 == TREE_OPERAND (exp, 2))
02028 return exp;
02029
02030 new = fold (build (code, TREE_TYPE (exp), op0, op1, op2));
02031 break;
02032
02033 case INDIRECT_REF:
02034 case BUFFER_REF:
02035 op0 = substitute_in_expr (TREE_OPERAND (exp, 0), f, r);
02036 if (op0 == TREE_OPERAND (exp, 0))
02037 return exp;
02038
02039 new = fold (build1 (code, TREE_TYPE (exp), op0));
02040 break;
02041
02042 default:
02043 abort ();
02044 }
02045 break;
02046
02047 default:
02048 abort ();
02049 }
02050
02051 TREE_READONLY (new) = TREE_READONLY (exp);
02052 return new;
02053 }
02054
02055
02056
02057
02058
02059
02060
02061
02062
02063 tree
02064 stabilize_reference (ref)
02065 tree ref;
02066 {
02067 tree result;
02068 enum tree_code code = TREE_CODE (ref);
02069
02070 switch (code)
02071 {
02072 case VAR_DECL:
02073 case PARM_DECL:
02074 case RESULT_DECL:
02075
02076 return ref;
02077
02078 case NOP_EXPR:
02079 case CONVERT_EXPR:
02080 case FLOAT_EXPR:
02081 case FIX_TRUNC_EXPR:
02082 case FIX_FLOOR_EXPR:
02083 case FIX_ROUND_EXPR:
02084 case FIX_CEIL_EXPR:
02085 result = build_nt (code, stabilize_reference (TREE_OPERAND (ref, 0)));
02086 break;
02087
02088 case INDIRECT_REF:
02089 result = build_nt (INDIRECT_REF,
02090 stabilize_reference_1 (TREE_OPERAND (ref, 0)));
02091 break;
02092
02093 case COMPONENT_REF:
02094 result = build_nt (COMPONENT_REF,
02095 stabilize_reference (TREE_OPERAND (ref, 0)),
02096 TREE_OPERAND (ref, 1));
02097 break;
02098
02099 case BIT_FIELD_REF:
02100 result = build_nt (BIT_FIELD_REF,
02101 stabilize_reference (TREE_OPERAND (ref, 0)),
02102 stabilize_reference_1 (TREE_OPERAND (ref, 1)),
02103 stabilize_reference_1 (TREE_OPERAND (ref, 2)));
02104 break;
02105
02106 case ARRAY_REF:
02107 result = build_nt (ARRAY_REF,
02108 stabilize_reference (TREE_OPERAND (ref, 0)),
02109 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
02110 break;
02111
02112 case ARRAY_RANGE_REF:
02113 result = build_nt (ARRAY_RANGE_REF,
02114 stabilize_reference (TREE_OPERAND (ref, 0)),
02115 stabilize_reference_1 (TREE_OPERAND (ref, 1)));
02116 break;
02117
02118 case COMPOUND_EXPR:
02119
02120
02121
02122 return stabilize_reference_1 (ref);
02123
02124 case RTL_EXPR:
02125 result = build1 (INDIRECT_REF, TREE_TYPE (ref),
02126 save_expr (build1 (ADDR_EXPR,
02127 build_pointer_type (TREE_TYPE (ref)),
02128 ref)));
02129 break;
02130
02131
02132
02133 default:
02134 return ref;
02135
02136 case ERROR_MARK:
02137 return error_mark_node;
02138 }
02139
02140 TREE_TYPE (result) = TREE_TYPE (ref);
02141 TREE_READONLY (result) = TREE_READONLY (ref);
02142 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (ref);
02143 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (ref);
02144
02145 return result;
02146 }
02147
02148
02149
02150
02151
02152
02153
02154
02155
02156
02157
02158
02159
02160
02161 tree
02162 stabilize_reference_1 (e)
02163 tree e;
02164 {
02165 tree result;
02166 enum tree_code code = TREE_CODE (e);
02167
02168
02169
02170
02171
02172
02173 if (TREE_CONSTANT (e) || code == SAVE_EXPR)
02174 return e;
02175
02176 switch (TREE_CODE_CLASS (code))
02177 {
02178 case 'x':
02179 case 't':
02180 case 'd':
02181 case 'b':
02182 case '<':
02183 case 's':
02184 case 'e':
02185 case 'r':
02186
02187
02188
02189
02190 if (TREE_SIDE_EFFECTS (e))
02191 return save_expr (e);
02192 return e;
02193
02194 case 'c':
02195
02196
02197 return e;
02198
02199 case '2':
02200
02201
02202
02203 if (code == TRUNC_DIV_EXPR || code == TRUNC_MOD_EXPR
02204 || code == FLOOR_DIV_EXPR || code == FLOOR_MOD_EXPR
02205 || code == CEIL_DIV_EXPR || code == CEIL_MOD_EXPR
02206 || code == ROUND_DIV_EXPR || code == ROUND_MOD_EXPR)
02207 return save_expr (e);
02208
02209 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)),
02210 stabilize_reference_1 (TREE_OPERAND (e, 1)));
02211 break;
02212
02213 case '1':
02214
02215 result = build_nt (code, stabilize_reference_1 (TREE_OPERAND (e, 0)));
02216 break;
02217
02218 default:
02219 abort ();
02220 }
02221
02222 TREE_TYPE (result) = TREE_TYPE (e);
02223 TREE_READONLY (result) = TREE_READONLY (e);
02224 TREE_SIDE_EFFECTS (result) = TREE_SIDE_EFFECTS (e);
02225 TREE_THIS_VOLATILE (result) = TREE_THIS_VOLATILE (e);
02226
02227 return result;
02228 }
02229
02230
02231
02232
02233
02234
02235
02236
02237 tree
02238 build VPARAMS ((enum tree_code code, tree tt, ...))
02239 {
02240 tree t;
02241 int length;
02242 int i;
02243 int fro;
02244 int constant;
02245
02246 VA_OPEN (p, tt);
02247 VA_FIXEDARG (p, enum tree_code, code);
02248 VA_FIXEDARG (p, tree, tt);
02249
02250 t = make_node (code);
02251 length = TREE_CODE_LENGTH (code);
02252 TREE_TYPE (t) = tt;
02253
02254
02255
02256
02257
02258 fro = first_rtl_op (code);
02259
02260
02261
02262 constant = (TREE_CODE_CLASS (code) == '<'
02263 || TREE_CODE_CLASS (code) == '1'
02264 || TREE_CODE_CLASS (code) == '2'
02265 || TREE_CODE_CLASS (code) == 'c');
02266
02267 if (length == 2)
02268 {
02269
02270 tree arg0 = va_arg (p, tree);
02271 tree arg1 = va_arg (p, tree);
02272
02273 TREE_OPERAND (t, 0) = arg0;
02274 TREE_OPERAND (t, 1) = arg1;
02275 TREE_READONLY (t) = 1;
02276 if (arg0 && fro > 0)
02277 {
02278 if (TREE_SIDE_EFFECTS (arg0))
02279 TREE_SIDE_EFFECTS (t) = 1;
02280 if (!TREE_READONLY (arg0))
02281 TREE_READONLY (t) = 0;
02282 if (!TREE_CONSTANT (arg0))
02283 constant = 0;
02284 }
02285
02286 if (arg1 && fro > 1)
02287 {
02288 if (TREE_SIDE_EFFECTS (arg1))
02289 TREE_SIDE_EFFECTS (t) = 1;
02290 if (!TREE_READONLY (arg1))
02291 TREE_READONLY (t) = 0;
02292 if (!TREE_CONSTANT (arg1))
02293 constant = 0;
02294 }
02295 }
02296 else if (length == 1)
02297 {
02298 tree arg0 = va_arg (p, tree);
02299
02300
02301
02302
02303
02304
02305 if (TREE_CODE_CLASS (code) != 's')
02306 abort ();
02307 TREE_OPERAND (t, 0) = arg0;
02308 }
02309 else
02310 {
02311 for (i = 0; i < length; i++)
02312 {
02313 tree operand = va_arg (p, tree);
02314
02315 TREE_OPERAND (t, i) = operand;
02316 if (operand && fro > i)
02317 {
02318 if (TREE_SIDE_EFFECTS (operand))
02319 TREE_SIDE_EFFECTS (t) = 1;
02320 if (!TREE_CONSTANT (operand))
02321 constant = 0;
02322 }
02323 }
02324 }
02325 VA_CLOSE (p);
02326
02327 TREE_CONSTANT (t) = constant;
02328 return t;
02329 }
02330
02331
02332
02333
02334
02335 tree
02336 build1 (code, type, node)
02337 enum tree_code code;
02338 tree type;
02339 tree node;
02340 {
02341 int length;
02342 #ifdef GATHER_STATISTICS
02343 tree_node_kind kind;
02344 #endif
02345 tree t;
02346
02347 #ifdef GATHER_STATISTICS
02348 if (TREE_CODE_CLASS (code) == 'r')
02349 kind = r_kind;
02350 else
02351 kind = e_kind;
02352 #endif
02353
02354 #ifdef ENABLE_CHECKING
02355 if (TREE_CODE_CLASS (code) == '2'
02356 || TREE_CODE_CLASS (code) == '<'
02357 || TREE_CODE_LENGTH (code) != 1)
02358 abort ();
02359 #endif
02360
02361 length = sizeof (struct tree_exp);
02362
02363 t = ggc_alloc_tree (length);
02364
02365 memset ((PTR) t, 0, sizeof (struct tree_common));
02366
02367 #ifdef GATHER_STATISTICS
02368 tree_node_counts[(int) kind]++;
02369 tree_node_sizes[(int) kind] += length;
02370 #endif
02371
02372 TREE_SET_CODE (t, code);
02373
02374 TREE_TYPE (t) = type;
02375 TREE_COMPLEXITY (t) = 0;
02376 TREE_OPERAND (t, 0) = node;
02377 if (node && first_rtl_op (code) != 0)
02378 {
02379 TREE_SIDE_EFFECTS (t) = TREE_SIDE_EFFECTS (node);
02380 TREE_READONLY (t) = TREE_READONLY (node);
02381 }
02382
02383 switch (code)
02384 {
02385 case INIT_EXPR:
02386 case MODIFY_EXPR:
02387 case VA_ARG_EXPR:
02388 case RTL_EXPR:
02389 case PREDECREMENT_EXPR:
02390 case PREINCREMENT_EXPR:
02391 case POSTDECREMENT_EXPR:
02392 case POSTINCREMENT_EXPR:
02393
02394
02395 TREE_SIDE_EFFECTS (t) = 1;
02396 TREE_READONLY (t) = 0;
02397 break;
02398
02399 case INDIRECT_REF:
02400
02401
02402 TREE_READONLY (t) = 0;
02403 break;
02404
02405 default:
02406 if (TREE_CODE_CLASS (code) == '1' && node && TREE_CONSTANT (node))
02407 TREE_CONSTANT (t) = 1;
02408 break;
02409 }
02410
02411 return t;
02412 }
02413
02414
02415
02416
02417
02418
02419 tree
02420 build_nt VPARAMS ((enum tree_code code, ...))
02421 {
02422 tree t;
02423 int length;
02424 int i;
02425
02426 VA_OPEN (p, code);
02427 VA_FIXEDARG (p, enum tree_code, code);
02428
02429 t = make_node (code);
02430 length = TREE_CODE_LENGTH (code);
02431
02432 for (i = 0; i < length; i++)
02433 TREE_OPERAND (t, i) = va_arg (p, tree);
02434
02435 VA_CLOSE (p);
02436 return t;
02437 }
02438
02439
02440
02441
02442
02443
02444
02445 tree
02446 build_decl (code, name, type)
02447 enum tree_code code;
02448 tree name, type;
02449 {
02450 tree t;
02451
02452 t = make_node (code);
02453
02454
02455
02456
02457
02458
02459 DECL_NAME (t) = name;
02460 TREE_TYPE (t) = type;
02461
02462 if (code == VAR_DECL || code == PARM_DECL || code == RESULT_DECL)
02463 layout_decl (t, 0);
02464 else if (code == FUNCTION_DECL)
02465 DECL_MODE (t) = FUNCTION_MODE;
02466
02467 #ifdef KEY
02468
02469
02470
02471 if (code == FUNCTION_DECL)
02472 erase_duplicates (t);
02473 #endif
02474 return t;
02475 }
02476
02477
02478
02479
02480
02481 tree
02482 build_block (vars, tags, subblocks, supercontext, chain)
02483 tree vars, tags ATTRIBUTE_UNUSED, subblocks, supercontext, chain;
02484 {
02485 tree block = make_node (BLOCK);
02486
02487 BLOCK_VARS (block) = vars;
02488 BLOCK_SUBBLOCKS (block) = subblocks;
02489 BLOCK_SUPERCONTEXT (block) = supercontext;
02490 BLOCK_CHAIN (block) = chain;
02491 return block;
02492 }
02493
02494
02495
02496
02497
02498
02499 tree
02500 build_expr_wfl (node, file, line, col)
02501 tree node;
02502 const char *file;
02503 int line, col;
02504 {
02505 static const char *last_file = 0;
02506 static tree last_filenode = NULL_TREE;
02507 tree wfl = make_node (EXPR_WITH_FILE_LOCATION);
02508
02509 EXPR_WFL_NODE (wfl) = node;
02510 EXPR_WFL_SET_LINECOL (wfl, line, col);
02511 if (file != last_file)
02512 {
02513 last_file = file;
02514 last_filenode = file ? get_identifier (file) : NULL_TREE;
02515 }
02516
02517 EXPR_WFL_FILENAME_NODE (wfl) = last_filenode;
02518 if (node)
02519 {
02520 TREE_SIDE_EFFECTS (wfl) = TREE_SIDE_EFFECTS (node);
02521 TREE_TYPE (wfl) = TREE_TYPE (node);
02522 }
02523
02524 return wfl;
02525 }
02526
02527
02528
02529
02530 tree
02531 build_decl_attribute_variant (ddecl, attribute)
02532 tree ddecl, attribute;
02533 {
02534 DECL_ATTRIBUTES (ddecl) = attribute;
02535 return ddecl;
02536 }
02537
02538
02539
02540
02541
02542
02543 tree
02544 build_type_attribute_variant (ttype, attribute)
02545 tree ttype, attribute;
02546 {
02547 if (! attribute_list_equal (TYPE_ATTRIBUTES (ttype), attribute))
02548 {
02549 unsigned int hashcode;
02550 tree ntype;
02551
02552 ntype = copy_node (ttype);
02553
02554 TYPE_POINTER_TO (ntype) = 0;
02555 TYPE_REFERENCE_TO (ntype) = 0;
02556 TYPE_ATTRIBUTES (ntype) = attribute;
02557
02558
02559 TYPE_MAIN_VARIANT (ntype) = ntype;
02560 TYPE_NEXT_VARIANT (ntype) = 0;
02561 set_type_quals (ntype, TYPE_UNQUALIFIED);
02562
02563 hashcode = (TYPE_HASH (TREE_CODE (ntype))
02564 + TYPE_HASH (TREE_TYPE (ntype))
02565 + attribute_hash_list (attribute));
02566
02567 switch (TREE_CODE (ntype))
02568 {
02569 case FUNCTION_TYPE:
02570 hashcode += TYPE_HASH (TYPE_ARG_TYPES (ntype));
02571 break;
02572 case ARRAY_TYPE:
02573 hashcode += TYPE_HASH (TYPE_DOMAIN (ntype));
02574 break;
02575 case INTEGER_TYPE:
02576 hashcode += TYPE_HASH (TYPE_MAX_VALUE (ntype));
02577 break;
02578 case REAL_TYPE:
02579 hashcode += TYPE_HASH (TYPE_PRECISION (ntype));
02580 break;
02581 default:
02582 break;
02583 }
02584
02585 ntype = type_hash_canon (hashcode, ntype);
02586 ttype = build_qualified_type (ntype, TYPE_QUALS (ttype));
02587 }
02588
02589 return ttype;
02590 }
02591
02592
02593
02594
02595
02596
02597
02598
02599
02600 int
02601 is_attribute_p (attr, ident)
02602 const char *attr;
02603 tree ident;
02604 {
02605 int ident_len, attr_len;
02606 const char *p;
02607
02608 if (TREE_CODE (ident) != IDENTIFIER_NODE)
02609 return 0;
02610
02611 if (strcmp (attr, IDENTIFIER_POINTER (ident)) == 0)
02612 return 1;
02613
02614 p = IDENTIFIER_POINTER (ident);
02615 ident_len = strlen (p);
02616 attr_len = strlen (attr);
02617
02618
02619 if (attr[0] == '_')
02620 {
02621 if (attr[1] != '_'
02622 || attr[attr_len - 2] != '_'
02623 || attr[attr_len - 1] != '_')
02624 abort ();
02625 if (ident_len == attr_len - 4
02626 && strncmp (attr + 2, p, attr_len - 4) == 0)
02627 return 1;
02628 }
02629 else
02630 {
02631 if (ident_len == attr_len + 4
02632 && p[0] == '_' && p[1] == '_'
02633 && p[ident_len - 2] == '_' && p[ident_len - 1] == '_'
02634 && strncmp (attr, p + 2, attr_len) == 0)
02635 return 1;
02636 }
02637
02638 return 0;
02639 }
02640
02641
02642
02643
02644
02645
02646
02647 tree
02648 lookup_attribute (attr_name, list)
02649 const char *attr_name;
02650 tree list;
02651 {
02652 tree l;
02653
02654 for (l = list; l; l = TREE_CHAIN (l))
02655 {
02656 if (TREE_CODE (TREE_PURPOSE (l)) != IDENTIFIER_NODE)
02657 abort ();
02658 if (is_attribute_p (attr_name, TREE_PURPOSE (l)))
02659 return l;
02660 }
02661
02662 return NULL_TREE;
02663 }
02664
02665
02666
02667 tree
02668 merge_attributes (a1, a2)
02669 tree a1, a2;
02670 {
02671 tree attributes;
02672
02673
02674
02675 if ((attributes = a1) == 0)
02676 attributes = a2;
02677
02678
02679
02680 else if (a2 != 0 && ! attribute_list_contained (a1, a2))
02681 {
02682 if (attribute_list_contained (a2, a1))
02683 attributes = a2;
02684 else
02685 {
02686
02687
02688 if (list_length (a1) < list_length (a2))
02689 attributes = a2, a2 = a1;
02690
02691 for (; a2 != 0; a2 = TREE_CHAIN (a2))
02692 {
02693 tree a;
02694 for (a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
02695 attributes);
02696 a != NULL_TREE;
02697 a = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (a2)),
02698 TREE_CHAIN (a)))
02699 {
02700 if (simple_cst_equal (TREE_VALUE (a), TREE_VALUE (a2)) == 1)
02701 break;
02702 }
02703 if (a == NULL_TREE)
02704 {
02705 a1 = copy_node (a2);
02706 TREE_CHAIN (a1) = attributes;
02707 attributes = a1;
02708 }
02709 }
02710 }
02711 }
02712 return attributes;
02713 }
02714
02715
02716
02717
02718 tree
02719 merge_type_attributes (t1, t2)
02720 tree t1, t2;
02721 {
02722 return merge_attributes (TYPE_ATTRIBUTES (t1),
02723 TYPE_ATTRIBUTES (t2));
02724 }
02725
02726
02727
02728
02729 tree
02730 merge_decl_attributes (olddecl, newdecl)
02731 tree olddecl, newdecl;
02732 {
02733 return merge_attributes (DECL_ATTRIBUTES (olddecl),
02734 DECL_ATTRIBUTES (newdecl));
02735 }
02736
02737 #ifdef TARGET_DLLIMPORT_DECL_ATTRIBUTES
02738
02739
02740
02741
02742
02743
02744
02745
02746
02747
02748 tree
02749 merge_dllimport_decl_attributes (old, new)
02750 tree old;
02751 tree new;
02752 {
02753 tree a;
02754 int delete_dllimport_p;
02755
02756 old = DECL_ATTRIBUTES (old);
02757 new = DECL_ATTRIBUTES (new);
02758
02759
02760
02761
02762
02763 if (lookup_attribute ("dllimport", old) != NULL_TREE
02764 && lookup_attribute ("dllimport", new) == NULL_TREE)
02765 delete_dllimport_p = 1;
02766 else
02767 delete_dllimport_p = 0;
02768
02769 a = merge_attributes (old, new);
02770
02771 if (delete_dllimport_p)
02772 {
02773 tree prev, t;
02774
02775
02776 for (prev = NULL_TREE, t = a; t; prev = t, t = TREE_CHAIN (t))
02777 {
02778 if (is_attribute_p ("dllimport", TREE_PURPOSE (t)))
02779 {
02780 if (prev == NULL_TREE)
02781 a = TREE_CHAIN (a);
02782 else
02783 TREE_CHAIN (prev) = TREE_CHAIN (t);
02784 break;
02785 }
02786 }
02787 }
02788
02789 return a;
02790 }
02791
02792 #endif
02793
02794
02795
02796
02797 static void
02798 set_type_quals (type, type_quals)
02799 tree type;
02800 int type_quals;
02801 {
02802 TYPE_READONLY (type) = (type_quals & TYPE_QUAL_CONST) != 0;
02803 TYPE_VOLATILE (type) = (type_quals & TYPE_QUAL_VOLATILE) != 0;
02804 TYPE_RESTRICT (type) = (type_quals & TYPE_QUAL_RESTRICT) != 0;
02805 #if defined(TARG_SL)
02806 TYPE_SBUF(type) = (type_quals & TYPE_QUAL_SBUF) != 0;
02807 TYPE_SDRAM(type) = (type_quals & TYPE_QUAL_SDRAM) != 0;
02808 TYPE_V1BUF (type) = (type_quals & TYPE_QUAL_V1BUF) != 0;
02809 TYPE_V2BUF (type) = (type_quals & TYPE_QUAL_V2BUF) != 0;
02810 TYPE_V4BUF (type) = (type_quals & TYPE_QUAL_V4BUF) != 0;
02811 #endif // TARG_SL
02812 }
02813
02814
02815
02816
02817
02818 tree
02819 get_qualified_type (type, type_quals)
02820 tree type;
02821 int type_quals;
02822 {
02823 tree t;
02824
02825
02826
02827
02828 for (t = TYPE_MAIN_VARIANT (type); t; t = TYPE_NEXT_VARIANT (t))
02829 if (TYPE_QUALS (t) == type_quals && TYPE_NAME (t) == TYPE_NAME (type)
02830 && TYPE_CONTEXT (t) == TYPE_CONTEXT (type))
02831 return t;
02832
02833 return NULL_TREE;
02834 }
02835
02836 #if defined(TARG_SL)
02837 bool Check_Vbuf_Type_Spec(type)
02838 tree type;
02839 {
02840 if(!type) error(" type tree is NULL\n");
02841 bool finished = 0;
02842 do {
02843 switch(TREE_CODE(type)) {
02844 case POINTER_TYPE:
02845 case ARRAY_TYPE:
02846 case REFERENCE_TYPE:
02847 type = TREE_TYPE(type);
02848 break;
02849 default:
02850 finished = 1;
02851 }
02852 }while(!finished);
02853 if(TREE_CODE(type) != INTEGER_TYPE)
02854 error("can't recognized this type");
02855
02856
02857
02858
02859
02860
02861
02862
02863 return ( TYPE_MODE(type) == QImode);
02864 }
02865 #endif // TARG_SL
02866
02867
02868
02869
02870
02871 tree
02872 build_qualified_type (type, type_quals)
02873 tree type;
02874 int type_quals;
02875 {
02876 tree t;
02877
02878 #if defined(TARG_SL)
02879
02880 switch(type_quals) {
02881 case TYPE_QUAL_V1BUF:
02882 case TYPE_QUAL_V2BUF:
02883 case TYPE_QUAL_V4BUF:
02884 if(!Check_Vbuf_Type_Spec(type)) {
02885 error( "vbuf type specifier isn't char");
02886 }
02887 break;
02888 default:
02889 break;
02890 }
02891 #endif
02892
02893
02894 t = get_qualified_type (type, type_quals);
02895
02896
02897 if (!t)
02898 {
02899 t = build_type_copy (type);
02900 set_type_quals (t, type_quals);
02901 }
02902
02903 return t;
02904 }
02905
02906
02907
02908
02909 tree
02910 build_type_copy (type)
02911 tree type;
02912 {
02913 tree t, m = TYPE_MAIN_VARIANT (type);
02914
02915 t = copy_node (type);
02916
02917 TYPE_POINTER_TO (t) = 0;
02918 TYPE_REFERENCE_TO (t) = 0;
02919
02920
02921 TYPE_NEXT_VARIANT (t) = TYPE_NEXT_VARIANT (m);
02922 TYPE_NEXT_VARIANT (m) = t;
02923
02924 return t;
02925 }
02926
02927
02928
02929
02930
02931
02932
02933
02934 unsigned int
02935 type_hash_list (list)
02936 tree list;
02937 {
02938 unsigned int hashcode;
02939 tree tail;
02940
02941 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
02942 hashcode += TYPE_HASH (TREE_VALUE (tail));
02943
02944 return hashcode;
02945 }
02946
02947
02948
02949
02950
02951 static int
02952 type_hash_eq (va, vb)
02953 const void *va;
02954 const void *vb;
02955 {
02956 const struct type_hash *a = va, *b = vb;
02957 if (a->hash == b->hash
02958 && TREE_CODE (a->type) == TREE_CODE (b->type)
02959 && TREE_TYPE (a->type) == TREE_TYPE (b->type)
02960 && attribute_list_equal (TYPE_ATTRIBUTES (a->type),
02961 TYPE_ATTRIBUTES (b->type))
02962 && TYPE_ALIGN (a->type) == TYPE_ALIGN (b->type)
02963 && (TYPE_MAX_VALUE (a->type) == TYPE_MAX_VALUE (b->type)
02964 || tree_int_cst_equal (TYPE_MAX_VALUE (a->type),
02965 TYPE_MAX_VALUE (b->type)))
02966 && (TYPE_MIN_VALUE (a->type) == TYPE_MIN_VALUE (b->type)
02967 || tree_int_cst_equal (TYPE_MIN_VALUE (a->type),
02968 TYPE_MIN_VALUE (b->type)))
02969
02970 && (TYPE_DOMAIN (a->type) == TYPE_DOMAIN (b->type)
02971 || (TYPE_DOMAIN (a->type)
02972 && TREE_CODE (TYPE_DOMAIN (a->type)) == TREE_LIST
02973 && TYPE_DOMAIN (b->type)
02974 && TREE_CODE (TYPE_DOMAIN (b->type)) == TREE_LIST
02975 && type_list_equal (TYPE_DOMAIN (a->type),
02976 TYPE_DOMAIN (b->type)))))
02977 return 1;
02978 return 0;
02979 }
02980
02981
02982
02983 static hashval_t
02984 type_hash_hash (item)
02985 const void *item;
02986 {
02987 return ((const struct type_hash *) item)->hash;
02988 }
02989
02990
02991
02992
02993 tree
02994 type_hash_lookup (hashcode, type)
02995 unsigned int hashcode;
02996 tree type;
02997 {
02998 struct type_hash *h, in;
02999
03000
03001
03002 layout_type (type);
03003
03004 in.hash = hashcode;
03005 in.type = type;
03006
03007 h = htab_find_with_hash (type_hash_table, &in, hashcode);
03008 if (h)
03009 return h->type;
03010 return NULL_TREE;
03011 }
03012
03013
03014
03015
03016 void
03017 type_hash_add (hashcode, type)
03018 unsigned int hashcode;
03019 tree type;
03020 {
03021 struct type_hash *h;
03022 void **loc;
03023
03024 h = (struct type_hash *) ggc_alloc (sizeof (struct type_hash));
03025 h->hash = hashcode;
03026 h->type = type;
03027 loc = htab_find_slot_with_hash (type_hash_table, h, hashcode, INSERT);
03028 *(struct type_hash **) loc = h;
03029 }
03030
03031
03032
03033
03034
03035
03036
03037
03038
03039
03040
03041
03042
03043 int debug_no_type_hash = 0;
03044
03045 tree
03046 type_hash_canon (hashcode, type)
03047 unsigned int hashcode;
03048 tree type;
03049 {
03050 tree t1;
03051
03052 if (debug_no_type_hash)
03053 return type;
03054
03055
03056
03057 t1 = type_hash_lookup (hashcode, type);
03058 if (t1 != 0)
03059 {
03060 #ifdef GATHER_STATISTICS
03061 tree_node_counts[(int) t_kind]--;
03062 tree_node_sizes[(int) t_kind] -= sizeof (struct tree_type);
03063 #endif
03064 return t1;
03065 }
03066 else
03067 {
03068 type_hash_add (hashcode, type);
03069 return type;
03070 }
03071 }
03072
03073
03074
03075
03076
03077
03078
03079 static int
03080 type_hash_marked_p (p)
03081 const void *p;
03082 {
03083 tree type = ((struct type_hash *) p)->type;
03084
03085 return ggc_marked_p (type) || TYPE_SYMTAB_POINTER (type);
03086 }
03087
03088 static void
03089 print_type_hash_statistics ()
03090 {
03091 fprintf (stderr, "Type hash: size %ld, %ld elements, %f collisions\n",
03092 (long) htab_size (type_hash_table),
03093 (long) htab_elements (type_hash_table),
03094 htab_collisions (type_hash_table));
03095 }
03096
03097
03098
03099
03100
03101 unsigned int
03102 attribute_hash_list (list)
03103 tree list;
03104 {
03105 unsigned int hashcode;
03106 tree tail;
03107
03108 for (hashcode = 0, tail = list; tail; tail = TREE_CHAIN (tail))
03109
03110 hashcode += TYPE_HASH (TREE_PURPOSE (tail));
03111 return hashcode;
03112 }
03113
03114
03115
03116
03117 int
03118 attribute_list_equal (l1, l2)
03119 tree l1, l2;
03120 {
03121 return attribute_list_contained (l1, l2)
03122 && attribute_list_contained (l2, l1);
03123 }
03124
03125
03126
03127
03128
03129
03130
03131
03132
03133 int
03134 attribute_list_contained (l1, l2)
03135 tree l1, l2;
03136 {
03137 tree t1, t2;
03138
03139
03140 if (l1 == l2)
03141 return 1;
03142
03143
03144 for (t1 = l1, t2 = l2;
03145 t1 != 0 && t2 != 0
03146 && TREE_PURPOSE (t1) == TREE_PURPOSE (t2)
03147 && TREE_VALUE (t1) == TREE_VALUE (t2);
03148 t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2));
03149
03150
03151 if (t1 == 0 && t2 == 0)
03152 return 1;
03153
03154 for (; t2 != 0; t2 = TREE_CHAIN (t2))
03155 {
03156 tree attr;
03157 for (attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)), l1);
03158 attr != NULL_TREE;
03159 attr = lookup_attribute (IDENTIFIER_POINTER (TREE_PURPOSE (t2)),
03160 TREE_CHAIN (attr)))
03161 {
03162 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) == 1)
03163 break;
03164 }
03165
03166 if (attr == 0)
03167 return 0;
03168
03169 if (simple_cst_equal (TREE_VALUE (t2), TREE_VALUE (attr)) != 1)
03170 return 0;
03171 }
03172
03173 return 1;
03174 }
03175
03176
03177
03178
03179
03180
03181 int
03182 type_list_equal (l1, l2)
03183 tree l1, l2;
03184 {
03185 tree t1, t2;
03186
03187 for (t1 = l1, t2 = l2; t1 && t2; t1 = TREE_CHAIN (t1), t2 = TREE_CHAIN (t2))
03188 if (TREE_VALUE (t1) != TREE_VALUE (t2)
03189 || (TREE_PURPOSE (t1) != TREE_PURPOSE (t2)
03190 && ! (1 == simple_cst_equal (TREE_PURPOSE (t1), TREE_PURPOSE (t2))
03191 && (TREE_TYPE (TREE_PURPOSE (t1))
03192 == TREE_TYPE (TREE_PURPOSE (t2))))))
03193 return 0;
03194
03195 return t1 == t2;
03196 }
03197
03198
03199
03200
03201
03202 int
03203 type_num_arguments (type)
03204 tree type;
03205 {
03206 int i = 0;
03207 tree t;
03208
03209 for (t = TYPE_ARG_TYPES (type); t; t = TREE_CHAIN (t))
03210
03211
03212 if (VOID_TYPE_P (TREE_VALUE (t)))
03213 break;
03214 else
03215 ++i;
03216
03217 return i;
03218 }
03219
03220
03221
03222
03223 int
03224 tree_int_cst_equal (t1, t2)
03225 tree t1, t2;
03226 {
03227 if (t1 == t2)
03228 return 1;
03229
03230 if (t1 == 0 || t2 == 0)
03231 return 0;
03232
03233 if (TREE_CODE (t1) == INTEGER_CST
03234 && TREE_CODE (t2) == INTEGER_CST
03235 && TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
03236 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2))
03237 return 1;
03238
03239 return 0;
03240 }
03241
03242
03243
03244
03245 int
03246 tree_int_cst_lt (t1, t2)
03247 tree t1, t2;
03248 {
03249 if (t1 == t2)
03250 return 0;
03251
03252 if (TREE_UNSIGNED (TREE_TYPE (t1)) != TREE_UNSIGNED (TREE_TYPE (t2)))
03253 {
03254 int t1_sgn = tree_int_cst_sgn (t1);
03255 int t2_sgn = tree_int_cst_sgn (t2);
03256
03257 if (t1_sgn < t2_sgn)
03258 return 1;
03259 else if (t1_sgn > t2_sgn)
03260 return 0;
03261
03262
03263
03264 }
03265 else if (! TREE_UNSIGNED (TREE_TYPE (t1)))
03266 return INT_CST_LT (t1, t2);
03267
03268 return INT_CST_LT_UNSIGNED (t1, t2);
03269 }
03270
03271
03272
03273 int
03274 tree_int_cst_compare (t1, t2)
03275 tree t1;
03276 tree t2;
03277 {
03278 if (tree_int_cst_lt (t1, t2))
03279 return -1;
03280 else if (tree_int_cst_lt (t2, t1))
03281 return 1;
03282 else
03283 return 0;
03284 }
03285
03286
03287
03288
03289
03290
03291 int
03292 host_integerp (t, pos)
03293 tree t;
03294 int pos;
03295 {
03296 return (TREE_CODE (t) == INTEGER_CST
03297 && ! TREE_OVERFLOW (t)
03298 && ((TREE_INT_CST_HIGH (t) == 0
03299 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) >= 0)
03300 || (! pos && TREE_INT_CST_HIGH (t) == -1
03301 && (HOST_WIDE_INT) TREE_INT_CST_LOW (t) < 0
03302 && ! TREE_UNSIGNED (TREE_TYPE (t)))
03303 || (pos && TREE_INT_CST_HIGH (t) == 0)));
03304 }
03305
03306
03307
03308
03309
03310 HOST_WIDE_INT
03311 tree_low_cst (t, pos)
03312 tree t;
03313 int pos;
03314 {
03315 if (host_integerp (t, pos))
03316 return TREE_INT_CST_LOW (t);
03317 else
03318 abort ();
03319 }
03320
03321
03322
03323 int
03324 tree_int_cst_msb (t)
03325 tree t;
03326 {
03327 int prec;
03328 HOST_WIDE_INT h;
03329 unsigned HOST_WIDE_INT l;
03330
03331
03332
03333 prec = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (t))) - 1;
03334 rshift_double (TREE_INT_CST_LOW (t), TREE_INT_CST_HIGH (t), prec,
03335 2 * HOST_BITS_PER_WIDE_INT, &l, &h, 0);
03336 return (l & 1) == 1;
03337 }
03338
03339
03340
03341
03342
03343 int
03344 tree_int_cst_sgn (t)
03345 tree t;
03346 {
03347 if (TREE_INT_CST_LOW (t) == 0 && TREE_INT_CST_HIGH (t) == 0)
03348 return 0;
03349 else if (TREE_UNSIGNED (TREE_TYPE (t)))
03350 return 1;
03351 else if (TREE_INT_CST_HIGH (t) < 0)
03352 return -1;
03353 else
03354 return 1;
03355 }
03356
03357
03358
03359
03360 int
03361 simple_cst_list_equal (l1, l2)
03362 tree l1, l2;
03363 {
03364 while (l1 != NULL_TREE && l2 != NULL_TREE)
03365 {
03366 if (simple_cst_equal (TREE_VALUE (l1), TREE_VALUE (l2)) != 1)
03367 return 0;
03368
03369 l1 = TREE_CHAIN (l1);
03370 l2 = TREE_CHAIN (l2);
03371 }
03372
03373 return l1 == l2;
03374 }
03375
03376
03377
03378
03379
03380
03381
03382 int
03383 simple_cst_equal (t1, t2)
03384 tree t1, t2;
03385 {
03386 enum tree_code code1, code2;
03387 int cmp;
03388 int i;
03389
03390 if (t1 == t2)
03391 return 1;
03392 if (t1 == 0 || t2 == 0)
03393 return 0;
03394
03395 code1 = TREE_CODE (t1);
03396 code2 = TREE_CODE (t2);
03397
03398 if (code1 == NOP_EXPR || code1 == CONVERT_EXPR || code1 == NON_LVALUE_EXPR)
03399 {
03400 if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
03401 || code2 == NON_LVALUE_EXPR)
03402 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03403 else
03404 return simple_cst_equal (TREE_OPERAND (t1, 0), t2);
03405 }
03406
03407 else if (code2 == NOP_EXPR || code2 == CONVERT_EXPR
03408 || code2 == NON_LVALUE_EXPR)
03409 return simple_cst_equal (t1, TREE_OPERAND (t2, 0));
03410
03411 if (code1 != code2)
03412 return 0;
03413
03414 switch (code1)
03415 {
03416 case INTEGER_CST:
03417 return (TREE_INT_CST_LOW (t1) == TREE_INT_CST_LOW (t2)
03418 && TREE_INT_CST_HIGH (t1) == TREE_INT_CST_HIGH (t2));
03419
03420 case REAL_CST:
03421 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
03422
03423 case STRING_CST:
03424 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
03425 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
03426 TREE_STRING_LENGTH (t1)));
03427
03428 case CONSTRUCTOR:
03429 if (CONSTRUCTOR_ELTS (t1) == CONSTRUCTOR_ELTS (t2))
03430 return 1;
03431 else
03432 abort ();
03433
03434 case SAVE_EXPR:
03435 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03436
03437 case CALL_EXPR:
03438 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03439 if (cmp <= 0)
03440 return cmp;
03441 return
03442 simple_cst_list_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
03443
03444 case TARGET_EXPR:
03445
03446
03447
03448
03449 if ((TREE_CODE (TREE_OPERAND (t1, 0)) == VAR_DECL
03450 && DECL_NAME (TREE_OPERAND (t1, 0)) == NULL_TREE
03451 && !DECL_RTL_SET_P (TREE_OPERAND (t1, 0)))
03452 || (TREE_CODE (TREE_OPERAND (t2, 0)) == VAR_DECL
03453 && DECL_NAME (TREE_OPERAND (t2, 0)) == NULL_TREE
03454 && !DECL_RTL_SET_P (TREE_OPERAND (t2, 0))))
03455 cmp = 1;
03456 else
03457 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03458
03459 if (cmp <= 0)
03460 return cmp;
03461
03462 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1));
03463
03464 case WITH_CLEANUP_EXPR:
03465 cmp = simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03466 if (cmp <= 0)
03467 return cmp;
03468
03469 return simple_cst_equal (TREE_OPERAND (t1, 1), TREE_OPERAND (t1, 1));
03470
03471 case COMPONENT_REF:
03472 if (TREE_OPERAND (t1, 1) == TREE_OPERAND (t2, 1))
03473 return simple_cst_equal (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
03474
03475 return 0;
03476
03477 case VAR_DECL:
03478 case PARM_DECL:
03479 case CONST_DECL:
03480 case FUNCTION_DECL:
03481 return 0;
03482
03483 default:
03484 break;
03485 }
03486
03487
03488
03489
03490
03491 if ((int) code1 >= (int) LAST_AND_UNUSED_TREE_CODE)
03492 return -1;
03493
03494 switch (TREE_CODE_CLASS (code1))
03495 {
03496 case '1':
03497 case '2':
03498 case '<':
03499 case 'e':
03500 case 'r':
03501 case 's':
03502 cmp = 1;
03503 for (i = 0; i < TREE_CODE_LENGTH (code1); i++)
03504 {
03505 cmp = simple_cst_equal (TREE_OPERAND (t1, i), TREE_OPERAND (t2, i));
03506 if (cmp <= 0)
03507 return cmp;
03508 }
03509
03510 return cmp;
03511
03512 default:
03513 return -1;
03514 }
03515 }
03516
03517
03518
03519
03520
03521 int
03522 compare_tree_int (t, u)
03523 tree t;
03524 unsigned HOST_WIDE_INT u;
03525 {
03526 if (tree_int_cst_sgn (t) < 0)
03527 return -1;
03528 else if (TREE_INT_CST_HIGH (t) != 0)
03529 return 1;
03530 else if (TREE_INT_CST_LOW (t) == u)
03531 return 0;
03532 else if (TREE_INT_CST_LOW (t) < u)
03533 return -1;
03534 else
03535 return 1;
03536 }
03537
03538
03539
03540
03541
03542
03543
03544
03545 tree
03546 build_pointer_type (to_type)
03547 tree to_type;
03548 {
03549 tree t = TYPE_POINTER_TO (to_type);
03550
03551
03552
03553 if (t != 0)
03554 return t;
03555
03556
03557 t = make_node (POINTER_TYPE);
03558
03559 TREE_TYPE (t) = to_type;
03560
03561
03562 TYPE_POINTER_TO (to_type) = t;
03563
03564
03565
03566
03567 layout_type (t);
03568
03569 return t;
03570 }
03571
03572
03573
03574 tree
03575 build_reference_type (to_type)
03576 tree to_type;
03577 {
03578 tree t = TYPE_REFERENCE_TO (to_type);
03579
03580
03581
03582 if (t)
03583 return t;
03584
03585
03586 t = make_node (REFERENCE_TYPE);
03587
03588 TREE_TYPE (t) = to_type;
03589
03590
03591 TYPE_REFERENCE_TO (to_type) = t;
03592
03593 layout_type (t);
03594
03595 return t;
03596 }
03597
03598
03599
03600
03601
03602
03603 tree
03604 build_type_no_quals (t)
03605 tree t;
03606 {
03607 switch (TREE_CODE (t))
03608 {
03609 case POINTER_TYPE:
03610 return build_pointer_type (build_type_no_quals (TREE_TYPE (t)));
03611 case REFERENCE_TYPE:
03612 return build_reference_type (build_type_no_quals (TREE_TYPE (t)));
03613 default:
03614 return TYPE_MAIN_VARIANT (t);
03615 }
03616 }
03617
03618
03619
03620
03621
03622
03623
03624
03625
03626
03627 tree
03628 build_index_type (maxval)
03629 tree maxval;
03630 {
03631 tree itype = make_node (INTEGER_TYPE);
03632
03633 TREE_TYPE (itype) = sizetype;
03634 TYPE_PRECISION (itype) = TYPE_PRECISION (sizetype);
03635 TYPE_MIN_VALUE (itype) = size_zero_node;
03636 TYPE_MAX_VALUE (itype) = convert (sizetype, maxval);
03637 TYPE_MODE (itype) = TYPE_MODE (sizetype);
03638 TYPE_SIZE (itype) = TYPE_SIZE (sizetype);
03639 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (sizetype);
03640 TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
03641 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (sizetype);
03642
03643 if (host_integerp (maxval, 1))
03644 return type_hash_canon (tree_low_cst (maxval, 1), itype);
03645 else
03646 return itype;
03647 }
03648
03649
03650
03651
03652
03653
03654 tree
03655 build_range_type (type, lowval, highval)
03656 tree type, lowval, highval;
03657 {
03658 tree itype = make_node (INTEGER_TYPE);
03659
03660 TREE_TYPE (itype) = type;
03661 if (type == NULL_TREE)
03662 type = sizetype;
03663
03664 TYPE_MIN_VALUE (itype) = convert (type, lowval);
03665 TYPE_MAX_VALUE (itype) = highval ? convert (type, highval) : NULL;
03666
03667 TYPE_PRECISION (itype) = TYPE_PRECISION (type);
03668 TYPE_MODE (itype) = TYPE_MODE (type);
03669 TYPE_SIZE (itype) = TYPE_SIZE (type);
03670 TYPE_SIZE_UNIT (itype) = TYPE_SIZE_UNIT (type);
03671 TYPE_ALIGN (itype) = TYPE_ALIGN (type);
03672 TYPE_USER_ALIGN (itype) = TYPE_USER_ALIGN (type);
03673
03674 if (host_integerp (lowval, 0) && highval != 0 && host_integerp (highval, 0))
03675 return type_hash_canon (tree_low_cst (highval, 0)
03676 - tree_low_cst (lowval, 0),
03677 itype);
03678 else
03679 return itype;
03680 }
03681
03682
03683
03684
03685 tree
03686 build_index_2_type (lowval, highval)
03687 tree lowval, highval;
03688 {
03689 return build_range_type (sizetype, lowval, highval);
03690 }
03691
03692
03693
03694
03695
03696
03697 int
03698 index_type_equal (itype1, itype2)
03699 tree itype1, itype2;
03700 {
03701 if (TREE_CODE (itype1) != TREE_CODE (itype2))
03702 return 0;
03703
03704 if (TREE_CODE (itype1) == INTEGER_TYPE)
03705 {
03706 if (TYPE_PRECISION (itype1) != TYPE_PRECISION (itype2)
03707 || TYPE_MODE (itype1) != TYPE_MODE (itype2)
03708 || simple_cst_equal (TYPE_SIZE (itype1), TYPE_SIZE (itype2)) != 1
03709 || TYPE_ALIGN (itype1) != TYPE_ALIGN (itype2))
03710 return 0;
03711
03712 if (1 == simple_cst_equal (TYPE_MIN_VALUE (itype1),
03713 TYPE_MIN_VALUE (itype2))
03714 && 1 == simple_cst_equal (TYPE_MAX_VALUE (itype1),
03715 TYPE_MAX_VALUE (itype2)))
03716 return 1;
03717 }
03718
03719 return 0;
03720 }
03721
03722
03723
03724
03725
03726 tree
03727 build_array_type (elt_type, index_type)
03728 tree elt_type, index_type;
03729 {
03730 tree t;
03731 unsigned int hashcode;
03732
03733 if (TREE_CODE (elt_type) == FUNCTION_TYPE)
03734 {
03735 error ("arrays of functions are not meaningful");
03736 elt_type = integer_type_node;
03737 }
03738
03739
03740 build_pointer_type (elt_type);
03741
03742
03743
03744 t = make_node (ARRAY_TYPE);
03745 TREE_TYPE (t) = elt_type;
03746 TYPE_DOMAIN (t) = index_type;
03747
03748 if (index_type == 0)
03749 {
03750 return t;
03751 }
03752
03753 hashcode = TYPE_HASH (elt_type) + TYPE_HASH (index_type);
03754 t = type_hash_canon (hashcode, t);
03755
03756 if (!COMPLETE_TYPE_P (t))
03757 layout_type (t);
03758 return t;
03759 }
03760
03761
03762
03763
03764 tree
03765 get_inner_array_type (array)
03766 tree array;
03767 {
03768 tree type = TREE_TYPE (array);
03769
03770 while (TREE_CODE (type) == ARRAY_TYPE)
03771 type = TREE_TYPE (type);
03772
03773 return type;
03774 }
03775
03776
03777
03778
03779
03780
03781
03782
03783 tree
03784 build_function_type (value_type, arg_types)
03785 tree value_type, arg_types;
03786 {
03787 tree t;
03788 unsigned int hashcode;
03789
03790 if (TREE_CODE (value_type) == FUNCTION_TYPE)
03791 {
03792 error ("function return type cannot be function");
03793 value_type = integer_type_node;
03794 }
03795
03796
03797 t = make_node (FUNCTION_TYPE);
03798 TREE_TYPE (t) = value_type;
03799 TYPE_ARG_TYPES (t) = arg_types;
03800
03801
03802 hashcode = TYPE_HASH (value_type) + type_hash_list (arg_types);
03803 t = type_hash_canon (hashcode, t);
03804
03805 if (!COMPLETE_TYPE_P (t))
03806 layout_type (t);
03807 return t;
03808 }
03809
03810
03811
03812
03813
03814
03815 tree
03816 build_function_type_list VPARAMS ((tree return_type, ...))
03817 {
03818 tree t, args, last;
03819
03820 VA_OPEN (p, return_type);
03821 VA_FIXEDARG (p, tree, return_type);
03822
03823 t = va_arg (p, tree);
03824 for (args = NULL_TREE; t != NULL_TREE; t = va_arg (p, tree))
03825 args = tree_cons (NULL_TREE, t, args);
03826
03827 last = args;
03828 args = nreverse (args);
03829 TREE_CHAIN (last) = void_list_node;
03830 args = build_function_type (return_type, args);
03831
03832 VA_CLOSE (p);
03833 return args;
03834 }
03835
03836
03837
03838
03839
03840
03841 tree
03842 build_method_type (basetype, type)
03843 tree basetype, type;
03844 {
03845 tree t;
03846 unsigned int hashcode;
03847
03848
03849 t = make_node (METHOD_TYPE);
03850
03851 if (TREE_CODE (type) != FUNCTION_TYPE)
03852 abort ();
03853
03854 TYPE_METHOD_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
03855 TREE_TYPE (t) = TREE_TYPE (type);
03856
03857
03858
03859
03860 TYPE_ARG_TYPES (t)
03861 = tree_cons (NULL_TREE,
03862 build_pointer_type (basetype), TYPE_ARG_TYPES (type));
03863
03864
03865 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
03866 t = type_hash_canon (hashcode, t);
03867
03868 if (!COMPLETE_TYPE_P (t))
03869 layout_type (t);
03870
03871 return t;
03872 }
03873
03874
03875
03876
03877
03878 tree
03879 build_offset_type (basetype, type)
03880 tree basetype, type;
03881 {
03882 tree t;
03883 unsigned int hashcode;
03884
03885
03886 t = make_node (OFFSET_TYPE);
03887
03888 TYPE_OFFSET_BASETYPE (t) = TYPE_MAIN_VARIANT (basetype);
03889 TREE_TYPE (t) = type;
03890
03891
03892 hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);
03893 t = type_hash_canon (hashcode, t);
03894
03895 if (!COMPLETE_TYPE_P (t))
03896 layout_type (t);
03897
03898 return t;
03899 }
03900
03901
03902
03903 tree
03904 build_complex_type (component_type)
03905 tree component_type;
03906 {
03907 tree t;
03908 unsigned int hashcode;
03909
03910
03911 t = make_node (COMPLEX_TYPE);
03912
03913 TREE_TYPE (t) = TYPE_MAIN_VARIANT (component_type);
03914 set_type_quals (t, TYPE_QUALS (component_type));
03915
03916
03917 hashcode = TYPE_HASH (component_type);
03918 t = type_hash_canon (hashcode, t);
03919
03920 if (!COMPLETE_TYPE_P (t))
03921 layout_type (t);
03922
03923
03924
03925 if ((write_symbols == DWARF2_DEBUG || write_symbols == VMS_AND_DWARF2_DEBUG)
03926 && ! TYPE_NAME (t))
03927 {
03928 const char *name;
03929 if (component_type == char_type_node)
03930 name = "complex char";
03931 else if (component_type == signed_char_type_node)
03932 name = "complex signed char";
03933 else if (component_type == unsigned_char_type_node)
03934 name = "complex unsigned char";
03935 else if (component_type == short_integer_type_node)
03936 name = "complex short int";
03937 else if (component_type == short_unsigned_type_node)
03938 name = "complex short unsigned int";
03939 else if (component_type == integer_type_node)
03940 name = "complex int";
03941 else if (component_type == unsigned_type_node)
03942 name = "complex unsigned int";
03943 else if (component_type == long_integer_type_node)
03944 name = "complex long int";
03945 else if (component_type == long_unsigned_type_node)
03946 name = "complex long unsigned int";
03947 else if (component_type == long_long_integer_type_node)
03948 name = "complex long long int";
03949 else if (component_type == long_long_unsigned_type_node)
03950 name = "complex long long unsigned int";
03951 else
03952 name = 0;
03953
03954 if (name != 0)
03955 TYPE_NAME (t) = get_identifier (name);
03956 }
03957
03958 return t;
03959 }
03960
03961
03962
03963
03964
03965
03966
03967
03968
03969
03970
03971
03972
03973
03974
03975
03976
03977
03978
03979
03980
03981
03982
03983
03984 tree
03985 get_unwidened (op, for_type)
03986 tree op;
03987 tree for_type;
03988 {
03989
03990 tree type = TREE_TYPE (op);
03991 unsigned final_prec
03992 = TYPE_PRECISION (for_type != 0 ? for_type : type);
03993 int uns
03994 = (for_type != 0 && for_type != type
03995 && final_prec > TYPE_PRECISION (type)
03996 && TREE_UNSIGNED (type));
03997 tree win = op;
03998
03999 while (TREE_CODE (op) == NOP_EXPR)
04000 {
04001 int bitschange
04002 = TYPE_PRECISION (TREE_TYPE (op))
04003 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0)));
04004
04005
04006
04007 if (bitschange < 0
04008 && final_prec > TYPE_PRECISION (TREE_TYPE (op)))
04009 break;
04010
04011
04012
04013 op = TREE_OPERAND (op, 0);
04014
04015
04016
04017
04018
04019
04020
04021
04022 if (bitschange > 0)
04023 {
04024 if (! uns || final_prec <= TYPE_PRECISION (TREE_TYPE (op)))
04025 win = op;
04026
04027
04028
04029 if ((uns || TREE_CODE (op) == NOP_EXPR)
04030 && TREE_UNSIGNED (TREE_TYPE (op)))
04031 {
04032 uns = 1;
04033 win = op;
04034 }
04035 }
04036 }
04037
04038 if (TREE_CODE (op) == COMPONENT_REF
04039
04040 && TREE_CODE (type) != REAL_TYPE
04041
04042 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0
04043 && host_integerp (DECL_SIZE (TREE_OPERAND (op, 1)), 1))
04044 {
04045 unsigned int innerprec
04046 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
04047 int unsignedp = TREE_UNSIGNED (TREE_OPERAND (op, 1));
04048 type = (*lang_hooks.types.type_for_size) (innerprec, unsignedp);
04049
04050
04051
04052
04053
04054
04055
04056 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
04057 && (for_type || ! DECL_BIT_FIELD (TREE_OPERAND (op, 1)))
04058 && (! uns || final_prec <= innerprec || unsignedp)
04059 && type != 0)
04060 {
04061 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
04062 TREE_OPERAND (op, 1));
04063 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
04064 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
04065 }
04066 }
04067
04068 return win;
04069 }
04070
04071
04072
04073
04074
04075
04076 tree
04077 get_narrower (op, unsignedp_ptr)
04078 tree op;
04079 int *unsignedp_ptr;
04080 {
04081 int uns = 0;
04082 int first = 1;
04083 tree win = op;
04084
04085 while (TREE_CODE (op) == NOP_EXPR)
04086 {
04087 int bitschange
04088 = (TYPE_PRECISION (TREE_TYPE (op))
04089 - TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (op, 0))));
04090
04091
04092 if (bitschange < 0)
04093 break;
04094
04095
04096
04097
04098 if (bitschange > 0)
04099 {
04100 op = TREE_OPERAND (op, 0);
04101
04102
04103 if (first)
04104 uns = TREE_UNSIGNED (TREE_TYPE (op));
04105
04106
04107
04108 else if (uns != TREE_UNSIGNED (TREE_TYPE (op)))
04109 break;
04110 first = 0;
04111 }
04112 else
04113 {
04114
04115
04116 if (first)
04117 uns = TREE_UNSIGNED (TREE_TYPE (op));
04118 first = 0;
04119 op = TREE_OPERAND (op, 0);
04120 }
04121
04122 win = op;
04123 }
04124
04125 if (TREE_CODE (op) == COMPONENT_REF
04126
04127 && TREE_CODE (TREE_TYPE (op)) != REAL_TYPE
04128
04129 && DECL_SIZE (TREE_OPERAND (op, 1)) != 0)
04130 {
04131 unsigned HOST_WIDE_INT innerprec
04132 = tree_low_cst (DECL_SIZE (TREE_OPERAND (op, 1)), 1);
04133 tree type = (*lang_hooks.types.type_for_size) (innerprec,
04134 TREE_UNSIGNED (op));
04135
04136
04137
04138
04139
04140
04141
04142
04143
04144 if (innerprec < TYPE_PRECISION (TREE_TYPE (op))
04145 && ! DECL_BIT_FIELD (TREE_OPERAND (op, 1))
04146 && (first || uns == TREE_UNSIGNED (TREE_OPERAND (op, 1)))
04147 && type != 0)
04148 {
04149 if (first)
04150 uns = TREE_UNSIGNED (TREE_OPERAND (op, 1));
04151 win = build (COMPONENT_REF, type, TREE_OPERAND (op, 0),
04152 TREE_OPERAND (op, 1));
04153 TREE_SIDE_EFFECTS (win) = TREE_SIDE_EFFECTS (op);
04154 TREE_THIS_VOLATILE (win) = TREE_THIS_VOLATILE (op);
04155 }
04156 }
04157 *unsignedp_ptr = uns;
04158 return win;
04159 }
04160
04161
04162
04163
04164 int
04165 int_fits_type_p (c, type)
04166 tree c, type;
04167 {
04168
04169
04170
04171 if (TYPE_MAX_VALUE (type) != NULL_TREE
04172 && TYPE_MIN_VALUE (type) != NULL_TREE
04173 && TREE_CODE (TYPE_MAX_VALUE (type)) == INTEGER_CST
04174 && TREE_CODE (TYPE_MIN_VALUE (type)) == INTEGER_CST)
04175 {
04176 if (TREE_UNSIGNED (type))
04177 return (! INT_CST_LT_UNSIGNED (TYPE_MAX_VALUE (type), c)
04178 && ! INT_CST_LT_UNSIGNED (c, TYPE_MIN_VALUE (type))
04179
04180 && ! (TREE_INT_CST_HIGH (c) < 0
04181 && ! TREE_UNSIGNED (TREE_TYPE (c))));
04182 else
04183 return (! INT_CST_LT (TYPE_MAX_VALUE (type), c)
04184 && ! INT_CST_LT (c, TYPE_MIN_VALUE (type))
04185
04186 && ! (TREE_INT_CST_HIGH (c) < 0
04187 && TREE_UNSIGNED (TREE_TYPE (c))));
04188 }
04189 else if (TREE_CODE (type) == INTEGER_TYPE && TREE_TYPE (type) != 0)
04190 return int_fits_type_p (c, TREE_TYPE (type));
04191 else
04192 {
04193 c = copy_node (c);
04194 TREE_TYPE (c) = type;
04195 return !force_fit_type (c, 0);
04196 }
04197 }
04198
04199
04200
04201
04202
04203
04204
04205
04206
04207
04208
04209 bool
04210 variably_modified_type_p (type)
04211 tree type;
04212 {
04213 if (type == error_mark_node)
04214 return false;
04215
04216
04217
04218
04219
04220
04221 if (TYPE_SIZE (type)
04222 && TYPE_SIZE (type) != error_mark_node
04223 && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST)
04224 return true;
04225
04226
04227
04228 if ((TREE_CODE (type) == POINTER_TYPE
04229 || TREE_CODE (type) == REFERENCE_TYPE)
04230 && variably_modified_type_p (TREE_TYPE (type)))
04231 return true;
04232
04233
04234
04235
04236 if (TREE_CODE (type) == ARRAY_TYPE
04237 && variably_modified_type_p (TREE_TYPE (type)))
04238 return true;
04239
04240
04241
04242 if (TREE_CODE (type) == FUNCTION_TYPE
04243 || TREE_CODE (type) == METHOD_TYPE)
04244 {
04245 tree parm;
04246
04247 if (variably_modified_type_p (TREE_TYPE (type)))
04248 return true;
04249 for (parm = TYPE_ARG_TYPES (type);
04250 parm && parm != void_list_node;
04251 parm = TREE_CHAIN (parm))
04252 if (variably_modified_type_p (TREE_VALUE (parm)))
04253 return true;
04254 }
04255
04256
04257
04258 return (*lang_hooks.tree_inlining.var_mod_type_p) (type);
04259 }
04260
04261
04262
04263
04264 tree
04265 get_containing_scope (t)
04266 tree t;
04267 {
04268 return (TYPE_P (t) ? TYPE_CONTEXT (t) : DECL_CONTEXT (t));
04269 }
04270
04271
04272
04273
04274 tree
04275 decl_function_context (decl)
04276 tree decl;
04277 {
04278 tree context;
04279
04280 if (TREE_CODE (decl) == ERROR_MARK)
04281 return 0;
04282
04283 if (TREE_CODE (decl) == SAVE_EXPR)
04284 context = SAVE_EXPR_CONTEXT (decl);
04285
04286
04287
04288
04289
04290
04291
04292 else if (TREE_CODE (decl) == FUNCTION_DECL && DECL_VINDEX (decl))
04293 context
04294 = TYPE_MAIN_VARIANT
04295 (TREE_TYPE (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl)))));
04296 else
04297 context = DECL_CONTEXT (decl);
04298
04299 while (context && TREE_CODE (context) != FUNCTION_DECL)
04300 {
04301 if (TREE_CODE (context) == BLOCK)
04302 context = BLOCK_SUPERCONTEXT (context);
04303 else
04304 context = get_containing_scope (context);
04305 }
04306
04307 return context;
04308 }
04309
04310
04311
04312
04313
04314 tree
04315 decl_type_context (decl)
04316 tree decl;
04317 {
04318 tree context = DECL_CONTEXT (decl);
04319
04320 while (context)
04321 {
04322 if (TREE_CODE (context) == NAMESPACE_DECL)
04323 return NULL_TREE;
04324
04325 if (TREE_CODE (context) == RECORD_TYPE
04326 || TREE_CODE (context) == UNION_TYPE
04327 || TREE_CODE (context) == QUAL_UNION_TYPE)
04328 return context;
04329
04330 if (TREE_CODE (context) == TYPE_DECL
04331 || TREE_CODE (context) == FUNCTION_DECL)
04332 context = DECL_CONTEXT (context);
04333
04334 else if (TREE_CODE (context) == BLOCK)
04335 context = BLOCK_SUPERCONTEXT (context);
04336
04337 else
04338
04339 abort ();
04340 }
04341 return NULL_TREE;
04342 }
04343
04344
04345
04346
04347
04348 tree
04349 get_callee_fndecl (call)
04350 tree call;
04351 {
04352 tree addr;
04353
04354
04355
04356 if (TREE_CODE (call) != CALL_EXPR)
04357 abort ();
04358
04359
04360
04361 addr = TREE_OPERAND (call, 0);
04362
04363 STRIP_NOPS (addr);
04364
04365
04366 if (DECL_P (addr) && TREE_CODE (addr) != FUNCTION_DECL
04367 && TREE_READONLY (addr) && ! TREE_THIS_VOLATILE (addr)
04368 && DECL_INITIAL (addr))
04369 addr = DECL_INITIAL (addr);
04370
04371
04372
04373 if (TREE_CODE (addr) == ADDR_EXPR
04374 && TREE_CODE (TREE_OPERAND (addr, 0)) == FUNCTION_DECL)
04375 return TREE_OPERAND (addr, 0);
04376
04377
04378 return NULL_TREE;
04379 }
04380
04381
04382
04383 void
04384 print_obstack_statistics (str, o)
04385 const char *str;
04386 struct obstack *o;
04387 {
04388 struct _obstack_chunk *chunk = o->chunk;
04389 int n_chunks = 1;
04390 int n_alloc = 0;
04391
04392 n_alloc += o->next_free - chunk->contents;
04393 chunk = chunk->prev;
04394 while (chunk)
04395 {
04396 n_chunks += 1;
04397 n_alloc += chunk->limit - &chunk->contents[0];
04398 chunk = chunk->prev;
04399 }
04400 fprintf (stderr, "obstack %s: %u bytes, %d chunks\n",
04401 str, n_alloc, n_chunks);
04402 }
04403
04404
04405
04406
04407 void
04408 dump_tree_statistics ()
04409 {
04410 #ifdef GATHER_STATISTICS
04411 int i;
04412 int total_nodes, total_bytes;
04413 #endif
04414
04415 fprintf (stderr, "\n??? tree nodes created\n\n");
04416 #ifdef GATHER_STATISTICS
04417 fprintf (stderr, "Kind Nodes Bytes\n");
04418 fprintf (stderr, "-------------------------------------\n");
04419 total_nodes = total_bytes = 0;
04420 for (i = 0; i < (int) all_kinds; i++)
04421 {
04422 fprintf (stderr, "%-20s %6d %9d\n", tree_node_kind_names[i],
04423 tree_node_counts[i], tree_node_sizes[i]);
04424 total_nodes += tree_node_counts[i];
04425 total_bytes += tree_node_sizes[i];
04426 }
04427 fprintf (stderr, "-------------------------------------\n");
04428 fprintf (stderr, "%-20s %6d %9d\n", "Total", total_nodes, total_bytes);
04429 fprintf (stderr, "-------------------------------------\n");
04430 #else
04431 fprintf (stderr, "(No per-node statistics)\n");
04432 #endif
04433 print_type_hash_statistics ();
04434 (*lang_hooks.print_statistics) ();
04435 }
04436
04437 #define FILE_FUNCTION_FORMAT "_GLOBAL__%s_%s"
04438
04439 const char *flag_random_seed;
04440
04441
04442
04443 void
04444 default_flag_random_seed ()
04445 {
04446 unsigned HOST_WIDE_INT value;
04447 char *new_random_seed;
04448
04449 if (flag_random_seed != NULL)
04450 return;
04451
04452
04453 #ifdef KEY // bug 3099
04454 {
04455 int i;
04456 value = 0;
04457 if (main_input_filename) {
04458 for (i = 0; i < strlen (main_input_filename); i++) {
04459 value = (value << 1) ^ main_input_filename[i];
04460 }
04461 } else {
04462 value = getpid ();
04463 }
04464 }
04465 #else
04466 #ifdef HAVE_GETTIMEOFDAY
04467 {
04468 struct timeval tv;
04469
04470 gettimeofday (&tv, NULL);
04471 value = (((unsigned HOST_WIDE_INT) tv.tv_usec << 16)
04472 ^ tv.tv_sec ^ getpid ());
04473 }
04474 #else
04475 value = getpid ();
04476 #endif
04477 #endif
04478
04479
04480 new_random_seed = xmalloc (HOST_BITS_PER_WIDE_INT / 3 + 2);
04481 sprintf (new_random_seed, HOST_WIDE_INT_PRINT_UNSIGNED, value);
04482 flag_random_seed = new_random_seed;
04483 }
04484
04485
04486
04487
04488
04489
04490 static void
04491 append_random_chars (template)
04492 char *template;
04493 {
04494 static const char letters[]
04495 = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
04496 unsigned HOST_WIDE_INT v;
04497 size_t i;
04498
04499 default_flag_random_seed ();
04500
04501
04502
04503
04504 v = 0;
04505 for (i = 0; i < strlen (flag_random_seed); i++)
04506 v = (v << 4) ^ (v >> (HOST_BITS_PER_WIDE_INT - 4)) ^ flag_random_seed[i];
04507
04508 template += strlen (template);
04509
04510
04511 template[0] = letters[v % 62];
04512 v /= 62;
04513 template[1] = letters[v % 62];
04514 v /= 62;
04515 template[2] = letters[v % 62];
04516 v /= 62;
04517 template[3] = letters[v % 62];
04518 v /= 62;
04519 template[4] = letters[v % 62];
04520 v /= 62;
04521 template[5] = letters[v % 62];
04522
04523 template[6] = '\0';
04524 }
04525
04526
04527
04528
04529 void
04530 clean_symbol_name (p)
04531 char *p;
04532 {
04533 for (; *p; p++)
04534 if (! (ISALNUM (*p)
04535 #ifndef NO_DOLLAR_IN_LABEL
04536 || *p == '$'
04537 #endif
04538 #ifndef NO_DOT_IN_LABEL
04539 || *p == '.'
04540 #endif
04541 ))
04542 *p = '_';
04543 }
04544
04545
04546
04547
04548
04549 tree
04550 get_file_function_name_long (type)
04551 const char *type;
04552 {
04553 char *buf;
04554 const char *p;
04555 char *q;
04556
04557 if (first_global_object_name)
04558 p = first_global_object_name;
04559 else
04560 {
04561
04562
04563
04564 const char *name = weak_global_object_name;
04565 const char *file = main_input_filename;
04566
04567 if (! name)
04568 name = "";
04569 if (! file)
04570 file = input_filename;
04571
04572 q = (char *) alloca (7 + strlen (name) + strlen (file));
04573
04574 sprintf (q, "%s%s", name, file);
04575 append_random_chars (q);
04576 p = q;
04577 }
04578
04579 buf = (char *) alloca (sizeof (FILE_FUNCTION_FORMAT) + strlen (p)
04580 + strlen (type));
04581
04582
04583
04584
04585
04586 sprintf (buf, FILE_FUNCTION_FORMAT, type, p);
04587
04588
04589 if (p != first_global_object_name)
04590 clean_symbol_name (buf + 11);
04591
04592 return get_identifier (buf);
04593 }
04594
04595
04596
04597
04598 tree
04599 get_file_function_name (kind)
04600 int kind;
04601 {
04602 char p[2];
04603
04604 p[0] = kind;
04605 p[1] = 0;
04606
04607 return get_file_function_name_long (p);
04608 }
04609
04610
04611
04612
04613
04614
04615
04616
04617 tree
04618 get_set_constructor_bits (init, buffer, bit_size)
04619 tree init;
04620 char *buffer;
04621 int bit_size;
04622 {
04623 int i;
04624 tree vals;
04625 HOST_WIDE_INT domain_min
04626 = tree_low_cst (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (init))), 0);
04627 tree non_const_bits = NULL_TREE;
04628
04629 for (i = 0; i < bit_size; i++)
04630 buffer[i] = 0;
04631
04632 for (vals = TREE_OPERAND (init, 1);
04633 vals != NULL_TREE; vals = TREE_CHAIN (vals))
04634 {
04635 if (!host_integerp (TREE_VALUE (vals), 0)
04636 || (TREE_PURPOSE (vals) != NULL_TREE
04637 && !host_integerp (TREE_PURPOSE (vals), 0)))
04638 non_const_bits
04639 = tree_cons (TREE_PURPOSE (vals), TREE_VALUE (vals), non_const_bits);
04640 else if (TREE_PURPOSE (vals) != NULL_TREE)
04641 {
04642
04643 HOST_WIDE_INT lo_index
04644 = tree_low_cst (TREE_PURPOSE (vals), 0) - domain_min;
04645 HOST_WIDE_INT hi_index
04646 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
04647
04648 if (lo_index < 0 || lo_index >= bit_size
04649 || hi_index < 0 || hi_index >= bit_size)
04650 abort ();
04651 for (; lo_index <= hi_index; lo_index++)
04652 buffer[lo_index] = 1;
04653 }
04654 else
04655 {
04656
04657 HOST_WIDE_INT index
04658 = tree_low_cst (TREE_VALUE (vals), 0) - domain_min;
04659 if (index < 0 || index >= bit_size)
04660 {
04661 error ("invalid initializer for bit string");
04662 return NULL_TREE;
04663 }
04664 buffer[index] = 1;
04665 }
04666 }
04667 return non_const_bits;
04668 }
04669
04670
04671
04672
04673
04674
04675 tree
04676 get_set_constructor_bytes (init, buffer, wd_size)
04677 tree init;
04678 unsigned char *buffer;
04679 int wd_size;
04680 {
04681 int i;
04682 int set_word_size = BITS_PER_UNIT;
04683 int bit_size = wd_size * set_word_size;
04684 int bit_pos = 0;
04685 unsigned char *bytep = buffer;
04686 char *bit_buffer = (char *) alloca (bit_size);
04687 tree non_const_bits = get_set_constructor_bits (init, bit_buffer, bit_size);
04688
04689 for (i = 0; i < wd_size; i++)
04690 buffer[i] = 0;
04691
04692 for (i = 0; i < bit_size; i++)
04693 {
04694 if (bit_buffer[i])
04695 {
04696 if (BYTES_BIG_ENDIAN)
04697 *bytep |= (1 << (set_word_size - 1 - bit_pos));
04698 else
04699 *bytep |= 1 << bit_pos;
04700 }
04701 bit_pos++;
04702 if (bit_pos >= set_word_size)
04703 bit_pos = 0, bytep++;
04704 }
04705 return non_const_bits;
04706 }
04707
04708 #if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
04709
04710
04711
04712 void
04713 tree_check_failed (node, code, file, line, function)
04714 const tree node;
04715 enum tree_code code;
04716 const char *file;
04717 int line;
04718 const char *function;
04719 {
04720 internal_error ("tree check: expected %s, have %s in %s, at %s:%d",
04721 tree_code_name[code], tree_code_name[TREE_CODE (node)],
04722 function, trim_filename (file), line);
04723 }
04724
04725
04726
04727
04728 void
04729 tree_class_check_failed (node, cl, file, line, function)
04730 const tree node;
04731 int cl;
04732 const char *file;
04733 int line;
04734 const char *function;
04735 {
04736 internal_error
04737 ("tree check: expected class '%c', have '%c' (%s) in %s, at %s:%d",
04738 cl, TREE_CODE_CLASS (TREE_CODE (node)),
04739 tree_code_name[TREE_CODE (node)], function, trim_filename (file), line);
04740 }
04741
04742
04743
04744
04745 void
04746 tree_vec_elt_check_failed (idx, len, file, line, function)
04747 int idx;
04748 int len;
04749 const char *file;
04750 int line;
04751 const char *function;
04752 {
04753 internal_error
04754 ("tree check: accessed elt %d of tree_vec with %d elts in %s, at %s:%d",
04755 idx + 1, len, function, trim_filename (file), line);
04756 }
04757
04758 #endif
04759
04760
04761
04762
04763 static void
04764 finish_vector_type (t)
04765 tree t;
04766 {
04767 layout_type (t);
04768
04769 {
04770 tree index = build_int_2 (TYPE_VECTOR_SUBPARTS (t) - 1, 0);
04771 tree array = build_array_type (TREE_TYPE (t),
04772 build_index_type (index));
04773 tree rt = make_node (RECORD_TYPE);
04774
04775 TYPE_FIELDS (rt) = build_decl (FIELD_DECL, get_identifier ("f"), array);
04776 DECL_CONTEXT (TYPE_FIELDS (rt)) = rt;
04777 layout_type (rt);
04778 TYPE_DEBUG_REPRESENTATION_TYPE (t) = rt;
04779
04780
04781
04782
04783 TYPE_UID (rt) = TYPE_UID (t);
04784 }
04785 }
04786
04787
04788
04789
04790
04791 void
04792 build_common_tree_nodes (signed_char)
04793 int signed_char;
04794 {
04795 error_mark_node = make_node (ERROR_MARK);
04796 TREE_TYPE (error_mark_node) = error_mark_node;
04797
04798 initialize_sizetypes ();
04799
04800
04801 signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
04802 unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);
04803
04804
04805
04806 char_type_node
04807 = (signed_char
04808 ? make_signed_type (CHAR_TYPE_SIZE)
04809 : make_unsigned_type (CHAR_TYPE_SIZE));
04810
04811 short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
04812 short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
04813 integer_type_node = make_signed_type (INT_TYPE_SIZE);
04814 unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);
04815 long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);
04816 long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);
04817 long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);
04818 long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);
04819
04820 intQI_type_node = make_signed_type (GET_MODE_BITSIZE (QImode));
04821 intHI_type_node = make_signed_type (GET_MODE_BITSIZE (HImode));
04822 intSI_type_node = make_signed_type (GET_MODE_BITSIZE (SImode));
04823 intDI_type_node = make_signed_type (GET_MODE_BITSIZE (DImode));
04824 intTI_type_node = make_signed_type (GET_MODE_BITSIZE (TImode));
04825
04826 unsigned_intQI_type_node = make_unsigned_type (GET_MODE_BITSIZE (QImode));
04827 unsigned_intHI_type_node = make_unsigned_type (GET_MODE_BITSIZE (HImode));
04828 unsigned_intSI_type_node = make_unsigned_type (GET_MODE_BITSIZE (SImode));
04829 unsigned_intDI_type_node = make_unsigned_type (GET_MODE_BITSIZE (DImode));
04830 unsigned_intTI_type_node = make_unsigned_type (GET_MODE_BITSIZE (TImode));
04831 }
04832
04833
04834
04835
04836 void
04837 build_common_tree_nodes_2 (short_double)
04838 int short_double;
04839 {
04840
04841 integer_zero_node = build_int_2 (0, 0);
04842 integer_one_node = build_int_2 (1, 0);
04843 integer_minus_one_node = build_int_2 (-1, -1);
04844
04845 size_zero_node = size_int (0);
04846 size_one_node = size_int (1);
04847 bitsize_zero_node = bitsize_int (0);
04848 bitsize_one_node = bitsize_int (1);
04849 bitsize_unit_node = bitsize_int (BITS_PER_UNIT);
04850
04851 void_type_node = make_node (VOID_TYPE);
04852 layout_type (void_type_node);
04853
04854
04855
04856 TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;
04857 TYPE_USER_ALIGN (void_type_node) = 0;
04858
04859 null_pointer_node = build_int_2 (0, 0);
04860 TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);
04861 layout_type (TREE_TYPE (null_pointer_node));
04862
04863 ptr_type_node = build_pointer_type (void_type_node);
04864 const_ptr_type_node
04865 = build_pointer_type (build_type_variant (void_type_node, 1, 0));
04866
04867 float_type_node = make_node (REAL_TYPE);
04868 TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;
04869 layout_type (float_type_node);
04870
04871 double_type_node = make_node (REAL_TYPE);
04872 if (short_double)
04873 TYPE_PRECISION (double_type_node) = FLOAT_TYPE_SIZE;
04874 else
04875 TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;
04876 layout_type (double_type_node);
04877
04878 long_double_type_node = make_node (REAL_TYPE);
04879 TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;
04880 layout_type (long_double_type_node);
04881
04882 float_ptr_type_node = build_pointer_type (float_type_node);
04883 double_ptr_type_node = build_pointer_type (double_type_node);
04884 long_double_ptr_type_node = build_pointer_type (long_double_type_node);
04885 integer_ptr_type_node = build_pointer_type (integer_type_node);
04886
04887 #if defined(TARG_SL) || defined(TARG_SL2)
04888 short_ptr_type_node = build_pointer_type (short_integer_type_node);
04889 #endif
04890
04891 complex_integer_type_node = make_node (COMPLEX_TYPE);
04892 TREE_TYPE (complex_integer_type_node) = integer_type_node;
04893 layout_type (complex_integer_type_node);
04894
04895 complex_float_type_node = make_node (COMPLEX_TYPE);
04896 TREE_TYPE (complex_float_type_node) = float_type_node;
04897 layout_type (complex_float_type_node);
04898
04899 complex_double_type_node = make_node (COMPLEX_TYPE);
04900 TREE_TYPE (complex_double_type_node) = double_type_node;
04901 layout_type (complex_double_type_node);
04902
04903 complex_long_double_type_node = make_node (COMPLEX_TYPE);
04904 TREE_TYPE (complex_long_double_type_node) = long_double_type_node;
04905 layout_type (complex_long_double_type_node);
04906
04907 {
04908 tree t;
04909 BUILD_VA_LIST_TYPE (t);
04910
04911
04912
04913
04914
04915
04916 if (TREE_CODE (t) != RECORD_TYPE)
04917 t = build_type_copy (t);
04918
04919 va_list_type_node = t;
04920 }
04921
04922 unsigned_V4SI_type_node
04923 = make_vector (V4SImode, unsigned_intSI_type_node, 1);
04924 unsigned_V2HI_type_node
04925 = make_vector (V2HImode, unsigned_intHI_type_node, 1);
04926 unsigned_V2SI_type_node
04927 = make_vector (V2SImode, unsigned_intSI_type_node, 1);
04928 unsigned_V2DI_type_node
04929 = make_vector (V2DImode, unsigned_intDI_type_node, 1);
04930 unsigned_V4HI_type_node
04931 = make_vector (V4HImode, unsigned_intHI_type_node, 1);
04932 unsigned_V8QI_type_node
04933 = make_vector (V8QImode, unsigned_intQI_type_node, 1);
04934 unsigned_V8HI_type_node
04935 = make_vector (V8HImode, unsigned_intHI_type_node, 1);
04936 unsigned_V16QI_type_node
04937 = make_vector (V16QImode, unsigned_intQI_type_node, 1);
04938 unsigned_V1DI_type_node
04939 = make_vector (V1DImode, unsigned_intDI_type_node, 1);
04940
04941 V16SF_type_node = make_vector (V16SFmode, float_type_node, 0);
04942 V4SF_type_node = make_vector (V4SFmode, float_type_node, 0);
04943 V4SI_type_node = make_vector (V4SImode, intSI_type_node, 0);
04944 V2HI_type_node = make_vector (V2HImode, intHI_type_node, 0);
04945 V2SI_type_node = make_vector (V2SImode, intSI_type_node, 0);
04946 V2DI_type_node = make_vector (V2DImode, intDI_type_node, 0);
04947 V4HI_type_node = make_vector (V4HImode, intHI_type_node, 0);
04948 V8QI_type_node = make_vector (V8QImode, intQI_type_node, 0);
04949 V8HI_type_node = make_vector (V8HImode, intHI_type_node, 0);
04950 V2SF_type_node = make_vector (V2SFmode, float_type_node, 0);
04951 V2DF_type_node = make_vector (V2DFmode, double_type_node, 0);
04952 V16QI_type_node = make_vector (V16QImode, intQI_type_node, 0);
04953 V1DI_type_node = make_vector (V1DImode, intDI_type_node, 0);
04954 }
04955
04956
04957
04958
04959 static tree
04960 make_vector (mode, innertype, unsignedp)
04961 enum machine_mode mode;
04962 tree innertype;
04963 int unsignedp;
04964 {
04965 tree t;
04966
04967 t = make_node (VECTOR_TYPE);
04968 TREE_TYPE (t) = innertype;
04969 TYPE_MODE (t) = mode;
04970 TREE_UNSIGNED (TREE_TYPE (t)) = unsignedp;
04971 finish_vector_type (t);
04972
04973 return t;
04974 }
04975
04976
04977
04978
04979 bool
04980 initializer_zerop (init)
04981 tree init;
04982 {
04983 STRIP_NOPS (init);
04984
04985 switch (TREE_CODE (init))
04986 {
04987 case INTEGER_CST:
04988 return integer_zerop (init);
04989 case REAL_CST:
04990 return real_zerop (init)
04991 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (init));
04992 case COMPLEX_CST:
04993 return integer_zerop (init)
04994 || (real_zerop (init)
04995 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_REALPART (init)))
04996 && ! REAL_VALUE_MINUS_ZERO (TREE_REAL_CST (TREE_IMAGPART (init))));
04997 case CONSTRUCTOR:
04998 {
04999 if (AGGREGATE_TYPE_P (TREE_TYPE (init)))
05000 {
05001 tree aggr_init = TREE_OPERAND (init, 1);
05002
05003 while (aggr_init)
05004 {
05005 if (! initializer_zerop (TREE_VALUE (aggr_init)))
05006 return false;
05007 aggr_init = TREE_CHAIN (aggr_init);
05008 }
05009 return true;
05010 }
05011 return false;
05012 }
05013 default:
05014 return false;
05015 }
05016 }
05017
05018 #include "gt-tree.h"