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