1 /* Lower TLS operations to emulation functions. 2 Copyright (C) 2006-2015 Free Software Foundation, Inc. 3 4 This file is part of GCC. 5 6 GCC is free software; you can redistribute it and/or modify it 7 under the terms of the GNU General Public License as published by the 8 Free Software Foundation; either version 3, or (at your option) any 9 later version. 10 11 GCC is distributed in the hope that it will be useful, but WITHOUT 12 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with GCC; see the file COPYING3. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 #include "config.h" 21 #include "system.h" 22 #include "coretypes.h" 23 #include "hash-set.h" 24 #include "machmode.h" 25 #include "vec.h" 26 #include "double-int.h" 27 #include "input.h" 28 #include "alias.h" 29 #include "symtab.h" 30 #include "options.h" 31 #include "wide-int.h" 32 #include "inchash.h" 33 #include "tree.h" 34 #include "fold-const.h" 35 #include "stor-layout.h" 36 #include "varasm.h" 37 #include "predict.h" 38 #include "tm.h" 39 #include "hard-reg-set.h" 40 #include "input.h" 41 #include "function.h" 42 #include "dominance.h" 43 #include "cfg.h" 44 #include "basic-block.h" 45 #include "tree-ssa-alias.h" 46 #include "internal-fn.h" 47 #include "gimple-expr.h" 48 #include "is-a.h" 49 #include "gimple.h" 50 #include "gimple-iterator.h" 51 #include "gimple-walk.h" 52 #include "tree-pass.h" 53 #include "gimple-ssa.h" 54 #include "hash-map.h" 55 #include "plugin-api.h" 56 #include "ipa-ref.h" 57 #include "cgraph.h" 58 #include "tree-phinodes.h" 59 #include "ssa-iterators.h" 60 #include "stringpool.h" 61 #include "tree-ssanames.h" 62 #include "langhooks.h" 63 #include "target.h" 64 #include "targhooks.h" 65 #include "tree-iterator.h" 66 67 /* Whenever a target does not support thread-local storage (TLS) natively, 68 we can emulate it with some run-time support in libgcc. This will in 69 turn rely on "keyed storage" a-la pthread_key_create; essentially all 70 thread libraries provide such functionality. 71 72 In order to coordinate with the libgcc runtime, each TLS variable is 73 described by a "control variable". This control variable records the 74 required size, alignment, and initial value of the TLS variable for 75 instantiation at runtime. It also stores an integer token to be used 76 by the runtime to find the address of the variable within each thread. 77 78 On the compiler side, this means that we need to replace all instances 79 of "tls_var" in the code with "*__emutls_get_addr(&control_var)". We 80 also need to eliminate "tls_var" from the symbol table and introduce 81 "control_var". 82 83 We used to perform all of the transformations during conversion to rtl, 84 and the variable substitutions magically within assemble_variable. 85 However, this late fiddling of the symbol table conflicts with LTO and 86 whole-program compilation. Therefore we must now make all the changes 87 to the symbol table early in the GIMPLE optimization path, before we 88 write things out to LTO intermediate files. */ 89 90 /* Value for TLS varpool node where a pointer to control variable and 91 access variable are stored. */ 92 struct tls_var_data 93 { 94 varpool_node *control_var; 95 tree access; 96 }; 97 98 /* TLS map accesses mapping between a TLS varpool node and a pair 99 made by control variable and access variable. */ 100 static hash_map<varpool_node *, tls_var_data> *tls_map = NULL; 101 102 /* The type of the control structure, shared with the emutls.c runtime. */ 103 static tree emutls_object_type; 104 105 #if !defined (NO_DOT_IN_LABEL) 106 # define EMUTLS_SEPARATOR "." 107 #elif !defined (NO_DOLLAR_IN_LABEL) 108 # define EMUTLS_SEPARATOR "$" 109 #else 110 # define EMUTLS_SEPARATOR "_" 111 #endif 112 113 /* Create an IDENTIFIER_NODE by prefixing PREFIX to the 114 IDENTIFIER_NODE NAME's name. */ 115 116 static tree 117 prefix_name (const char *prefix, tree name) 118 { 119 unsigned plen = strlen (prefix); 120 unsigned nlen = strlen (IDENTIFIER_POINTER (name)); 121 char *toname = (char *) alloca (plen + nlen + 1); 122 123 memcpy (toname, prefix, plen); 124 memcpy (toname + plen, IDENTIFIER_POINTER (name), nlen + 1); 125 126 return get_identifier (toname); 127 } 128 129 /* Create an identifier for the struct __emutls_object, given an identifier 130 of the DECL_ASSEMBLY_NAME of the original object. */ 131 132 static tree 133 get_emutls_object_name (tree name) 134 { 135 const char *prefix = (targetm.emutls.var_prefix 136 ? targetm.emutls.var_prefix 137 : "__emutls_v" EMUTLS_SEPARATOR); 138 return prefix_name (prefix, name); 139 } 140 141 /* Create the fields of the type for the control variables. Ordinarily 142 this must match struct __emutls_object defined in emutls.c. However 143 this is a target hook so that VxWorks can define its own layout. */ 144 145 tree 146 default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED) 147 { 148 tree word_type_node, field, next_field; 149 150 field = build_decl (UNKNOWN_LOCATION, 151 FIELD_DECL, get_identifier ("__templ"), ptr_type_node); 152 DECL_CONTEXT (field) = type; 153 next_field = field; 154 155 field = build_decl (UNKNOWN_LOCATION, 156 FIELD_DECL, get_identifier ("__offset"), 157 ptr_type_node); 158 DECL_CONTEXT (field) = type; 159 DECL_CHAIN (field) = next_field; 160 next_field = field; 161 162 word_type_node = lang_hooks.types.type_for_mode (word_mode, 1); 163 field = build_decl (UNKNOWN_LOCATION, 164 FIELD_DECL, get_identifier ("__align"), 165 word_type_node); 166 DECL_CONTEXT (field) = type; 167 DECL_CHAIN (field) = next_field; 168 next_field = field; 169 170 field = build_decl (UNKNOWN_LOCATION, 171 FIELD_DECL, get_identifier ("__size"), word_type_node); 172 DECL_CONTEXT (field) = type; 173 DECL_CHAIN (field) = next_field; 174 175 return field; 176 } 177 178 /* Initialize emulated tls object TO, which refers to TLS variable DECL and 179 is initialized by PROXY. As above, this is the default implementation of 180 a target hook overridden by VxWorks. */ 181 182 tree 183 default_emutls_var_init (tree to, tree decl, tree proxy) 184 { 185 vec<constructor_elt, va_gc> *v; 186 vec_alloc (v, 4); 187 constructor_elt elt; 188 tree type = TREE_TYPE (to); 189 tree field = TYPE_FIELDS (type); 190 191 elt.index = field; 192 elt.value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl)); 193 v->quick_push (elt); 194 195 field = DECL_CHAIN (field); 196 elt.index = field; 197 elt.value = build_int_cst (TREE_TYPE (field), 198 DECL_ALIGN_UNIT (decl)); 199 v->quick_push (elt); 200 201 field = DECL_CHAIN (field); 202 elt.index = field; 203 elt.value = null_pointer_node; 204 v->quick_push (elt); 205 206 field = DECL_CHAIN (field); 207 elt.index = field; 208 elt.value = proxy; 209 v->quick_push (elt); 210 211 return build_constructor (type, v); 212 } 213 214 /* Create the structure for struct __emutls_object. This should match the 215 structure at the top of emutls.c, modulo the union there. */ 216 217 static tree 218 get_emutls_object_type (void) 219 { 220 tree type, type_name, field; 221 222 type = emutls_object_type; 223 if (type) 224 return type; 225 226 emutls_object_type = type = lang_hooks.types.make_type (RECORD_TYPE); 227 type_name = NULL; 228 field = targetm.emutls.var_fields (type, &type_name); 229 if (!type_name) 230 type_name = get_identifier ("__emutls_object"); 231 type_name = build_decl (UNKNOWN_LOCATION, 232 TYPE_DECL, type_name, type); 233 TYPE_NAME (type) = type_name; 234 TYPE_FIELDS (type) = field; 235 layout_type (type); 236 237 return type; 238 } 239 240 /* Create a read-only variable like DECL, with the same DECL_INITIAL. 241 This will be used for initializing the emulated tls data area. */ 242 243 static tree 244 get_emutls_init_templ_addr (tree decl) 245 { 246 tree name, to; 247 248 if (targetm.emutls.register_common && !DECL_INITIAL (decl) 249 && !DECL_SECTION_NAME (decl)) 250 return null_pointer_node; 251 252 name = DECL_ASSEMBLER_NAME (decl); 253 if (!targetm.emutls.tmpl_prefix || targetm.emutls.tmpl_prefix[0]) 254 { 255 const char *prefix = (targetm.emutls.tmpl_prefix 256 ? targetm.emutls.tmpl_prefix 257 : "__emutls_t" EMUTLS_SEPARATOR); 258 name = prefix_name (prefix, name); 259 } 260 261 to = build_decl (DECL_SOURCE_LOCATION (decl), 262 VAR_DECL, name, TREE_TYPE (decl)); 263 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to)); 264 265 DECL_ARTIFICIAL (to) = 1; 266 TREE_USED (to) = TREE_USED (decl); 267 TREE_READONLY (to) = 1; 268 DECL_IGNORED_P (to) = 1; 269 DECL_CONTEXT (to) = DECL_CONTEXT (decl); 270 DECL_PRESERVE_P (to) = DECL_PRESERVE_P (decl); 271 272 DECL_WEAK (to) = DECL_WEAK (decl); 273 if (DECL_ONE_ONLY (decl)) 274 { 275 TREE_STATIC (to) = TREE_STATIC (decl); 276 TREE_PUBLIC (to) = TREE_PUBLIC (decl); 277 DECL_VISIBILITY (to) = DECL_VISIBILITY (decl); 278 make_decl_one_only (to, DECL_ASSEMBLER_NAME (to)); 279 } 280 else 281 TREE_STATIC (to) = 1; 282 283 DECL_VISIBILITY_SPECIFIED (to) = DECL_VISIBILITY_SPECIFIED (decl); 284 DECL_INITIAL (to) = DECL_INITIAL (decl); 285 DECL_INITIAL (decl) = NULL; 286 287 if (targetm.emutls.tmpl_section) 288 set_decl_section_name (to, targetm.emutls.tmpl_section); 289 else 290 set_decl_section_name (to, DECL_SECTION_NAME (decl)); 291 292 /* Create varpool node for the new variable and finalize it if it is 293 not external one. */ 294 if (DECL_EXTERNAL (to)) 295 varpool_node::get_create (to); 296 else 297 varpool_node::add (to); 298 return build_fold_addr_expr (to); 299 } 300 301 /* Create and return the control variable for the TLS variable DECL. */ 302 303 static tree 304 new_emutls_decl (tree decl, tree alias_of) 305 { 306 tree name, to; 307 308 name = DECL_ASSEMBLER_NAME (decl); 309 to = build_decl (DECL_SOURCE_LOCATION (decl), VAR_DECL, 310 get_emutls_object_name (name), 311 get_emutls_object_type ()); 312 313 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to)); 314 315 DECL_ARTIFICIAL (to) = 1; 316 DECL_IGNORED_P (to) = 1; 317 TREE_READONLY (to) = 0; 318 TREE_STATIC (to) = 1; 319 320 DECL_PRESERVE_P (to) = DECL_PRESERVE_P (decl); 321 DECL_CONTEXT (to) = DECL_CONTEXT (decl); 322 TREE_USED (to) = TREE_USED (decl); 323 TREE_PUBLIC (to) = TREE_PUBLIC (decl); 324 DECL_EXTERNAL (to) = DECL_EXTERNAL (decl); 325 DECL_COMMON (to) = DECL_COMMON (decl); 326 DECL_WEAK (to) = DECL_WEAK (decl); 327 DECL_VISIBILITY (to) = DECL_VISIBILITY (decl); 328 DECL_VISIBILITY_SPECIFIED (to) = DECL_VISIBILITY_SPECIFIED (decl); 329 DECL_DLLIMPORT_P (to) = DECL_DLLIMPORT_P (decl); 330 331 DECL_ATTRIBUTES (to) = targetm.merge_decl_attributes (decl, to); 332 333 if (DECL_ONE_ONLY (decl)) 334 make_decl_one_only (to, DECL_ASSEMBLER_NAME (to)); 335 336 set_decl_tls_model (to, TLS_MODEL_EMULATED); 337 338 /* If we're not allowed to change the proxy object's alignment, 339 pretend it has been set by the user. */ 340 if (targetm.emutls.var_align_fixed) 341 DECL_USER_ALIGN (to) = 1; 342 343 /* If the target wants the control variables grouped, do so. */ 344 if (!DECL_COMMON (to) && targetm.emutls.var_section) 345 { 346 set_decl_section_name (to, targetm.emutls.var_section); 347 } 348 349 /* If this variable is defined locally, then we need to initialize the 350 control structure with size and alignment information. Initialization 351 of COMMON block variables happens elsewhere via a constructor. */ 352 if (!DECL_EXTERNAL (to) 353 && (!DECL_COMMON (to) 354 || (DECL_INITIAL (decl) 355 && DECL_INITIAL (decl) != error_mark_node))) 356 { 357 tree tmpl = get_emutls_init_templ_addr (decl); 358 DECL_INITIAL (to) = targetm.emutls.var_init (to, decl, tmpl); 359 record_references_in_initializer (to, false); 360 } 361 362 /* Create varpool node for the new variable and finalize it if it is 363 not external one. */ 364 if (DECL_EXTERNAL (to)) 365 varpool_node::get_create (to); 366 else if (!alias_of) 367 varpool_node::add (to); 368 else 369 { 370 varpool_node *n; 371 varpool_node *t = varpool_node::get_for_asmname 372 (DECL_ASSEMBLER_NAME (DECL_VALUE_EXPR (alias_of))); 373 374 n = varpool_node::create_alias (to, t->decl); 375 n->resolve_alias (t); 376 } 377 return to; 378 } 379 380 /* Generate a call statement to initialize CONTROL_DECL for TLS_DECL. 381 This only needs to happen for TLS COMMON variables; non-COMMON 382 variables can be initialized statically. Insert the generated 383 call statement at the end of PSTMTS. */ 384 385 static void 386 emutls_common_1 (tree tls_decl, tree control_decl, tree *pstmts) 387 { 388 tree x; 389 tree word_type_node; 390 391 if (! DECL_COMMON (tls_decl) 392 || (DECL_INITIAL (tls_decl) 393 && DECL_INITIAL (tls_decl) != error_mark_node)) 394 return; 395 396 word_type_node = lang_hooks.types.type_for_mode (word_mode, 1); 397 398 x = build_call_expr (builtin_decl_explicit (BUILT_IN_EMUTLS_REGISTER_COMMON), 399 4, build_fold_addr_expr (control_decl), 400 fold_convert (word_type_node, 401 DECL_SIZE_UNIT (tls_decl)), 402 build_int_cst (word_type_node, 403 DECL_ALIGN_UNIT (tls_decl)), 404 get_emutls_init_templ_addr (tls_decl)); 405 406 append_to_statement_list (x, pstmts); 407 } 408 409 struct lower_emutls_data 410 { 411 struct cgraph_node *cfun_node; 412 struct cgraph_node *builtin_node; 413 tree builtin_decl; 414 basic_block bb; 415 int bb_freq; 416 location_t loc; 417 gimple_seq seq; 418 }; 419 420 /* Given a TLS variable DECL, return an SSA_NAME holding its address. 421 Append any new computation statements required to D->SEQ. */ 422 423 static tree 424 gen_emutls_addr (tree decl, struct lower_emutls_data *d) 425 { 426 /* Compute the address of the TLS variable with help from runtime. */ 427 tls_var_data *data = tls_map->get (varpool_node::get (decl)); 428 tree addr = data->access; 429 430 if (addr == NULL) 431 { 432 varpool_node *cvar; 433 tree cdecl; 434 gcall *x; 435 436 cvar = data->control_var; 437 cdecl = cvar->decl; 438 TREE_ADDRESSABLE (cdecl) = 1; 439 440 addr = create_tmp_var (build_pointer_type (TREE_TYPE (decl))); 441 x = gimple_build_call (d->builtin_decl, 1, build_fold_addr_expr (cdecl)); 442 gimple_set_location (x, d->loc); 443 444 addr = make_ssa_name (addr, x); 445 gimple_call_set_lhs (x, addr); 446 447 gimple_seq_add_stmt (&d->seq, x); 448 449 d->cfun_node->create_edge (d->builtin_node, x, d->bb->count, d->bb_freq); 450 451 /* We may be adding a new reference to a new variable to the function. 452 This means we have to play with the ipa-reference web. */ 453 d->cfun_node->create_reference (cvar, IPA_REF_ADDR, x); 454 455 /* Record this ssa_name for possible use later in the basic block. */ 456 data->access = addr; 457 } 458 459 return addr; 460 } 461 462 /* Callback for walk_gimple_op. D = WI->INFO is a struct lower_emutls_data. 463 Given an operand *PTR within D->STMT, if the operand references a TLS 464 variable, then lower the reference to a call to the runtime. Insert 465 any new statements required into D->SEQ; the caller is responsible for 466 placing those appropriately. */ 467 468 static tree 469 lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data) 470 { 471 struct walk_stmt_info *wi = (struct walk_stmt_info *) cb_data; 472 struct lower_emutls_data *d = (struct lower_emutls_data *) wi->info; 473 tree t = *ptr; 474 bool is_addr = false; 475 tree addr; 476 477 *walk_subtrees = 0; 478 479 switch (TREE_CODE (t)) 480 { 481 case ADDR_EXPR: 482 /* If this is not a straight-forward "&var", but rather something 483 like "&var.a", then we may need special handling. */ 484 if (TREE_CODE (TREE_OPERAND (t, 0)) != VAR_DECL) 485 { 486 bool save_changed; 487 488 /* If we're allowed more than just is_gimple_val, continue. */ 489 if (!wi->val_only) 490 { 491 *walk_subtrees = 1; 492 return NULL_TREE; 493 } 494 495 /* See if any substitution would be made. */ 496 save_changed = wi->changed; 497 wi->changed = false; 498 wi->val_only = false; 499 walk_tree (&TREE_OPERAND (t, 0), lower_emutls_1, wi, NULL); 500 wi->val_only = true; 501 502 /* If so, then extract this entire sub-expression "&p->a" into a 503 new assignment statement, and substitute yet another SSA_NAME. */ 504 if (wi->changed) 505 { 506 gimple x; 507 508 addr = create_tmp_var (TREE_TYPE (t)); 509 x = gimple_build_assign (addr, t); 510 gimple_set_location (x, d->loc); 511 512 addr = make_ssa_name (addr, x); 513 gimple_assign_set_lhs (x, addr); 514 515 gimple_seq_add_stmt (&d->seq, x); 516 517 *ptr = addr; 518 } 519 else 520 wi->changed = save_changed; 521 522 return NULL_TREE; 523 } 524 525 t = TREE_OPERAND (t, 0); 526 is_addr = true; 527 /* FALLTHRU */ 528 529 case VAR_DECL: 530 if (!DECL_THREAD_LOCAL_P (t)) 531 return NULL_TREE; 532 break; 533 534 default: 535 /* We're not interested in other decls or types, only subexpressions. */ 536 if (EXPR_P (t)) 537 *walk_subtrees = 1; 538 /* FALLTHRU */ 539 540 case SSA_NAME: 541 /* Special-case the return of SSA_NAME, since it's so common. */ 542 return NULL_TREE; 543 } 544 545 addr = gen_emutls_addr (t, d); 546 if (is_addr) 547 { 548 /* Replace "&var" with "addr" in the statement. */ 549 *ptr = addr; 550 } 551 else 552 { 553 /* Replace "var" with "*addr" in the statement. */ 554 t = build2 (MEM_REF, TREE_TYPE (t), addr, 555 build_int_cst (TREE_TYPE (addr), 0)); 556 *ptr = t; 557 } 558 559 wi->changed = true; 560 return NULL_TREE; 561 } 562 563 /* Lower all of the operands of STMT. */ 564 565 static void 566 lower_emutls_stmt (gimple stmt, struct lower_emutls_data *d) 567 { 568 struct walk_stmt_info wi; 569 570 d->loc = gimple_location (stmt); 571 572 memset (&wi, 0, sizeof (wi)); 573 wi.info = d; 574 wi.val_only = true; 575 walk_gimple_op (stmt, lower_emutls_1, &wi); 576 577 if (wi.changed) 578 update_stmt (stmt); 579 } 580 581 /* Lower the I'th operand of PHI. */ 582 583 static void 584 lower_emutls_phi_arg (gphi *phi, unsigned int i, 585 struct lower_emutls_data *d) 586 { 587 struct walk_stmt_info wi; 588 struct phi_arg_d *pd = gimple_phi_arg (phi, i); 589 590 /* Early out for a very common case we don't care about. */ 591 if (TREE_CODE (pd->def) == SSA_NAME) 592 return; 593 594 d->loc = pd->locus; 595 596 memset (&wi, 0, sizeof (wi)); 597 wi.info = d; 598 wi.val_only = true; 599 walk_tree (&pd->def, lower_emutls_1, &wi, NULL); 600 601 /* For normal statements, we let update_stmt do its job. But for phi 602 nodes, we have to manipulate the immediate use list by hand. */ 603 if (wi.changed) 604 { 605 gcc_assert (TREE_CODE (pd->def) == SSA_NAME); 606 link_imm_use_stmt (&pd->imm_use, pd->def, phi); 607 } 608 } 609 610 /* Reset access variable for a given TLS variable data DATA. */ 611 612 bool 613 reset_access (varpool_node * const &, tls_var_data *data, void *) 614 { 615 data->access = NULL; 616 617 return true; 618 } 619 620 /* Clear the access variables, in order to begin a new block. */ 621 622 static inline void 623 clear_access_vars (void) 624 { 625 tls_map->traverse<void *, reset_access> (NULL); 626 } 627 628 /* Lower the entire function NODE. */ 629 630 static void 631 lower_emutls_function_body (struct cgraph_node *node) 632 { 633 struct lower_emutls_data d; 634 bool any_edge_inserts = false; 635 636 push_cfun (DECL_STRUCT_FUNCTION (node->decl)); 637 638 d.cfun_node = node; 639 d.builtin_decl = builtin_decl_explicit (BUILT_IN_EMUTLS_GET_ADDRESS); 640 /* This is where we introduce the declaration to the IL and so we have to 641 create a node for it. */ 642 d.builtin_node = cgraph_node::get_create (d.builtin_decl); 643 644 FOR_EACH_BB_FN (d.bb, cfun) 645 { 646 unsigned int i, nedge; 647 648 /* Lower each of the PHI nodes of the block, as we may have 649 propagated &tlsvar into a PHI argument. These loops are 650 arranged so that we process each edge at once, and each 651 PHI argument for that edge. */ 652 if (!gimple_seq_empty_p (phi_nodes (d.bb))) 653 { 654 /* The calls will be inserted on the edges, and the frequencies 655 will be computed during the commit process. */ 656 d.bb_freq = 0; 657 658 nedge = EDGE_COUNT (d.bb->preds); 659 for (i = 0; i < nedge; ++i) 660 { 661 edge e = EDGE_PRED (d.bb, i); 662 663 /* We can re-use any SSA_NAME created on this edge. */ 664 clear_access_vars (); 665 d.seq = NULL; 666 667 for (gphi_iterator gsi = gsi_start_phis (d.bb); 668 !gsi_end_p (gsi); 669 gsi_next (&gsi)) 670 lower_emutls_phi_arg (gsi.phi (), i, &d); 671 672 /* Insert all statements generated by all phi nodes for this 673 particular edge all at once. */ 674 if (d.seq) 675 { 676 gsi_insert_seq_on_edge (e, d.seq); 677 any_edge_inserts = true; 678 } 679 } 680 } 681 682 d.bb_freq = compute_call_stmt_bb_frequency (current_function_decl, d.bb); 683 684 /* We can re-use any SSA_NAME created during this basic block. */ 685 clear_access_vars (); 686 687 /* Lower each of the statements of the block. */ 688 for (gimple_stmt_iterator gsi = gsi_start_bb (d.bb); !gsi_end_p (gsi); 689 gsi_next (&gsi)) 690 { 691 d.seq = NULL; 692 lower_emutls_stmt (gsi_stmt (gsi), &d); 693 694 /* If any new statements were created, insert them immediately 695 before the first use. This prevents variable lifetimes from 696 becoming unnecessarily long. */ 697 if (d.seq) 698 gsi_insert_seq_before (&gsi, d.seq, GSI_SAME_STMT); 699 } 700 } 701 702 if (any_edge_inserts) 703 gsi_commit_edge_inserts (); 704 705 pop_cfun (); 706 } 707 708 /* Create emutls variable for VAR, DATA is pointer to static 709 ctor body we can add constructors to. 710 Callback for varpool_for_variable_and_aliases. */ 711 712 static bool 713 create_emultls_var (varpool_node *var, void *data) 714 { 715 tree cdecl; 716 tls_var_data value; 717 718 cdecl = new_emutls_decl (var->decl, 719 var->alias && var->analyzed 720 ? var->get_alias_target ()->decl : NULL); 721 722 varpool_node *cvar = varpool_node::get (cdecl); 723 724 if (!var->alias) 725 { 726 /* Make sure the COMMON block control variable gets initialized. 727 Note that there's no point in doing this for aliases; we only 728 need to do this once for the main variable. */ 729 emutls_common_1 (var->decl, cdecl, (tree *)data); 730 } 731 if (var->alias && !var->analyzed) 732 cvar->alias = true; 733 734 /* Indicate that the value of the TLS variable may be found elsewhere, 735 preventing the variable from re-appearing in the GIMPLE. We cheat 736 and use the control variable here (rather than a full call_expr), 737 which is special-cased inside the DWARF2 output routines. */ 738 SET_DECL_VALUE_EXPR (var->decl, cdecl); 739 DECL_HAS_VALUE_EXPR_P (var->decl) = 1; 740 741 value.control_var = cvar; 742 tls_map->put (var, value); 743 744 return false; 745 } 746 747 /* Main entry point to the tls lowering pass. */ 748 749 static unsigned int 750 ipa_lower_emutls (void) 751 { 752 varpool_node *var; 753 cgraph_node *func; 754 bool any_aliases = false; 755 tree ctor_body = NULL; 756 hash_set <varpool_node *> visited; 757 auto_vec <varpool_node *> tls_vars; 758 759 /* Examine all global variables for TLS variables. */ 760 FOR_EACH_VARIABLE (var) 761 if (DECL_THREAD_LOCAL_P (var->decl) 762 && !visited.add (var)) 763 { 764 gcc_checking_assert (TREE_STATIC (var->decl) 765 || DECL_EXTERNAL (var->decl)); 766 tls_vars.safe_push (var); 767 if (var->alias && var->definition 768 && !visited.add (var->ultimate_alias_target ())) 769 tls_vars.safe_push (var->ultimate_alias_target ()); 770 } 771 772 /* If we found no TLS variables, then there is no further work to do. */ 773 if (tls_vars.is_empty ()) 774 { 775 if (dump_file) 776 fprintf (dump_file, "No TLS variables found.\n"); 777 return 0; 778 } 779 780 tls_map = new hash_map <varpool_node *, tls_var_data> (); 781 782 /* Create the control variables for each TLS variable. */ 783 for (unsigned i = 0; i < tls_vars.length (); i++) 784 { 785 var = tls_vars[i]; 786 787 if (var->alias && !var->analyzed) 788 any_aliases = true; 789 else if (!var->alias) 790 var->call_for_symbol_and_aliases (create_emultls_var, &ctor_body, true); 791 } 792 793 /* If there were any aliases, then frob the alias_pairs vector. */ 794 if (any_aliases) 795 { 796 alias_pair *p; 797 unsigned int i; 798 FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p) 799 if (DECL_THREAD_LOCAL_P (p->decl)) 800 { 801 p->decl = tls_map->get 802 (varpool_node::get (p->decl))->control_var->decl; 803 p->target = get_emutls_object_name (p->target); 804 } 805 } 806 807 /* Adjust all uses of TLS variables within the function bodies. */ 808 FOR_EACH_DEFINED_FUNCTION (func) 809 if (func->lowered) 810 lower_emutls_function_body (func); 811 812 /* Generate the constructor for any COMMON control variables created. */ 813 if (ctor_body) 814 cgraph_build_static_cdtor ('I', ctor_body, DEFAULT_INIT_PRIORITY); 815 816 delete tls_map; 817 818 return 0; 819 } 820 821 namespace { 822 823 const pass_data pass_data_ipa_lower_emutls = 824 { 825 SIMPLE_IPA_PASS, /* type */ 826 "emutls", /* name */ 827 OPTGROUP_NONE, /* optinfo_flags */ 828 TV_IPA_OPT, /* tv_id */ 829 ( PROP_cfg | PROP_ssa ), /* properties_required */ 830 0, /* properties_provided */ 831 0, /* properties_destroyed */ 832 0, /* todo_flags_start */ 833 0, /* todo_flags_finish */ 834 }; 835 836 class pass_ipa_lower_emutls : public simple_ipa_opt_pass 837 { 838 public: 839 pass_ipa_lower_emutls (gcc::context *ctxt) 840 : simple_ipa_opt_pass (pass_data_ipa_lower_emutls, ctxt) 841 {} 842 843 /* opt_pass methods: */ 844 virtual bool gate (function *) 845 { 846 /* If the target supports TLS natively, we need do nothing here. */ 847 return !targetm.have_tls; 848 } 849 850 virtual unsigned int execute (function *) { return ipa_lower_emutls (); } 851 852 }; // class pass_ipa_lower_emutls 853 854 } // anon namespace 855 856 simple_ipa_opt_pass * 857 make_pass_ipa_lower_emutls (gcc::context *ctxt) 858 { 859 return new pass_ipa_lower_emutls (ctxt); 860 } 861