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