gcc/tree-emutls.c

   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 };