Mercurial > hg > CbC > CbC_gcc
annotate gcc/lto-streamer-out.c @ 128:fe568345ddd5
fix CbC-example
| author | mir3636 |
|---|---|
| date | Wed, 11 Apr 2018 19:32:28 +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 } |