Mercurial > hg > CbC > CbC_gcc
annotate gcc/cgraphunit.c @ 55:77e2b8dfacca gcc-4.4.5
update it from 4.4.3 to 4.5.0
| author | ryoma <e075725@ie.u-ryukyu.ac.jp> |
|---|---|
| date | Fri, 12 Feb 2010 23:39:51 +0900 |
| parents | 855418dad1a3 |
| children | b7f97abdc517 |
| rev | line source |
|---|---|
| 0 | 1 /* Callgraph based interprocedural optimizations. |
| 2 Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009 | |
| 3 Free Software Foundation, Inc. | |
| 4 Contributed by Jan Hubicka | |
| 5 | |
| 6 This file is part of GCC. | |
| 7 | |
| 8 GCC is free software; you can redistribute it and/or modify it under | |
| 9 the terms of the GNU General Public License as published by the Free | |
| 10 Software Foundation; either version 3, or (at your option) any later | |
| 11 version. | |
| 12 | |
| 13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY | |
| 14 WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
| 15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
| 16 for more details. | |
| 17 | |
| 18 You should have received a copy of the GNU General Public License | |
| 19 along with GCC; see the file COPYING3. If not see | |
| 20 <http://www.gnu.org/licenses/>. */ | |
| 21 | |
| 22 /* This module implements main driver of compilation process as well as | |
| 23 few basic interprocedural optimizers. | |
| 24 | |
| 25 The main scope of this file is to act as an interface in between | |
| 26 tree based frontends and the backend (and middle end) | |
| 27 | |
| 28 The front-end is supposed to use following functionality: | |
| 29 | |
| 30 - cgraph_finalize_function | |
| 31 | |
| 32 This function is called once front-end has parsed whole body of function | |
| 33 and it is certain that the function body nor the declaration will change. | |
| 34 | |
| 35 (There is one exception needed for implementing GCC extern inline | |
| 36 function.) | |
| 37 | |
| 38 - varpool_finalize_variable | |
| 39 | |
| 40 This function has same behavior as the above but is used for static | |
| 41 variables. | |
| 42 | |
| 43 - cgraph_finalize_compilation_unit | |
| 44 | |
| 45 This function is called once (source level) compilation unit is finalized | |
| 46 and it will no longer change. | |
| 47 | |
| 48 In the the call-graph construction and local function | |
| 49 analysis takes place here. Bodies of unreachable functions are released | |
| 50 to conserve memory usage. | |
| 51 | |
| 52 The function can be called multiple times when multiple source level | |
| 53 compilation units are combined (such as in C frontend) | |
| 54 | |
| 55 - cgraph_optimize | |
| 56 | |
| 57 In this unit-at-a-time compilation the intra procedural analysis takes | |
| 58 place here. In particular the static functions whose address is never | |
| 59 taken are marked as local. Backend can then use this information to | |
| 60 modify calling conventions, do better inlining or similar optimizations. | |
| 61 | |
| 62 - cgraph_mark_needed_node | |
| 63 - varpool_mark_needed_node | |
| 64 | |
| 65 When function or variable is referenced by some hidden way the call-graph | |
| 66 data structure must be updated accordingly by this function. | |
| 67 There should be little need to call this function and all the references | |
| 68 should be made explicit to cgraph code. At present these functions are | |
| 69 used by C++ frontend to explicitly mark the keyed methods. | |
| 70 | |
| 71 - analyze_expr callback | |
| 72 | |
| 73 This function is responsible for lowering tree nodes not understood by | |
| 74 generic code into understandable ones or alternatively marking | |
| 75 callgraph and varpool nodes referenced by the as needed. | |
| 76 | |
| 77 ??? On the tree-ssa genericizing should take place here and we will avoid | |
| 78 need for these hooks (replacing them by genericizing hook) | |
| 79 | |
| 80 Analyzing of all functions is deferred | |
| 81 to cgraph_finalize_compilation_unit and expansion into cgraph_optimize. | |
| 82 | |
| 83 In cgraph_finalize_compilation_unit the reachable functions are | |
| 84 analyzed. During analysis the call-graph edges from reachable | |
| 85 functions are constructed and their destinations are marked as | |
| 86 reachable. References to functions and variables are discovered too | |
| 87 and variables found to be needed output to the assembly file. Via | |
| 88 mark_referenced call in assemble_variable functions referenced by | |
| 89 static variables are noticed too. | |
| 90 | |
| 91 The intra-procedural information is produced and its existence | |
| 92 indicated by global_info_ready. Once this flag is set it is impossible | |
| 93 to change function from !reachable to reachable and thus | |
| 94 assemble_variable no longer call mark_referenced. | |
| 95 | |
| 96 Finally the call-graph is topologically sorted and all reachable functions | |
| 97 that has not been completely inlined or are not external are output. | |
| 98 | |
| 99 ??? It is possible that reference to function or variable is optimized | |
| 100 out. We can not deal with this nicely because topological order is not | |
| 101 suitable for it. For tree-ssa we may consider another pass doing | |
| 102 optimization and re-discovering reachable functions. | |
| 103 | |
| 104 ??? Reorganize code so variables are output very last and only if they | |
| 105 really has been referenced by produced code, so we catch more cases | |
| 106 where reference has been optimized out. */ | |
| 107 | |
| 108 | |
| 109 #include "config.h" | |
| 110 #include "system.h" | |
| 111 #include "coretypes.h" | |
| 112 #include "tm.h" | |
| 113 #include "tree.h" | |
| 114 #include "rtl.h" | |
| 115 #include "tree-flow.h" | |
| 116 #include "tree-inline.h" | |
| 117 #include "langhooks.h" | |
| 118 #include "pointer-set.h" | |
| 119 #include "toplev.h" | |
| 120 #include "flags.h" | |
| 121 #include "ggc.h" | |
| 122 #include "debug.h" | |
| 123 #include "target.h" | |
| 124 #include "cgraph.h" | |
| 125 #include "diagnostic.h" | |
| 126 #include "timevar.h" | |
| 127 #include "params.h" | |
| 128 #include "fibheap.h" | |
| 129 #include "intl.h" | |
| 130 #include "function.h" | |
| 131 #include "ipa-prop.h" | |
| 132 #include "gimple.h" | |
| 133 #include "tree-iterator.h" | |
| 134 #include "tree-pass.h" | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
135 #include "tree-dump.h" |
| 0 | 136 #include "output.h" |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
137 #include "coverage.h" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
138 #include "plugin.h" |
| 0 | 139 |
| 140 static void cgraph_expand_all_functions (void); | |
| 141 static void cgraph_mark_functions_to_output (void); | |
| 142 static void cgraph_expand_function (struct cgraph_node *); | |
| 143 static void cgraph_output_pending_asms (void); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
144 static void cgraph_analyze_function (struct cgraph_node *); |
| 0 | 145 |
| 146 static FILE *cgraph_dump_file; | |
| 147 | |
| 148 /* A vector of FUNCTION_DECLs declared as static constructors. */ | |
| 149 static GTY (()) VEC(tree, gc) *static_ctors; | |
| 150 /* A vector of FUNCTION_DECLs declared as static destructors. */ | |
| 151 static GTY (()) VEC(tree, gc) *static_dtors; | |
| 152 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
153 /* Used for vtable lookup in thunk adjusting. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
154 static GTY (()) tree vtable_entry_type; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
155 |
| 0 | 156 /* When target does not have ctors and dtors, we call all constructor |
| 157 and destructor by special initialization/destruction function | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
158 recognized by collect2. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
159 |
| 0 | 160 When we are going to build this function, collect all constructors and |
| 161 destructors and turn them into normal functions. */ | |
| 162 | |
| 163 static void | |
| 164 record_cdtor_fn (tree fndecl) | |
| 165 { | |
| 166 struct cgraph_node *node; | |
| 167 if (targetm.have_ctors_dtors | |
| 168 || (!DECL_STATIC_CONSTRUCTOR (fndecl) | |
| 169 && !DECL_STATIC_DESTRUCTOR (fndecl))) | |
| 170 return; | |
| 171 | |
| 172 if (DECL_STATIC_CONSTRUCTOR (fndecl)) | |
| 173 { | |
| 174 VEC_safe_push (tree, gc, static_ctors, fndecl); | |
| 175 DECL_STATIC_CONSTRUCTOR (fndecl) = 0; | |
| 176 } | |
| 177 if (DECL_STATIC_DESTRUCTOR (fndecl)) | |
| 178 { | |
| 179 VEC_safe_push (tree, gc, static_dtors, fndecl); | |
| 180 DECL_STATIC_DESTRUCTOR (fndecl) = 0; | |
| 181 } | |
| 182 node = cgraph_node (fndecl); | |
| 183 node->local.disregard_inline_limits = 1; | |
| 184 cgraph_mark_reachable_node (node); | |
| 185 } | |
| 186 | |
| 187 /* Define global constructors/destructor functions for the CDTORS, of | |
| 188 which they are LEN. The CDTORS are sorted by initialization | |
| 189 priority. If CTOR_P is true, these are constructors; otherwise, | |
| 190 they are destructors. */ | |
| 191 | |
| 192 static void | |
| 193 build_cdtor (bool ctor_p, tree *cdtors, size_t len) | |
| 194 { | |
| 195 size_t i; | |
| 196 | |
| 197 i = 0; | |
| 198 while (i < len) | |
| 199 { | |
| 200 tree body; | |
| 201 tree fn; | |
| 202 priority_type priority; | |
| 203 | |
| 204 priority = 0; | |
| 205 body = NULL_TREE; | |
| 206 /* Find the next batch of constructors/destructors with the same | |
| 207 initialization priority. */ | |
| 208 do | |
| 209 { | |
| 210 priority_type p; | |
| 211 fn = cdtors[i]; | |
| 212 p = ctor_p ? DECL_INIT_PRIORITY (fn) : DECL_FINI_PRIORITY (fn); | |
| 213 if (!body) | |
| 214 priority = p; | |
| 215 else if (p != priority) | |
| 216 break; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
217 append_to_statement_list (build_function_call_expr (UNKNOWN_LOCATION, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
218 fn, 0), |
| 0 | 219 &body); |
| 220 ++i; | |
| 221 } | |
| 222 while (i < len); | |
| 223 gcc_assert (body != NULL_TREE); | |
| 224 /* Generate a function to call all the function of like | |
| 225 priority. */ | |
| 226 cgraph_build_static_cdtor (ctor_p ? 'I' : 'D', body, priority); | |
| 227 } | |
| 228 } | |
| 229 | |
| 230 /* Comparison function for qsort. P1 and P2 are actually of type | |
| 231 "tree *" and point to static constructors. DECL_INIT_PRIORITY is | |
| 232 used to determine the sort order. */ | |
| 233 | |
| 234 static int | |
| 235 compare_ctor (const void *p1, const void *p2) | |
| 236 { | |
| 237 tree f1; | |
| 238 tree f2; | |
| 239 int priority1; | |
| 240 int priority2; | |
| 241 | |
| 242 f1 = *(const tree *)p1; | |
| 243 f2 = *(const tree *)p2; | |
| 244 priority1 = DECL_INIT_PRIORITY (f1); | |
| 245 priority2 = DECL_INIT_PRIORITY (f2); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
246 |
| 0 | 247 if (priority1 < priority2) |
| 248 return -1; | |
| 249 else if (priority1 > priority2) | |
| 250 return 1; | |
| 251 else | |
| 252 /* Ensure a stable sort. */ | |
| 253 return (const tree *)p1 - (const tree *)p2; | |
| 254 } | |
| 255 | |
| 256 /* Comparison function for qsort. P1 and P2 are actually of type | |
| 257 "tree *" and point to static destructors. DECL_FINI_PRIORITY is | |
| 258 used to determine the sort order. */ | |
| 259 | |
| 260 static int | |
| 261 compare_dtor (const void *p1, const void *p2) | |
| 262 { | |
| 263 tree f1; | |
| 264 tree f2; | |
| 265 int priority1; | |
| 266 int priority2; | |
| 267 | |
| 268 f1 = *(const tree *)p1; | |
| 269 f2 = *(const tree *)p2; | |
| 270 priority1 = DECL_FINI_PRIORITY (f1); | |
| 271 priority2 = DECL_FINI_PRIORITY (f2); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
272 |
| 0 | 273 if (priority1 < priority2) |
| 274 return -1; | |
| 275 else if (priority1 > priority2) | |
| 276 return 1; | |
| 277 else | |
| 278 /* Ensure a stable sort. */ | |
| 279 return (const tree *)p1 - (const tree *)p2; | |
| 280 } | |
| 281 | |
| 282 /* Generate functions to call static constructors and destructors | |
| 283 for targets that do not support .ctors/.dtors sections. These | |
| 284 functions have magic names which are detected by collect2. */ | |
| 285 | |
| 286 static void | |
| 287 cgraph_build_cdtor_fns (void) | |
| 288 { | |
| 289 if (!VEC_empty (tree, static_ctors)) | |
| 290 { | |
| 291 gcc_assert (!targetm.have_ctors_dtors); | |
| 292 qsort (VEC_address (tree, static_ctors), | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
293 VEC_length (tree, static_ctors), |
| 0 | 294 sizeof (tree), |
| 295 compare_ctor); | |
| 296 build_cdtor (/*ctor_p=*/true, | |
| 297 VEC_address (tree, static_ctors), | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
298 VEC_length (tree, static_ctors)); |
| 0 | 299 VEC_truncate (tree, static_ctors, 0); |
| 300 } | |
| 301 | |
| 302 if (!VEC_empty (tree, static_dtors)) | |
| 303 { | |
| 304 gcc_assert (!targetm.have_ctors_dtors); | |
| 305 qsort (VEC_address (tree, static_dtors), | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
306 VEC_length (tree, static_dtors), |
| 0 | 307 sizeof (tree), |
| 308 compare_dtor); | |
| 309 build_cdtor (/*ctor_p=*/false, | |
| 310 VEC_address (tree, static_dtors), | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
311 VEC_length (tree, static_dtors)); |
| 0 | 312 VEC_truncate (tree, static_dtors, 0); |
| 313 } | |
| 314 } | |
| 315 | |
| 316 /* Determine if function DECL is needed. That is, visible to something | |
| 317 either outside this translation unit, something magic in the system | |
| 318 configury. */ | |
| 319 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
320 bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
321 cgraph_decide_is_function_needed (struct cgraph_node *node, tree decl) |
| 0 | 322 { |
| 323 /* If the user told us it is used, then it must be so. */ | |
| 324 if (node->local.externally_visible) | |
| 325 return true; | |
| 326 | |
| 327 /* ??? If the assembler name is set by hand, it is possible to assemble | |
| 328 the name later after finalizing the function and the fact is noticed | |
| 329 in assemble_name then. This is arguably a bug. */ | |
| 330 if (DECL_ASSEMBLER_NAME_SET_P (decl) | |
| 331 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))) | |
| 332 return true; | |
| 333 | |
| 334 /* With -fkeep-inline-functions we are keeping all inline functions except | |
| 335 for extern inline ones. */ | |
| 336 if (flag_keep_inline_functions | |
| 337 && DECL_DECLARED_INLINE_P (decl) | |
| 338 && !DECL_EXTERNAL (decl) | |
| 339 && !lookup_attribute ("always_inline", DECL_ATTRIBUTES (decl))) | |
| 340 return true; | |
| 341 | |
| 342 /* If we decided it was needed before, but at the time we didn't have | |
| 343 the body of the function available, then it's still needed. We have | |
| 344 to go back and re-check its dependencies now. */ | |
| 345 if (node->needed) | |
| 346 return true; | |
| 347 | |
| 348 /* Externally visible functions must be output. The exception is | |
| 349 COMDAT functions that must be output only when they are needed. | |
| 350 | |
| 351 When not optimizing, also output the static functions. (see | |
| 352 PR24561), but don't do so for always_inline functions, functions | |
| 353 declared inline and nested functions. These was optimized out | |
| 354 in the original implementation and it is unclear whether we want | |
| 355 to change the behavior here. */ | |
| 356 if (((TREE_PUBLIC (decl) | |
| 357 || (!optimize && !node->local.disregard_inline_limits | |
| 358 && !DECL_DECLARED_INLINE_P (decl) | |
| 359 && !node->origin)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
360 && !flag_whole_program |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
361 && !flag_lto |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
362 && !flag_whopr) |
| 0 | 363 && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl)) |
| 364 return true; | |
| 365 | |
| 366 /* Constructors and destructors are reachable from the runtime by | |
| 367 some mechanism. */ | |
| 368 if (DECL_STATIC_CONSTRUCTOR (decl) || DECL_STATIC_DESTRUCTOR (decl)) | |
| 369 return true; | |
| 370 | |
| 371 return false; | |
| 372 } | |
| 373 | |
| 374 /* Process CGRAPH_NEW_FUNCTIONS and perform actions necessary to add these | |
| 375 functions into callgraph in a way so they look like ordinary reachable | |
| 376 functions inserted into callgraph already at construction time. */ | |
| 377 | |
| 378 bool | |
| 379 cgraph_process_new_functions (void) | |
| 380 { | |
| 381 bool output = false; | |
| 382 tree fndecl; | |
| 383 struct cgraph_node *node; | |
| 384 | |
| 385 /* Note that this queue may grow as its being processed, as the new | |
| 386 functions may generate new ones. */ | |
| 387 while (cgraph_new_nodes) | |
| 388 { | |
| 389 node = cgraph_new_nodes; | |
| 390 fndecl = node->decl; | |
| 391 cgraph_new_nodes = cgraph_new_nodes->next_needed; | |
| 392 switch (cgraph_state) | |
| 393 { | |
| 394 case CGRAPH_STATE_CONSTRUCTION: | |
| 395 /* At construction time we just need to finalize function and move | |
| 396 it into reachable functions list. */ | |
| 397 | |
| 398 node->next_needed = NULL; | |
| 399 cgraph_finalize_function (fndecl, false); | |
| 400 cgraph_mark_reachable_node (node); | |
| 401 output = true; | |
| 402 break; | |
| 403 | |
| 404 case CGRAPH_STATE_IPA: | |
| 405 case CGRAPH_STATE_IPA_SSA: | |
| 406 /* When IPA optimization already started, do all essential | |
| 407 transformations that has been already performed on the whole | |
| 408 cgraph but not on this function. */ | |
| 409 | |
| 410 gimple_register_cfg_hooks (); | |
| 411 if (!node->analyzed) | |
| 412 cgraph_analyze_function (node); | |
| 413 push_cfun (DECL_STRUCT_FUNCTION (fndecl)); | |
| 414 current_function_decl = fndecl; | |
| 415 compute_inline_parameters (node); | |
| 416 if ((cgraph_state == CGRAPH_STATE_IPA_SSA | |
| 417 && !gimple_in_ssa_p (DECL_STRUCT_FUNCTION (fndecl))) | |
| 418 /* When not optimizing, be sure we run early local passes anyway | |
| 419 to expand OMP. */ | |
| 420 || !optimize) | |
| 421 execute_pass_list (pass_early_local_passes.pass.sub); | |
| 422 free_dominance_info (CDI_POST_DOMINATORS); | |
| 423 free_dominance_info (CDI_DOMINATORS); | |
| 424 pop_cfun (); | |
| 425 current_function_decl = NULL; | |
| 426 break; | |
| 427 | |
| 428 case CGRAPH_STATE_EXPANSION: | |
| 429 /* Functions created during expansion shall be compiled | |
| 430 directly. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
431 node->process = 0; |
| 0 | 432 cgraph_expand_function (node); |
| 433 break; | |
| 434 | |
| 435 default: | |
| 436 gcc_unreachable (); | |
| 437 break; | |
| 438 } | |
| 439 cgraph_call_function_insertion_hooks (node); | |
| 440 } | |
| 441 return output; | |
| 442 } | |
| 443 | |
| 444 /* As an GCC extension we allow redefinition of the function. The | |
| 445 semantics when both copies of bodies differ is not well defined. | |
| 446 We replace the old body with new body so in unit at a time mode | |
| 447 we always use new body, while in normal mode we may end up with | |
| 448 old body inlined into some functions and new body expanded and | |
| 449 inlined in others. | |
| 450 | |
| 451 ??? It may make more sense to use one body for inlining and other | |
| 452 body for expanding the function but this is difficult to do. */ | |
| 453 | |
| 454 static void | |
| 455 cgraph_reset_node (struct cgraph_node *node) | |
| 456 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
457 /* If node->process is set, then we have already begun whole-unit analysis. |
| 0 | 458 This is *not* testing for whether we've already emitted the function. |
| 459 That case can be sort-of legitimately seen with real function redefinition | |
| 460 errors. I would argue that the front end should never present us with | |
| 461 such a case, but don't enforce that for now. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
462 gcc_assert (!node->process); |
| 0 | 463 |
| 464 /* Reset our data structures so we can analyze the function again. */ | |
| 465 memset (&node->local, 0, sizeof (node->local)); | |
| 466 memset (&node->global, 0, sizeof (node->global)); | |
| 467 memset (&node->rtl, 0, sizeof (node->rtl)); | |
| 468 node->analyzed = false; | |
| 469 node->local.redefined_extern_inline = true; | |
| 470 node->local.finalized = false; | |
| 471 | |
| 472 cgraph_node_remove_callees (node); | |
| 473 | |
| 474 /* We may need to re-queue the node for assembling in case | |
| 475 we already proceeded it and ignored as not needed or got | |
| 476 a re-declaration in IMA mode. */ | |
| 477 if (node->reachable) | |
| 478 { | |
| 479 struct cgraph_node *n; | |
| 480 | |
| 481 for (n = cgraph_nodes_queue; n; n = n->next_needed) | |
| 482 if (n == node) | |
| 483 break; | |
| 484 if (!n) | |
| 485 node->reachable = 0; | |
| 486 } | |
| 487 } | |
| 488 | |
| 489 static void | |
| 490 cgraph_lower_function (struct cgraph_node *node) | |
| 491 { | |
| 492 if (node->lowered) | |
| 493 return; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
494 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
495 if (node->nested) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
496 lower_nested_functions (node->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
497 gcc_assert (!node->nested); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
498 |
| 0 | 499 tree_lowering_passes (node->decl); |
| 500 node->lowered = true; | |
| 501 } | |
| 502 | |
| 503 /* DECL has been parsed. Take it, queue it, compile it at the whim of the | |
| 504 logic in effect. If NESTED is true, then our caller cannot stand to have | |
| 505 the garbage collector run at the moment. We would need to either create | |
| 506 a new GC context, or just not compile right now. */ | |
| 507 | |
| 508 void | |
| 509 cgraph_finalize_function (tree decl, bool nested) | |
| 510 { | |
| 511 struct cgraph_node *node = cgraph_node (decl); | |
| 512 | |
| 513 if (node->local.finalized) | |
| 514 cgraph_reset_node (node); | |
| 515 | |
| 516 node->pid = cgraph_max_pid ++; | |
| 517 notice_global_symbol (decl); | |
| 518 node->local.finalized = true; | |
| 519 node->lowered = DECL_STRUCT_FUNCTION (decl)->cfg != NULL; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
520 node->finalized_by_frontend = true; |
| 0 | 521 record_cdtor_fn (node->decl); |
| 522 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
523 if (cgraph_decide_is_function_needed (node, decl)) |
| 0 | 524 cgraph_mark_needed_node (node); |
| 525 | |
| 526 /* Since we reclaim unreachable nodes at the end of every language | |
| 527 level unit, we need to be conservative about possible entry points | |
| 528 there. */ | |
| 529 if ((TREE_PUBLIC (decl) && !DECL_COMDAT (decl) && !DECL_EXTERNAL (decl))) | |
| 530 cgraph_mark_reachable_node (node); | |
| 531 | |
| 532 /* If we've not yet emitted decl, tell the debug info about it. */ | |
| 533 if (!TREE_ASM_WRITTEN (decl)) | |
| 534 (*debug_hooks->deferred_inline_function) (decl); | |
| 535 | |
| 536 /* Possibly warn about unused parameters. */ | |
| 537 if (warn_unused_parameter) | |
| 538 do_warn_unused_parameter (decl); | |
| 539 | |
| 540 if (!nested) | |
| 541 ggc_collect (); | |
| 542 } | |
| 543 | |
| 544 /* C99 extern inline keywords allow changing of declaration after function | |
| 545 has been finalized. We need to re-decide if we want to mark the function as | |
| 546 needed then. */ | |
| 547 | |
| 548 void | |
| 549 cgraph_mark_if_needed (tree decl) | |
| 550 { | |
| 551 struct cgraph_node *node = cgraph_node (decl); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
552 if (node->local.finalized && cgraph_decide_is_function_needed (node, decl)) |
| 0 | 553 cgraph_mark_needed_node (node); |
| 554 } | |
| 555 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
556 /* Return TRUE if NODE2 is equivalent to NODE or its clone. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
557 static bool |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
558 clone_of_p (struct cgraph_node *node, struct cgraph_node *node2) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
559 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
560 while (node != node2 && node2) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
561 node2 = node2->clone_of; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
562 return node2 != NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
563 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
564 |
| 0 | 565 /* Verify cgraph nodes of given cgraph node. */ |
| 566 void | |
| 567 verify_cgraph_node (struct cgraph_node *node) | |
| 568 { | |
| 569 struct cgraph_edge *e; | |
| 570 struct function *this_cfun = DECL_STRUCT_FUNCTION (node->decl); | |
| 571 struct function *saved_cfun = cfun; | |
| 572 basic_block this_block; | |
| 573 gimple_stmt_iterator gsi; | |
| 574 bool error_found = false; | |
| 575 | |
| 576 if (errorcount || sorrycount) | |
| 577 return; | |
| 578 | |
| 579 timevar_push (TV_CGRAPH_VERIFY); | |
| 580 /* debug_generic_stmt needs correct cfun */ | |
| 581 set_cfun (this_cfun); | |
| 582 for (e = node->callees; e; e = e->next_callee) | |
| 583 if (e->aux) | |
| 584 { | |
| 585 error ("aux field set for edge %s->%s", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
586 identifier_to_locale (cgraph_node_name (e->caller)), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
587 identifier_to_locale (cgraph_node_name (e->callee))); |
| 0 | 588 error_found = true; |
| 589 } | |
| 590 if (node->count < 0) | |
| 591 { | |
| 592 error ("Execution count is negative"); | |
| 593 error_found = true; | |
| 594 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
595 if (node->global.inlined_to && node->local.externally_visible) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
596 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
597 error ("Externally visible inline clone"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
598 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
599 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
600 if (node->global.inlined_to && node->address_taken) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
601 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
602 error ("Inline clone with address taken"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
603 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
604 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
605 if (node->global.inlined_to && node->needed) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
606 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
607 error ("Inline clone is needed"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
608 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
609 } |
| 0 | 610 for (e = node->callers; e; e = e->next_caller) |
| 611 { | |
| 612 if (e->count < 0) | |
| 613 { | |
| 614 error ("caller edge count is negative"); | |
| 615 error_found = true; | |
| 616 } | |
| 617 if (e->frequency < 0) | |
| 618 { | |
| 619 error ("caller edge frequency is negative"); | |
| 620 error_found = true; | |
| 621 } | |
| 622 if (e->frequency > CGRAPH_FREQ_MAX) | |
| 623 { | |
| 624 error ("caller edge frequency is too large"); | |
| 625 error_found = true; | |
| 626 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
627 if (gimple_has_body_p (e->caller->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
628 && !e->caller->global.inlined_to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
629 && (e->frequency |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
630 != compute_call_stmt_bb_frequency (e->caller->decl, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
631 gimple_bb (e->call_stmt)))) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
632 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
633 error ("caller edge frequency %i does not match BB freqency %i", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
634 e->frequency, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
635 compute_call_stmt_bb_frequency (e->caller->decl, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
636 gimple_bb (e->call_stmt))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
637 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
638 } |
| 0 | 639 if (!e->inline_failed) |
| 640 { | |
| 641 if (node->global.inlined_to | |
| 642 != (e->caller->global.inlined_to | |
| 643 ? e->caller->global.inlined_to : e->caller)) | |
| 644 { | |
| 645 error ("inlined_to pointer is wrong"); | |
| 646 error_found = true; | |
| 647 } | |
| 648 if (node->callers->next_caller) | |
| 649 { | |
| 650 error ("multiple inline callers"); | |
| 651 error_found = true; | |
| 652 } | |
| 653 } | |
| 654 else | |
| 655 if (node->global.inlined_to) | |
| 656 { | |
| 657 error ("inlined_to pointer set for noninline callers"); | |
| 658 error_found = true; | |
| 659 } | |
| 660 } | |
| 661 if (!node->callers && node->global.inlined_to) | |
| 662 { | |
| 663 error ("inlined_to pointer is set but no predecessors found"); | |
| 664 error_found = true; | |
| 665 } | |
| 666 if (node->global.inlined_to == node) | |
| 667 { | |
| 668 error ("inlined_to pointer refers to itself"); | |
| 669 error_found = true; | |
| 670 } | |
| 671 | |
| 672 if (!cgraph_node (node->decl)) | |
| 673 { | |
| 674 error ("node not found in cgraph_hash"); | |
| 675 error_found = true; | |
| 676 } | |
| 677 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
678 if (node->clone_of) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
679 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
680 struct cgraph_node *n; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
681 for (n = node->clone_of->clones; n; n = n->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
682 if (n == node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
683 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
684 if (!n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
685 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
686 error ("node has wrong clone_of"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
687 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
688 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
689 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
690 if (node->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
691 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
692 struct cgraph_node *n; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
693 for (n = node->clones; n; n = n->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
694 if (n->clone_of != node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
695 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
696 if (n) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
697 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
698 error ("node has wrong clone list"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
699 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
700 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
701 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
702 if ((node->prev_sibling_clone || node->next_sibling_clone) && !node->clone_of) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
703 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
704 error ("node is in clone list but it is not clone"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
705 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
706 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
707 if (!node->prev_sibling_clone && node->clone_of && node->clone_of->clones != node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
708 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
709 error ("node has wrong prev_clone pointer"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
710 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
711 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
712 if (node->prev_sibling_clone && node->prev_sibling_clone->next_sibling_clone != node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
713 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
714 error ("double linked list of clones corrupted"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
715 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
716 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
717 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
718 if (node->analyzed && gimple_has_body_p (node->decl) |
| 0 | 719 && !TREE_ASM_WRITTEN (node->decl) |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
720 && (!DECL_EXTERNAL (node->decl) || node->global.inlined_to) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
721 && !flag_wpa) |
| 0 | 722 { |
| 723 if (this_cfun->cfg) | |
| 724 { | |
| 725 /* The nodes we're interested in are never shared, so walk | |
| 726 the tree ignoring duplicates. */ | |
| 727 struct pointer_set_t *visited_nodes = pointer_set_create (); | |
| 728 /* Reach the trees by walking over the CFG, and note the | |
| 729 enclosing basic-blocks in the call edges. */ | |
| 730 FOR_EACH_BB_FN (this_block, this_cfun) | |
| 731 for (gsi = gsi_start_bb (this_block); | |
| 732 !gsi_end_p (gsi); | |
| 733 gsi_next (&gsi)) | |
| 734 { | |
| 735 gimple stmt = gsi_stmt (gsi); | |
| 736 tree decl; | |
| 737 if (is_gimple_call (stmt) && (decl = gimple_call_fndecl (stmt))) | |
| 738 { | |
| 739 struct cgraph_edge *e = cgraph_edge (node, stmt); | |
| 740 if (e) | |
| 741 { | |
| 742 if (e->aux) | |
| 743 { | |
| 744 error ("shared call_stmt:"); | |
| 745 debug_gimple_stmt (stmt); | |
| 746 error_found = true; | |
| 747 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
748 if (e->callee->same_body_alias) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
749 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
750 error ("edge points to same body alias:"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
751 debug_tree (e->callee->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
752 error_found = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
753 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
754 else if (!clone_of_p (cgraph_node (decl), e->callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
755 && !e->callee->global.inlined_to) |
| 0 | 756 { |
| 757 error ("edge points to wrong declaration:"); | |
| 758 debug_tree (e->callee->decl); | |
| 759 fprintf (stderr," Instead of:"); | |
| 760 debug_tree (decl); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
761 error_found = true; |
| 0 | 762 } |
| 763 e->aux = (void *)1; | |
| 764 } | |
| 765 else | |
| 766 { | |
| 767 error ("missing callgraph edge for call stmt:"); | |
| 768 debug_gimple_stmt (stmt); | |
| 769 error_found = true; | |
| 770 } | |
| 771 } | |
| 772 } | |
| 773 pointer_set_destroy (visited_nodes); | |
| 774 } | |
| 775 else | |
| 776 /* No CFG available?! */ | |
| 777 gcc_unreachable (); | |
| 778 | |
| 779 for (e = node->callees; e; e = e->next_callee) | |
| 780 { | |
| 781 if (!e->aux && !e->indirect_call) | |
| 782 { | |
| 783 error ("edge %s->%s has no corresponding call_stmt", | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
784 identifier_to_locale (cgraph_node_name (e->caller)), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
785 identifier_to_locale (cgraph_node_name (e->callee))); |
| 0 | 786 debug_gimple_stmt (e->call_stmt); |
| 787 error_found = true; | |
| 788 } | |
| 789 e->aux = 0; | |
| 790 } | |
| 791 } | |
| 792 if (error_found) | |
| 793 { | |
| 794 dump_cgraph_node (stderr, node); | |
| 795 internal_error ("verify_cgraph_node failed"); | |
| 796 } | |
| 797 set_cfun (saved_cfun); | |
| 798 timevar_pop (TV_CGRAPH_VERIFY); | |
| 799 } | |
| 800 | |
| 801 /* Verify whole cgraph structure. */ | |
| 802 void | |
| 803 verify_cgraph (void) | |
| 804 { | |
| 805 struct cgraph_node *node; | |
| 806 | |
| 807 if (sorrycount || errorcount) | |
| 808 return; | |
| 809 | |
| 810 for (node = cgraph_nodes; node; node = node->next) | |
| 811 verify_cgraph_node (node); | |
| 812 } | |
| 813 | |
| 814 /* Output all asm statements we have stored up to be output. */ | |
| 815 | |
| 816 static void | |
| 817 cgraph_output_pending_asms (void) | |
| 818 { | |
| 819 struct cgraph_asm_node *can; | |
| 820 | |
| 821 if (errorcount || sorrycount) | |
| 822 return; | |
| 823 | |
| 824 for (can = cgraph_asm_nodes; can; can = can->next) | |
| 825 assemble_asm (can->asm_str); | |
| 826 cgraph_asm_nodes = NULL; | |
| 827 } | |
| 828 | |
| 829 /* Analyze the function scheduled to be output. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
830 static void |
| 0 | 831 cgraph_analyze_function (struct cgraph_node *node) |
| 832 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
833 tree save = current_function_decl; |
| 0 | 834 tree decl = node->decl; |
| 835 | |
| 836 current_function_decl = decl; | |
| 837 push_cfun (DECL_STRUCT_FUNCTION (decl)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
838 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
839 /* Make sure to gimplify bodies only once. During analyzing a |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
840 function we lower it, which will require gimplified nested |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
841 functions, so we can end up here with an already gimplified |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
842 body. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
843 if (!gimple_body (decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
844 gimplify_function_tree (decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
845 dump_function (TDI_generic, decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
846 |
| 0 | 847 cgraph_lower_function (node); |
| 848 node->analyzed = true; | |
| 849 | |
| 850 pop_cfun (); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
851 current_function_decl = save; |
| 0 | 852 } |
| 853 | |
| 854 /* Look for externally_visible and used attributes and mark cgraph nodes | |
| 855 accordingly. | |
| 856 | |
| 857 We cannot mark the nodes at the point the attributes are processed (in | |
| 858 handle_*_attribute) because the copy of the declarations available at that | |
| 859 point may not be canonical. For example, in: | |
| 860 | |
| 861 void f(); | |
| 862 void f() __attribute__((used)); | |
| 863 | |
| 864 the declaration we see in handle_used_attribute will be the second | |
| 865 declaration -- but the front end will subsequently merge that declaration | |
| 866 with the original declaration and discard the second declaration. | |
| 867 | |
| 868 Furthermore, we can't mark these nodes in cgraph_finalize_function because: | |
| 869 | |
| 870 void f() {} | |
| 871 void f() __attribute__((externally_visible)); | |
| 872 | |
| 873 is valid. | |
| 874 | |
| 875 So, we walk the nodes at the end of the translation unit, applying the | |
| 876 attributes at that point. */ | |
| 877 | |
| 878 static void | |
| 879 process_function_and_variable_attributes (struct cgraph_node *first, | |
| 880 struct varpool_node *first_var) | |
| 881 { | |
| 882 struct cgraph_node *node; | |
| 883 struct varpool_node *vnode; | |
| 884 | |
| 885 for (node = cgraph_nodes; node != first; node = node->next) | |
| 886 { | |
| 887 tree decl = node->decl; | |
| 888 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl))) | |
| 889 { | |
| 890 mark_decl_referenced (decl); | |
| 891 if (node->local.finalized) | |
| 892 cgraph_mark_needed_node (node); | |
| 893 } | |
| 894 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl))) | |
| 895 { | |
| 896 if (! TREE_PUBLIC (node->decl)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
897 warning_at (DECL_SOURCE_LOCATION (node->decl), OPT_Wattributes, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
898 "%<externally_visible%>" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
899 " attribute have effect only on public objects"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
900 else if (node->local.finalized) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
901 cgraph_mark_needed_node (node); |
| 0 | 902 } |
| 903 } | |
| 904 for (vnode = varpool_nodes; vnode != first_var; vnode = vnode->next) | |
| 905 { | |
| 906 tree decl = vnode->decl; | |
| 907 if (lookup_attribute ("used", DECL_ATTRIBUTES (decl))) | |
| 908 { | |
| 909 mark_decl_referenced (decl); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
910 vnode->force_output = true; |
| 0 | 911 if (vnode->finalized) |
| 912 varpool_mark_needed_node (vnode); | |
| 913 } | |
| 914 if (lookup_attribute ("externally_visible", DECL_ATTRIBUTES (decl))) | |
| 915 { | |
| 916 if (! TREE_PUBLIC (vnode->decl)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
917 warning_at (DECL_SOURCE_LOCATION (vnode->decl), OPT_Wattributes, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
918 "%<externally_visible%>" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
919 " attribute have effect only on public objects"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
920 else if (vnode->finalized) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
921 varpool_mark_needed_node (vnode); |
| 0 | 922 } |
| 923 } | |
| 924 } | |
| 925 | |
| 926 /* Process CGRAPH_NODES_NEEDED queue, analyze each function (and transitively | |
| 927 each reachable functions) and build cgraph. | |
| 928 The function can be called multiple times after inserting new nodes | |
| 929 into beginning of queue. Just the new part of queue is re-scanned then. */ | |
| 930 | |
| 931 static void | |
| 932 cgraph_analyze_functions (void) | |
| 933 { | |
| 934 /* Keep track of already processed nodes when called multiple times for | |
| 935 intermodule optimization. */ | |
| 936 static struct cgraph_node *first_analyzed; | |
| 937 struct cgraph_node *first_processed = first_analyzed; | |
| 938 static struct varpool_node *first_analyzed_var; | |
| 939 struct cgraph_node *node, *next; | |
| 940 | |
| 941 process_function_and_variable_attributes (first_processed, | |
| 942 first_analyzed_var); | |
| 943 first_processed = cgraph_nodes; | |
| 944 first_analyzed_var = varpool_nodes; | |
| 945 varpool_analyze_pending_decls (); | |
| 946 if (cgraph_dump_file) | |
| 947 { | |
| 948 fprintf (cgraph_dump_file, "Initial entry points:"); | |
| 949 for (node = cgraph_nodes; node != first_analyzed; node = node->next) | |
| 950 if (node->needed) | |
| 951 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node)); | |
| 952 fprintf (cgraph_dump_file, "\n"); | |
| 953 } | |
| 954 cgraph_process_new_functions (); | |
| 955 | |
| 956 /* Propagate reachability flag and lower representation of all reachable | |
| 957 functions. In the future, lowering will introduce new functions and | |
| 958 new entry points on the way (by template instantiation and virtual | |
| 959 method table generation for instance). */ | |
| 960 while (cgraph_nodes_queue) | |
| 961 { | |
| 962 struct cgraph_edge *edge; | |
| 963 tree decl = cgraph_nodes_queue->decl; | |
| 964 | |
| 965 node = cgraph_nodes_queue; | |
| 966 cgraph_nodes_queue = cgraph_nodes_queue->next_needed; | |
| 967 node->next_needed = NULL; | |
| 968 | |
| 969 /* ??? It is possible to create extern inline function and later using | |
| 970 weak alias attribute to kill its body. See | |
| 971 gcc.c-torture/compile/20011119-1.c */ | |
| 972 if (!DECL_STRUCT_FUNCTION (decl)) | |
| 973 { | |
| 974 cgraph_reset_node (node); | |
| 975 continue; | |
| 976 } | |
| 977 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
978 if (!node->analyzed) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
979 cgraph_analyze_function (node); |
| 0 | 980 |
| 981 for (edge = node->callees; edge; edge = edge->next_callee) | |
| 982 if (!edge->callee->reachable) | |
| 983 cgraph_mark_reachable_node (edge->callee); | |
| 984 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
985 if (node->same_comdat_group) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
986 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
987 for (next = node->same_comdat_group; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
988 next != node; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
989 next = next->same_comdat_group) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
990 cgraph_mark_reachable_node (next); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
991 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
992 |
| 0 | 993 /* If decl is a clone of an abstract function, mark that abstract |
| 994 function so that we don't release its body. The DECL_INITIAL() of that | |
| 995 abstract function declaration will be later needed to output debug info. */ | |
| 996 if (DECL_ABSTRACT_ORIGIN (decl)) | |
| 997 { | |
| 998 struct cgraph_node *origin_node = cgraph_node (DECL_ABSTRACT_ORIGIN (decl)); | |
| 999 origin_node->abstract_and_needed = true; | |
| 1000 } | |
| 1001 | |
| 1002 /* We finalize local static variables during constructing callgraph | |
| 1003 edges. Process their attributes too. */ | |
| 1004 process_function_and_variable_attributes (first_processed, | |
| 1005 first_analyzed_var); | |
| 1006 first_processed = cgraph_nodes; | |
| 1007 first_analyzed_var = varpool_nodes; | |
| 1008 varpool_analyze_pending_decls (); | |
| 1009 cgraph_process_new_functions (); | |
| 1010 } | |
| 1011 | |
| 1012 /* Collect entry points to the unit. */ | |
| 1013 if (cgraph_dump_file) | |
| 1014 { | |
| 1015 fprintf (cgraph_dump_file, "Unit entry points:"); | |
| 1016 for (node = cgraph_nodes; node != first_analyzed; node = node->next) | |
| 1017 if (node->needed) | |
| 1018 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node)); | |
| 1019 fprintf (cgraph_dump_file, "\n\nInitial "); | |
| 1020 dump_cgraph (cgraph_dump_file); | |
| 1021 } | |
| 1022 | |
| 1023 if (cgraph_dump_file) | |
| 1024 fprintf (cgraph_dump_file, "\nReclaiming functions:"); | |
| 1025 | |
| 1026 for (node = cgraph_nodes; node != first_analyzed; node = next) | |
| 1027 { | |
| 1028 tree decl = node->decl; | |
| 1029 next = node->next; | |
| 1030 | |
| 1031 if (node->local.finalized && !gimple_has_body_p (decl)) | |
| 1032 cgraph_reset_node (node); | |
| 1033 | |
| 1034 if (!node->reachable && gimple_has_body_p (decl)) | |
| 1035 { | |
| 1036 if (cgraph_dump_file) | |
| 1037 fprintf (cgraph_dump_file, " %s", cgraph_node_name (node)); | |
| 1038 cgraph_remove_node (node); | |
| 1039 continue; | |
| 1040 } | |
| 1041 else | |
| 1042 node->next_needed = NULL; | |
| 1043 gcc_assert (!node->local.finalized || gimple_has_body_p (decl)); | |
| 1044 gcc_assert (node->analyzed == node->local.finalized); | |
| 1045 } | |
| 1046 if (cgraph_dump_file) | |
| 1047 { | |
| 1048 fprintf (cgraph_dump_file, "\n\nReclaimed "); | |
| 1049 dump_cgraph (cgraph_dump_file); | |
| 1050 } | |
| 1051 first_analyzed = cgraph_nodes; | |
| 1052 ggc_collect (); | |
| 1053 } | |
| 1054 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1055 |
| 0 | 1056 /* Analyze the whole compilation unit once it is parsed completely. */ |
| 1057 | |
| 1058 void | |
| 1059 cgraph_finalize_compilation_unit (void) | |
| 1060 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1061 timevar_push (TV_CGRAPH); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1062 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1063 /* Do not skip analyzing the functions if there were errors, we |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1064 miss diagnostics for following functions otherwise. */ |
| 0 | 1065 |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1066 /* Emit size functions we didn't inline. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1067 finalize_size_functions (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1068 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1069 /* Call functions declared with the "constructor" or "destructor" |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1070 attribute. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1071 cgraph_build_cdtor_fns (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1072 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1073 /* Mark alias targets necessary and emit diagnostics. */ |
| 0 | 1074 finish_aliases_1 (); |
| 1075 | |
| 1076 if (!quiet_flag) | |
| 1077 { | |
| 1078 fprintf (stderr, "\nAnalyzing compilation unit\n"); | |
| 1079 fflush (stderr); | |
| 1080 } | |
| 1081 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1082 /* Gimplify and lower all functions, compute reachability and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1083 remove unreachable nodes. */ |
| 0 | 1084 cgraph_analyze_functions (); |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1085 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1086 /* Mark alias targets necessary and emit diagnostics. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1087 finish_aliases_1 (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1088 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1089 /* Gimplify and lower thunks. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1090 cgraph_analyze_functions (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1091 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1092 /* Finally drive the pass manager. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1093 cgraph_optimize (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1094 |
| 0 | 1095 timevar_pop (TV_CGRAPH); |
| 1096 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1097 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1098 |
| 0 | 1099 /* Figure out what functions we want to assemble. */ |
| 1100 | |
| 1101 static void | |
| 1102 cgraph_mark_functions_to_output (void) | |
| 1103 { | |
| 1104 struct cgraph_node *node; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1105 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1106 bool check_same_comdat_groups = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1107 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1108 for (node = cgraph_nodes; node; node = node->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1109 gcc_assert (!node->process); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1110 #endif |
| 0 | 1111 |
| 1112 for (node = cgraph_nodes; node; node = node->next) | |
| 1113 { | |
| 1114 tree decl = node->decl; | |
| 1115 struct cgraph_edge *e; | |
| 1116 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1117 gcc_assert (!node->process || node->same_comdat_group); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1118 if (node->process) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1119 continue; |
| 0 | 1120 |
| 1121 for (e = node->callers; e; e = e->next_caller) | |
| 1122 if (e->inline_failed) | |
| 1123 break; | |
| 1124 | |
| 1125 /* We need to output all local functions that are used and not | |
| 1126 always inlined, as well as those that are reachable from | |
| 1127 outside the current compilation unit. */ | |
| 1128 if (node->analyzed | |
| 1129 && !node->global.inlined_to | |
| 1130 && (node->needed | |
| 1131 || (e && node->reachable)) | |
| 1132 && !TREE_ASM_WRITTEN (decl) | |
| 1133 && !DECL_EXTERNAL (decl)) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1134 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1135 node->process = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1136 if (node->same_comdat_group) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1137 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1138 struct cgraph_node *next; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1139 for (next = node->same_comdat_group; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1140 next != node; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1141 next = next->same_comdat_group) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1142 next->process = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1143 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1144 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1145 else if (node->same_comdat_group) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1146 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1147 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1148 check_same_comdat_groups = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1149 #endif |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1150 } |
| 0 | 1151 else |
| 1152 { | |
| 1153 /* We should've reclaimed all functions that are not needed. */ | |
| 1154 #ifdef ENABLE_CHECKING | |
| 1155 if (!node->global.inlined_to | |
| 1156 && gimple_has_body_p (decl) | |
| 1157 && !DECL_EXTERNAL (decl)) | |
| 1158 { | |
| 1159 dump_cgraph_node (stderr, node); | |
| 1160 internal_error ("failed to reclaim unneeded function"); | |
| 1161 } | |
| 1162 #endif | |
| 1163 gcc_assert (node->global.inlined_to | |
| 1164 || !gimple_has_body_p (decl) | |
| 1165 || DECL_EXTERNAL (decl)); | |
| 1166 | |
| 1167 } | |
| 1168 | |
| 1169 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1170 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1171 if (check_same_comdat_groups) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1172 for (node = cgraph_nodes; node; node = node->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1173 if (node->same_comdat_group && !node->process) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1174 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1175 tree decl = node->decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1176 if (!node->global.inlined_to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1177 && gimple_has_body_p (decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1178 && !DECL_EXTERNAL (decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1179 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1180 dump_cgraph_node (stderr, node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1181 internal_error ("failed to reclaim unneeded function"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1182 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1183 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1184 #endif |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1185 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1186 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1187 /* DECL is FUNCTION_DECL. Initialize datastructures so DECL is a function |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1188 in lowered gimple form. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1189 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1190 Set current_function_decl and cfun to newly constructed empty function body. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1191 return basic block in the function body. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1192 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1193 static basic_block |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1194 init_lowered_empty_function (tree decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1195 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1196 basic_block bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1197 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1198 current_function_decl = decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1199 allocate_struct_function (decl, false); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1200 gimple_register_cfg_hooks (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1201 init_empty_tree_cfg (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1202 init_tree_ssa (cfun); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1203 init_ssa_operands (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1204 cfun->gimple_df->in_ssa_p = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1205 DECL_INITIAL (decl) = make_node (BLOCK); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1206 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1207 DECL_SAVED_TREE (decl) = error_mark_node; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1208 cfun->curr_properties |= |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1209 (PROP_gimple_lcf | PROP_gimple_leh | PROP_cfg | PROP_referenced_vars | |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1210 PROP_ssa); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1211 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1212 /* Create BB for body of the function and connect it properly. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1213 bb = create_basic_block (NULL, (void *) 0, ENTRY_BLOCK_PTR); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1214 make_edge (ENTRY_BLOCK_PTR, bb, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1215 make_edge (bb, EXIT_BLOCK_PTR, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1216 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1217 return bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1218 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1219 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1220 /* Adjust PTR by the constant FIXED_OFFSET, and by the vtable |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1221 offset indicated by VIRTUAL_OFFSET, if that is |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1222 non-null. THIS_ADJUSTING is nonzero for a this adjusting thunk and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1223 zero for a result adjusting thunk. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1224 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1225 static tree |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1226 thunk_adjust (gimple_stmt_iterator * bsi, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1227 tree ptr, bool this_adjusting, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1228 HOST_WIDE_INT fixed_offset, tree virtual_offset) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1229 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1230 gimple stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1231 tree ret; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1232 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1233 if (this_adjusting) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1234 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1235 stmt = gimple_build_assign (ptr, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1236 fold_build2_loc (input_location, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1237 POINTER_PLUS_EXPR, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1238 TREE_TYPE (ptr), ptr, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1239 size_int (fixed_offset))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1240 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1241 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1242 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1243 /* If there's a virtual offset, look up that value in the vtable and |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1244 adjust the pointer again. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1245 if (virtual_offset) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1246 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1247 tree vtabletmp; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1248 tree vtabletmp2; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1249 tree vtabletmp3; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1250 tree offsettmp; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1251 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1252 if (!vtable_entry_type) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1253 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1254 tree vfunc_type = make_node (FUNCTION_TYPE); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1255 TREE_TYPE (vfunc_type) = integer_type_node; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1256 TYPE_ARG_TYPES (vfunc_type) = NULL_TREE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1257 layout_type (vfunc_type); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1258 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1259 vtable_entry_type = build_pointer_type (vfunc_type); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1260 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1261 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1262 vtabletmp = |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1263 create_tmp_var (build_pointer_type |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1264 (build_pointer_type (vtable_entry_type)), "vptr"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1265 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1266 /* The vptr is always at offset zero in the object. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1267 stmt = gimple_build_assign (vtabletmp, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1268 build1 (NOP_EXPR, TREE_TYPE (vtabletmp), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1269 ptr)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1270 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1271 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1272 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1273 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1274 /* Form the vtable address. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1275 vtabletmp2 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp)), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1276 "vtableaddr"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1277 stmt = gimple_build_assign (vtabletmp2, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1278 build1 (INDIRECT_REF, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1279 TREE_TYPE (vtabletmp2), vtabletmp)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1280 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1281 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1282 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1283 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1284 /* Find the entry with the vcall offset. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1285 stmt = gimple_build_assign (vtabletmp2, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1286 fold_build2_loc (input_location, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1287 POINTER_PLUS_EXPR, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1288 TREE_TYPE (vtabletmp2), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1289 vtabletmp2, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1290 fold_convert (sizetype, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1291 virtual_offset))); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1292 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1293 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1294 /* Get the offset itself. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1295 vtabletmp3 = create_tmp_var (TREE_TYPE (TREE_TYPE (vtabletmp2)), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1296 "vcalloffset"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1297 stmt = gimple_build_assign (vtabletmp3, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1298 build1 (INDIRECT_REF, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1299 TREE_TYPE (vtabletmp3), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1300 vtabletmp2)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1301 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1302 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1303 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1304 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1305 /* Cast to sizetype. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1306 offsettmp = create_tmp_var (sizetype, "offset"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1307 stmt = gimple_build_assign (offsettmp, fold_convert (sizetype, vtabletmp3)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1308 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1309 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1310 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1311 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1312 /* Adjust the `this' pointer. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1313 ptr = fold_build2_loc (input_location, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1314 POINTER_PLUS_EXPR, TREE_TYPE (ptr), ptr, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1315 offsettmp); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1316 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1317 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1318 if (!this_adjusting) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1319 /* Adjust the pointer by the constant. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1320 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1321 tree ptrtmp; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1322 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1323 if (TREE_CODE (ptr) == VAR_DECL) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1324 ptrtmp = ptr; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1325 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1326 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1327 ptrtmp = create_tmp_var (TREE_TYPE (ptr), "ptr"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1328 stmt = gimple_build_assign (ptrtmp, ptr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1329 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1330 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1331 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1332 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1333 ptr = fold_build2_loc (input_location, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1334 POINTER_PLUS_EXPR, TREE_TYPE (ptrtmp), ptrtmp, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1335 size_int (fixed_offset)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1336 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1337 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1338 /* Emit the statement and gimplify the adjustment expression. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1339 ret = create_tmp_var (TREE_TYPE (ptr), "adjusted_this"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1340 stmt = gimple_build_assign (ret, ptr); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1341 mark_symbols_for_renaming (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1342 find_referenced_vars_in (stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1343 gsi_insert_after (bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1344 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1345 return ret; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1346 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1347 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1348 /* Produce assembler for thunk NODE. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1349 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1350 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1351 assemble_thunk (struct cgraph_node *node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1352 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1353 bool this_adjusting = node->thunk.this_adjusting; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1354 HOST_WIDE_INT fixed_offset = node->thunk.fixed_offset; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1355 HOST_WIDE_INT virtual_value = node->thunk.virtual_value; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1356 tree virtual_offset = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1357 tree alias = node->thunk.alias; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1358 tree thunk_fndecl = node->decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1359 tree a = DECL_ARGUMENTS (thunk_fndecl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1360 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1361 current_function_decl = thunk_fndecl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1362 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1363 if (this_adjusting |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1364 && targetm.asm_out.can_output_mi_thunk (thunk_fndecl, fixed_offset, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1365 virtual_value, alias)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1366 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1367 const char *fnname; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1368 tree fn_block; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1369 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1370 DECL_RESULT (thunk_fndecl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1371 = build_decl (DECL_SOURCE_LOCATION (thunk_fndecl), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1372 RESULT_DECL, 0, integer_type_node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1373 fnname = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (thunk_fndecl)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1374 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1375 /* The back end expects DECL_INITIAL to contain a BLOCK, so we |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1376 create one. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1377 fn_block = make_node (BLOCK); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1378 BLOCK_VARS (fn_block) = a; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1379 DECL_INITIAL (thunk_fndecl) = fn_block; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1380 init_function_start (thunk_fndecl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1381 cfun->is_thunk = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1382 assemble_start_function (thunk_fndecl, fnname); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1383 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1384 targetm.asm_out.output_mi_thunk (asm_out_file, thunk_fndecl, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1385 fixed_offset, virtual_value, alias); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1386 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1387 assemble_end_function (thunk_fndecl, fnname); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1388 init_insn_lengths (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1389 free_after_compilation (cfun); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1390 set_cfun (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1391 TREE_ASM_WRITTEN (thunk_fndecl) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1392 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1393 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1394 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1395 tree restype; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1396 basic_block bb, then_bb, else_bb, return_bb; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1397 gimple_stmt_iterator bsi; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1398 int nargs = 0; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1399 tree arg; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1400 int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1401 tree resdecl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1402 tree restmp = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1403 VEC(tree, heap) *vargs; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1404 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1405 gimple call; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1406 gimple ret; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1407 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1408 DECL_IGNORED_P (thunk_fndecl) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1409 bitmap_obstack_initialize (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1410 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1411 if (node->thunk.virtual_offset_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1412 virtual_offset = size_int (virtual_value); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1413 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1414 /* Build the return declaration for the function. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1415 restype = TREE_TYPE (TREE_TYPE (thunk_fndecl)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1416 if (DECL_RESULT (thunk_fndecl) == NULL_TREE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1417 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1418 resdecl = build_decl (input_location, RESULT_DECL, 0, restype); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1419 DECL_ARTIFICIAL (resdecl) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1420 DECL_IGNORED_P (resdecl) = 1; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1421 DECL_RESULT (thunk_fndecl) = resdecl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1422 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1423 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1424 resdecl = DECL_RESULT (thunk_fndecl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1425 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1426 bb = then_bb = else_bb = return_bb = init_lowered_empty_function (thunk_fndecl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1427 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1428 bsi = gsi_start_bb (bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1429 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1430 /* Build call to the function being thunked. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1431 if (!VOID_TYPE_P (restype)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1432 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1433 if (!is_gimple_reg_type (restype)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1434 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1435 restmp = resdecl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1436 cfun->local_decls = tree_cons (NULL_TREE, restmp, cfun->local_decls); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1437 BLOCK_VARS (DECL_INITIAL (current_function_decl)) = restmp; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1438 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1439 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1440 restmp = create_tmp_var_raw (restype, "retval"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1441 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1442 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1443 for (arg = a; arg; arg = TREE_CHAIN (arg)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1444 nargs++; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1445 vargs = VEC_alloc (tree, heap, nargs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1446 if (this_adjusting) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1447 VEC_quick_push (tree, vargs, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1448 thunk_adjust (&bsi, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1449 a, 1, fixed_offset, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1450 virtual_offset)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1451 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1452 VEC_quick_push (tree, vargs, a); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1453 for (i = 1, arg = TREE_CHAIN (a); i < nargs; i++, arg = TREE_CHAIN (arg)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1454 VEC_quick_push (tree, vargs, arg); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1455 call = gimple_build_call_vec (build_fold_addr_expr_loc (0, alias), vargs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1456 VEC_free (tree, heap, vargs); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1457 gimple_call_set_cannot_inline (call, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1458 gimple_call_set_from_thunk (call, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1459 if (restmp) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1460 gimple_call_set_lhs (call, restmp); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1461 gsi_insert_after (&bsi, call, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1462 mark_symbols_for_renaming (call); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1463 find_referenced_vars_in (call); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1464 update_stmt (call); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1465 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1466 if (restmp && !this_adjusting) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1467 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1468 tree true_label = NULL_TREE, false_label = NULL_TREE; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1469 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1470 if (TREE_CODE (TREE_TYPE (restmp)) == POINTER_TYPE) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1471 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1472 gimple stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1473 /* If the return type is a pointer, we need to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1474 protect against NULL. We know there will be an |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1475 adjustment, because that's why we're emitting a |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1476 thunk. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1477 then_bb = create_basic_block (NULL, (void *) 0, bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1478 return_bb = create_basic_block (NULL, (void *) 0, then_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1479 else_bb = create_basic_block (NULL, (void *) 0, else_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1480 remove_edge (single_succ_edge (bb)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1481 true_label = gimple_block_label (then_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1482 false_label = gimple_block_label (else_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1483 stmt = gimple_build_cond (NE_EXPR, restmp, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1484 fold_convert (TREE_TYPE (restmp), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1485 integer_zero_node), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1486 NULL_TREE, NULL_TREE); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1487 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1488 make_edge (bb, then_bb, EDGE_TRUE_VALUE); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1489 make_edge (bb, else_bb, EDGE_FALSE_VALUE); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1490 make_edge (return_bb, EXIT_BLOCK_PTR, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1491 make_edge (then_bb, return_bb, EDGE_FALLTHRU); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1492 make_edge (else_bb, return_bb, EDGE_FALLTHRU); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1493 bsi = gsi_last_bb (then_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1494 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1495 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1496 restmp = thunk_adjust (&bsi, restmp, /*this_adjusting=*/0, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1497 fixed_offset, virtual_offset); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1498 if (true_label) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1499 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1500 gimple stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1501 bsi = gsi_last_bb (else_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1502 stmt = gimple_build_assign (restmp, fold_convert (TREE_TYPE (restmp), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1503 integer_zero_node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1504 gsi_insert_after (&bsi, stmt, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1505 bsi = gsi_last_bb (return_bb); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1506 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1507 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1508 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1509 gimple_call_set_tail (call, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1510 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1511 /* Build return value. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1512 ret = gimple_build_return (restmp); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1513 gsi_insert_after (&bsi, ret, GSI_NEW_STMT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1514 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1515 delete_unreachable_blocks (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1516 update_ssa (TODO_update_ssa); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1517 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1518 cgraph_remove_same_body_alias (node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1519 /* Since we want to emit the thunk, we explicitly mark its name as |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1520 referenced. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1521 mark_decl_referenced (thunk_fndecl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1522 cgraph_add_new_function (thunk_fndecl, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1523 bitmap_obstack_release (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1524 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1525 current_function_decl = NULL; |
| 0 | 1526 } |
| 1527 | |
| 1528 /* Expand function specified by NODE. */ | |
| 1529 | |
| 1530 static void | |
| 1531 cgraph_expand_function (struct cgraph_node *node) | |
| 1532 { | |
| 1533 tree decl = node->decl; | |
| 1534 | |
| 1535 /* We ought to not compile any inline clones. */ | |
| 1536 gcc_assert (!node->global.inlined_to); | |
| 1537 | |
| 1538 announce_function (decl); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1539 node->process = 0; |
| 0 | 1540 |
| 1541 gcc_assert (node->lowered); | |
| 1542 | |
| 1543 /* Generate RTL for the body of DECL. */ | |
| 1544 tree_rest_of_compilation (decl); | |
| 1545 | |
| 1546 /* Make sure that BE didn't give up on compiling. */ | |
| 1547 gcc_assert (TREE_ASM_WRITTEN (decl)); | |
| 1548 current_function_decl = NULL; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1549 if (node->same_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1550 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1551 struct cgraph_node *alias, *next; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1552 bool saved_alias = node->alias; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1553 for (alias = node->same_body; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1554 alias && alias->next; alias = alias->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1555 ; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1556 /* Walk aliases in the order they were created; it is possible that |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1557 thunks reffers to the aliases made earlier. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1558 for (; alias; alias = next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1559 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1560 next = alias->previous; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1561 if (!alias->thunk.thunk_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1562 assemble_alias (alias->decl, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1563 DECL_ASSEMBLER_NAME (alias->thunk.alias)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1564 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1565 assemble_thunk (alias); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1566 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1567 node->alias = saved_alias; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1568 } |
| 0 | 1569 gcc_assert (!cgraph_preserve_function_body_p (decl)); |
| 1570 cgraph_release_function_body (node); | |
| 1571 /* Eliminate all call edges. This is important so the GIMPLE_CALL no longer | |
| 1572 points to the dead function body. */ | |
| 1573 cgraph_node_remove_callees (node); | |
| 1574 | |
| 1575 cgraph_function_flags_ready = true; | |
| 1576 } | |
| 1577 | |
| 1578 /* Return true when CALLER_DECL should be inlined into CALLEE_DECL. */ | |
| 1579 | |
| 1580 bool | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1581 cgraph_inline_p (struct cgraph_edge *e, cgraph_inline_failed_t *reason) |
| 0 | 1582 { |
| 1583 *reason = e->inline_failed; | |
| 1584 return !e->inline_failed; | |
| 1585 } | |
| 1586 | |
| 1587 | |
| 1588 | |
| 1589 /* Expand all functions that must be output. | |
| 1590 | |
| 1591 Attempt to topologically sort the nodes so function is output when | |
| 1592 all called functions are already assembled to allow data to be | |
| 1593 propagated across the callgraph. Use a stack to get smaller distance | |
| 1594 between a function and its callees (later we may choose to use a more | |
| 1595 sophisticated algorithm for function reordering; we will likely want | |
| 1596 to use subsections to make the output functions appear in top-down | |
| 1597 order). */ | |
| 1598 | |
| 1599 static void | |
| 1600 cgraph_expand_all_functions (void) | |
| 1601 { | |
| 1602 struct cgraph_node *node; | |
| 1603 struct cgraph_node **order = XCNEWVEC (struct cgraph_node *, cgraph_n_nodes); | |
| 1604 int order_pos, new_order_pos = 0; | |
| 1605 int i; | |
| 1606 | |
| 1607 order_pos = cgraph_postorder (order); | |
| 1608 gcc_assert (order_pos == cgraph_n_nodes); | |
| 1609 | |
| 1610 /* Garbage collector may remove inline clones we eliminate during | |
| 1611 optimization. So we must be sure to not reference them. */ | |
| 1612 for (i = 0; i < order_pos; i++) | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1613 if (order[i]->process) |
| 0 | 1614 order[new_order_pos++] = order[i]; |
| 1615 | |
| 1616 for (i = new_order_pos - 1; i >= 0; i--) | |
| 1617 { | |
| 1618 node = order[i]; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1619 if (node->process) |
| 0 | 1620 { |
| 1621 gcc_assert (node->reachable); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1622 node->process = 0; |
| 0 | 1623 cgraph_expand_function (node); |
| 1624 } | |
| 1625 } | |
| 1626 cgraph_process_new_functions (); | |
| 1627 | |
| 1628 free (order); | |
| 1629 | |
| 1630 } | |
| 1631 | |
| 1632 /* This is used to sort the node types by the cgraph order number. */ | |
| 1633 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1634 enum cgraph_order_sort_kind |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1635 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1636 ORDER_UNDEFINED = 0, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1637 ORDER_FUNCTION, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1638 ORDER_VAR, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1639 ORDER_ASM |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1640 }; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1641 |
| 0 | 1642 struct cgraph_order_sort |
| 1643 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1644 enum cgraph_order_sort_kind kind; |
| 0 | 1645 union |
| 1646 { | |
| 1647 struct cgraph_node *f; | |
| 1648 struct varpool_node *v; | |
| 1649 struct cgraph_asm_node *a; | |
| 1650 } u; | |
| 1651 }; | |
| 1652 | |
| 1653 /* Output all functions, variables, and asm statements in the order | |
| 1654 according to their order fields, which is the order in which they | |
| 1655 appeared in the file. This implements -fno-toplevel-reorder. In | |
| 1656 this mode we may output functions and variables which don't really | |
| 1657 need to be output. */ | |
| 1658 | |
| 1659 static void | |
| 1660 cgraph_output_in_order (void) | |
| 1661 { | |
| 1662 int max; | |
| 1663 size_t size; | |
| 1664 struct cgraph_order_sort *nodes; | |
| 1665 int i; | |
| 1666 struct cgraph_node *pf; | |
| 1667 struct varpool_node *pv; | |
| 1668 struct cgraph_asm_node *pa; | |
| 1669 | |
| 1670 max = cgraph_order; | |
| 1671 size = max * sizeof (struct cgraph_order_sort); | |
| 1672 nodes = (struct cgraph_order_sort *) alloca (size); | |
| 1673 memset (nodes, 0, size); | |
| 1674 | |
| 1675 varpool_analyze_pending_decls (); | |
| 1676 | |
| 1677 for (pf = cgraph_nodes; pf; pf = pf->next) | |
| 1678 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1679 if (pf->process) |
| 0 | 1680 { |
| 1681 i = pf->order; | |
| 1682 gcc_assert (nodes[i].kind == ORDER_UNDEFINED); | |
| 1683 nodes[i].kind = ORDER_FUNCTION; | |
| 1684 nodes[i].u.f = pf; | |
| 1685 } | |
| 1686 } | |
| 1687 | |
| 1688 for (pv = varpool_nodes_queue; pv; pv = pv->next_needed) | |
| 1689 { | |
| 1690 i = pv->order; | |
| 1691 gcc_assert (nodes[i].kind == ORDER_UNDEFINED); | |
| 1692 nodes[i].kind = ORDER_VAR; | |
| 1693 nodes[i].u.v = pv; | |
| 1694 } | |
| 1695 | |
| 1696 for (pa = cgraph_asm_nodes; pa; pa = pa->next) | |
| 1697 { | |
| 1698 i = pa->order; | |
| 1699 gcc_assert (nodes[i].kind == ORDER_UNDEFINED); | |
| 1700 nodes[i].kind = ORDER_ASM; | |
| 1701 nodes[i].u.a = pa; | |
| 1702 } | |
| 1703 | |
| 1704 /* In toplevel reorder mode we output all statics; mark them as needed. */ | |
| 1705 for (i = 0; i < max; ++i) | |
| 1706 { | |
| 1707 if (nodes[i].kind == ORDER_VAR) | |
| 1708 { | |
| 1709 varpool_mark_needed_node (nodes[i].u.v); | |
| 1710 } | |
| 1711 } | |
| 1712 varpool_empty_needed_queue (); | |
| 1713 | |
| 1714 for (i = 0; i < max; ++i) | |
| 1715 { | |
| 1716 switch (nodes[i].kind) | |
| 1717 { | |
| 1718 case ORDER_FUNCTION: | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1719 nodes[i].u.f->process = 0; |
| 0 | 1720 cgraph_expand_function (nodes[i].u.f); |
| 1721 break; | |
| 1722 | |
| 1723 case ORDER_VAR: | |
| 1724 varpool_assemble_decl (nodes[i].u.v); | |
| 1725 break; | |
| 1726 | |
| 1727 case ORDER_ASM: | |
| 1728 assemble_asm (nodes[i].u.a->asm_str); | |
| 1729 break; | |
| 1730 | |
| 1731 case ORDER_UNDEFINED: | |
| 1732 break; | |
| 1733 | |
| 1734 default: | |
| 1735 gcc_unreachable (); | |
| 1736 } | |
| 1737 } | |
| 1738 | |
| 1739 cgraph_asm_nodes = NULL; | |
| 1740 } | |
| 1741 | |
| 1742 /* Return true when function body of DECL still needs to be kept around | |
| 1743 for later re-use. */ | |
| 1744 bool | |
| 1745 cgraph_preserve_function_body_p (tree decl) | |
| 1746 { | |
| 1747 struct cgraph_node *node; | |
| 1748 | |
| 1749 gcc_assert (cgraph_global_info_ready); | |
| 1750 /* Look if there is any clone around. */ | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1751 node = cgraph_node (decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1752 if (node->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1753 return true; |
| 0 | 1754 return false; |
| 1755 } | |
| 1756 | |
| 1757 static void | |
| 1758 ipa_passes (void) | |
| 1759 { | |
| 1760 set_cfun (NULL); | |
| 1761 current_function_decl = NULL; | |
| 1762 gimple_register_cfg_hooks (); | |
| 1763 bitmap_obstack_initialize (NULL); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1764 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1765 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_START, NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1766 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1767 if (!in_lto_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1768 execute_ipa_pass_list (all_small_ipa_passes); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1769 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1770 /* If pass_all_early_optimizations was not scheduled, the state of |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1771 the cgraph will not be properly updated. Update it now. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1772 if (cgraph_state < CGRAPH_STATE_IPA_SSA) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1773 cgraph_state = CGRAPH_STATE_IPA_SSA; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1774 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1775 if (!in_lto_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1776 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1777 /* Generate coverage variables and constructors. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1778 coverage_finish (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1779 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1780 /* Process new functions added. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1781 set_cfun (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1782 current_function_decl = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1783 cgraph_process_new_functions (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1784 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1785 execute_ipa_summary_passes |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1786 ((struct ipa_opt_pass_d *) all_regular_ipa_passes); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1787 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1788 execute_ipa_summary_passes ((struct ipa_opt_pass_d *) all_lto_gen_passes); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1789 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1790 if (!in_lto_p) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1791 ipa_write_summaries (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1792 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1793 if (!flag_ltrans) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1794 execute_ipa_pass_list (all_regular_ipa_passes); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1795 invoke_plugin_callbacks (PLUGIN_ALL_IPA_PASSES_END, NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1796 |
| 0 | 1797 bitmap_obstack_release (NULL); |
| 1798 } | |
| 1799 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1800 |
| 0 | 1801 /* Perform simple optimizations based on callgraph. */ |
| 1802 | |
| 1803 void | |
| 1804 cgraph_optimize (void) | |
| 1805 { | |
| 1806 if (errorcount || sorrycount) | |
| 1807 return; | |
| 1808 | |
| 1809 #ifdef ENABLE_CHECKING | |
| 1810 verify_cgraph (); | |
| 1811 #endif | |
| 1812 | |
| 1813 /* Frontend may output common variables after the unit has been finalized. | |
| 1814 It is safe to deal with them here as they are always zero initialized. */ | |
| 1815 varpool_analyze_pending_decls (); | |
| 1816 | |
| 1817 timevar_push (TV_CGRAPHOPT); | |
| 1818 if (pre_ipa_mem_report) | |
| 1819 { | |
| 1820 fprintf (stderr, "Memory consumption before IPA\n"); | |
| 1821 dump_memory_report (false); | |
| 1822 } | |
| 1823 if (!quiet_flag) | |
| 1824 fprintf (stderr, "Performing interprocedural optimizations\n"); | |
| 1825 cgraph_state = CGRAPH_STATE_IPA; | |
| 1826 | |
| 1827 /* Don't run the IPA passes if there was any error or sorry messages. */ | |
| 1828 if (errorcount == 0 && sorrycount == 0) | |
| 1829 ipa_passes (); | |
| 1830 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1831 /* Do nothing else if any IPA pass found errors. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1832 if (errorcount || sorrycount) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1833 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1834 timevar_pop (TV_CGRAPHOPT); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1835 return; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1836 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1837 |
| 0 | 1838 /* This pass remove bodies of extern inline functions we never inlined. |
| 1839 Do this later so other IPA passes see what is really going on. */ | |
| 1840 cgraph_remove_unreachable_nodes (false, dump_file); | |
| 1841 cgraph_global_info_ready = true; | |
| 1842 if (cgraph_dump_file) | |
| 1843 { | |
| 1844 fprintf (cgraph_dump_file, "Optimized "); | |
| 1845 dump_cgraph (cgraph_dump_file); | |
| 1846 dump_varpool (cgraph_dump_file); | |
| 1847 } | |
| 1848 if (post_ipa_mem_report) | |
| 1849 { | |
| 1850 fprintf (stderr, "Memory consumption after IPA\n"); | |
| 1851 dump_memory_report (false); | |
| 1852 } | |
| 1853 timevar_pop (TV_CGRAPHOPT); | |
| 1854 | |
| 1855 /* Output everything. */ | |
| 36 | 1856 (*debug_hooks->assembly_start) (); |
| 0 | 1857 if (!quiet_flag) |
| 1858 fprintf (stderr, "Assembling functions:\n"); | |
| 1859 #ifdef ENABLE_CHECKING | |
| 1860 verify_cgraph (); | |
| 1861 #endif | |
| 1862 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1863 cgraph_materialize_all_clones (); |
| 0 | 1864 cgraph_mark_functions_to_output (); |
| 1865 | |
| 1866 cgraph_state = CGRAPH_STATE_EXPANSION; | |
| 1867 if (!flag_toplevel_reorder) | |
| 1868 cgraph_output_in_order (); | |
| 1869 else | |
| 1870 { | |
| 1871 cgraph_output_pending_asms (); | |
| 1872 | |
| 1873 cgraph_expand_all_functions (); | |
| 1874 varpool_remove_unreferenced_decls (); | |
| 1875 | |
| 1876 varpool_assemble_pending_decls (); | |
| 1877 } | |
| 1878 cgraph_process_new_functions (); | |
| 1879 cgraph_state = CGRAPH_STATE_FINISHED; | |
| 1880 | |
| 1881 if (cgraph_dump_file) | |
| 1882 { | |
| 1883 fprintf (cgraph_dump_file, "\nFinal "); | |
| 1884 dump_cgraph (cgraph_dump_file); | |
| 1885 } | |
| 1886 #ifdef ENABLE_CHECKING | |
| 1887 verify_cgraph (); | |
| 1888 /* Double check that all inline clones are gone and that all | |
| 1889 function bodies have been released from memory. */ | |
| 1890 if (!(sorrycount || errorcount)) | |
| 1891 { | |
| 1892 struct cgraph_node *node; | |
| 1893 bool error_found = false; | |
| 1894 | |
| 1895 for (node = cgraph_nodes; node; node = node->next) | |
| 1896 if (node->analyzed | |
| 1897 && (node->global.inlined_to | |
| 1898 || gimple_has_body_p (node->decl))) | |
| 1899 { | |
| 1900 error_found = true; | |
| 1901 dump_cgraph_node (stderr, node); | |
| 1902 } | |
| 1903 if (error_found) | |
| 1904 internal_error ("nodes with unreleased memory found"); | |
| 1905 } | |
| 1906 #endif | |
| 1907 } | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1908 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1909 |
| 0 | 1910 /* Generate and emit a static constructor or destructor. WHICH must |
| 1911 be one of 'I' (for a constructor) or 'D' (for a destructor). BODY | |
| 1912 is a STATEMENT_LIST containing GENERIC statements. PRIORITY is the | |
| 1913 initialization priority for this constructor or destructor. */ | |
| 1914 | |
| 1915 void | |
| 1916 cgraph_build_static_cdtor (char which, tree body, int priority) | |
| 1917 { | |
| 1918 static int counter = 0; | |
| 1919 char which_buf[16]; | |
| 1920 tree decl, name, resdecl; | |
| 1921 | |
| 1922 /* The priority is encoded in the constructor or destructor name. | |
| 1923 collect2 will sort the names and arrange that they are called at | |
| 1924 program startup. */ | |
| 1925 sprintf (which_buf, "%c_%.5d_%d", which, priority, counter++); | |
| 1926 name = get_file_function_name (which_buf); | |
| 1927 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1928 decl = build_decl (input_location, FUNCTION_DECL, name, |
| 0 | 1929 build_function_type (void_type_node, void_list_node)); |
| 1930 current_function_decl = decl; | |
| 1931 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1932 resdecl = build_decl (input_location, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1933 RESULT_DECL, NULL_TREE, void_type_node); |
| 0 | 1934 DECL_ARTIFICIAL (resdecl) = 1; |
| 1935 DECL_RESULT (decl) = resdecl; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1936 DECL_CONTEXT (resdecl) = decl; |
| 0 | 1937 |
| 1938 allocate_struct_function (decl, false); | |
| 1939 | |
| 1940 TREE_STATIC (decl) = 1; | |
| 1941 TREE_USED (decl) = 1; | |
| 1942 DECL_ARTIFICIAL (decl) = 1; | |
| 1943 DECL_NO_INSTRUMENT_FUNCTION_ENTRY_EXIT (decl) = 1; | |
| 1944 DECL_SAVED_TREE (decl) = body; | |
| 1945 TREE_PUBLIC (decl) = ! targetm.have_ctors_dtors; | |
| 1946 DECL_UNINLINABLE (decl) = 1; | |
| 1947 | |
| 1948 DECL_INITIAL (decl) = make_node (BLOCK); | |
| 1949 TREE_USED (DECL_INITIAL (decl)) = 1; | |
| 1950 | |
| 1951 DECL_SOURCE_LOCATION (decl) = input_location; | |
| 1952 cfun->function_end_locus = input_location; | |
| 1953 | |
| 1954 switch (which) | |
| 1955 { | |
| 1956 case 'I': | |
| 1957 DECL_STATIC_CONSTRUCTOR (decl) = 1; | |
| 1958 decl_init_priority_insert (decl, priority); | |
| 1959 break; | |
| 1960 case 'D': | |
| 1961 DECL_STATIC_DESTRUCTOR (decl) = 1; | |
| 1962 decl_fini_priority_insert (decl, priority); | |
| 1963 break; | |
| 1964 default: | |
| 1965 gcc_unreachable (); | |
| 1966 } | |
| 1967 | |
| 1968 gimplify_function_tree (decl); | |
| 1969 | |
| 1970 cgraph_add_new_function (decl, false); | |
| 1971 cgraph_mark_needed_node (cgraph_node (decl)); | |
| 1972 set_cfun (NULL); | |
| 1973 } | |
| 1974 | |
| 1975 void | |
| 1976 init_cgraph (void) | |
| 1977 { | |
| 1978 cgraph_dump_file = dump_begin (TDI_cgraph, NULL); | |
| 1979 } | |
| 1980 | |
| 1981 /* The edges representing the callers of the NEW_VERSION node were | |
| 1982 fixed by cgraph_function_versioning (), now the call_expr in their | |
| 1983 respective tree code should be updated to call the NEW_VERSION. */ | |
| 1984 | |
| 1985 static void | |
| 1986 update_call_expr (struct cgraph_node *new_version) | |
| 1987 { | |
| 1988 struct cgraph_edge *e; | |
| 1989 | |
| 1990 gcc_assert (new_version); | |
| 1991 | |
| 1992 /* Update the call expr on the edges to call the new version. */ | |
| 1993 for (e = new_version->callers; e; e = e->next_caller) | |
| 1994 { | |
| 1995 struct function *inner_function = DECL_STRUCT_FUNCTION (e->caller->decl); | |
| 1996 gimple_call_set_fndecl (e->call_stmt, new_version->decl); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
1997 maybe_clean_eh_stmt_fn (inner_function, e->call_stmt); |
| 0 | 1998 } |
| 1999 } | |
| 2000 | |
| 2001 | |
| 2002 /* Create a new cgraph node which is the new version of | |
| 2003 OLD_VERSION node. REDIRECT_CALLERS holds the callers | |
| 2004 edges which should be redirected to point to | |
| 2005 NEW_VERSION. ALL the callees edges of OLD_VERSION | |
| 2006 are cloned to the new version node. Return the new | |
| 2007 version node. */ | |
| 2008 | |
| 2009 static struct cgraph_node * | |
| 2010 cgraph_copy_node_for_versioning (struct cgraph_node *old_version, | |
| 2011 tree new_decl, | |
| 2012 VEC(cgraph_edge_p,heap) *redirect_callers) | |
| 2013 { | |
| 2014 struct cgraph_node *new_version; | |
| 2015 struct cgraph_edge *e, *new_e; | |
| 2016 struct cgraph_edge *next_callee; | |
| 2017 unsigned i; | |
| 2018 | |
| 2019 gcc_assert (old_version); | |
| 2020 | |
| 2021 new_version = cgraph_node (new_decl); | |
| 2022 | |
| 2023 new_version->analyzed = true; | |
| 2024 new_version->local = old_version->local; | |
| 2025 new_version->global = old_version->global; | |
| 2026 new_version->rtl = new_version->rtl; | |
| 2027 new_version->reachable = true; | |
| 2028 new_version->count = old_version->count; | |
| 2029 | |
| 2030 /* Clone the old node callees. Recursive calls are | |
| 2031 also cloned. */ | |
| 2032 for (e = old_version->callees;e; e=e->next_callee) | |
| 2033 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2034 new_e = cgraph_clone_edge (e, new_version, e->call_stmt, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2035 e->lto_stmt_uid, 0, e->frequency, |
| 0 | 2036 e->loop_nest, true); |
| 2037 new_e->count = e->count; | |
| 2038 } | |
| 2039 /* Fix recursive calls. | |
| 2040 If OLD_VERSION has a recursive call after the | |
| 2041 previous edge cloning, the new version will have an edge | |
| 2042 pointing to the old version, which is wrong; | |
| 2043 Redirect it to point to the new version. */ | |
| 2044 for (e = new_version->callees ; e; e = next_callee) | |
| 2045 { | |
| 2046 next_callee = e->next_callee; | |
| 2047 if (e->callee == old_version) | |
| 2048 cgraph_redirect_edge_callee (e, new_version); | |
| 2049 | |
| 2050 if (!next_callee) | |
| 2051 break; | |
| 2052 } | |
| 2053 for (i = 0; VEC_iterate (cgraph_edge_p, redirect_callers, i, e); i++) | |
| 2054 { | |
| 2055 /* Redirect calls to the old version node to point to its new | |
| 2056 version. */ | |
| 2057 cgraph_redirect_edge_callee (e, new_version); | |
| 2058 } | |
| 2059 | |
| 2060 return new_version; | |
| 2061 } | |
| 2062 | |
| 2063 /* Perform function versioning. | |
| 2064 Function versioning includes copying of the tree and | |
| 2065 a callgraph update (creating a new cgraph node and updating | |
| 2066 its callees and callers). | |
| 2067 | |
| 2068 REDIRECT_CALLERS varray includes the edges to be redirected | |
| 2069 to the new version. | |
| 2070 | |
| 2071 TREE_MAP is a mapping of tree nodes we want to replace with | |
| 2072 new ones (according to results of prior analysis). | |
| 2073 OLD_VERSION_NODE is the node that is versioned. | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2074 It returns the new version's cgraph node. |
| 0 | 2075 ARGS_TO_SKIP lists arguments to be omitted from functions |
| 2076 */ | |
| 2077 | |
| 2078 struct cgraph_node * | |
| 2079 cgraph_function_versioning (struct cgraph_node *old_version_node, | |
| 2080 VEC(cgraph_edge_p,heap) *redirect_callers, | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2081 VEC (ipa_replace_map_p,gc)* tree_map, |
| 0 | 2082 bitmap args_to_skip) |
| 2083 { | |
| 2084 tree old_decl = old_version_node->decl; | |
| 2085 struct cgraph_node *new_version_node = NULL; | |
| 2086 tree new_decl; | |
| 2087 | |
| 2088 if (!tree_versionable_function_p (old_decl)) | |
| 2089 return NULL; | |
| 2090 | |
| 2091 /* Make a new FUNCTION_DECL tree node for the | |
| 2092 new version. */ | |
| 2093 if (!args_to_skip) | |
| 2094 new_decl = copy_node (old_decl); | |
| 2095 else | |
| 2096 new_decl = build_function_decl_skip_args (old_decl, args_to_skip); | |
| 2097 | |
| 2098 /* Create the new version's call-graph node. | |
| 2099 and update the edges of the new node. */ | |
| 2100 new_version_node = | |
| 2101 cgraph_copy_node_for_versioning (old_version_node, new_decl, | |
| 2102 redirect_callers); | |
| 2103 | |
| 2104 /* Copy the OLD_VERSION_NODE function tree to the new version. */ | |
| 2105 tree_function_versioning (old_decl, new_decl, tree_map, false, args_to_skip); | |
| 2106 | |
| 2107 /* Update the new version's properties. | |
| 2108 Make The new version visible only within this translation unit. Make sure | |
| 2109 that is not weak also. | |
| 2110 ??? We cannot use COMDAT linkage because there is no | |
| 2111 ABI support for this. */ | |
| 2112 DECL_EXTERNAL (new_version_node->decl) = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2113 DECL_COMDAT_GROUP (new_version_node->decl) = NULL_TREE; |
| 0 | 2114 TREE_PUBLIC (new_version_node->decl) = 0; |
| 2115 DECL_COMDAT (new_version_node->decl) = 0; | |
| 2116 DECL_WEAK (new_version_node->decl) = 0; | |
| 2117 DECL_VIRTUAL_P (new_version_node->decl) = 0; | |
| 2118 new_version_node->local.externally_visible = 0; | |
| 2119 new_version_node->local.local = 1; | |
| 2120 new_version_node->lowered = true; | |
| 2121 | |
| 2122 /* Update the call_expr on the edges to call the new version node. */ | |
| 2123 update_call_expr (new_version_node); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2124 |
| 0 | 2125 cgraph_call_function_insertion_hooks (new_version_node); |
| 2126 return new_version_node; | |
| 2127 } | |
| 2128 | |
| 2129 /* Produce separate function body for inline clones so the offline copy can be | |
| 2130 modified without affecting them. */ | |
| 2131 struct cgraph_node * | |
| 2132 save_inline_function_body (struct cgraph_node *node) | |
| 2133 { | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2134 struct cgraph_node *first_clone, *n; |
| 0 | 2135 |
| 2136 gcc_assert (node == cgraph_node (node->decl)); | |
| 2137 | |
| 2138 cgraph_lower_function (node); | |
| 2139 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2140 first_clone = node->clones; |
| 0 | 2141 |
| 2142 first_clone->decl = copy_node (node->decl); | |
| 2143 cgraph_insert_node_to_hashtable (first_clone); | |
| 2144 gcc_assert (first_clone == cgraph_node (first_clone->decl)); | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2145 if (first_clone->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2146 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2147 for (n = first_clone->next_sibling_clone; n->next_sibling_clone; n = n->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2148 n->clone_of = first_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2149 n->clone_of = first_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2150 n->next_sibling_clone = first_clone->clones; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2151 if (first_clone->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2152 first_clone->clones->prev_sibling_clone = n; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2153 first_clone->clones = first_clone->next_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2154 first_clone->next_sibling_clone->prev_sibling_clone = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2155 first_clone->next_sibling_clone = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2156 gcc_assert (!first_clone->prev_sibling_clone); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2157 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2158 first_clone->clone_of = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2159 node->clones = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2160 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2161 if (first_clone->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2162 for (n = first_clone->clones; n != first_clone;) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2163 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2164 gcc_assert (n->decl == node->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2165 n->decl = first_clone->decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2166 if (n->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2167 n = n->clones; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2168 else if (n->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2169 n = n->next_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2170 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2171 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2172 while (n != first_clone && !n->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2173 n = n->clone_of; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2174 if (n != first_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2175 n = n->next_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2176 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2177 } |
| 0 | 2178 |
| 2179 /* Copy the OLD_VERSION_NODE function tree to the new version. */ | |
| 2180 tree_function_versioning (node->decl, first_clone->decl, NULL, true, NULL); | |
| 2181 | |
| 2182 DECL_EXTERNAL (first_clone->decl) = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2183 DECL_COMDAT_GROUP (first_clone->decl) = NULL_TREE; |
| 0 | 2184 TREE_PUBLIC (first_clone->decl) = 0; |
| 2185 DECL_COMDAT (first_clone->decl) = 0; | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2186 VEC_free (ipa_opt_pass, heap, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2187 first_clone->ipa_transforms_to_apply); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2188 first_clone->ipa_transforms_to_apply = NULL; |
| 0 | 2189 |
| 2190 #ifdef ENABLE_CHECKING | |
| 2191 verify_cgraph_node (first_clone); | |
| 2192 #endif | |
| 2193 return first_clone; | |
| 2194 } | |
| 2195 | |
|
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2196 /* Given virtual clone, turn it into actual clone. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2197 static void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2198 cgraph_materialize_clone (struct cgraph_node *node) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2199 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2200 bitmap_obstack_initialize (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2201 /* Copy the OLD_VERSION_NODE function tree to the new version. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2202 tree_function_versioning (node->clone_of->decl, node->decl, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2203 node->clone.tree_map, true, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2204 node->clone.args_to_skip); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2205 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2206 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2207 dump_function_to_file (node->clone_of->decl, cgraph_dump_file, dump_flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2208 dump_function_to_file (node->decl, cgraph_dump_file, dump_flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2209 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2210 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2211 /* Function is no longer clone. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2212 if (node->next_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2213 node->next_sibling_clone->prev_sibling_clone = node->prev_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2214 if (node->prev_sibling_clone) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2215 node->prev_sibling_clone->next_sibling_clone = node->next_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2216 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2217 node->clone_of->clones = node->next_sibling_clone; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2218 node->next_sibling_clone = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2219 node->prev_sibling_clone = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2220 if (!node->clone_of->analyzed && !node->clone_of->clones) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2221 cgraph_remove_node (node->clone_of); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2222 node->clone_of = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2223 bitmap_obstack_release (NULL); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2224 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2225 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2226 /* Once all functions from compilation unit are in memory, produce all clones |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2227 and update all calls. |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2228 We might also do this on demand if we don't want to bring all functions to |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2229 memory prior compilation, but current WHOPR implementation does that and it is |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2230 is bit easier to keep everything right in this order. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2231 void |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2232 cgraph_materialize_all_clones (void) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2233 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2234 struct cgraph_node *node; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2235 bool stabilized = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2236 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2237 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2238 fprintf (cgraph_dump_file, "Materializing clones\n"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2239 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2240 verify_cgraph (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2241 #endif |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2242 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2243 /* We can also do topological order, but number of iterations should be |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2244 bounded by number of IPA passes since single IPA pass is probably not |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2245 going to create clones of clones it created itself. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2246 while (!stabilized) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2247 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2248 stabilized = true; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2249 for (node = cgraph_nodes; node; node = node->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2250 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2251 if (node->clone_of && node->decl != node->clone_of->decl |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2252 && !gimple_has_body_p (node->decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2253 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2254 if (gimple_has_body_p (node->clone_of->decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2255 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2256 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2257 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2258 fprintf (cgraph_dump_file, "clonning %s to %s\n", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2259 cgraph_node_name (node->clone_of), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2260 cgraph_node_name (node)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2261 if (node->clone.tree_map) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2262 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2263 unsigned int i; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2264 fprintf (cgraph_dump_file, " replace map: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2265 for (i = 0; i < VEC_length (ipa_replace_map_p, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2266 node->clone.tree_map); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2267 i++) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2268 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2269 struct ipa_replace_map *replace_info; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2270 replace_info = VEC_index (ipa_replace_map_p, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2271 node->clone.tree_map, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2272 i); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2273 print_generic_expr (cgraph_dump_file, replace_info->old_tree, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2274 fprintf (cgraph_dump_file, " -> "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2275 print_generic_expr (cgraph_dump_file, replace_info->new_tree, 0); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2276 fprintf (cgraph_dump_file, "%s%s;", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2277 replace_info->replace_p ? "(replace)":"", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2278 replace_info->ref_p ? "(ref)":""); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2279 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2280 fprintf (cgraph_dump_file, "\n"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2281 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2282 if (node->clone.args_to_skip) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2283 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2284 fprintf (cgraph_dump_file, " args_to_skip: "); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2285 dump_bitmap (cgraph_dump_file, node->clone.args_to_skip); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2286 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2287 if (node->clone.args_to_skip) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2288 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2289 fprintf (cgraph_dump_file, " combined_args_to_skip:"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2290 dump_bitmap (cgraph_dump_file, node->clone.combined_args_to_skip); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2291 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2292 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2293 cgraph_materialize_clone (node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2294 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2295 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2296 stabilized = false; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2297 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2298 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2299 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2300 for (node = cgraph_nodes; node; node = node->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2301 if (!node->analyzed && node->callees) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2302 cgraph_node_remove_callees (node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2303 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2304 fprintf (cgraph_dump_file, "Updating call sites\n"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2305 for (node = cgraph_nodes; node; node = node->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2306 if (node->analyzed && gimple_has_body_p (node->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2307 && (!node->clone_of || node->clone_of->decl != node->decl)) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2308 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2309 struct cgraph_edge *e; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2310 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2311 current_function_decl = node->decl; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2312 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2313 for (e = node->callees; e; e = e->next_callee) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2314 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2315 tree decl = gimple_call_fndecl (e->call_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2316 /* When function gets inlined, indirect inlining might've invented |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2317 new edge for orginally indirect stmt. Since we are not |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2318 preserving clones in the original form, we must not update here |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2319 since other inline clones don't need to contain call to the same |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2320 call. Inliner will do the substitution for us later. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2321 if (decl && decl != e->callee->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2322 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2323 gimple new_stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2324 gimple_stmt_iterator gsi; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2325 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2326 if (e->callee->same_body) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2327 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2328 struct cgraph_node *alias; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2329 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2330 for (alias = e->callee->same_body; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2331 alias; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2332 alias = alias->next) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2333 if (decl == alias->decl) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2334 break; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2335 /* Don't update call from same body alias to the real |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2336 function. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2337 if (alias) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2338 continue; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2339 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2340 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2341 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2342 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2343 fprintf (cgraph_dump_file, "updating call of %s in %s:", |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2344 cgraph_node_name (node), |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2345 cgraph_node_name (e->callee)); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2346 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2347 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2348 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2349 if (e->callee->clone.combined_args_to_skip) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2350 new_stmt = gimple_call_copy_skip_args (e->call_stmt, |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2351 e->callee->clone.combined_args_to_skip); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2352 else |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2353 new_stmt = e->call_stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2354 if (gimple_vdef (new_stmt) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2355 && TREE_CODE (gimple_vdef (new_stmt)) == SSA_NAME) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2356 SSA_NAME_DEF_STMT (gimple_vdef (new_stmt)) = new_stmt; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2357 gimple_call_set_fndecl (new_stmt, e->callee->decl); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2358 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2359 gsi = gsi_for_stmt (e->call_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2360 gsi_replace (&gsi, new_stmt, true); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2361 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2362 /* Update EH information too, just in case. */ |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2363 maybe_clean_or_replace_eh_stmt (e->call_stmt, new_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2364 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2365 cgraph_set_call_stmt_including_clones (node, e->call_stmt, new_stmt); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2366 |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2367 if (cgraph_dump_file) |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2368 { |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2369 fprintf (cgraph_dump_file, " updated to:"); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2370 print_gimple_stmt (cgraph_dump_file, e->call_stmt, 0, dump_flags); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2371 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2372 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2373 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2374 pop_cfun (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2375 current_function_decl = NULL; |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2376 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2377 verify_cgraph_node (node); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2378 #endif |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2379 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2380 #ifdef ENABLE_CHECKING |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2381 verify_cgraph (); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2382 #endif |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2383 cgraph_remove_unreachable_nodes (false, cgraph_dump_file); |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2384 } |
|
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
36
diff
changeset
|
2385 |
| 0 | 2386 #include "gt-cgraphunit.h" |