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