Mercurial > hg > CbC > CbC_gcc
annotate gcc/lto-streamer-out.c @ 136:4627f235cf2a
fix c-next example
| author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Thu, 08 Nov 2018 14:11:56 +0900 |
| parents | 84e7813d76e9 |
| children | 1830386684a0 |
| rev | line source |
|---|---|
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1 /* Write the GIMPLE representation to a file stream. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 |
| 131 | 3 Copyright (C) 2009-2018 Free Software Foundation, Inc. |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4 Contributed by Kenneth Zadeck <zadeck@naturalbridge.com> |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5 Re-implemented by Diego Novillo <dnovillo@google.com> |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7 This file is part of GCC. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 GCC is free software; you can redistribute it and/or modify it under |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
10 the terms of the GNU General Public License as published by the Free |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
11 Software Foundation; either version 3, or (at your option) any later |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
12 version. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
13 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15 WARRANTY; without even the implied warranty of MERCHANTABILITY or |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 for more details. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
18 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
19 You should have received a copy of the GNU General Public License |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
20 along with GCC; see the file COPYING3. If not see |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
21 <http://www.gnu.org/licenses/>. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
22 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
23 #include "config.h" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24 #include "system.h" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
25 #include "coretypes.h" |
| 111 | 26 #include "backend.h" |
| 27 #include "target.h" | |
| 28 #include "rtl.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
29 #include "tree.h" |
| 111 | 30 #include "gimple.h" |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
31 #include "tree-pass.h" |
| 111 | 32 #include "ssa.h" |
| 33 #include "gimple-streamer.h" | |
| 34 #include "alias.h" | |
| 35 #include "stor-layout.h" | |
| 36 #include "gimple-iterator.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
37 #include "except.h" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
38 #include "lto-symtab.h" |
| 111 | 39 #include "cgraph.h" |
| 40 #include "cfgloop.h" | |
| 41 #include "builtins.h" | |
| 42 #include "gomp-constants.h" | |
| 43 #include "debug.h" | |
| 131 | 44 #include "omp-offload.h" |
| 45 #include "print-tree.h" | |
| 111 | 46 |
| 47 | |
| 48 static void lto_write_tree (struct output_block*, tree, bool); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
49 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
50 /* Clear the line info stored in DATA_IN. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
51 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
52 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
53 clear_line_info (struct output_block *ob) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
54 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
55 ob->current_file = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
56 ob->current_line = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
57 ob->current_col = 0; |
| 111 | 58 ob->current_sysp = false; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
59 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
60 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
61 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
62 /* Create the output block and return it. SECTION_TYPE is |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
63 LTO_section_function_body or LTO_static_initializer. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
64 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
65 struct output_block * |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
66 create_output_block (enum lto_section_type section_type) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
67 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
68 struct output_block *ob = XCNEW (struct output_block); |
| 131 | 69 if (streamer_dump_file) |
| 70 fprintf (streamer_dump_file, "Creating output block for %s\n", | |
| 71 lto_section_name [section_type]); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
72 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
73 ob->section_type = section_type; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
74 ob->decl_state = lto_get_out_decl_state (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
75 ob->main_stream = XCNEW (struct lto_output_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
76 ob->string_stream = XCNEW (struct lto_output_stream); |
| 111 | 77 ob->writer_cache = streamer_tree_cache_create (!flag_wpa, true, false); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
78 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
79 if (section_type == LTO_section_function_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
80 ob->cfg_stream = XCNEW (struct lto_output_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
81 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
82 clear_line_info (ob); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
83 |
| 111 | 84 ob->string_hash_table = new hash_table<string_slot_hasher> (37); |
| 85 gcc_obstack_init (&ob->obstack); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
86 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
87 return ob; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
88 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
89 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
90 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
91 /* Destroy the output block OB. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
92 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
93 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
94 destroy_output_block (struct output_block *ob) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
95 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
96 enum lto_section_type section_type = ob->section_type; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
97 |
| 111 | 98 delete ob->string_hash_table; |
| 99 ob->string_hash_table = NULL; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
100 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
101 free (ob->main_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
102 free (ob->string_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
103 if (section_type == LTO_section_function_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
104 free (ob->cfg_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
105 |
| 111 | 106 streamer_tree_cache_delete (ob->writer_cache); |
| 107 obstack_free (&ob->obstack, NULL); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
108 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
109 free (ob); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
110 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
111 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
112 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
113 /* Look up NODE in the type table and write the index for it to OB. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
114 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
115 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
116 output_type_ref (struct output_block *ob, tree node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
117 { |
| 111 | 118 streamer_write_record_start (ob, LTO_type_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
119 lto_output_type_ref_index (ob->decl_state, ob->main_stream, node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
120 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
121 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
122 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
123 /* Return true if tree node T is written to various tables. For these |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
124 nodes, we sometimes want to write their phyiscal representation |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
125 (via lto_output_tree), and sometimes we need to emit an index |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
126 reference into a table (via lto_output_tree_ref). */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
127 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
128 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
129 tree_is_indexable (tree t) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
130 { |
| 111 | 131 /* Parameters and return values of functions of variably modified types |
| 132 must go to global stream, because they may be used in the type | |
| 133 definition. */ | |
| 134 if ((TREE_CODE (t) == PARM_DECL || TREE_CODE (t) == RESULT_DECL) | |
| 135 && DECL_CONTEXT (t)) | |
| 136 return variably_modified_type_p (TREE_TYPE (DECL_CONTEXT (t)), NULL_TREE); | |
| 131 | 137 /* IMPORTED_DECL is put into BLOCK and thus it never can be shared. |
| 138 We should no longer need to stream it. */ | |
| 111 | 139 else if (TREE_CODE (t) == IMPORTED_DECL) |
| 131 | 140 gcc_unreachable (); |
| 141 else if (TREE_CODE (t) == LABEL_DECL) | |
| 142 return FORCED_LABEL (t) || DECL_NONLOCAL (t); | |
| 111 | 143 else if (((VAR_P (t) && !TREE_STATIC (t)) |
| 144 || TREE_CODE (t) == TYPE_DECL | |
| 145 || TREE_CODE (t) == CONST_DECL | |
| 146 || TREE_CODE (t) == NAMELIST_DECL) | |
| 147 && decl_function_context (t)) | |
| 148 return false; | |
| 149 else if (TREE_CODE (t) == DEBUG_EXPR_DECL) | |
| 150 return false; | |
| 151 /* Variably modified types need to be streamed alongside function | |
| 152 bodies because they can refer to local entities. Together with | |
| 153 them we have to localize their members as well. | |
| 154 ??? In theory that includes non-FIELD_DECLs as well. */ | |
| 155 else if (TYPE_P (t) | |
| 156 && variably_modified_type_p (t, NULL_TREE)) | |
| 157 return false; | |
| 158 else if (TREE_CODE (t) == FIELD_DECL | |
| 159 && variably_modified_type_p (DECL_CONTEXT (t), NULL_TREE)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
160 return false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
161 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
162 return (TYPE_P (t) || DECL_P (t) || TREE_CODE (t) == SSA_NAME); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
163 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
164 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
165 |
| 111 | 166 /* Output info about new location into bitpack BP. |
| 167 After outputting bitpack, lto_output_location_data has | |
| 168 to be done to output actual data. */ | |
| 169 | |
| 170 void | |
| 171 lto_output_location (struct output_block *ob, struct bitpack_d *bp, | |
| 172 location_t loc) | |
| 173 { | |
| 174 expanded_location xloc; | |
| 175 | |
| 176 loc = LOCATION_LOCUS (loc); | |
| 177 bp_pack_int_in_range (bp, 0, RESERVED_LOCATION_COUNT, | |
| 178 loc < RESERVED_LOCATION_COUNT | |
| 179 ? loc : RESERVED_LOCATION_COUNT); | |
| 180 if (loc < RESERVED_LOCATION_COUNT) | |
| 181 return; | |
| 182 | |
| 183 xloc = expand_location (loc); | |
| 184 | |
| 185 bp_pack_value (bp, ob->current_file != xloc.file, 1); | |
| 186 bp_pack_value (bp, ob->current_line != xloc.line, 1); | |
| 187 bp_pack_value (bp, ob->current_col != xloc.column, 1); | |
| 188 | |
| 189 if (ob->current_file != xloc.file) | |
| 190 { | |
| 191 bp_pack_string (ob, bp, xloc.file, true); | |
| 192 bp_pack_value (bp, xloc.sysp, 1); | |
| 193 } | |
| 194 ob->current_file = xloc.file; | |
| 195 ob->current_sysp = xloc.sysp; | |
| 196 | |
| 197 if (ob->current_line != xloc.line) | |
| 198 bp_pack_var_len_unsigned (bp, xloc.line); | |
| 199 ob->current_line = xloc.line; | |
| 200 | |
| 201 if (ob->current_col != xloc.column) | |
| 202 bp_pack_var_len_unsigned (bp, xloc.column); | |
| 203 ob->current_col = xloc.column; | |
| 204 } | |
| 205 | |
| 206 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
207 /* If EXPR is an indexable tree node, output a reference to it to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
208 output block OB. Otherwise, output the physical representation of |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209 EXPR to OB. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
210 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
211 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
212 lto_output_tree_ref (struct output_block *ob, tree expr) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
213 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
214 enum tree_code code; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
215 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
216 if (TYPE_P (expr)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
217 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
218 output_type_ref (ob, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
219 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
222 code = TREE_CODE (expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
223 switch (code) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
224 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
225 case SSA_NAME: |
| 111 | 226 streamer_write_record_start (ob, LTO_ssa_name_ref); |
| 227 streamer_write_uhwi (ob, SSA_NAME_VERSION (expr)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
228 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
230 case FIELD_DECL: |
| 111 | 231 streamer_write_record_start (ob, LTO_field_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
232 lto_output_field_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
233 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
234 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
235 case FUNCTION_DECL: |
| 111 | 236 streamer_write_record_start (ob, LTO_function_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
237 lto_output_fn_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
238 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
239 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
240 case VAR_DECL: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
241 case DEBUG_EXPR_DECL: |
| 111 | 242 gcc_assert (decl_function_context (expr) == NULL || TREE_STATIC (expr)); |
| 243 /* FALLTHRU */ | |
| 244 case PARM_DECL: | |
| 245 streamer_write_record_start (ob, LTO_global_decl_ref); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
246 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
248 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
249 case CONST_DECL: |
| 111 | 250 streamer_write_record_start (ob, LTO_const_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
251 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
252 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
253 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
254 case IMPORTED_DECL: |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
255 gcc_assert (decl_function_context (expr) == NULL); |
| 111 | 256 streamer_write_record_start (ob, LTO_imported_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
257 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
258 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
259 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
260 case TYPE_DECL: |
| 111 | 261 streamer_write_record_start (ob, LTO_type_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
262 lto_output_type_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
263 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
264 |
| 111 | 265 case NAMELIST_DECL: |
| 266 streamer_write_record_start (ob, LTO_namelist_decl_ref); | |
| 267 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); | |
| 268 break; | |
| 269 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
270 case NAMESPACE_DECL: |
| 111 | 271 streamer_write_record_start (ob, LTO_namespace_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
272 lto_output_namespace_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
273 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
274 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
275 case LABEL_DECL: |
| 111 | 276 streamer_write_record_start (ob, LTO_label_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
277 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
278 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
279 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
280 case RESULT_DECL: |
| 111 | 281 streamer_write_record_start (ob, LTO_result_decl_ref); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
282 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
283 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
284 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
285 case TRANSLATION_UNIT_DECL: |
| 111 | 286 streamer_write_record_start (ob, LTO_translation_unit_decl_ref); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
287 lto_output_var_decl_index (ob->decl_state, ob->main_stream, expr); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
288 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
289 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
290 default: |
| 111 | 291 /* No other node is indexable, so it should have been handled by |
| 292 lto_output_tree. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
293 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
294 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
296 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
297 |
| 111 | 298 /* Return true if EXPR is a tree node that can be written to disk. */ |
| 299 | |
| 300 static inline bool | |
| 301 lto_is_streamable (tree expr) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
302 { |
| 111 | 303 enum tree_code code = TREE_CODE (expr); |
| 304 | |
| 305 /* Notice that we reject SSA_NAMEs as well. We only emit the SSA | |
| 306 name version in lto_output_tree_ref (see output_ssa_names). */ | |
| 307 return !is_lang_specific (expr) | |
| 308 && code != SSA_NAME | |
| 309 && code != CALL_EXPR | |
| 310 && code != LANG_TYPE | |
| 311 && code != MODIFY_EXPR | |
| 312 && code != INIT_EXPR | |
| 313 && code != TARGET_EXPR | |
| 314 && code != BIND_EXPR | |
| 315 && code != WITH_CLEANUP_EXPR | |
| 316 && code != STATEMENT_LIST | |
| 317 && (code == CASE_LABEL_EXPR | |
| 318 || code == DECL_EXPR | |
| 319 || TREE_CODE_CLASS (code) != tcc_statement); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
320 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
321 |
| 111 | 322 /* Very rough estimate of streaming size of the initializer. If we ignored |
| 323 presence of strings, we could simply just count number of non-indexable | |
| 324 tree nodes and number of references to indexable nodes. Strings however | |
| 325 may be very large and we do not want to dump them int othe global stream. | |
| 326 | |
| 327 Count the size of initializer until the size in DATA is positive. */ | |
| 328 | |
| 329 static tree | |
| 330 subtract_estimated_size (tree *tp, int *ws, void *data) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
331 { |
| 111 | 332 long *sum = (long *)data; |
| 333 if (tree_is_indexable (*tp)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
334 { |
| 111 | 335 /* Indexable tree is one reference to global stream. |
| 336 Guess it may be about 4 bytes. */ | |
| 337 *sum -= 4; | |
| 338 *ws = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
339 } |
| 111 | 340 /* String table entry + base of tree node needs to be streamed. */ |
| 341 if (TREE_CODE (*tp) == STRING_CST) | |
| 342 *sum -= TREE_STRING_LENGTH (*tp) + 8; | |
| 343 else | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
344 { |
| 111 | 345 /* Identifiers are also variable length but should not appear |
| 346 naked in constructor. */ | |
| 347 gcc_checking_assert (TREE_CODE (*tp) != IDENTIFIER_NODE); | |
| 348 /* We do not really make attempt to work out size of pickled tree, as | |
| 349 it is very variable. Make it bigger than the reference. */ | |
| 350 *sum -= 16; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
351 } |
| 111 | 352 if (*sum < 0) |
| 353 return *tp; | |
| 354 return NULL_TREE; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
355 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
356 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
357 |
| 111 | 358 /* For EXPR lookup and return what we want to stream to OB as DECL_INITIAL. */ |
| 359 | |
| 360 static tree | |
| 361 get_symbol_initial_value (lto_symtab_encoder_t encoder, tree expr) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
362 { |
| 111 | 363 gcc_checking_assert (DECL_P (expr) |
| 364 && TREE_CODE (expr) != FUNCTION_DECL | |
| 365 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL); | |
| 366 | |
| 367 /* Handle DECL_INITIAL for symbols. */ | |
| 368 tree initial = DECL_INITIAL (expr); | |
| 369 if (VAR_P (expr) | |
| 370 && (TREE_STATIC (expr) || DECL_EXTERNAL (expr)) | |
| 371 && !DECL_IN_CONSTANT_POOL (expr) | |
| 372 && initial) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373 { |
| 111 | 374 varpool_node *vnode; |
| 375 /* Extra section needs about 30 bytes; do not produce it for simple | |
| 376 scalar values. */ | |
| 377 if (!(vnode = varpool_node::get (expr)) | |
| 378 || !lto_symtab_encoder_encode_initializer_p (encoder, vnode)) | |
| 379 initial = error_mark_node; | |
| 380 if (initial != error_mark_node) | |
| 381 { | |
| 382 long max_size = 30; | |
| 383 if (walk_tree (&initial, subtract_estimated_size, (void *)&max_size, | |
| 384 NULL)) | |
| 385 initial = error_mark_node; | |
| 386 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
387 } |
| 111 | 388 |
| 389 return initial; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
390 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
391 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
392 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
393 /* Write a physical representation of tree node EXPR to output block |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
394 OB. If REF_P is true, the leaves of EXPR are emitted as references |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
395 via lto_output_tree_ref. IX is the index into the streamer cache |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
396 where EXPR is stored. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
397 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
398 static void |
| 111 | 399 lto_write_tree_1 (struct output_block *ob, tree expr, bool ref_p) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
400 { |
| 111 | 401 /* Pack all the non-pointer fields in EXPR into a bitpack and write |
| 402 the resulting bitpack. */ | |
| 403 streamer_write_tree_bitfields (ob, expr); | |
| 404 | |
| 405 /* Write all the pointer fields in EXPR. */ | |
| 406 streamer_write_tree_body (ob, expr, ref_p); | |
| 407 | |
| 408 /* Write any LTO-specific data to OB. */ | |
| 409 if (DECL_P (expr) | |
| 410 && TREE_CODE (expr) != FUNCTION_DECL | |
| 411 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL) | |
| 412 { | |
| 413 /* Handle DECL_INITIAL for symbols. */ | |
| 414 tree initial = get_symbol_initial_value | |
| 415 (ob->decl_state->symtab_node_encoder, expr); | |
| 416 stream_write_tree (ob, initial, ref_p); | |
| 417 } | |
| 418 | |
| 419 /* Stream references to early generated DIEs. Keep in sync with the | |
| 420 trees handled in dwarf2out_die_ref_for_decl. */ | |
| 421 if ((DECL_P (expr) | |
| 422 && TREE_CODE (expr) != FIELD_DECL | |
| 423 && TREE_CODE (expr) != DEBUG_EXPR_DECL | |
| 424 && TREE_CODE (expr) != TYPE_DECL) | |
| 425 || TREE_CODE (expr) == BLOCK) | |
| 426 { | |
| 427 const char *sym; | |
| 428 unsigned HOST_WIDE_INT off; | |
| 429 if (debug_info_level > DINFO_LEVEL_NONE | |
| 430 && debug_hooks->die_ref_for_decl (expr, &sym, &off)) | |
| 431 { | |
| 432 streamer_write_string (ob, ob->main_stream, sym, true); | |
| 433 streamer_write_uhwi (ob, off); | |
| 434 } | |
| 435 else | |
| 436 streamer_write_string (ob, ob->main_stream, NULL, true); | |
| 437 } | |
| 438 } | |
| 439 | |
| 440 /* Write a physical representation of tree node EXPR to output block | |
| 441 OB. If REF_P is true, the leaves of EXPR are emitted as references | |
| 442 via lto_output_tree_ref. IX is the index into the streamer cache | |
| 443 where EXPR is stored. */ | |
| 444 | |
| 445 static void | |
| 446 lto_write_tree (struct output_block *ob, tree expr, bool ref_p) | |
| 447 { | |
| 448 if (!lto_is_streamable (expr)) | |
| 449 internal_error ("tree code %qs is not supported in LTO streams", | |
| 450 get_tree_code_name (TREE_CODE (expr))); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
451 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
452 /* Write the header, containing everything needed to materialize |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
453 EXPR on the reading side. */ |
| 111 | 454 streamer_write_tree_header (ob, expr); |
| 455 | |
| 456 lto_write_tree_1 (ob, expr, ref_p); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
457 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
458 /* Mark the end of EXPR. */ |
| 111 | 459 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
460 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
461 |
| 111 | 462 /* Emit the physical representation of tree node EXPR to output block OB, |
| 463 If THIS_REF_P is true, the leaves of EXPR are emitted as references via | |
| 464 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
465 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
466 static void |
| 111 | 467 lto_output_tree_1 (struct output_block *ob, tree expr, hashval_t hash, |
| 468 bool ref_p, bool this_ref_p) | |
| 469 { | |
| 470 unsigned ix; | |
| 471 | |
| 472 gcc_checking_assert (expr != NULL_TREE | |
| 473 && !(this_ref_p && tree_is_indexable (expr))); | |
| 474 | |
| 475 bool exists_p = streamer_tree_cache_insert (ob->writer_cache, | |
| 476 expr, hash, &ix); | |
| 477 gcc_assert (!exists_p); | |
| 478 if (TREE_CODE (expr) == INTEGER_CST | |
| 479 && !TREE_OVERFLOW (expr)) | |
| 480 { | |
| 481 /* Shared INTEGER_CST nodes are special because they need their | |
| 482 original type to be materialized by the reader (to implement | |
| 483 TYPE_CACHED_VALUES). */ | |
| 484 streamer_write_integer_cst (ob, expr, ref_p); | |
| 485 } | |
| 486 else | |
| 487 { | |
| 488 /* This is the first time we see EXPR, write its fields | |
| 489 to OB. */ | |
| 490 lto_write_tree (ob, expr, ref_p); | |
| 491 } | |
| 492 } | |
| 493 | |
| 494 class DFS | |
| 495 { | |
| 496 public: | |
| 497 DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p, | |
| 498 bool single_p); | |
| 499 ~DFS (); | |
| 500 | |
| 501 struct scc_entry | |
| 502 { | |
| 503 tree t; | |
| 504 hashval_t hash; | |
| 505 }; | |
| 506 vec<scc_entry> sccstack; | |
| 507 | |
| 508 private: | |
| 509 struct sccs | |
| 510 { | |
| 511 unsigned int dfsnum; | |
| 512 unsigned int low; | |
| 513 }; | |
| 514 struct worklist | |
| 515 { | |
| 516 tree expr; | |
| 517 sccs *from_state; | |
| 518 sccs *cstate; | |
| 519 bool ref_p; | |
| 520 bool this_ref_p; | |
| 521 }; | |
| 522 | |
| 523 static int scc_entry_compare (const void *, const void *); | |
| 524 | |
| 525 void DFS_write_tree_body (struct output_block *ob, | |
| 526 tree expr, sccs *expr_state, bool ref_p); | |
| 527 | |
| 528 void DFS_write_tree (struct output_block *ob, sccs *from_state, | |
| 529 tree expr, bool ref_p, bool this_ref_p); | |
| 530 | |
| 531 hashval_t | |
| 532 hash_scc (struct output_block *ob, unsigned first, unsigned size, | |
| 533 bool ref_p, bool this_ref_p); | |
| 534 | |
| 535 hash_map<tree, sccs *> sccstate; | |
| 536 vec<worklist> worklist_vec; | |
| 537 struct obstack sccstate_obstack; | |
| 538 }; | |
| 539 | |
| 540 /* Emit the physical representation of tree node EXPR to output block OB, | |
| 541 using depth-first search on the subgraph. If THIS_REF_P is true, the | |
| 542 leaves of EXPR are emitted as references via lto_output_tree_ref. | |
| 543 REF_P is used for streaming siblings of EXPR. If SINGLE_P is true, | |
| 544 this is for a rewalk of a single leaf SCC. */ | |
| 545 | |
| 546 DFS::DFS (struct output_block *ob, tree expr, bool ref_p, bool this_ref_p, | |
| 547 bool single_p) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
548 { |
| 111 | 549 unsigned int next_dfs_num = 1; |
| 550 sccstack.create (0); | |
| 551 gcc_obstack_init (&sccstate_obstack); | |
| 552 worklist_vec = vNULL; | |
| 553 DFS_write_tree (ob, NULL, expr, ref_p, this_ref_p); | |
| 554 while (!worklist_vec.is_empty ()) | |
| 555 { | |
| 556 worklist &w = worklist_vec.last (); | |
| 557 expr = w.expr; | |
| 558 sccs *from_state = w.from_state; | |
| 559 sccs *cstate = w.cstate; | |
| 560 ref_p = w.ref_p; | |
| 561 this_ref_p = w.this_ref_p; | |
| 562 if (cstate == NULL) | |
| 563 { | |
| 564 sccs **slot = &sccstate.get_or_insert (expr); | |
| 565 cstate = *slot; | |
| 566 if (cstate) | |
| 567 { | |
| 568 gcc_checking_assert (from_state); | |
| 569 if (cstate->dfsnum < from_state->dfsnum) | |
| 570 from_state->low = MIN (cstate->dfsnum, from_state->low); | |
| 571 worklist_vec.pop (); | |
| 572 continue; | |
| 573 } | |
| 574 | |
| 575 scc_entry e = { expr, 0 }; | |
| 576 /* Not yet visited. DFS recurse and push it onto the stack. */ | |
| 577 *slot = cstate = XOBNEW (&sccstate_obstack, struct sccs); | |
| 578 sccstack.safe_push (e); | |
| 579 cstate->dfsnum = next_dfs_num++; | |
| 580 cstate->low = cstate->dfsnum; | |
| 581 w.cstate = cstate; | |
| 582 | |
| 583 if (TREE_CODE (expr) == INTEGER_CST | |
| 584 && !TREE_OVERFLOW (expr)) | |
| 585 DFS_write_tree (ob, cstate, TREE_TYPE (expr), ref_p, ref_p); | |
| 586 else | |
| 587 { | |
| 588 DFS_write_tree_body (ob, expr, cstate, ref_p); | |
| 589 | |
| 590 /* Walk any LTO-specific edges. */ | |
| 591 if (DECL_P (expr) | |
| 592 && TREE_CODE (expr) != FUNCTION_DECL | |
| 593 && TREE_CODE (expr) != TRANSLATION_UNIT_DECL) | |
| 594 { | |
| 595 /* Handle DECL_INITIAL for symbols. */ | |
| 596 tree initial | |
| 597 = get_symbol_initial_value (ob->decl_state->symtab_node_encoder, | |
| 598 expr); | |
| 599 DFS_write_tree (ob, cstate, initial, ref_p, ref_p); | |
| 600 } | |
| 601 } | |
| 602 continue; | |
| 603 } | |
| 604 | |
| 605 /* See if we found an SCC. */ | |
| 606 if (cstate->low == cstate->dfsnum) | |
| 607 { | |
| 608 unsigned first, size; | |
| 609 tree x; | |
| 610 | |
| 611 /* If we are re-walking a single leaf SCC just pop it, | |
| 612 let earlier worklist item access the sccstack. */ | |
| 613 if (single_p) | |
| 614 { | |
| 615 worklist_vec.pop (); | |
| 616 continue; | |
| 617 } | |
| 618 | |
| 619 /* Pop the SCC and compute its size. */ | |
| 620 first = sccstack.length (); | |
| 621 do | |
| 622 { | |
| 623 x = sccstack[--first].t; | |
| 624 } | |
| 625 while (x != expr); | |
| 626 size = sccstack.length () - first; | |
| 627 | |
| 628 /* No need to compute hashes for LTRANS units, we don't perform | |
| 629 any merging there. */ | |
| 630 hashval_t scc_hash = 0; | |
| 631 unsigned scc_entry_len = 0; | |
| 632 if (!flag_wpa) | |
| 633 { | |
| 634 scc_hash = hash_scc (ob, first, size, ref_p, this_ref_p); | |
| 635 | |
| 636 /* Put the entries with the least number of collisions first. */ | |
| 637 unsigned entry_start = 0; | |
| 638 scc_entry_len = size + 1; | |
| 639 for (unsigned i = 0; i < size;) | |
| 640 { | |
| 641 unsigned from = i; | |
| 642 for (i = i + 1; i < size | |
| 643 && (sccstack[first + i].hash | |
| 644 == sccstack[first + from].hash); ++i) | |
| 645 ; | |
| 646 if (i - from < scc_entry_len) | |
| 647 { | |
| 648 scc_entry_len = i - from; | |
| 649 entry_start = from; | |
| 650 } | |
| 651 } | |
| 652 for (unsigned i = 0; i < scc_entry_len; ++i) | |
| 653 std::swap (sccstack[first + i], | |
| 654 sccstack[first + entry_start + i]); | |
| 655 | |
| 656 /* We already sorted SCC deterministically in hash_scc. */ | |
| 657 | |
| 658 /* Check that we have only one SCC. | |
| 659 Naturally we may have conflicts if hash function is not | |
| 660 strong enough. Lets see how far this gets. */ | |
| 661 gcc_checking_assert (scc_entry_len == 1); | |
| 662 } | |
| 663 | |
| 664 /* Write LTO_tree_scc. */ | |
| 665 streamer_write_record_start (ob, LTO_tree_scc); | |
| 666 streamer_write_uhwi (ob, size); | |
| 667 streamer_write_uhwi (ob, scc_hash); | |
| 668 | |
| 669 /* Write size-1 SCCs without wrapping them inside SCC bundles. | |
| 670 All INTEGER_CSTs need to be handled this way as we need | |
| 671 their type to materialize them. Also builtins are handled | |
| 672 this way. | |
| 673 ??? We still wrap these in LTO_tree_scc so at the | |
| 674 input side we can properly identify the tree we want | |
| 675 to ultimatively return. */ | |
| 676 if (size == 1) | |
| 677 lto_output_tree_1 (ob, expr, scc_hash, ref_p, this_ref_p); | |
| 678 else | |
| 679 { | |
| 680 /* Write the size of the SCC entry candidates. */ | |
| 681 streamer_write_uhwi (ob, scc_entry_len); | |
| 682 | |
| 683 /* Write all headers and populate the streamer cache. */ | |
| 684 for (unsigned i = 0; i < size; ++i) | |
| 685 { | |
| 686 hashval_t hash = sccstack[first+i].hash; | |
| 687 tree t = sccstack[first+i].t; | |
| 688 bool exists_p = streamer_tree_cache_insert (ob->writer_cache, | |
| 689 t, hash, NULL); | |
| 690 gcc_assert (!exists_p); | |
| 691 | |
| 692 if (!lto_is_streamable (t)) | |
| 693 internal_error ("tree code %qs is not supported " | |
| 694 "in LTO streams", | |
| 695 get_tree_code_name (TREE_CODE (t))); | |
| 696 | |
| 697 /* Write the header, containing everything needed to | |
| 698 materialize EXPR on the reading side. */ | |
| 699 streamer_write_tree_header (ob, t); | |
| 700 } | |
| 701 | |
| 702 /* Write the bitpacks and tree references. */ | |
| 703 for (unsigned i = 0; i < size; ++i) | |
| 704 { | |
| 705 lto_write_tree_1 (ob, sccstack[first+i].t, ref_p); | |
| 706 | |
| 707 /* Mark the end of the tree. */ | |
| 708 streamer_write_zero (ob); | |
| 709 } | |
| 710 } | |
| 711 | |
| 712 /* Finally truncate the vector. */ | |
| 713 sccstack.truncate (first); | |
| 714 | |
| 715 if (from_state) | |
| 716 from_state->low = MIN (from_state->low, cstate->low); | |
| 717 worklist_vec.pop (); | |
| 718 continue; | |
| 719 } | |
| 720 | |
| 721 gcc_checking_assert (from_state); | |
| 722 from_state->low = MIN (from_state->low, cstate->low); | |
| 723 if (cstate->dfsnum < from_state->dfsnum) | |
| 724 from_state->low = MIN (cstate->dfsnum, from_state->low); | |
| 725 worklist_vec.pop (); | |
| 726 } | |
| 727 worklist_vec.release (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
728 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
729 |
| 111 | 730 DFS::~DFS () |
| 731 { | |
| 732 sccstack.release (); | |
| 733 obstack_free (&sccstate_obstack, NULL); | |
| 734 } | |
| 735 | |
| 736 /* Handle the tree EXPR in the DFS walk with SCC state EXPR_STATE and | |
| 737 DFS recurse for all tree edges originating from it. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
738 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
739 void |
| 111 | 740 DFS::DFS_write_tree_body (struct output_block *ob, |
| 741 tree expr, sccs *expr_state, bool ref_p) | |
| 742 { | |
| 743 #define DFS_follow_tree_edge(DEST) \ | |
| 744 DFS_write_tree (ob, expr_state, DEST, ref_p, ref_p) | |
| 745 | |
| 746 enum tree_code code; | |
| 747 | |
| 131 | 748 if (streamer_dump_file) |
| 749 { | |
| 750 print_node_brief (streamer_dump_file, " Streaming ", | |
| 751 expr, 4); | |
| 752 fprintf (streamer_dump_file, " to %s\n", | |
| 753 lto_section_name [ob->section_type]); | |
| 754 } | |
| 755 | |
| 111 | 756 code = TREE_CODE (expr); |
| 757 | |
| 758 if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) | |
| 759 { | |
| 760 if (TREE_CODE (expr) != IDENTIFIER_NODE) | |
| 761 DFS_follow_tree_edge (TREE_TYPE (expr)); | |
| 762 } | |
| 763 | |
| 764 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) | |
| 765 { | |
| 131 | 766 unsigned int count = vector_cst_encoded_nelts (expr); |
| 767 for (unsigned int i = 0; i < count; ++i) | |
| 768 DFS_follow_tree_edge (VECTOR_CST_ENCODED_ELT (expr, i)); | |
| 111 | 769 } |
| 770 | |
| 131 | 771 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST)) |
| 772 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) | |
| 773 DFS_follow_tree_edge (POLY_INT_CST_COEFF (expr, i)); | |
| 774 | |
| 111 | 775 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX)) |
| 776 { | |
| 777 DFS_follow_tree_edge (TREE_REALPART (expr)); | |
| 778 DFS_follow_tree_edge (TREE_IMAGPART (expr)); | |
| 779 } | |
| 780 | |
| 781 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) | |
| 782 { | |
| 783 /* Drop names that were created for anonymous entities. */ | |
| 784 if (DECL_NAME (expr) | |
| 785 && TREE_CODE (DECL_NAME (expr)) == IDENTIFIER_NODE | |
| 786 && anon_aggrname_p (DECL_NAME (expr))) | |
| 787 ; | |
| 788 else | |
| 789 DFS_follow_tree_edge (DECL_NAME (expr)); | |
| 790 if (TREE_CODE (expr) != TRANSLATION_UNIT_DECL | |
| 791 && ! DECL_CONTEXT (expr)) | |
| 792 DFS_follow_tree_edge ((*all_translation_units)[0]); | |
| 793 else | |
| 794 DFS_follow_tree_edge (DECL_CONTEXT (expr)); | |
| 795 } | |
| 796 | |
| 797 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
| 798 { | |
| 799 DFS_follow_tree_edge (DECL_SIZE (expr)); | |
| 800 DFS_follow_tree_edge (DECL_SIZE_UNIT (expr)); | |
| 801 | |
| 802 /* Note, DECL_INITIAL is not handled here. Since DECL_INITIAL needs | |
| 803 special handling in LTO, it must be handled by streamer hooks. */ | |
| 804 | |
| 805 DFS_follow_tree_edge (DECL_ATTRIBUTES (expr)); | |
| 806 | |
| 131 | 807 /* We use DECL_ABSTRACT_ORIGIN == error_mark_node to mark |
| 111 | 808 declarations which should be eliminated by decl merging. Be sure none |
| 809 leaks to this point. */ | |
| 810 gcc_assert (DECL_ABSTRACT_ORIGIN (expr) != error_mark_node); | |
| 811 DFS_follow_tree_edge (DECL_ABSTRACT_ORIGIN (expr)); | |
| 812 | |
| 813 if ((VAR_P (expr) | |
| 814 || TREE_CODE (expr) == PARM_DECL) | |
| 815 && DECL_HAS_VALUE_EXPR_P (expr)) | |
| 816 DFS_follow_tree_edge (DECL_VALUE_EXPR (expr)); | |
| 131 | 817 if (VAR_P (expr) |
| 818 && DECL_HAS_DEBUG_EXPR_P (expr)) | |
| 111 | 819 DFS_follow_tree_edge (DECL_DEBUG_EXPR (expr)); |
| 820 } | |
| 821 | |
| 822 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) | |
| 823 { | |
| 824 /* Make sure we don't inadvertently set the assembler name. */ | |
| 825 if (DECL_ASSEMBLER_NAME_SET_P (expr)) | |
| 826 DFS_follow_tree_edge (DECL_ASSEMBLER_NAME (expr)); | |
| 827 } | |
| 828 | |
| 829 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL)) | |
| 830 { | |
| 831 DFS_follow_tree_edge (DECL_FIELD_OFFSET (expr)); | |
| 832 DFS_follow_tree_edge (DECL_BIT_FIELD_TYPE (expr)); | |
| 833 DFS_follow_tree_edge (DECL_BIT_FIELD_REPRESENTATIVE (expr)); | |
| 834 DFS_follow_tree_edge (DECL_FIELD_BIT_OFFSET (expr)); | |
| 131 | 835 gcc_checking_assert (!DECL_FCONTEXT (expr)); |
| 111 | 836 } |
| 837 | |
| 838 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) | |
| 839 { | |
| 131 | 840 gcc_checking_assert (DECL_VINDEX (expr) == NULL); |
| 111 | 841 DFS_follow_tree_edge (DECL_FUNCTION_PERSONALITY (expr)); |
| 842 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_TARGET (expr)); | |
| 843 DFS_follow_tree_edge (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (expr)); | |
| 844 } | |
| 845 | |
| 846 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) | |
| 847 { | |
| 848 DFS_follow_tree_edge (TYPE_SIZE (expr)); | |
| 849 DFS_follow_tree_edge (TYPE_SIZE_UNIT (expr)); | |
| 850 DFS_follow_tree_edge (TYPE_ATTRIBUTES (expr)); | |
| 851 DFS_follow_tree_edge (TYPE_NAME (expr)); | |
| 852 /* Do not follow TYPE_POINTER_TO or TYPE_REFERENCE_TO. They will be | |
| 853 reconstructed during fixup. */ | |
| 854 /* Do not follow TYPE_NEXT_VARIANT, we reconstruct the variant lists | |
| 855 during fixup. */ | |
| 856 DFS_follow_tree_edge (TYPE_MAIN_VARIANT (expr)); | |
| 857 DFS_follow_tree_edge (TYPE_CONTEXT (expr)); | |
| 858 /* TYPE_CANONICAL is re-computed during type merging, so no need | |
| 859 to follow it here. */ | |
| 131 | 860 /* Do not stream TYPE_STUB_DECL; it is not needed by LTO but currently |
| 861 it can not be freed by free_lang_data without triggering ICEs in | |
| 862 langhooks. */ | |
| 111 | 863 } |
| 864 | |
| 865 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)) | |
| 866 { | |
| 867 if (TREE_CODE (expr) == ENUMERAL_TYPE) | |
| 868 DFS_follow_tree_edge (TYPE_VALUES (expr)); | |
| 869 else if (TREE_CODE (expr) == ARRAY_TYPE) | |
| 870 DFS_follow_tree_edge (TYPE_DOMAIN (expr)); | |
| 871 else if (RECORD_OR_UNION_TYPE_P (expr)) | |
| 872 for (tree t = TYPE_FIELDS (expr); t; t = TREE_CHAIN (t)) | |
| 873 DFS_follow_tree_edge (t); | |
| 874 else if (TREE_CODE (expr) == FUNCTION_TYPE | |
| 875 || TREE_CODE (expr) == METHOD_TYPE) | |
| 876 DFS_follow_tree_edge (TYPE_ARG_TYPES (expr)); | |
| 877 | |
| 878 if (!POINTER_TYPE_P (expr)) | |
| 879 DFS_follow_tree_edge (TYPE_MIN_VALUE_RAW (expr)); | |
| 880 DFS_follow_tree_edge (TYPE_MAX_VALUE_RAW (expr)); | |
| 881 } | |
| 882 | |
| 883 if (CODE_CONTAINS_STRUCT (code, TS_LIST)) | |
| 884 { | |
| 885 DFS_follow_tree_edge (TREE_PURPOSE (expr)); | |
| 886 DFS_follow_tree_edge (TREE_VALUE (expr)); | |
| 887 DFS_follow_tree_edge (TREE_CHAIN (expr)); | |
| 888 } | |
| 889 | |
| 890 if (CODE_CONTAINS_STRUCT (code, TS_VEC)) | |
| 891 { | |
| 892 for (int i = 0; i < TREE_VEC_LENGTH (expr); i++) | |
| 893 DFS_follow_tree_edge (TREE_VEC_ELT (expr, i)); | |
| 894 } | |
| 895 | |
| 896 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) | |
| 897 { | |
| 898 for (int i = 0; i < TREE_OPERAND_LENGTH (expr); i++) | |
| 899 DFS_follow_tree_edge (TREE_OPERAND (expr, i)); | |
| 900 DFS_follow_tree_edge (TREE_BLOCK (expr)); | |
| 901 } | |
| 902 | |
| 903 if (CODE_CONTAINS_STRUCT (code, TS_BLOCK)) | |
| 904 { | |
| 905 for (tree t = BLOCK_VARS (expr); t; t = TREE_CHAIN (t)) | |
| 131 | 906 { |
| 907 /* We would have to stream externals in the block chain as | |
| 908 non-references but we should have dropped them in | |
| 909 free-lang-data. */ | |
| 910 gcc_assert (!VAR_OR_FUNCTION_DECL_P (t) || !DECL_EXTERNAL (t)); | |
| 111 | 911 DFS_follow_tree_edge (t); |
| 131 | 912 } |
| 111 | 913 |
| 914 DFS_follow_tree_edge (BLOCK_SUPERCONTEXT (expr)); | |
| 131 | 915 DFS_follow_tree_edge (BLOCK_ABSTRACT_ORIGIN (expr)); |
| 916 | |
| 111 | 917 /* Do not follow BLOCK_NONLOCALIZED_VARS. We cannot handle debug |
| 918 information for early inlined BLOCKs so drop it on the floor instead | |
| 919 of ICEing in dwarf2out.c. */ | |
| 920 | |
| 921 /* BLOCK_FRAGMENT_ORIGIN and BLOCK_FRAGMENT_CHAIN is not live at LTO | |
| 922 streaming time. */ | |
| 923 | |
| 924 /* Do not output BLOCK_SUBBLOCKS. Instead on streaming-in this | |
| 925 list is re-constructed from BLOCK_SUPERCONTEXT. */ | |
| 926 } | |
| 927 | |
| 928 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) | |
| 929 { | |
| 930 unsigned i; | |
| 931 tree t; | |
| 932 | |
| 933 /* Note that the number of BINFO slots has already been emitted in | |
| 934 EXPR's header (see streamer_write_tree_header) because this length | |
| 935 is needed to build the empty BINFO node on the reader side. */ | |
| 936 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (expr), i, t) | |
| 937 DFS_follow_tree_edge (t); | |
| 938 DFS_follow_tree_edge (BINFO_OFFSET (expr)); | |
| 939 DFS_follow_tree_edge (BINFO_VTABLE (expr)); | |
| 131 | 940 |
| 941 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX, | |
| 942 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used | |
| 943 by C++ FE only. */ | |
| 111 | 944 } |
| 945 | |
| 946 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) | |
| 947 { | |
| 948 unsigned i; | |
| 949 tree index, value; | |
| 950 | |
| 951 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (expr), i, index, value) | |
| 952 { | |
| 953 DFS_follow_tree_edge (index); | |
| 954 DFS_follow_tree_edge (value); | |
| 955 } | |
| 956 } | |
| 957 | |
| 958 if (code == OMP_CLAUSE) | |
| 959 { | |
| 960 int i; | |
| 961 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (expr)]; i++) | |
| 962 DFS_follow_tree_edge (OMP_CLAUSE_OPERAND (expr, i)); | |
| 963 DFS_follow_tree_edge (OMP_CLAUSE_CHAIN (expr)); | |
| 964 } | |
| 965 | |
| 966 #undef DFS_follow_tree_edge | |
| 967 } | |
| 968 | |
| 969 /* Return a hash value for the tree T. | |
| 970 CACHE holds hash values of trees outside current SCC. MAP, if non-NULL, | |
| 971 may hold hash values if trees inside current SCC. */ | |
| 972 | |
| 973 static hashval_t | |
| 974 hash_tree (struct streamer_tree_cache_d *cache, hash_map<tree, hashval_t> *map, tree t) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
975 { |
| 111 | 976 inchash::hash hstate; |
| 977 | |
| 978 #define visit(SIBLING) \ | |
| 979 do { \ | |
| 980 unsigned ix; \ | |
| 981 if (!SIBLING) \ | |
| 982 hstate.add_int (0); \ | |
| 983 else if (streamer_tree_cache_lookup (cache, SIBLING, &ix)) \ | |
| 984 hstate.add_int (streamer_tree_cache_get_hash (cache, ix)); \ | |
| 985 else if (map) \ | |
| 986 hstate.add_int (*map->get (SIBLING)); \ | |
| 987 else \ | |
| 988 hstate.add_int (1); \ | |
| 989 } while (0) | |
| 990 | |
| 991 /* Hash TS_BASE. */ | |
| 992 enum tree_code code = TREE_CODE (t); | |
| 993 hstate.add_int (code); | |
| 994 if (!TYPE_P (t)) | |
| 995 { | |
| 996 hstate.add_flag (TREE_SIDE_EFFECTS (t)); | |
| 997 hstate.add_flag (TREE_CONSTANT (t)); | |
| 998 hstate.add_flag (TREE_READONLY (t)); | |
| 999 hstate.add_flag (TREE_PUBLIC (t)); | |
| 1000 } | |
| 1001 hstate.add_flag (TREE_ADDRESSABLE (t)); | |
| 1002 hstate.add_flag (TREE_THIS_VOLATILE (t)); | |
| 1003 if (DECL_P (t)) | |
| 1004 hstate.add_flag (DECL_UNSIGNED (t)); | |
| 1005 else if (TYPE_P (t)) | |
| 1006 hstate.add_flag (TYPE_UNSIGNED (t)); | |
| 1007 if (TYPE_P (t)) | |
| 1008 hstate.add_flag (TYPE_ARTIFICIAL (t)); | |
| 1009 else | |
| 1010 hstate.add_flag (TREE_NO_WARNING (t)); | |
| 1011 hstate.add_flag (TREE_NOTHROW (t)); | |
| 1012 hstate.add_flag (TREE_STATIC (t)); | |
| 1013 hstate.add_flag (TREE_PROTECTED (t)); | |
| 1014 hstate.add_flag (TREE_DEPRECATED (t)); | |
| 1015 if (code != TREE_BINFO) | |
| 1016 hstate.add_flag (TREE_PRIVATE (t)); | |
| 1017 if (TYPE_P (t)) | |
| 1018 { | |
| 1019 hstate.add_flag (AGGREGATE_TYPE_P (t) | |
| 1020 ? TYPE_REVERSE_STORAGE_ORDER (t) : TYPE_SATURATING (t)); | |
| 1021 hstate.add_flag (TYPE_ADDR_SPACE (t)); | |
| 1022 } | |
| 1023 else if (code == SSA_NAME) | |
| 1024 hstate.add_flag (SSA_NAME_IS_DEFAULT_DEF (t)); | |
| 1025 hstate.commit_flag (); | |
| 1026 | |
| 1027 if (CODE_CONTAINS_STRUCT (code, TS_INT_CST)) | |
| 1028 hstate.add_wide_int (wi::to_widest (t)); | |
| 1029 | |
| 1030 if (CODE_CONTAINS_STRUCT (code, TS_REAL_CST)) | |
| 1031 { | |
| 1032 REAL_VALUE_TYPE r = TREE_REAL_CST (t); | |
| 1033 hstate.add_flag (r.cl); | |
| 1034 hstate.add_flag (r.sign); | |
| 1035 hstate.add_flag (r.signalling); | |
| 1036 hstate.add_flag (r.canonical); | |
| 1037 hstate.commit_flag (); | |
| 1038 hstate.add_int (r.uexp); | |
| 1039 hstate.add (r.sig, sizeof (r.sig)); | |
| 1040 } | |
| 1041 | |
| 1042 if (CODE_CONTAINS_STRUCT (code, TS_FIXED_CST)) | |
| 1043 { | |
| 1044 FIXED_VALUE_TYPE f = TREE_FIXED_CST (t); | |
| 1045 hstate.add_int (f.mode); | |
| 1046 hstate.add_int (f.data.low); | |
| 1047 hstate.add_int (f.data.high); | |
| 1048 } | |
| 1049 | |
| 1050 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
| 1051 { | |
| 1052 hstate.add_hwi (DECL_MODE (t)); | |
| 1053 hstate.add_flag (DECL_NONLOCAL (t)); | |
| 1054 hstate.add_flag (DECL_VIRTUAL_P (t)); | |
| 1055 hstate.add_flag (DECL_IGNORED_P (t)); | |
| 1056 hstate.add_flag (DECL_ABSTRACT_P (t)); | |
| 1057 hstate.add_flag (DECL_ARTIFICIAL (t)); | |
| 1058 hstate.add_flag (DECL_USER_ALIGN (t)); | |
| 1059 hstate.add_flag (DECL_PRESERVE_P (t)); | |
| 1060 hstate.add_flag (DECL_EXTERNAL (t)); | |
| 1061 hstate.add_flag (DECL_GIMPLE_REG_P (t)); | |
| 1062 hstate.commit_flag (); | |
| 1063 hstate.add_int (DECL_ALIGN (t)); | |
| 1064 if (code == LABEL_DECL) | |
| 1065 { | |
| 1066 hstate.add_int (EH_LANDING_PAD_NR (t)); | |
| 1067 hstate.add_int (LABEL_DECL_UID (t)); | |
| 1068 } | |
| 1069 else if (code == FIELD_DECL) | |
| 1070 { | |
| 1071 hstate.add_flag (DECL_PACKED (t)); | |
| 1072 hstate.add_flag (DECL_NONADDRESSABLE_P (t)); | |
| 131 | 1073 hstate.add_flag (DECL_PADDING_P (t)); |
| 111 | 1074 hstate.add_int (DECL_OFFSET_ALIGN (t)); |
| 1075 } | |
| 1076 else if (code == VAR_DECL) | |
| 1077 { | |
| 1078 hstate.add_flag (DECL_HAS_DEBUG_EXPR_P (t)); | |
| 1079 hstate.add_flag (DECL_NONLOCAL_FRAME (t)); | |
| 1080 } | |
| 1081 if (code == RESULT_DECL | |
| 1082 || code == PARM_DECL | |
| 1083 || code == VAR_DECL) | |
| 1084 { | |
| 1085 hstate.add_flag (DECL_BY_REFERENCE (t)); | |
| 1086 if (code == VAR_DECL | |
| 1087 || code == PARM_DECL) | |
| 1088 hstate.add_flag (DECL_HAS_VALUE_EXPR_P (t)); | |
| 1089 } | |
| 1090 hstate.commit_flag (); | |
| 1091 } | |
| 1092 | |
| 1093 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WRTL)) | |
| 1094 hstate.add_int (DECL_REGISTER (t)); | |
| 1095 | |
| 1096 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) | |
| 1097 { | |
| 1098 hstate.add_flag (DECL_COMMON (t)); | |
| 1099 hstate.add_flag (DECL_DLLIMPORT_P (t)); | |
| 1100 hstate.add_flag (DECL_WEAK (t)); | |
| 1101 hstate.add_flag (DECL_SEEN_IN_BIND_EXPR_P (t)); | |
| 1102 hstate.add_flag (DECL_COMDAT (t)); | |
| 1103 hstate.add_flag (DECL_VISIBILITY_SPECIFIED (t)); | |
| 1104 hstate.add_int (DECL_VISIBILITY (t)); | |
| 1105 if (code == VAR_DECL) | |
| 1106 { | |
| 1107 /* DECL_IN_TEXT_SECTION is set during final asm output only. */ | |
| 1108 hstate.add_flag (DECL_HARD_REGISTER (t)); | |
| 1109 hstate.add_flag (DECL_IN_CONSTANT_POOL (t)); | |
| 1110 } | |
| 1111 if (TREE_CODE (t) == FUNCTION_DECL) | |
| 1112 { | |
| 1113 hstate.add_flag (DECL_FINAL_P (t)); | |
| 1114 hstate.add_flag (DECL_CXX_CONSTRUCTOR_P (t)); | |
| 1115 hstate.add_flag (DECL_CXX_DESTRUCTOR_P (t)); | |
| 1116 } | |
| 1117 hstate.commit_flag (); | |
| 1118 } | |
| 1119 | |
| 1120 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) | |
| 1121 { | |
| 1122 hstate.add_int (DECL_BUILT_IN_CLASS (t)); | |
| 1123 hstate.add_flag (DECL_STATIC_CONSTRUCTOR (t)); | |
| 1124 hstate.add_flag (DECL_STATIC_DESTRUCTOR (t)); | |
| 1125 hstate.add_flag (DECL_UNINLINABLE (t)); | |
| 1126 hstate.add_flag (DECL_POSSIBLY_INLINED (t)); | |
| 1127 hstate.add_flag (DECL_IS_NOVOPS (t)); | |
| 1128 hstate.add_flag (DECL_IS_RETURNS_TWICE (t)); | |
| 1129 hstate.add_flag (DECL_IS_MALLOC (t)); | |
| 1130 hstate.add_flag (DECL_IS_OPERATOR_NEW (t)); | |
| 1131 hstate.add_flag (DECL_DECLARED_INLINE_P (t)); | |
| 1132 hstate.add_flag (DECL_STATIC_CHAIN (t)); | |
| 1133 hstate.add_flag (DECL_NO_INLINE_WARNING_P (t)); | |
| 1134 hstate.add_flag (DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (t)); | |
| 1135 hstate.add_flag (DECL_NO_LIMIT_STACK (t)); | |
| 1136 hstate.add_flag (DECL_DISREGARD_INLINE_LIMITS (t)); | |
| 1137 hstate.add_flag (DECL_PURE_P (t)); | |
| 1138 hstate.add_flag (DECL_LOOPING_CONST_OR_PURE_P (t)); | |
| 1139 hstate.commit_flag (); | |
| 1140 if (DECL_BUILT_IN_CLASS (t) != NOT_BUILT_IN) | |
| 1141 hstate.add_int (DECL_FUNCTION_CODE (t)); | |
| 1142 } | |
| 1143 | |
| 1144 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) | |
| 1145 { | |
| 1146 hstate.add_hwi (TYPE_MODE (t)); | |
| 1147 hstate.add_flag (TYPE_STRING_FLAG (t)); | |
| 1148 /* TYPE_NO_FORCE_BLK is private to stor-layout and need | |
| 1149 no streaming. */ | |
| 1150 hstate.add_flag (TYPE_NEEDS_CONSTRUCTING (t)); | |
| 1151 hstate.add_flag (TYPE_PACKED (t)); | |
| 1152 hstate.add_flag (TYPE_RESTRICT (t)); | |
| 1153 hstate.add_flag (TYPE_USER_ALIGN (t)); | |
| 1154 hstate.add_flag (TYPE_READONLY (t)); | |
| 1155 if (RECORD_OR_UNION_TYPE_P (t)) | |
| 1156 { | |
| 1157 hstate.add_flag (TYPE_TRANSPARENT_AGGR (t)); | |
| 1158 hstate.add_flag (TYPE_FINAL_P (t)); | |
| 1159 } | |
| 1160 else if (code == ARRAY_TYPE) | |
| 1161 hstate.add_flag (TYPE_NONALIASED_COMPONENT (t)); | |
| 1162 if (AGGREGATE_TYPE_P (t)) | |
| 1163 hstate.add_flag (TYPE_TYPELESS_STORAGE (t)); | |
| 1164 hstate.commit_flag (); | |
| 1165 hstate.add_int (TYPE_PRECISION (t)); | |
| 1166 hstate.add_int (TYPE_ALIGN (t)); | |
| 131 | 1167 hstate.add_int (TYPE_EMPTY_P (t)); |
| 111 | 1168 } |
| 1169 | |
| 1170 if (CODE_CONTAINS_STRUCT (code, TS_TRANSLATION_UNIT_DECL)) | |
| 1171 hstate.add (TRANSLATION_UNIT_LANGUAGE (t), | |
| 1172 strlen (TRANSLATION_UNIT_LANGUAGE (t))); | |
| 1173 | |
| 1174 if (CODE_CONTAINS_STRUCT (code, TS_TARGET_OPTION) | |
| 1175 /* We don't stream these when passing things to a different target. */ | |
| 1176 && !lto_stream_offload_p) | |
| 1177 hstate.add_hwi (cl_target_option_hash (TREE_TARGET_OPTION (t))); | |
| 1178 | |
| 1179 if (CODE_CONTAINS_STRUCT (code, TS_OPTIMIZATION)) | |
| 1180 hstate.add_hwi (cl_optimization_hash (TREE_OPTIMIZATION (t))); | |
| 1181 | |
| 1182 if (CODE_CONTAINS_STRUCT (code, TS_IDENTIFIER)) | |
| 1183 hstate.merge_hash (IDENTIFIER_HASH_VALUE (t)); | |
| 1184 | |
| 1185 if (CODE_CONTAINS_STRUCT (code, TS_STRING)) | |
| 1186 hstate.add (TREE_STRING_POINTER (t), TREE_STRING_LENGTH (t)); | |
| 1187 | |
| 1188 if (CODE_CONTAINS_STRUCT (code, TS_TYPED)) | |
| 1189 { | |
| 1190 if (code != IDENTIFIER_NODE) | |
| 1191 visit (TREE_TYPE (t)); | |
| 1192 } | |
| 1193 | |
| 1194 if (CODE_CONTAINS_STRUCT (code, TS_VECTOR)) | |
| 131 | 1195 { |
| 1196 unsigned int count = vector_cst_encoded_nelts (t); | |
| 1197 for (unsigned int i = 0; i < count; ++i) | |
| 1198 visit (VECTOR_CST_ENCODED_ELT (t, i)); | |
| 1199 } | |
| 1200 | |
| 1201 if (CODE_CONTAINS_STRUCT (code, TS_POLY_INT_CST)) | |
| 1202 for (unsigned int i = 0; i < NUM_POLY_INT_COEFFS; ++i) | |
| 1203 visit (POLY_INT_CST_COEFF (t, i)); | |
| 111 | 1204 |
| 1205 if (CODE_CONTAINS_STRUCT (code, TS_COMPLEX)) | |
| 1206 { | |
| 1207 visit (TREE_REALPART (t)); | |
| 1208 visit (TREE_IMAGPART (t)); | |
| 1209 } | |
| 1210 | |
| 1211 if (CODE_CONTAINS_STRUCT (code, TS_DECL_MINIMAL)) | |
| 1212 { | |
| 1213 /* Drop names that were created for anonymous entities. */ | |
| 1214 if (DECL_NAME (t) | |
| 1215 && TREE_CODE (DECL_NAME (t)) == IDENTIFIER_NODE | |
| 1216 && anon_aggrname_p (DECL_NAME (t))) | |
| 1217 ; | |
| 1218 else | |
| 1219 visit (DECL_NAME (t)); | |
| 1220 if (DECL_FILE_SCOPE_P (t)) | |
| 1221 ; | |
| 1222 else | |
| 1223 visit (DECL_CONTEXT (t)); | |
| 1224 } | |
| 1225 | |
| 1226 if (CODE_CONTAINS_STRUCT (code, TS_DECL_COMMON)) | |
| 1227 { | |
| 1228 visit (DECL_SIZE (t)); | |
| 1229 visit (DECL_SIZE_UNIT (t)); | |
| 1230 visit (DECL_ATTRIBUTES (t)); | |
| 1231 if ((code == VAR_DECL | |
| 1232 || code == PARM_DECL) | |
| 1233 && DECL_HAS_VALUE_EXPR_P (t)) | |
| 1234 visit (DECL_VALUE_EXPR (t)); | |
| 1235 if (code == VAR_DECL | |
| 1236 && DECL_HAS_DEBUG_EXPR_P (t)) | |
| 1237 visit (DECL_DEBUG_EXPR (t)); | |
| 1238 /* ??? Hash DECL_INITIAL as streamed. Needs the output-block to | |
| 1239 be able to call get_symbol_initial_value. */ | |
| 1240 } | |
| 1241 | |
| 1242 if (CODE_CONTAINS_STRUCT (code, TS_DECL_WITH_VIS)) | |
| 1243 { | |
| 1244 if (DECL_ASSEMBLER_NAME_SET_P (t)) | |
| 1245 visit (DECL_ASSEMBLER_NAME (t)); | |
| 1246 } | |
| 1247 | |
| 1248 if (CODE_CONTAINS_STRUCT (code, TS_FIELD_DECL)) | |
| 1249 { | |
| 1250 visit (DECL_FIELD_OFFSET (t)); | |
| 1251 visit (DECL_BIT_FIELD_TYPE (t)); | |
| 1252 visit (DECL_BIT_FIELD_REPRESENTATIVE (t)); | |
| 1253 visit (DECL_FIELD_BIT_OFFSET (t)); | |
| 1254 } | |
| 1255 | |
| 1256 if (CODE_CONTAINS_STRUCT (code, TS_FUNCTION_DECL)) | |
| 1257 { | |
| 1258 visit (DECL_FUNCTION_PERSONALITY (t)); | |
| 1259 visit (DECL_FUNCTION_SPECIFIC_TARGET (t)); | |
| 1260 visit (DECL_FUNCTION_SPECIFIC_OPTIMIZATION (t)); | |
| 1261 } | |
| 1262 | |
| 1263 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_COMMON)) | |
| 1264 { | |
| 1265 visit (TYPE_SIZE (t)); | |
| 1266 visit (TYPE_SIZE_UNIT (t)); | |
| 1267 visit (TYPE_ATTRIBUTES (t)); | |
| 1268 visit (TYPE_NAME (t)); | |
| 1269 visit (TYPE_MAIN_VARIANT (t)); | |
| 1270 if (TYPE_FILE_SCOPE_P (t)) | |
| 1271 ; | |
| 1272 else | |
| 1273 visit (TYPE_CONTEXT (t)); | |
| 1274 } | |
| 1275 | |
| 1276 if (CODE_CONTAINS_STRUCT (code, TS_TYPE_NON_COMMON)) | |
| 1277 { | |
| 1278 if (code == ENUMERAL_TYPE) | |
| 1279 visit (TYPE_VALUES (t)); | |
| 1280 else if (code == ARRAY_TYPE) | |
| 1281 visit (TYPE_DOMAIN (t)); | |
| 1282 else if (RECORD_OR_UNION_TYPE_P (t)) | |
| 1283 for (tree f = TYPE_FIELDS (t); f; f = TREE_CHAIN (f)) | |
| 1284 visit (f); | |
| 1285 else if (code == FUNCTION_TYPE | |
| 1286 || code == METHOD_TYPE) | |
| 1287 visit (TYPE_ARG_TYPES (t)); | |
| 1288 if (!POINTER_TYPE_P (t)) | |
| 1289 visit (TYPE_MIN_VALUE_RAW (t)); | |
| 1290 visit (TYPE_MAX_VALUE_RAW (t)); | |
| 1291 } | |
| 1292 | |
| 1293 if (CODE_CONTAINS_STRUCT (code, TS_LIST)) | |
| 1294 { | |
| 1295 visit (TREE_PURPOSE (t)); | |
| 1296 visit (TREE_VALUE (t)); | |
| 1297 visit (TREE_CHAIN (t)); | |
| 1298 } | |
| 1299 | |
| 1300 if (CODE_CONTAINS_STRUCT (code, TS_VEC)) | |
| 1301 for (int i = 0; i < TREE_VEC_LENGTH (t); ++i) | |
| 1302 visit (TREE_VEC_ELT (t, i)); | |
| 1303 | |
| 1304 if (CODE_CONTAINS_STRUCT (code, TS_EXP)) | |
| 1305 { | |
| 1306 hstate.add_hwi (TREE_OPERAND_LENGTH (t)); | |
| 1307 for (int i = 0; i < TREE_OPERAND_LENGTH (t); ++i) | |
| 1308 visit (TREE_OPERAND (t, i)); | |
| 1309 } | |
| 1310 | |
| 1311 if (CODE_CONTAINS_STRUCT (code, TS_BINFO)) | |
| 1312 { | |
| 1313 unsigned i; | |
| 1314 tree b; | |
| 1315 FOR_EACH_VEC_ELT (*BINFO_BASE_BINFOS (t), i, b) | |
| 1316 visit (b); | |
| 1317 visit (BINFO_OFFSET (t)); | |
| 1318 visit (BINFO_VTABLE (t)); | |
| 1319 /* Do not walk BINFO_INHERITANCE_CHAIN, BINFO_SUBVTT_INDEX | |
| 131 | 1320 BINFO_BASE_ACCESSES and BINFO_VPTR_INDEX; these are used |
| 1321 by C++ FE only. */ | |
| 111 | 1322 } |
| 1323 | |
| 1324 if (CODE_CONTAINS_STRUCT (code, TS_CONSTRUCTOR)) | |
| 1325 { | |
| 1326 unsigned i; | |
| 1327 tree index, value; | |
| 1328 hstate.add_hwi (CONSTRUCTOR_NELTS (t)); | |
| 1329 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (t), i, index, value) | |
| 1330 { | |
| 1331 visit (index); | |
| 1332 visit (value); | |
| 1333 } | |
| 1334 } | |
| 1335 | |
| 1336 if (code == OMP_CLAUSE) | |
| 1337 { | |
| 1338 int i; | |
| 1339 HOST_WIDE_INT val; | |
| 1340 | |
| 1341 hstate.add_hwi (OMP_CLAUSE_CODE (t)); | |
| 1342 switch (OMP_CLAUSE_CODE (t)) | |
| 1343 { | |
| 1344 case OMP_CLAUSE_DEFAULT: | |
| 1345 val = OMP_CLAUSE_DEFAULT_KIND (t); | |
| 1346 break; | |
| 1347 case OMP_CLAUSE_SCHEDULE: | |
| 1348 val = OMP_CLAUSE_SCHEDULE_KIND (t); | |
| 1349 break; | |
| 1350 case OMP_CLAUSE_DEPEND: | |
| 1351 val = OMP_CLAUSE_DEPEND_KIND (t); | |
| 1352 break; | |
| 1353 case OMP_CLAUSE_MAP: | |
| 1354 val = OMP_CLAUSE_MAP_KIND (t); | |
| 1355 break; | |
| 1356 case OMP_CLAUSE_PROC_BIND: | |
| 1357 val = OMP_CLAUSE_PROC_BIND_KIND (t); | |
| 1358 break; | |
| 1359 case OMP_CLAUSE_REDUCTION: | |
| 1360 val = OMP_CLAUSE_REDUCTION_CODE (t); | |
| 1361 break; | |
| 1362 default: | |
| 1363 val = 0; | |
| 1364 break; | |
| 1365 } | |
| 1366 hstate.add_hwi (val); | |
| 1367 for (i = 0; i < omp_clause_num_ops[OMP_CLAUSE_CODE (t)]; i++) | |
| 1368 visit (OMP_CLAUSE_OPERAND (t, i)); | |
| 1369 visit (OMP_CLAUSE_CHAIN (t)); | |
| 1370 } | |
| 1371 | |
| 1372 return hstate.end (); | |
| 1373 | |
| 1374 #undef visit | |
| 1375 } | |
| 1376 | |
| 1377 /* Compare two SCC entries by their hash value for qsorting them. */ | |
| 1378 | |
| 1379 int | |
| 1380 DFS::scc_entry_compare (const void *p1_, const void *p2_) | |
| 1381 { | |
| 1382 const scc_entry *p1 = (const scc_entry *) p1_; | |
| 1383 const scc_entry *p2 = (const scc_entry *) p2_; | |
| 1384 if (p1->hash < p2->hash) | |
| 1385 return -1; | |
| 1386 else if (p1->hash > p2->hash) | |
| 1387 return 1; | |
| 1388 return 0; | |
| 1389 } | |
| 1390 | |
| 1391 /* Return a hash value for the SCC on the SCC stack from FIRST with SIZE. | |
| 1392 THIS_REF_P and REF_P are as passed to lto_output_tree for FIRST. */ | |
| 1393 | |
| 1394 hashval_t | |
| 1395 DFS::hash_scc (struct output_block *ob, unsigned first, unsigned size, | |
| 1396 bool ref_p, bool this_ref_p) | |
| 1397 { | |
| 1398 unsigned int last_classes = 0, iterations = 0; | |
| 1399 | |
| 1400 /* Compute hash values for the SCC members. */ | |
| 1401 for (unsigned i = 0; i < size; ++i) | |
| 1402 sccstack[first+i].hash | |
| 1403 = hash_tree (ob->writer_cache, NULL, sccstack[first+i].t); | |
| 1404 | |
| 1405 if (size == 1) | |
| 1406 return sccstack[first].hash; | |
| 1407 | |
| 1408 /* We aim to get unique hash for every tree within SCC and compute hash value | |
| 1409 of the whole SCC by combining all values together in a stable (entry-point | |
| 1410 independent) order. This guarantees that the same SCC regions within | |
| 1411 different translation units will get the same hash values and therefore | |
| 1412 will be merged at WPA time. | |
| 1413 | |
| 1414 Often the hashes are already unique. In that case we compute the SCC hash | |
| 1415 by combining individual hash values in an increasing order. | |
| 1416 | |
| 1417 If there are duplicates, we seek at least one tree with unique hash (and | |
| 1418 pick one with minimal hash and this property). Then we obtain a stable | |
| 1419 order by DFS walk starting from this unique tree and then use the index | |
| 1420 within this order to make individual hash values unique. | |
| 1421 | |
| 1422 If there is no tree with unique hash, we iteratively propagate the hash | |
| 1423 values across the internal edges of SCC. This usually quickly leads | |
| 1424 to unique hashes. Consider, for example, an SCC containing two pointers | |
| 1425 that are identical except for the types they point to and assume that | |
| 1426 these types are also part of the SCC. The propagation will add the | |
| 1427 points-to type information into their hash values. */ | |
| 1428 do | |
| 1429 { | |
| 1430 /* Sort the SCC so we can easily check for uniqueness. */ | |
| 1431 qsort (&sccstack[first], size, sizeof (scc_entry), scc_entry_compare); | |
| 1432 | |
| 1433 unsigned int classes = 1; | |
| 1434 int firstunique = -1; | |
| 1435 | |
| 1436 /* Find the tree with lowest unique hash (if it exists) and compute | |
| 1437 the number of equivalence classes. */ | |
| 1438 if (sccstack[first].hash != sccstack[first+1].hash) | |
| 1439 firstunique = 0; | |
| 1440 for (unsigned i = 1; i < size; ++i) | |
| 1441 if (sccstack[first+i-1].hash != sccstack[first+i].hash) | |
| 1442 { | |
| 1443 classes++; | |
| 1444 if (firstunique == -1 | |
| 1445 && (i == size - 1 | |
| 1446 || sccstack[first+i+1].hash != sccstack[first+i].hash)) | |
| 1447 firstunique = i; | |
| 1448 } | |
| 1449 | |
| 1450 /* If we found a tree with unique hash, stop the iteration. */ | |
| 1451 if (firstunique != -1 | |
| 1452 /* Also terminate if we run out of iterations or if the number of | |
| 1453 equivalence classes is no longer increasing. | |
| 1454 For example a cyclic list of trees that are all equivalent will | |
| 1455 never have unique entry point; we however do not build such SCCs | |
| 1456 in our IL. */ | |
| 1457 || classes <= last_classes || iterations > 16) | |
| 1458 { | |
| 1459 hashval_t scc_hash; | |
| 1460 | |
| 1461 /* If some hashes are not unique (CLASSES != SIZE), use the DFS walk | |
| 1462 starting from FIRSTUNIQUE to obtain a stable order. */ | |
| 1463 if (classes != size && firstunique != -1) | |
| 1464 { | |
| 1465 hash_map <tree, hashval_t> map(size*2); | |
| 1466 | |
| 1467 /* Store hash values into a map, so we can associate them with | |
| 1468 the reordered SCC. */ | |
| 1469 for (unsigned i = 0; i < size; ++i) | |
| 1470 map.put (sccstack[first+i].t, sccstack[first+i].hash); | |
| 1471 | |
| 1472 DFS again (ob, sccstack[first+firstunique].t, ref_p, this_ref_p, | |
| 1473 true); | |
| 1474 gcc_assert (again.sccstack.length () == size); | |
| 1475 | |
| 1476 memcpy (sccstack.address () + first, | |
| 1477 again.sccstack.address (), | |
| 1478 sizeof (scc_entry) * size); | |
| 1479 | |
| 1480 /* Update hash values of individual members by hashing in the | |
| 1481 index within the stable order. This ensures uniqueness. | |
| 1482 Also compute the SCC hash by mixing in all hash values in | |
| 1483 the stable order we obtained. */ | |
| 1484 sccstack[first].hash = *map.get (sccstack[first].t); | |
| 1485 scc_hash = sccstack[first].hash; | |
| 1486 for (unsigned i = 1; i < size; ++i) | |
| 1487 { | |
| 1488 sccstack[first+i].hash | |
| 1489 = iterative_hash_hashval_t (i, | |
| 1490 *map.get (sccstack[first+i].t)); | |
| 1491 scc_hash | |
| 1492 = iterative_hash_hashval_t (scc_hash, | |
| 1493 sccstack[first+i].hash); | |
| 1494 } | |
| 1495 } | |
| 1496 /* If we got a unique hash value for each tree, then sort already | |
| 1497 ensured entry-point independent order. Only compute the final | |
| 1498 SCC hash. | |
| 1499 | |
| 1500 If we failed to find the unique entry point, we go by the same | |
| 1501 route. We will eventually introduce unwanted hash conflicts. */ | |
| 1502 else | |
| 1503 { | |
| 1504 scc_hash = sccstack[first].hash; | |
| 1505 for (unsigned i = 1; i < size; ++i) | |
| 1506 scc_hash | |
| 1507 = iterative_hash_hashval_t (scc_hash, sccstack[first+i].hash); | |
| 1508 | |
| 1509 /* We cannot 100% guarantee that the hash won't conflict so as | |
| 1510 to make it impossible to find a unique hash. This however | |
| 1511 should be an extremely rare case. ICE for now so possible | |
| 1512 issues are found and evaluated. */ | |
| 1513 gcc_checking_assert (classes == size); | |
| 1514 } | |
| 1515 | |
| 1516 /* To avoid conflicts across SCCs, iteratively hash the whole SCC | |
| 1517 hash into the hash of each element. */ | |
| 1518 for (unsigned i = 0; i < size; ++i) | |
| 1519 sccstack[first+i].hash | |
| 1520 = iterative_hash_hashval_t (sccstack[first+i].hash, scc_hash); | |
| 1521 return scc_hash; | |
| 1522 } | |
| 1523 | |
| 1524 last_classes = classes; | |
| 1525 iterations++; | |
| 1526 | |
| 1527 /* We failed to identify the entry point; propagate hash values across | |
| 1528 the edges. */ | |
| 1529 hash_map <tree, hashval_t> map(size*2); | |
| 1530 | |
| 1531 for (unsigned i = 0; i < size; ++i) | |
| 1532 map.put (sccstack[first+i].t, sccstack[first+i].hash); | |
| 1533 | |
| 1534 for (unsigned i = 0; i < size; i++) | |
| 1535 sccstack[first+i].hash | |
| 1536 = hash_tree (ob->writer_cache, &map, sccstack[first+i].t); | |
| 1537 } | |
| 1538 while (true); | |
| 1539 } | |
| 1540 | |
| 1541 /* DFS walk EXPR and stream SCCs of tree bodies if they are not | |
| 1542 already in the streamer cache. Main routine called for | |
| 1543 each visit of EXPR. */ | |
| 1544 | |
| 1545 void | |
| 1546 DFS::DFS_write_tree (struct output_block *ob, sccs *from_state, | |
| 1547 tree expr, bool ref_p, bool this_ref_p) | |
| 1548 { | |
| 1549 /* Handle special cases. */ | |
| 1550 if (expr == NULL_TREE) | |
| 1551 return; | |
| 1552 | |
| 1553 /* Do not DFS walk into indexable trees. */ | |
| 1554 if (this_ref_p && tree_is_indexable (expr)) | |
| 1555 return; | |
| 1556 | |
| 1557 /* Check if we already streamed EXPR. */ | |
| 1558 if (streamer_tree_cache_lookup (ob->writer_cache, expr, NULL)) | |
| 1559 return; | |
| 1560 | |
| 1561 worklist w; | |
| 1562 w.expr = expr; | |
| 1563 w.from_state = from_state; | |
| 1564 w.cstate = NULL; | |
| 1565 w.ref_p = ref_p; | |
| 1566 w.this_ref_p = this_ref_p; | |
| 1567 worklist_vec.safe_push (w); | |
| 1568 } | |
| 1569 | |
| 1570 | |
| 1571 /* Emit the physical representation of tree node EXPR to output block OB. | |
| 1572 If THIS_REF_P is true, the leaves of EXPR are emitted as references via | |
| 1573 lto_output_tree_ref. REF_P is used for streaming siblings of EXPR. */ | |
| 1574 | |
| 1575 void | |
| 1576 lto_output_tree (struct output_block *ob, tree expr, | |
| 1577 bool ref_p, bool this_ref_p) | |
| 1578 { | |
| 1579 unsigned ix; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1580 bool existed_p; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1581 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1582 if (expr == NULL_TREE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1583 { |
| 111 | 1584 streamer_write_record_start (ob, LTO_null); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1585 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1586 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1587 |
| 111 | 1588 if (this_ref_p && tree_is_indexable (expr)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1589 { |
| 111 | 1590 lto_output_tree_ref (ob, expr); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1591 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1592 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1593 |
| 111 | 1594 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1595 if (existed_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1596 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1597 /* If a node has already been streamed out, make sure that |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1598 we don't write it more than once. Otherwise, the reader |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1599 will instantiate two different nodes for the same object. */ |
| 111 | 1600 streamer_write_record_start (ob, LTO_tree_pickle_reference); |
| 1601 streamer_write_uhwi (ob, ix); | |
| 1602 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS, | |
| 1603 lto_tree_code_to_tag (TREE_CODE (expr))); | |
| 1604 lto_stats.num_pickle_refs_output++; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1605 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1606 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1607 { |
| 111 | 1608 /* This is the first time we see EXPR, write all reachable |
| 1609 trees to OB. */ | |
| 1610 static bool in_dfs_walk; | |
| 1611 | |
| 1612 /* Protect against recursion which means disconnect between | |
| 1613 what tree edges we walk in the DFS walk and what edges | |
| 1614 we stream out. */ | |
| 1615 gcc_assert (!in_dfs_walk); | |
| 1616 | |
| 131 | 1617 if (streamer_dump_file) |
| 1618 { | |
| 1619 print_node_brief (streamer_dump_file, " Streaming SCC of ", | |
| 1620 expr, 4); | |
| 1621 fprintf (streamer_dump_file, "\n"); | |
| 1622 } | |
| 1623 | |
| 111 | 1624 /* Start the DFS walk. */ |
| 1625 /* Save ob state ... */ | |
| 1626 /* let's see ... */ | |
| 1627 in_dfs_walk = true; | |
| 1628 DFS (ob, expr, ref_p, this_ref_p, false); | |
| 1629 in_dfs_walk = false; | |
| 1630 | |
| 1631 /* Finally append a reference to the tree we were writing. | |
| 1632 ??? If expr ended up as a singleton we could have | |
| 1633 inlined it here and avoid outputting a reference. */ | |
| 1634 existed_p = streamer_tree_cache_lookup (ob->writer_cache, expr, &ix); | |
| 1635 gcc_assert (existed_p); | |
| 1636 streamer_write_record_start (ob, LTO_tree_pickle_reference); | |
| 1637 streamer_write_uhwi (ob, ix); | |
| 1638 streamer_write_enum (ob->main_stream, LTO_tags, LTO_NUM_TAGS, | |
| 1639 lto_tree_code_to_tag (TREE_CODE (expr))); | |
| 131 | 1640 if (streamer_dump_file) |
| 1641 { | |
| 1642 print_node_brief (streamer_dump_file, " Finished SCC of ", | |
| 1643 expr, 4); | |
| 1644 fprintf (streamer_dump_file, "\n\n"); | |
| 1645 } | |
| 111 | 1646 lto_stats.num_pickle_refs_output++; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1647 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1648 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1649 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1650 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1651 /* Output to OB a list of try/catch handlers starting with FIRST. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1652 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1653 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1654 output_eh_try_list (struct output_block *ob, eh_catch first) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1655 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1656 eh_catch n; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1657 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1658 for (n = first; n; n = n->next_catch) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1659 { |
| 111 | 1660 streamer_write_record_start (ob, LTO_eh_catch); |
| 1661 stream_write_tree (ob, n->type_list, true); | |
| 1662 stream_write_tree (ob, n->filter_list, true); | |
| 1663 stream_write_tree (ob, n->label, true); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1664 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1665 |
| 111 | 1666 streamer_write_record_start (ob, LTO_null); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1667 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1668 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1669 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1670 /* Output EH region R in function FN to OB. CURR_RN is the slot index |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1671 that is being emitted in FN->EH->REGION_ARRAY. This is used to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1672 detect EH region sharing. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1673 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1674 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1675 output_eh_region (struct output_block *ob, eh_region r) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1676 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1677 enum LTO_tags tag; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1678 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1679 if (r == NULL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1680 { |
| 111 | 1681 streamer_write_record_start (ob, LTO_null); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1682 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1683 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1684 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1685 if (r->type == ERT_CLEANUP) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1686 tag = LTO_ert_cleanup; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1687 else if (r->type == ERT_TRY) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1688 tag = LTO_ert_try; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1689 else if (r->type == ERT_ALLOWED_EXCEPTIONS) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1690 tag = LTO_ert_allowed_exceptions; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1691 else if (r->type == ERT_MUST_NOT_THROW) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1692 tag = LTO_ert_must_not_throw; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1693 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1694 gcc_unreachable (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1695 |
| 111 | 1696 streamer_write_record_start (ob, tag); |
| 1697 streamer_write_hwi (ob, r->index); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1698 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1699 if (r->outer) |
| 111 | 1700 streamer_write_hwi (ob, r->outer->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1701 else |
| 111 | 1702 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1703 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1704 if (r->inner) |
| 111 | 1705 streamer_write_hwi (ob, r->inner->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1706 else |
| 111 | 1707 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1708 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1709 if (r->next_peer) |
| 111 | 1710 streamer_write_hwi (ob, r->next_peer->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1711 else |
| 111 | 1712 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1713 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1714 if (r->type == ERT_TRY) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1715 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1716 output_eh_try_list (ob, r->u.eh_try.first_catch); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1717 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1718 else if (r->type == ERT_ALLOWED_EXCEPTIONS) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1719 { |
| 111 | 1720 stream_write_tree (ob, r->u.allowed.type_list, true); |
| 1721 stream_write_tree (ob, r->u.allowed.label, true); | |
| 1722 streamer_write_uhwi (ob, r->u.allowed.filter); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1723 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1724 else if (r->type == ERT_MUST_NOT_THROW) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1725 { |
| 111 | 1726 stream_write_tree (ob, r->u.must_not_throw.failure_decl, true); |
| 1727 bitpack_d bp = bitpack_create (ob->main_stream); | |
| 1728 stream_output_location (ob, &bp, r->u.must_not_throw.failure_loc); | |
| 1729 streamer_write_bitpack (&bp); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1730 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1731 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1732 if (r->landing_pads) |
| 111 | 1733 streamer_write_hwi (ob, r->landing_pads->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1734 else |
| 111 | 1735 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1736 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1737 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1738 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1739 /* Output landing pad LP to OB. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1740 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1741 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1742 output_eh_lp (struct output_block *ob, eh_landing_pad lp) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1743 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1744 if (lp == NULL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1745 { |
| 111 | 1746 streamer_write_record_start (ob, LTO_null); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1747 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1748 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1749 |
| 111 | 1750 streamer_write_record_start (ob, LTO_eh_landing_pad); |
| 1751 streamer_write_hwi (ob, lp->index); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1752 if (lp->next_lp) |
| 111 | 1753 streamer_write_hwi (ob, lp->next_lp->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1754 else |
| 111 | 1755 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1756 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1757 if (lp->region) |
| 111 | 1758 streamer_write_hwi (ob, lp->region->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1759 else |
| 111 | 1760 streamer_write_zero (ob); |
| 1761 | |
| 1762 stream_write_tree (ob, lp->post_landing_pad, true); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1763 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1764 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1765 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1766 /* Output the existing eh_table to OB. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1767 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1768 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1769 output_eh_regions (struct output_block *ob, struct function *fn) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1770 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1771 if (fn->eh && fn->eh->region_tree) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1772 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1773 unsigned i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1774 eh_region eh; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1775 eh_landing_pad lp; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1776 tree ttype; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1777 |
| 111 | 1778 streamer_write_record_start (ob, LTO_eh_table); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1779 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1780 /* Emit the index of the root of the EH region tree. */ |
| 111 | 1781 streamer_write_hwi (ob, fn->eh->region_tree->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1782 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1783 /* Emit all the EH regions in the region array. */ |
| 111 | 1784 streamer_write_hwi (ob, vec_safe_length (fn->eh->region_array)); |
| 1785 FOR_EACH_VEC_SAFE_ELT (fn->eh->region_array, i, eh) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1786 output_eh_region (ob, eh); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1787 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1788 /* Emit all landing pads. */ |
| 111 | 1789 streamer_write_hwi (ob, vec_safe_length (fn->eh->lp_array)); |
| 1790 FOR_EACH_VEC_SAFE_ELT (fn->eh->lp_array, i, lp) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1791 output_eh_lp (ob, lp); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1792 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1793 /* Emit all the runtime type data. */ |
| 111 | 1794 streamer_write_hwi (ob, vec_safe_length (fn->eh->ttype_data)); |
| 1795 FOR_EACH_VEC_SAFE_ELT (fn->eh->ttype_data, i, ttype) | |
| 1796 stream_write_tree (ob, ttype, true); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1797 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1798 /* Emit the table of action chains. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1799 if (targetm.arm_eabi_unwinder) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1800 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1801 tree t; |
| 111 | 1802 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.arm_eabi)); |
| 1803 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.arm_eabi, i, t) | |
| 1804 stream_write_tree (ob, t, true); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1805 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1806 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1807 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1808 uchar c; |
| 111 | 1809 streamer_write_hwi (ob, vec_safe_length (fn->eh->ehspec_data.other)); |
| 1810 FOR_EACH_VEC_SAFE_ELT (fn->eh->ehspec_data.other, i, c) | |
| 1811 streamer_write_char_stream (ob->main_stream, c); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1812 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1813 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1814 |
| 111 | 1815 /* The LTO_null either terminates the record or indicates that there |
| 1816 are no eh_records at all. */ | |
| 1817 streamer_write_record_start (ob, LTO_null); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1818 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1819 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1820 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1821 /* Output all of the active ssa names to the ssa_names stream. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1822 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1823 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1824 output_ssa_names (struct output_block *ob, struct function *fn) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1825 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1826 unsigned int i, len; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1827 |
| 111 | 1828 len = vec_safe_length (SSANAMES (fn)); |
| 1829 streamer_write_uhwi (ob, len); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1830 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1831 for (i = 1; i < len; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1832 { |
| 111 | 1833 tree ptr = (*SSANAMES (fn))[i]; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1834 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1835 if (ptr == NULL_TREE |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1836 || SSA_NAME_IN_FREE_LIST (ptr) |
| 111 | 1837 || virtual_operand_p (ptr) |
| 1838 /* Simply skip unreleased SSA names. */ | |
| 1839 || (! SSA_NAME_IS_DEFAULT_DEF (ptr) | |
| 1840 && (! SSA_NAME_DEF_STMT (ptr) | |
| 1841 || ! gimple_bb (SSA_NAME_DEF_STMT (ptr))))) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1842 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1843 |
| 111 | 1844 streamer_write_uhwi (ob, i); |
| 1845 streamer_write_char_stream (ob->main_stream, | |
| 1846 SSA_NAME_IS_DEFAULT_DEF (ptr)); | |
| 1847 if (SSA_NAME_VAR (ptr)) | |
| 1848 stream_write_tree (ob, SSA_NAME_VAR (ptr), true); | |
| 1849 else | |
| 1850 /* ??? This drops SSA_NAME_IDENTIFIER on the floor. */ | |
| 1851 stream_write_tree (ob, TREE_TYPE (ptr), true); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1852 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1853 |
| 111 | 1854 streamer_write_zero (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1855 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1856 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1857 |
| 111 | 1858 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1859 /* Output the cfg. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1860 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1861 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1862 output_cfg (struct output_block *ob, struct function *fn) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1863 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1864 struct lto_output_stream *tmp_stream = ob->main_stream; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1865 basic_block bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1866 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1867 ob->main_stream = ob->cfg_stream; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1868 |
| 111 | 1869 streamer_write_enum (ob->main_stream, profile_status_d, PROFILE_LAST, |
| 1870 profile_status_for_fn (fn)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1871 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1872 /* Output the number of the highest basic block. */ |
| 111 | 1873 streamer_write_uhwi (ob, last_basic_block_for_fn (fn)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1874 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1875 FOR_ALL_BB_FN (bb, fn) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1876 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1877 edge_iterator ei; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1878 edge e; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1879 |
| 111 | 1880 streamer_write_hwi (ob, bb->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1881 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1882 /* Output the successors and the edge flags. */ |
| 111 | 1883 streamer_write_uhwi (ob, EDGE_COUNT (bb->succs)); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1884 FOR_EACH_EDGE (e, ei, bb->succs) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1885 { |
| 111 | 1886 streamer_write_uhwi (ob, e->dest->index); |
| 1887 e->probability.stream_out (ob); | |
| 1888 streamer_write_uhwi (ob, e->flags); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1889 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1890 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1891 |
| 111 | 1892 streamer_write_hwi (ob, -1); |
| 1893 | |
| 1894 bb = ENTRY_BLOCK_PTR_FOR_FN (cfun); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1895 while (bb->next_bb) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1896 { |
| 111 | 1897 streamer_write_hwi (ob, bb->next_bb->index); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1898 bb = bb->next_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1899 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1900 |
| 111 | 1901 streamer_write_hwi (ob, -1); |
| 1902 | |
| 1903 /* ??? The cfgloop interface is tied to cfun. */ | |
| 1904 gcc_assert (cfun == fn); | |
| 1905 | |
| 1906 /* Output the number of loops. */ | |
| 1907 streamer_write_uhwi (ob, number_of_loops (fn)); | |
| 1908 | |
| 1909 /* Output each loop, skipping the tree root which has number zero. */ | |
| 1910 for (unsigned i = 1; i < number_of_loops (fn); ++i) | |
| 1911 { | |
| 1912 struct loop *loop = get_loop (fn, i); | |
| 1913 | |
| 1914 /* Write the index of the loop header. That's enough to rebuild | |
| 1915 the loop tree on the reader side. Stream -1 for an unused | |
| 1916 loop entry. */ | |
| 1917 if (!loop) | |
| 1918 { | |
| 1919 streamer_write_hwi (ob, -1); | |
| 1920 continue; | |
| 1921 } | |
| 1922 else | |
| 1923 streamer_write_hwi (ob, loop->header->index); | |
| 1924 | |
| 1925 /* Write everything copy_loop_info copies. */ | |
| 1926 streamer_write_enum (ob->main_stream, | |
| 1927 loop_estimation, EST_LAST, loop->estimate_state); | |
| 1928 streamer_write_hwi (ob, loop->any_upper_bound); | |
| 1929 if (loop->any_upper_bound) | |
| 1930 streamer_write_widest_int (ob, loop->nb_iterations_upper_bound); | |
| 1931 streamer_write_hwi (ob, loop->any_likely_upper_bound); | |
| 1932 if (loop->any_likely_upper_bound) | |
| 1933 streamer_write_widest_int (ob, loop->nb_iterations_likely_upper_bound); | |
| 1934 streamer_write_hwi (ob, loop->any_estimate); | |
| 1935 if (loop->any_estimate) | |
| 1936 streamer_write_widest_int (ob, loop->nb_iterations_estimate); | |
| 1937 | |
| 1938 /* Write OMP SIMD related info. */ | |
| 1939 streamer_write_hwi (ob, loop->safelen); | |
| 131 | 1940 streamer_write_hwi (ob, loop->unroll); |
| 111 | 1941 streamer_write_hwi (ob, loop->dont_vectorize); |
| 1942 streamer_write_hwi (ob, loop->force_vectorize); | |
| 1943 stream_write_tree (ob, loop->simduid, true); | |
| 1944 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1945 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1946 ob->main_stream = tmp_stream; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1947 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1948 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1949 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1950 /* Create the header in the file using OB. If the section type is for |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1951 a function, set FN to the decl for that function. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1952 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1953 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1954 produce_asm (struct output_block *ob, tree fn) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1955 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1956 enum lto_section_type section_type = ob->section_type; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1957 struct lto_function_header header; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1958 char *section_name; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1959 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1960 if (section_type == LTO_section_function_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1961 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1962 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (fn)); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1963 section_name = lto_get_section_name (section_type, name, NULL); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1964 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1965 else |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
1966 section_name = lto_get_section_name (section_type, NULL, NULL); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1967 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1968 lto_begin_section (section_name, !flag_wpa); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1969 free (section_name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1970 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1971 /* The entire header is stream computed here. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1972 memset (&header, 0, sizeof (struct lto_function_header)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1973 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1974 /* Write the header. */ |
| 111 | 1975 header.major_version = LTO_major_version; |
| 1976 header.minor_version = LTO_minor_version; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1977 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1978 if (section_type == LTO_section_function_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1979 header.cfg_size = ob->cfg_stream->total_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1980 header.main_size = ob->main_stream->total_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1981 header.string_size = ob->string_stream->total_size; |
| 111 | 1982 lto_write_data (&header, sizeof header); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1983 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1984 /* Put all of the gimple and the string table out the asm file as a |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1985 block of text. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1986 if (section_type == LTO_section_function_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1987 lto_write_stream (ob->cfg_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1988 lto_write_stream (ob->main_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1989 lto_write_stream (ob->string_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1990 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1991 lto_end_section (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1992 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1993 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
1994 |
| 111 | 1995 /* Output the base body of struct function FN using output block OB. */ |
| 1996 | |
| 1997 static void | |
| 1998 output_struct_function_base (struct output_block *ob, struct function *fn) | |
| 1999 { | |
| 2000 struct bitpack_d bp; | |
| 2001 unsigned i; | |
| 2002 tree t; | |
| 2003 | |
| 2004 /* Output the static chain and non-local goto save area. */ | |
| 2005 stream_write_tree (ob, fn->static_chain_decl, true); | |
| 2006 stream_write_tree (ob, fn->nonlocal_goto_save_area, true); | |
| 2007 | |
| 2008 /* Output all the local variables in the function. */ | |
| 2009 streamer_write_hwi (ob, vec_safe_length (fn->local_decls)); | |
| 2010 FOR_EACH_VEC_SAFE_ELT (fn->local_decls, i, t) | |
| 2011 stream_write_tree (ob, t, true); | |
| 2012 | |
| 2013 /* Output current IL state of the function. */ | |
| 2014 streamer_write_uhwi (ob, fn->curr_properties); | |
| 2015 | |
| 2016 /* Write all the attributes for FN. */ | |
| 2017 bp = bitpack_create (ob->main_stream); | |
| 2018 bp_pack_value (&bp, fn->is_thunk, 1); | |
| 2019 bp_pack_value (&bp, fn->has_local_explicit_reg_vars, 1); | |
| 2020 bp_pack_value (&bp, fn->returns_pcc_struct, 1); | |
| 2021 bp_pack_value (&bp, fn->returns_struct, 1); | |
| 2022 bp_pack_value (&bp, fn->can_throw_non_call_exceptions, 1); | |
| 2023 bp_pack_value (&bp, fn->can_delete_dead_exceptions, 1); | |
| 2024 bp_pack_value (&bp, fn->always_inline_functions_inlined, 1); | |
| 2025 bp_pack_value (&bp, fn->after_inlining, 1); | |
| 2026 bp_pack_value (&bp, fn->stdarg, 1); | |
| 2027 bp_pack_value (&bp, fn->has_nonlocal_label, 1); | |
| 2028 bp_pack_value (&bp, fn->has_forced_label_in_static, 1); | |
| 2029 bp_pack_value (&bp, fn->calls_alloca, 1); | |
| 2030 bp_pack_value (&bp, fn->calls_setjmp, 1); | |
| 2031 bp_pack_value (&bp, fn->has_force_vectorize_loops, 1); | |
| 2032 bp_pack_value (&bp, fn->has_simduid_loops, 1); | |
| 2033 bp_pack_value (&bp, fn->va_list_fpr_size, 8); | |
| 2034 bp_pack_value (&bp, fn->va_list_gpr_size, 8); | |
| 2035 bp_pack_value (&bp, fn->last_clique, sizeof (short) * 8); | |
| 2036 | |
| 2037 /* Output the function start and end loci. */ | |
| 2038 stream_output_location (ob, &bp, fn->function_start_locus); | |
| 2039 stream_output_location (ob, &bp, fn->function_end_locus); | |
| 2040 | |
| 131 | 2041 /* Save the instance discriminator if present. */ |
| 2042 int *instance_number_p = NULL; | |
| 2043 if (decl_to_instance_map) | |
| 2044 instance_number_p = decl_to_instance_map->get (fn->decl); | |
| 2045 bp_pack_value (&bp, !!instance_number_p, 1); | |
| 2046 if (instance_number_p) | |
| 2047 bp_pack_value (&bp, *instance_number_p, sizeof (int) * CHAR_BIT); | |
| 2048 | |
| 111 | 2049 streamer_write_bitpack (&bp); |
| 2050 } | |
| 2051 | |
| 2052 | |
| 2053 /* Collect all leaf BLOCKs beyond ROOT into LEAFS. */ | |
| 2054 | |
| 2055 static void | |
| 2056 collect_block_tree_leafs (tree root, vec<tree> &leafs) | |
| 2057 { | |
| 2058 for (root = BLOCK_SUBBLOCKS (root); root; root = BLOCK_CHAIN (root)) | |
| 2059 if (! BLOCK_SUBBLOCKS (root)) | |
| 2060 leafs.safe_push (root); | |
| 2061 else | |
| 2062 collect_block_tree_leafs (BLOCK_SUBBLOCKS (root), leafs); | |
| 2063 } | |
| 2064 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2065 /* Output the body of function NODE->DECL. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2066 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2067 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2068 output_function (struct cgraph_node *node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2069 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2070 tree function; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2071 struct function *fn; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2072 basic_block bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2073 struct output_block *ob; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2074 |
| 131 | 2075 if (streamer_dump_file) |
| 2076 fprintf (streamer_dump_file, "\nStreaming body of %s\n", | |
| 2077 node->name ()); | |
| 2078 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2079 function = node->decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2080 fn = DECL_STRUCT_FUNCTION (function); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2081 ob = create_output_block (LTO_section_function_body); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2082 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2083 clear_line_info (ob); |
| 111 | 2084 ob->symbol = node; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2085 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2086 gcc_assert (current_function_decl == NULL_TREE && cfun == NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2087 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2088 /* Set current_function_decl and cfun. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2089 push_cfun (fn); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2090 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2091 /* Make string 0 be a NULL string. */ |
| 111 | 2092 streamer_write_char_stream (ob->string_stream, 0); |
| 2093 | |
| 2094 streamer_write_record_start (ob, LTO_function); | |
| 2095 | |
| 2096 /* Output decls for parameters and args. */ | |
| 2097 stream_write_tree (ob, DECL_RESULT (function), true); | |
| 2098 streamer_write_chain (ob, DECL_ARGUMENTS (function), true); | |
| 2099 | |
| 2100 /* Output debug args if available. */ | |
| 2101 vec<tree, va_gc> **debugargs = decl_debug_args_lookup (function); | |
| 2102 if (! debugargs) | |
| 2103 streamer_write_uhwi (ob, 0); | |
| 2104 else | |
| 2105 { | |
| 2106 streamer_write_uhwi (ob, (*debugargs)->length ()); | |
| 2107 for (unsigned i = 0; i < (*debugargs)->length (); ++i) | |
| 2108 stream_write_tree (ob, (**debugargs)[i], true); | |
| 2109 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2110 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2111 /* Output DECL_INITIAL for the function, which contains the tree of |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2112 lexical scopes. */ |
| 111 | 2113 stream_write_tree (ob, DECL_INITIAL (function), true); |
| 2114 /* As we do not recurse into BLOCK_SUBBLOCKS but only BLOCK_SUPERCONTEXT | |
| 2115 collect block tree leafs and stream those. */ | |
| 2116 auto_vec<tree> block_tree_leafs; | |
| 2117 if (DECL_INITIAL (function)) | |
| 2118 collect_block_tree_leafs (DECL_INITIAL (function), block_tree_leafs); | |
| 2119 streamer_write_uhwi (ob, block_tree_leafs.length ()); | |
| 2120 for (unsigned i = 0; i < block_tree_leafs.length (); ++i) | |
| 2121 stream_write_tree (ob, block_tree_leafs[i], true); | |
| 2122 | |
| 2123 /* We also stream abstract functions where we stream only stuff needed for | |
| 2124 debug info. */ | |
| 2125 if (gimple_has_body_p (function)) | |
| 2126 { | |
| 131 | 2127 /* Fixup loops if required to match discovery done in the reader. */ |
| 2128 loop_optimizer_init (AVOID_CFG_MODIFICATIONS); | |
| 2129 | |
| 111 | 2130 streamer_write_uhwi (ob, 1); |
| 2131 output_struct_function_base (ob, fn); | |
| 2132 | |
| 2133 /* Output all the SSA names used in the function. */ | |
| 2134 output_ssa_names (ob, fn); | |
| 2135 | |
| 2136 /* Output any exception handling regions. */ | |
| 2137 output_eh_regions (ob, fn); | |
| 2138 | |
| 2139 | |
| 2140 /* We will renumber the statements. The code that does this uses | |
| 2141 the same ordering that we use for serializing them so we can use | |
| 2142 the same code on the other end and not have to write out the | |
| 2143 statement numbers. We do not assign UIDs to PHIs here because | |
| 2144 virtual PHIs get re-computed on-the-fly which would make numbers | |
| 2145 inconsistent. */ | |
| 2146 set_gimple_stmt_max_uid (cfun, 0); | |
| 2147 FOR_ALL_BB_FN (bb, cfun) | |
| 2148 { | |
| 2149 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); | |
| 2150 gsi_next (&gsi)) | |
| 2151 { | |
| 2152 gphi *stmt = gsi.phi (); | |
| 2153 | |
| 2154 /* Virtual PHIs are not going to be streamed. */ | |
| 2155 if (!virtual_operand_p (gimple_phi_result (stmt))) | |
| 2156 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); | |
| 2157 } | |
| 2158 for (gimple_stmt_iterator gsi = gsi_start_bb (bb); !gsi_end_p (gsi); | |
| 2159 gsi_next (&gsi)) | |
| 2160 { | |
| 2161 gimple *stmt = gsi_stmt (gsi); | |
| 2162 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); | |
| 2163 } | |
| 2164 } | |
| 2165 /* To avoid keeping duplicate gimple IDs in the statements, renumber | |
| 2166 virtual phis now. */ | |
| 2167 FOR_ALL_BB_FN (bb, cfun) | |
| 2168 { | |
| 2169 for (gphi_iterator gsi = gsi_start_phis (bb); !gsi_end_p (gsi); | |
| 2170 gsi_next (&gsi)) | |
| 2171 { | |
| 2172 gphi *stmt = gsi.phi (); | |
| 2173 if (virtual_operand_p (gimple_phi_result (stmt))) | |
| 2174 gimple_set_uid (stmt, inc_gimple_stmt_max_uid (cfun)); | |
| 2175 } | |
| 2176 } | |
| 2177 | |
| 2178 /* Output the code for the function. */ | |
| 2179 FOR_ALL_BB_FN (bb, fn) | |
| 2180 output_bb (ob, bb, fn); | |
| 2181 | |
| 2182 /* The terminator for this function. */ | |
| 2183 streamer_write_record_start (ob, LTO_null); | |
| 2184 | |
| 2185 output_cfg (ob, fn); | |
| 2186 | |
| 131 | 2187 loop_optimizer_finalize (); |
| 111 | 2188 pop_cfun (); |
| 2189 } | |
| 2190 else | |
| 2191 streamer_write_uhwi (ob, 0); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2192 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2193 /* Create a section to hold the pickled output of this function. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2194 produce_asm (ob, function); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2195 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2196 destroy_output_block (ob); |
| 131 | 2197 if (streamer_dump_file) |
| 2198 fprintf (streamer_dump_file, "Finished streaming %s\n", | |
| 2199 node->name ()); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2200 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2201 |
| 111 | 2202 /* Output the body of function NODE->DECL. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2203 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2204 static void |
| 111 | 2205 output_constructor (struct varpool_node *node) |
| 2206 { | |
| 2207 tree var = node->decl; | |
| 2208 struct output_block *ob; | |
| 2209 | |
| 131 | 2210 if (streamer_dump_file) |
| 2211 fprintf (streamer_dump_file, "\nStreaming constructor of %s\n", | |
| 2212 node->name ()); | |
| 2213 | |
| 111 | 2214 ob = create_output_block (LTO_section_function_body); |
| 2215 | |
| 2216 clear_line_info (ob); | |
| 2217 ob->symbol = node; | |
| 2218 | |
| 2219 /* Make string 0 be a NULL string. */ | |
| 2220 streamer_write_char_stream (ob->string_stream, 0); | |
| 2221 | |
| 2222 /* Output DECL_INITIAL for the function, which contains the tree of | |
| 2223 lexical scopes. */ | |
| 2224 stream_write_tree (ob, DECL_INITIAL (var), true); | |
| 2225 | |
| 2226 /* Create a section to hold the pickled output of this function. */ | |
| 2227 produce_asm (ob, var); | |
| 2228 | |
| 2229 destroy_output_block (ob); | |
| 131 | 2230 if (streamer_dump_file) |
| 2231 fprintf (streamer_dump_file, "Finished streaming %s\n", | |
| 2232 node->name ()); | |
| 111 | 2233 } |
| 2234 | |
| 2235 | |
| 2236 /* Emit toplevel asms. */ | |
| 2237 | |
| 2238 void | |
| 2239 lto_output_toplevel_asms (void) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2240 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2241 struct output_block *ob; |
| 111 | 2242 struct asm_node *can; |
| 2243 char *section_name; | |
| 2244 struct lto_simple_header_with_strings header; | |
| 2245 | |
| 2246 if (!symtab->first_asm_symbol ()) | |
| 2247 return; | |
| 2248 | |
| 2249 ob = create_output_block (LTO_section_asm); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2250 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2251 /* Make string 0 be a NULL string. */ |
| 111 | 2252 streamer_write_char_stream (ob->string_stream, 0); |
| 2253 | |
| 2254 for (can = symtab->first_asm_symbol (); can; can = can->next) | |
| 2255 { | |
| 2256 streamer_write_string_cst (ob, ob->main_stream, can->asm_str); | |
| 2257 streamer_write_hwi (ob, can->order); | |
| 2258 } | |
| 2259 | |
| 2260 streamer_write_string_cst (ob, ob->main_stream, NULL_TREE); | |
| 2261 | |
| 2262 section_name = lto_get_section_name (LTO_section_asm, NULL, NULL); | |
| 2263 lto_begin_section (section_name, !flag_wpa); | |
| 2264 free (section_name); | |
| 2265 | |
| 2266 /* The entire header stream is computed here. */ | |
| 2267 memset (&header, 0, sizeof (header)); | |
| 2268 | |
| 2269 /* Write the header. */ | |
| 2270 header.major_version = LTO_major_version; | |
| 2271 header.minor_version = LTO_minor_version; | |
| 2272 | |
| 2273 header.main_size = ob->main_stream->total_size; | |
| 2274 header.string_size = ob->string_stream->total_size; | |
| 2275 lto_write_data (&header, sizeof header); | |
| 2276 | |
| 2277 /* Put all of the gimple and the string table out the asm file as a | |
| 2278 block of text. */ | |
| 2279 lto_write_stream (ob->main_stream); | |
| 2280 lto_write_stream (ob->string_stream); | |
| 2281 | |
| 2282 lto_end_section (); | |
| 2283 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2284 destroy_output_block (ob); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2285 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2286 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2287 |
| 111 | 2288 /* Copy the function body or variable constructor of NODE without deserializing. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2289 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2290 static void |
| 111 | 2291 copy_function_or_variable (struct symtab_node *node) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2292 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2293 tree function = node->decl; |
| 111 | 2294 struct lto_file_decl_data *file_data = node->lto_file_data; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2295 const char *data; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2296 size_t len; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2297 const char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (function)); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2298 char *section_name = |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2299 lto_get_section_name (LTO_section_function_body, name, NULL); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2300 size_t i, j; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2301 struct lto_in_decl_state *in_state; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2302 struct lto_out_decl_state *out_state = lto_get_out_decl_state (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2303 |
| 131 | 2304 if (streamer_dump_file) |
| 2305 fprintf (streamer_dump_file, "Copying section for %s\n", name); | |
| 111 | 2306 lto_begin_section (section_name, false); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2307 free (section_name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2308 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2309 /* We may have renamed the declaration, e.g., a static function. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2310 name = lto_get_decl_name_mapping (file_data, name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2311 |
| 111 | 2312 data = lto_get_raw_section_data (file_data, LTO_section_function_body, |
| 2313 name, &len); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2314 gcc_assert (data); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2315 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2316 /* Do a bit copy of the function body. */ |
| 111 | 2317 lto_write_raw_data (data, len); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2318 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2319 /* Copy decls. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2320 in_state = |
| 111 | 2321 lto_get_function_in_decl_state (node->lto_file_data, function); |
| 2322 out_state->compressed = in_state->compressed; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2323 gcc_assert (in_state); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2324 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2325 for (i = 0; i < LTO_N_DECL_STREAMS; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2326 { |
| 111 | 2327 size_t n = vec_safe_length (in_state->streams[i]); |
| 2328 vec<tree, va_gc> *trees = in_state->streams[i]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2329 struct lto_tree_ref_encoder *encoder = &(out_state->streams[i]); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2330 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2331 /* The out state must have the same indices and the in state. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2332 So just copy the vector. All the encoders in the in state |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2333 must be empty where we reach here. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2334 gcc_assert (lto_tree_ref_encoder_size (encoder) == 0); |
| 111 | 2335 encoder->trees.reserve_exact (n); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2336 for (j = 0; j < n; j++) |
| 111 | 2337 encoder->trees.safe_push ((*trees)[j]); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2338 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2339 |
| 111 | 2340 lto_free_raw_section_data (file_data, LTO_section_function_body, name, |
| 2341 data, len); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2342 lto_end_section (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2343 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2344 |
| 111 | 2345 /* Wrap symbol references in *TP inside a type-preserving MEM_REF. */ |
| 2346 | |
| 2347 static tree | |
| 2348 wrap_refs (tree *tp, int *ws, void *) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2349 { |
| 111 | 2350 tree t = *tp; |
| 2351 if (handled_component_p (t) | |
| 2352 && TREE_CODE (TREE_OPERAND (t, 0)) == VAR_DECL | |
| 2353 && TREE_PUBLIC (TREE_OPERAND (t, 0))) | |
| 2354 { | |
| 2355 tree decl = TREE_OPERAND (t, 0); | |
| 2356 tree ptrtype = build_pointer_type (TREE_TYPE (decl)); | |
| 2357 TREE_OPERAND (t, 0) = build2 (MEM_REF, TREE_TYPE (decl), | |
| 2358 build1 (ADDR_EXPR, ptrtype, decl), | |
| 2359 build_int_cst (ptrtype, 0)); | |
| 2360 TREE_THIS_VOLATILE (TREE_OPERAND (t, 0)) = TREE_THIS_VOLATILE (decl); | |
| 2361 *ws = 0; | |
| 2362 } | |
| 2363 else if (TREE_CODE (t) == CONSTRUCTOR) | |
| 2364 ; | |
| 2365 else if (!EXPR_P (t)) | |
| 2366 *ws = 0; | |
| 2367 return NULL_TREE; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2368 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2369 |
| 131 | 2370 /* Remove functions that are no longer used from offload_funcs, and mark the |
| 2371 remaining ones with DECL_PRESERVE_P. */ | |
| 2372 | |
| 2373 static void | |
| 2374 prune_offload_funcs (void) | |
| 2375 { | |
| 2376 if (!offload_funcs) | |
| 2377 return; | |
| 2378 | |
| 2379 unsigned ix, ix2; | |
| 2380 tree *elem_ptr; | |
| 2381 VEC_ORDERED_REMOVE_IF (*offload_funcs, ix, ix2, elem_ptr, | |
| 2382 cgraph_node::get (*elem_ptr) == NULL); | |
| 2383 | |
| 2384 tree fn_decl; | |
| 2385 FOR_EACH_VEC_ELT (*offload_funcs, ix, fn_decl) | |
| 2386 DECL_PRESERVE_P (fn_decl) = 1; | |
| 2387 } | |
| 2388 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2389 /* Main entry point from the pass manager. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2390 |
| 111 | 2391 void |
| 2392 lto_output (void) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2393 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2394 struct lto_out_decl_state *decl_state; |
| 111 | 2395 bitmap output = NULL; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2396 int i, n_nodes; |
| 111 | 2397 lto_symtab_encoder_t encoder = lto_get_out_decl_state ()->symtab_node_encoder; |
| 2398 | |
| 131 | 2399 prune_offload_funcs (); |
| 2400 | |
| 111 | 2401 if (flag_checking) |
| 2402 output = lto_bitmap_alloc (); | |
| 2403 | |
| 2404 /* Initialize the streamer. */ | |
| 2405 lto_streamer_init (); | |
| 2406 | |
| 2407 n_nodes = lto_symtab_encoder_size (encoder); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2408 /* Process only the functions with bodies. */ |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2409 for (i = 0; i < n_nodes; i++) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2410 { |
| 111 | 2411 symtab_node *snode = lto_symtab_encoder_deref (encoder, i); |
| 2412 if (cgraph_node *node = dyn_cast <cgraph_node *> (snode)) | |
| 2413 { | |
| 2414 if (lto_symtab_encoder_encode_body_p (encoder, node) | |
| 2415 && !node->alias | |
| 2416 && (!node->thunk.thunk_p || !node->thunk.add_pointer_bounds_args)) | |
| 2417 { | |
| 2418 if (flag_checking) | |
| 2419 { | |
| 2420 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl))); | |
| 2421 bitmap_set_bit (output, DECL_UID (node->decl)); | |
| 2422 } | |
| 2423 decl_state = lto_new_out_decl_state (); | |
| 2424 lto_push_out_decl_state (decl_state); | |
| 131 | 2425 if (gimple_has_body_p (node->decl) |
| 2426 || (!flag_wpa | |
| 2427 && flag_incremental_link != INCREMENTAL_LINK_LTO) | |
| 111 | 2428 /* Thunks have no body but they may be synthetized |
| 2429 at WPA time. */ | |
| 2430 || DECL_ARGUMENTS (node->decl)) | |
| 2431 output_function (node); | |
| 2432 else | |
| 2433 copy_function_or_variable (node); | |
| 2434 gcc_assert (lto_get_out_decl_state () == decl_state); | |
| 2435 lto_pop_out_decl_state (); | |
| 2436 lto_record_function_out_decl_state (node->decl, decl_state); | |
| 2437 } | |
| 2438 } | |
| 2439 else if (varpool_node *node = dyn_cast <varpool_node *> (snode)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2440 { |
| 111 | 2441 /* Wrap symbol references inside the ctor in a type |
| 2442 preserving MEM_REF. */ | |
| 2443 tree ctor = DECL_INITIAL (node->decl); | |
| 2444 if (ctor && !in_lto_p) | |
| 2445 walk_tree (&ctor, wrap_refs, NULL, NULL); | |
| 2446 if (get_symbol_initial_value (encoder, node->decl) == error_mark_node | |
| 2447 && lto_symtab_encoder_encode_initializer_p (encoder, node) | |
| 2448 && !node->alias) | |
| 2449 { | |
| 2450 timevar_push (TV_IPA_LTO_CTORS_OUT); | |
| 2451 if (flag_checking) | |
| 2452 { | |
| 2453 gcc_assert (!bitmap_bit_p (output, DECL_UID (node->decl))); | |
| 2454 bitmap_set_bit (output, DECL_UID (node->decl)); | |
| 2455 } | |
| 2456 decl_state = lto_new_out_decl_state (); | |
| 2457 lto_push_out_decl_state (decl_state); | |
| 2458 if (DECL_INITIAL (node->decl) != error_mark_node | |
| 131 | 2459 || (!flag_wpa |
| 2460 && flag_incremental_link != INCREMENTAL_LINK_LTO)) | |
| 111 | 2461 output_constructor (node); |
| 2462 else | |
| 2463 copy_function_or_variable (node); | |
| 2464 gcc_assert (lto_get_out_decl_state () == decl_state); | |
| 2465 lto_pop_out_decl_state (); | |
| 2466 lto_record_function_out_decl_state (node->decl, decl_state); | |
| 2467 timevar_pop (TV_IPA_LTO_CTORS_OUT); | |
| 2468 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2469 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2470 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2471 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2472 /* Emit the callgraph after emitting function bodies. This needs to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2473 be done now to make sure that all the statements in every function |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2474 have been renumbered so that edges can be associated with call |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2475 statements using the statement UIDs. */ |
| 111 | 2476 output_symtab (); |
| 2477 | |
| 2478 output_offload_tables (); | |
| 2479 | |
| 2480 #if CHECKING_P | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2481 lto_bitmap_free (output); |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2482 #endif |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2483 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2484 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2485 /* Write each node in encoded by ENCODER to OB, as well as those reachable |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2486 from it and required for correct representation of its semantics. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2487 Each node in ENCODER must be a global declaration or a type. A node |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2488 is written only once, even if it appears multiple times in the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2489 vector. Certain transitively-reachable nodes, such as those |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2490 representing expressions, may be duplicated, but such nodes |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2491 must not appear in ENCODER itself. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2492 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2493 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2494 write_global_stream (struct output_block *ob, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2495 struct lto_tree_ref_encoder *encoder) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2496 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2497 tree t; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2498 size_t index; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2499 const size_t size = lto_tree_ref_encoder_size (encoder); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2500 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2501 for (index = 0; index < size; index++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2502 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2503 t = lto_tree_ref_encoder_get_tree (encoder, index); |
| 131 | 2504 if (streamer_dump_file) |
| 2505 { | |
| 2506 fprintf (streamer_dump_file, " %i:", (int)index); | |
| 2507 print_node_brief (streamer_dump_file, "", t, 4); | |
| 2508 fprintf (streamer_dump_file, "\n"); | |
| 2509 } | |
| 111 | 2510 if (!streamer_tree_cache_lookup (ob->writer_cache, t, NULL)) |
| 2511 stream_write_tree (ob, t, false); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2512 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2513 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2514 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2515 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2516 /* Write a sequence of indices into the globals vector corresponding |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2517 to the trees in ENCODER. These are used by the reader to map the |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2518 indices used to refer to global entities within function bodies to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2519 their referents. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2520 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2521 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2522 write_global_references (struct output_block *ob, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2523 struct lto_tree_ref_encoder *encoder) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2524 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2525 tree t; |
| 111 | 2526 uint32_t index; |
| 2527 const uint32_t size = lto_tree_ref_encoder_size (encoder); | |
| 2528 | |
| 2529 /* Write size and slot indexes as 32-bit unsigned numbers. */ | |
| 2530 uint32_t *data = XNEWVEC (uint32_t, size + 1); | |
| 2531 data[0] = size; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2532 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2533 for (index = 0; index < size; index++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2534 { |
| 111 | 2535 unsigned slot_num; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2536 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2537 t = lto_tree_ref_encoder_get_tree (encoder, index); |
| 111 | 2538 streamer_tree_cache_lookup (ob->writer_cache, t, &slot_num); |
| 2539 gcc_assert (slot_num != (unsigned)-1); | |
| 2540 data[index + 1] = slot_num; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2541 } |
| 111 | 2542 |
| 2543 lto_write_data (data, sizeof (int32_t) * (size + 1)); | |
| 2544 free (data); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2545 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2546 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2547 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2548 /* Write all the streams in an lto_out_decl_state STATE using |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2549 output block OB and output stream OUT_STREAM. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2550 |
| 111 | 2551 void |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2552 lto_output_decl_state_streams (struct output_block *ob, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2553 struct lto_out_decl_state *state) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2554 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2555 int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2556 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2557 for (i = 0; i < LTO_N_DECL_STREAMS; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2558 write_global_stream (ob, &state->streams[i]); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2559 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2560 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2561 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2562 /* Write all the references in an lto_out_decl_state STATE using |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2563 output block OB and output stream OUT_STREAM. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2564 |
| 111 | 2565 void |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2566 lto_output_decl_state_refs (struct output_block *ob, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2567 struct lto_out_decl_state *state) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2568 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2569 unsigned i; |
| 111 | 2570 unsigned ref; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2571 tree decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2572 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2573 /* Write reference to FUNCTION_DECL. If there is not function, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2574 write reference to void_type_node. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2575 decl = (state->fn_decl) ? state->fn_decl : void_type_node; |
| 111 | 2576 streamer_tree_cache_lookup (ob->writer_cache, decl, &ref); |
| 2577 gcc_assert (ref != (unsigned)-1); | |
| 2578 ref = ref * 2 + (state->compressed ? 1 : 0); | |
| 2579 lto_write_data (&ref, sizeof (uint32_t)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2580 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2581 for (i = 0; i < LTO_N_DECL_STREAMS; i++) |
| 111 | 2582 write_global_references (ob, &state->streams[i]); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2583 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2584 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2585 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2586 /* Return the written size of STATE. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2587 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2588 static size_t |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2589 lto_out_decl_state_written_size (struct lto_out_decl_state *state) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2590 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2591 int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2592 size_t size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2593 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2594 size = sizeof (int32_t); /* fn_ref. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2595 for (i = 0; i < LTO_N_DECL_STREAMS; i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2596 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2597 size += sizeof (int32_t); /* vector size. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2598 size += (lto_tree_ref_encoder_size (&state->streams[i]) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2599 * sizeof (int32_t)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2600 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2601 return size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2602 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2603 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2604 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2605 /* Write symbol T into STREAM in CACHE. SEEN specifies symbols we wrote |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2606 so far. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2607 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2608 static void |
| 111 | 2609 write_symbol (struct streamer_tree_cache_d *cache, |
| 2610 tree t, hash_set<const char *> *seen, bool alias) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2611 { |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2612 const char *name; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2613 enum gcc_plugin_symbol_kind kind; |
| 111 | 2614 enum gcc_plugin_symbol_visibility visibility = GCCPV_DEFAULT; |
| 2615 unsigned slot_num; | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2616 uint64_t size; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2617 const char *comdat; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2618 unsigned char c; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2619 |
| 131 | 2620 gcc_checking_assert (TREE_PUBLIC (t) |
| 2621 && (TREE_CODE (t) != FUNCTION_DECL | |
| 2622 || !fndecl_built_in_p (t)) | |
| 2623 && !DECL_ABSTRACT_P (t) | |
| 2624 && (!VAR_P (t) || !DECL_HARD_REGISTER (t))); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2625 |
| 111 | 2626 gcc_assert (VAR_OR_FUNCTION_DECL_P (t)); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2627 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2628 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (t)); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2629 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2630 /* This behaves like assemble_name_raw in varasm.c, performing the |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2631 same name manipulations that ASM_OUTPUT_LABELREF does. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2632 name = IDENTIFIER_POINTER ((*targetm.asm_out.mangle_assembler_name) (name)); |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2633 |
| 111 | 2634 if (seen->add (name)) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2635 return; |
| 111 | 2636 |
| 2637 streamer_tree_cache_lookup (cache, t, &slot_num); | |
| 2638 gcc_assert (slot_num != (unsigned)-1); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2639 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2640 if (DECL_EXTERNAL (t)) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2641 { |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2642 if (DECL_WEAK (t)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2643 kind = GCCPK_WEAKUNDEF; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2644 else |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2645 kind = GCCPK_UNDEF; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2646 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2647 else |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2648 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2649 if (DECL_WEAK (t)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2650 kind = GCCPK_WEAKDEF; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2651 else if (DECL_COMMON (t)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2652 kind = GCCPK_COMMON; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2653 else |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2654 kind = GCCPK_DEF; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2655 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2656 /* When something is defined, it should have node attached. */ |
| 111 | 2657 gcc_assert (alias || !VAR_P (t) || varpool_node::get (t)->definition); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2658 gcc_assert (alias || TREE_CODE (t) != FUNCTION_DECL |
| 111 | 2659 || (cgraph_node::get (t) |
| 2660 && cgraph_node::get (t)->definition)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2661 } |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2662 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2663 /* Imitate what default_elf_asm_output_external do. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2664 When symbol is external, we need to output it with DEFAULT visibility |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2665 when compiling with -fvisibility=default, while with HIDDEN visibility |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2666 when symbol has attribute (visibility("hidden")) specified. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2667 targetm.binds_local_p check DECL_VISIBILITY_SPECIFIED and gets this |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2668 right. */ |
| 111 | 2669 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2670 if (DECL_EXTERNAL (t) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2671 && !targetm.binds_local_p (t)) |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2672 visibility = GCCPV_DEFAULT; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2673 else |
| 111 | 2674 switch (DECL_VISIBILITY (t)) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2675 { |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2676 case VISIBILITY_DEFAULT: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2677 visibility = GCCPV_DEFAULT; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2678 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2679 case VISIBILITY_PROTECTED: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2680 visibility = GCCPV_PROTECTED; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2681 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2682 case VISIBILITY_HIDDEN: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2683 visibility = GCCPV_HIDDEN; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2684 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2685 case VISIBILITY_INTERNAL: |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2686 visibility = GCCPV_INTERNAL; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2687 break; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2688 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2689 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2690 if (kind == GCCPK_COMMON |
| 111 | 2691 && DECL_SIZE_UNIT (t) |
| 2692 && TREE_CODE (DECL_SIZE_UNIT (t)) == INTEGER_CST) | |
| 2693 size = TREE_INT_CST_LOW (DECL_SIZE_UNIT (t)); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2694 else |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2695 size = 0; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2696 |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2697 if (DECL_ONE_ONLY (t)) |
| 111 | 2698 comdat = IDENTIFIER_POINTER (decl_comdat_group_id (t)); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2699 else |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2700 comdat = ""; |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2701 |
| 111 | 2702 lto_write_data (name, strlen (name) + 1); |
| 2703 lto_write_data (comdat, strlen (comdat) + 1); | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2704 c = (unsigned char) kind; |
| 111 | 2705 lto_write_data (&c, 1); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2706 c = (unsigned char) visibility; |
| 111 | 2707 lto_write_data (&c, 1); |
| 2708 lto_write_data (&size, 8); | |
| 2709 lto_write_data (&slot_num, 4); | |
| 2710 } | |
| 2711 | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2712 /* Write an IL symbol table to OB. |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2713 SET and VSET are cgraph/varpool node sets we are outputting. */ |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2714 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2715 static void |
| 111 | 2716 produce_symtab (struct output_block *ob) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2717 { |
| 111 | 2718 struct streamer_tree_cache_d *cache = ob->writer_cache; |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2719 char *section_name = lto_get_section_name (LTO_section_symtab, NULL, NULL); |
| 111 | 2720 lto_symtab_encoder_t encoder = ob->decl_state->symtab_node_encoder; |
| 2721 lto_symtab_encoder_iterator lsei; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2722 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2723 lto_begin_section (section_name, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2724 free (section_name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2725 |
| 111 | 2726 hash_set<const char *> seen; |
| 2727 | |
| 2728 /* Write the symbol table. | |
| 2729 First write everything defined and then all declarations. | |
| 2730 This is necessary to handle cases where we have duplicated symbols. */ | |
| 2731 for (lsei = lsei_start (encoder); | |
| 2732 !lsei_end_p (lsei); lsei_next (&lsei)) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2733 { |
| 111 | 2734 symtab_node *node = lsei_node (lsei); |
| 2735 | |
| 131 | 2736 if (DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ()) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2737 continue; |
| 111 | 2738 write_symbol (cache, node->decl, &seen, false); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2739 } |
| 111 | 2740 for (lsei = lsei_start (encoder); |
| 2741 !lsei_end_p (lsei); lsei_next (&lsei)) | |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2742 { |
| 111 | 2743 symtab_node *node = lsei_node (lsei); |
| 2744 | |
| 131 | 2745 if (!DECL_EXTERNAL (node->decl) || !node->output_to_lto_symbol_table_p ()) |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2746 continue; |
| 111 | 2747 write_symbol (cache, node->decl, &seen, false); |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2748 } |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2749 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2750 lto_end_section (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2751 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2752 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2753 |
| 111 | 2754 /* Init the streamer_mode_table for output, where we collect info on what |
| 2755 machine_mode values have been streamed. */ | |
| 2756 void | |
| 2757 lto_output_init_mode_table (void) | |
| 2758 { | |
| 2759 memset (streamer_mode_table, '\0', MAX_MACHINE_MODE); | |
| 2760 } | |
| 2761 | |
| 2762 | |
| 2763 /* Write the mode table. */ | |
| 2764 static void | |
| 2765 lto_write_mode_table (void) | |
| 2766 { | |
| 2767 struct output_block *ob; | |
| 2768 ob = create_output_block (LTO_section_mode_table); | |
| 2769 bitpack_d bp = bitpack_create (ob->main_stream); | |
| 2770 | |
| 2771 /* Ensure that for GET_MODE_INNER (m) != m we have | |
| 2772 also the inner mode marked. */ | |
| 2773 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++) | |
| 2774 if (streamer_mode_table[i]) | |
| 2775 { | |
| 2776 machine_mode m = (machine_mode) i; | |
| 2777 machine_mode inner_m = GET_MODE_INNER (m); | |
| 2778 if (inner_m != m) | |
| 2779 streamer_mode_table[(int) inner_m] = 1; | |
| 2780 } | |
| 2781 /* First stream modes that have GET_MODE_INNER (m) == m, | |
| 2782 so that we can refer to them afterwards. */ | |
| 2783 for (int pass = 0; pass < 2; pass++) | |
| 2784 for (int i = 0; i < (int) MAX_MACHINE_MODE; i++) | |
| 2785 if (streamer_mode_table[i] && i != (int) VOIDmode && i != (int) BLKmode) | |
| 2786 { | |
| 2787 machine_mode m = (machine_mode) i; | |
| 2788 if ((GET_MODE_INNER (m) == m) ^ (pass == 0)) | |
| 2789 continue; | |
| 2790 bp_pack_value (&bp, m, 8); | |
| 2791 bp_pack_enum (&bp, mode_class, MAX_MODE_CLASS, GET_MODE_CLASS (m)); | |
| 131 | 2792 bp_pack_poly_value (&bp, GET_MODE_SIZE (m), 16); |
| 2793 bp_pack_poly_value (&bp, GET_MODE_PRECISION (m), 16); | |
| 111 | 2794 bp_pack_value (&bp, GET_MODE_INNER (m), 8); |
| 131 | 2795 bp_pack_poly_value (&bp, GET_MODE_NUNITS (m), 16); |
| 111 | 2796 switch (GET_MODE_CLASS (m)) |
| 2797 { | |
| 2798 case MODE_FRACT: | |
| 2799 case MODE_UFRACT: | |
| 2800 case MODE_ACCUM: | |
| 2801 case MODE_UACCUM: | |
| 2802 bp_pack_value (&bp, GET_MODE_IBIT (m), 8); | |
| 2803 bp_pack_value (&bp, GET_MODE_FBIT (m), 8); | |
| 2804 break; | |
| 2805 case MODE_FLOAT: | |
| 2806 case MODE_DECIMAL_FLOAT: | |
| 2807 bp_pack_string (ob, &bp, REAL_MODE_FORMAT (m)->name, true); | |
| 2808 break; | |
| 2809 default: | |
| 2810 break; | |
| 2811 } | |
| 2812 bp_pack_string (ob, &bp, GET_MODE_NAME (m), true); | |
| 2813 } | |
| 2814 bp_pack_value (&bp, VOIDmode, 8); | |
| 2815 | |
| 2816 streamer_write_bitpack (&bp); | |
| 2817 | |
| 2818 char *section_name | |
| 2819 = lto_get_section_name (LTO_section_mode_table, NULL, NULL); | |
| 2820 lto_begin_section (section_name, !flag_wpa); | |
| 2821 free (section_name); | |
| 2822 | |
| 2823 /* The entire header stream is computed here. */ | |
| 2824 struct lto_simple_header_with_strings header; | |
| 2825 memset (&header, 0, sizeof (header)); | |
| 2826 | |
| 2827 /* Write the header. */ | |
| 2828 header.major_version = LTO_major_version; | |
| 2829 header.minor_version = LTO_minor_version; | |
| 2830 | |
| 2831 header.main_size = ob->main_stream->total_size; | |
| 2832 header.string_size = ob->string_stream->total_size; | |
| 2833 lto_write_data (&header, sizeof header); | |
| 2834 | |
| 2835 /* Put all of the gimple and the string table out the asm file as a | |
| 2836 block of text. */ | |
| 2837 lto_write_stream (ob->main_stream); | |
| 2838 lto_write_stream (ob->string_stream); | |
| 2839 | |
| 2840 lto_end_section (); | |
| 2841 destroy_output_block (ob); | |
| 2842 } | |
| 2843 | |
| 2844 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2845 /* This pass is run after all of the functions are serialized and all |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2846 of the IPA passes have written their serialized forms. This pass |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2847 causes the vector of all of the global decls and types used from |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2848 this file to be written in to a section that can then be read in to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2849 recover these on other side. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2850 |
| 111 | 2851 void |
| 2852 produce_asm_for_decls (void) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2853 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2854 struct lto_out_decl_state *out_state; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2855 struct lto_out_decl_state *fn_out_state; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2856 struct lto_decl_header header; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2857 char *section_name; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2858 struct output_block *ob; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2859 unsigned idx, num_fns; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2860 size_t decl_state_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2861 int32_t num_decl_states; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2862 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2863 ob = create_output_block (LTO_section_decls); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2864 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2865 memset (&header, 0, sizeof (struct lto_decl_header)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2866 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2867 section_name = lto_get_section_name (LTO_section_decls, NULL, NULL); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2868 lto_begin_section (section_name, !flag_wpa); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2869 free (section_name); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2870 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2871 /* Make string 0 be a NULL string. */ |
| 111 | 2872 streamer_write_char_stream (ob->string_stream, 0); |
| 2873 | |
| 2874 gcc_assert (!alias_pairs); | |
| 2875 | |
| 2876 /* Get rid of the global decl state hash tables to save some memory. */ | |
| 2877 out_state = lto_get_out_decl_state (); | |
| 2878 for (int i = 0; i < LTO_N_DECL_STREAMS; i++) | |
| 2879 if (out_state->streams[i].tree_hash_table) | |
| 2880 { | |
| 2881 delete out_state->streams[i].tree_hash_table; | |
| 2882 out_state->streams[i].tree_hash_table = NULL; | |
| 2883 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2884 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2885 /* Write the global symbols. */ |
| 131 | 2886 if (streamer_dump_file) |
| 2887 fprintf (streamer_dump_file, "Outputting global stream\n"); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2888 lto_output_decl_state_streams (ob, out_state); |
| 111 | 2889 num_fns = lto_function_decl_states.length (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2890 for (idx = 0; idx < num_fns; idx++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2891 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2892 fn_out_state = |
| 111 | 2893 lto_function_decl_states[idx]; |
| 131 | 2894 if (streamer_dump_file) |
| 2895 fprintf (streamer_dump_file, "Outputting stream for %s\n", | |
| 2896 IDENTIFIER_POINTER | |
| 2897 (DECL_ASSEMBLER_NAME (fn_out_state->fn_decl))); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2898 lto_output_decl_state_streams (ob, fn_out_state); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2899 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2900 |
| 111 | 2901 header.major_version = LTO_major_version; |
| 2902 header.minor_version = LTO_minor_version; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2903 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2904 /* Currently not used. This field would allow us to preallocate |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2905 the globals vector, so that it need not be resized as it is extended. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2906 header.num_nodes = -1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2907 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2908 /* Compute the total size of all decl out states. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2909 decl_state_size = sizeof (int32_t); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2910 decl_state_size += lto_out_decl_state_written_size (out_state); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2911 for (idx = 0; idx < num_fns; idx++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2912 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2913 fn_out_state = |
| 111 | 2914 lto_function_decl_states[idx]; |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2915 decl_state_size += lto_out_decl_state_written_size (fn_out_state); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2916 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2917 header.decl_state_size = decl_state_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2918 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2919 header.main_size = ob->main_stream->total_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2920 header.string_size = ob->string_stream->total_size; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2921 |
| 111 | 2922 lto_write_data (&header, sizeof header); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2923 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2924 /* Write the main out-decl state, followed by out-decl states of |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2925 functions. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2926 num_decl_states = num_fns + 1; |
| 111 | 2927 lto_write_data (&num_decl_states, sizeof (num_decl_states)); |
| 2928 lto_output_decl_state_refs (ob, out_state); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2929 for (idx = 0; idx < num_fns; idx++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2930 { |
| 111 | 2931 fn_out_state = lto_function_decl_states[idx]; |
| 2932 lto_output_decl_state_refs (ob, fn_out_state); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2933 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2934 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2935 lto_write_stream (ob->main_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2936 lto_write_stream (ob->string_stream); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2937 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2938 lto_end_section (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2939 |
|
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2940 /* Write the symbol table. It is used by linker to determine dependencies |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2941 and thus we can skip it for WPA. */ |
|
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
2942 if (!flag_wpa) |
| 111 | 2943 produce_symtab (ob); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2944 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2945 /* Write command line opts. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2946 lto_write_options (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2947 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2948 /* Deallocate memory and clean up. */ |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2949 for (idx = 0; idx < num_fns; idx++) |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2950 { |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2951 fn_out_state = |
| 111 | 2952 lto_function_decl_states[idx]; |
|
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2953 lto_delete_out_decl_state (fn_out_state); |
|
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
2954 } |
| 111 | 2955 lto_symtab_encoder_delete (ob->decl_state->symtab_node_encoder); |
| 2956 lto_function_decl_states.release (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2957 destroy_output_block (ob); |
| 111 | 2958 if (lto_stream_offload_p) |
| 2959 lto_write_mode_table (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2960 } |