gcc/tree-emutls.c

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