gcc/tree-emutls.c

   1 /* Lower TLS operations to emulation functions.
   2    Copyright (C) 2006-2018 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   location_t loc;
 388   gimple_seq seq;
 389 };
 390
 391 /* Given a TLS variable DECL, return an SSA_NAME holding its address.
 392    Append any new computation statements required to D->SEQ.  */
 393
 394 static tree
 395 gen_emutls_addr (tree decl, struct lower_emutls_data *d)
 396 {
 397   /* Compute the address of the TLS variable with help from runtime.  */
 398   tls_var_data *data = tls_map->get (varpool_node::get (decl));
 399   tree addr = data->access;
 400
 401   if (addr == NULL)
 402     {
 403       varpool_node *cvar;
 404       tree cdecl;
 405       gcall *x;
 406
 407       cvar = data->control_var;
 408       cdecl = cvar->decl;
 409       TREE_ADDRESSABLE (cdecl) = 1;
 410
 411       addr = create_tmp_var (build_pointer_type (TREE_TYPE (decl)));
 412       x = gimple_build_call (d->builtin_decl, 1, build_fold_addr_expr (cdecl));
 413       gimple_set_location (x, d->loc);
 414
 415       addr = make_ssa_name (addr, x);
 416       gimple_call_set_lhs (x, addr);
 417
 418       gimple_seq_add_stmt (&d->seq, x);
 419
 420       d->cfun_node->create_edge (d->builtin_node, x, d->bb->count);
 421
 422       /* We may be adding a new reference to a new variable to the function.
 423          This means we have to play with the ipa-reference web.  */
 424       d->cfun_node->create_reference (cvar, IPA_REF_ADDR, x);
 425
 426       /* Record this ssa_name for possible use later in the basic block.  */
 427       data->access = addr;
 428     }
 429
 430   return addr;
 431 }
 432
 433 /* Callback for lower_emutls_1, return non-NULL if there is any TLS
 434    VAR_DECL in the subexpressions.  */
 435
 436 static tree
 437 lower_emutls_2 (tree *ptr, int *walk_subtrees, void *)
 438 {
 439   tree t = *ptr;
 440   if (TREE_CODE (t) == VAR_DECL)
 441     return DECL_THREAD_LOCAL_P (t) ? t : NULL_TREE;
 442   else if (!EXPR_P (t))
 443     *walk_subtrees = 0;
 444   return NULL_TREE;
 445 }
 446
 447 /* Callback for walk_gimple_op.  D = WI->INFO is a struct lower_emutls_data.
 448    Given an operand *PTR within D->STMT, if the operand references a TLS
 449    variable, then lower the reference to a call to the runtime.  Insert
 450    any new statements required into D->SEQ; the caller is responsible for
 451    placing those appropriately.  */
 452
 453 static tree
 454 lower_emutls_1 (tree *ptr, int *walk_subtrees, void *cb_data)
 455 {
 456   struct walk_stmt_info *wi = (struct walk_stmt_info *) cb_data;
 457   struct lower_emutls_data *d = (struct lower_emutls_data *) wi->info;
 458   tree t = *ptr;
 459   bool is_addr = false;
 460   tree addr;
 461
 462   *walk_subtrees = 0;
 463
 464   switch (TREE_CODE (t))
 465     {
 466     case ADDR_EXPR:
 467       /* If this is not a straight-forward "&var", but rather something
 468          like "&var.a", then we may need special handling.  */
 469       if (TREE_CODE (TREE_OPERAND (t, 0)) != VAR_DECL)
 470         {
 471           bool save_changed;
 472
 473           /* Gimple invariants are shareable trees, so before changing
 474              anything in them if we will need to change anything, unshare
 475              them.  */
 476           if (is_gimple_min_invariant (t)
 477               && walk_tree (&TREE_OPERAND (t, 0), lower_emutls_2, NULL, NULL))
 478             *ptr = t = unshare_expr (t);
 479
 480           /* If we're allowed more than just is_gimple_val, continue.  */
 481           if (!wi->val_only)
 482             {
 483               *walk_subtrees = 1;
 484               return NULL_TREE;
 485             }
 486
 487           /* See if any substitution would be made.  */
 488           save_changed = wi->changed;
 489           wi->changed = false;
 490           wi->val_only = false;
 491           walk_tree (&TREE_OPERAND (t, 0), lower_emutls_1, wi, NULL);
 492           wi->val_only = true;
 493
 494           /* If so, then extract this entire sub-expression "&p->a" into a
 495              new assignment statement, and substitute yet another SSA_NAME.  */
 496           if (wi->changed)
 497             {
 498               gimple *x;
 499
 500               addr = create_tmp_var (TREE_TYPE (t));
 501               x = gimple_build_assign (addr, t);
 502               gimple_set_location (x, d->loc);
 503
 504               addr = make_ssa_name (addr, x);
 505               gimple_assign_set_lhs (x, addr);
 506
 507               gimple_seq_add_stmt (&d->seq, x);
 508
 509               *ptr = addr;
 510             }
 511           else
 512             wi->changed = save_changed;
 513
 514           return NULL_TREE;
 515         }
 516
 517       t = TREE_OPERAND (t, 0);
 518       is_addr = true;
 519       /* FALLTHRU */
 520
 521     case VAR_DECL:
 522       if (!DECL_THREAD_LOCAL_P (t))
 523         return NULL_TREE;
 524       break;
 525
 526     default:
 527       /* We're not interested in other decls or types, only subexpressions.  */
 528       if (EXPR_P (t))
 529         *walk_subtrees = 1;
 530       /* FALLTHRU */
 531
 532     case SSA_NAME:
 533       /* Special-case the return of SSA_NAME, since it's so common.  */
 534       return NULL_TREE;
 535     }
 536
 537   addr = gen_emutls_addr (t, d);
 538   if (is_addr)
 539     {
 540       /* Replace "&var" with "addr" in the statement.  */
 541       *ptr = addr;
 542     }
 543   else
 544     {
 545       /* Replace "var" with "*addr" in the statement.  */
 546       t = build2 (MEM_REF, TREE_TYPE (t), addr,
 547                   build_int_cst (TREE_TYPE (addr), 0));
 548       *ptr = t;
 549     }
 550
 551   wi->changed = true;
 552   return NULL_TREE;
 553 }
 554
 555 /* Lower all of the operands of STMT.  */
 556
 557 static void
 558 lower_emutls_stmt (gimple *stmt, struct lower_emutls_data *d)
 559 {
 560   struct walk_stmt_info wi;
 561
 562   d->loc = gimple_location (stmt);
 563
 564   memset (&wi, 0, sizeof (wi));
 565   wi.info = d;
 566   wi.val_only = true;
 567   walk_gimple_op (stmt, lower_emutls_1, &wi);
 568
 569   if (wi.changed)
 570     update_stmt (stmt);
 571 }
 572
 573 /* Lower the I'th operand of PHI.  */
 574
 575 static void
 576 lower_emutls_phi_arg (gphi *phi, unsigned int i,
 577                       struct lower_emutls_data *d)
 578 {
 579   struct walk_stmt_info wi;
 580   struct phi_arg_d *pd = gimple_phi_arg (phi, i);
 581
 582   /* Early out for a very common case we don't care about.  */
 583   if (TREE_CODE (pd->def) == SSA_NAME)
 584     return;
 585
 586   d->loc = pd->locus;
 587
 588   memset (&wi, 0, sizeof (wi));
 589   wi.info = d;
 590   wi.val_only = true;
 591   walk_tree (&pd->def, lower_emutls_1, &wi, NULL);
 592
 593   /* For normal statements, we let update_stmt do its job.  But for phi
 594      nodes, we have to manipulate the immediate use list by hand.  */
 595   if (wi.changed)
 596     {
 597       gcc_assert (TREE_CODE (pd->def) == SSA_NAME);
 598       link_imm_use_stmt (&pd->imm_use, pd->def, phi);
 599     }
 600 }
 601
 602 /* Reset access variable for a given TLS variable data DATA.  */
 603
 604 bool
 605 reset_access (varpool_node * const &, tls_var_data *data, void *)
 606 {
 607   data->access = NULL;
 608
 609   return true;
 610 }
 611
 612 /* Clear the access variables, in order to begin a new block.  */
 613
 614 static inline void
 615 clear_access_vars (void)
 616 {
 617   tls_map->traverse<void *, reset_access> (NULL);
 618 }
 619
 620 /* Lower the entire function NODE.  */
 621
 622 static void
 623 lower_emutls_function_body (struct cgraph_node *node)
 624 {
 625   struct lower_emutls_data d;
 626   bool any_edge_inserts = false;
 627
 628   push_cfun (DECL_STRUCT_FUNCTION (node->decl));
 629
 630   d.cfun_node = node;
 631   d.builtin_decl = builtin_decl_explicit (BUILT_IN_EMUTLS_GET_ADDRESS);
 632   /* This is where we introduce the declaration to the IL and so we have to
 633      create a node for it.  */
 634   d.builtin_node = cgraph_node::get_create (d.builtin_decl);
 635
 636   FOR_EACH_BB_FN (d.bb, cfun)
 637     {
 638       unsigned int i, nedge;
 639
 640       /* Lower each of the PHI nodes of the block, as we may have
 641          propagated &tlsvar into a PHI argument.  These loops are
 642          arranged so that we process each edge at once, and each
 643          PHI argument for that edge.  */
 644       if (!gimple_seq_empty_p (phi_nodes (d.bb)))
 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 (gphi_iterator gsi = gsi_start_phis (d.bb);
 656                    !gsi_end_p (gsi);
 657                    gsi_next (&gsi))
 658                 lower_emutls_phi_arg (gsi.phi (), 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       /* We can re-use any SSA_NAME created during this basic block.  */
 671       clear_access_vars ();
 672
 673       /* Lower each of the statements of the block.  */
 674       for (gimple_stmt_iterator gsi = gsi_start_bb (d.bb); !gsi_end_p (gsi);
 675            gsi_next (&gsi))
 676         {
 677           d.seq = NULL;
 678           lower_emutls_stmt (gsi_stmt (gsi), &d);
 679
 680           /* If any new statements were created, insert them immediately
 681              before the first use.  This prevents variable lifetimes from
 682              becoming unnecessarily long.  */
 683           if (d.seq)
 684             gsi_insert_seq_before (&gsi, d.seq, GSI_SAME_STMT);
 685         }
 686     }
 687
 688   if (any_edge_inserts)
 689     gsi_commit_edge_inserts ();
 690
 691   pop_cfun ();
 692 }
 693
 694 /* Create emutls variable for VAR, DATA is pointer to static
 695    ctor body we can add constructors to.
 696    Callback for varpool_for_variable_and_aliases.  */
 697
 698 static bool
 699 create_emultls_var (varpool_node *var, void *data)
 700 {
 701   tree cdecl;
 702   tls_var_data value;
 703
 704   cdecl = new_emutls_decl (var->decl,
 705                            var->alias && var->analyzed
 706                            ? var->get_alias_target ()->decl : NULL);
 707
 708   varpool_node *cvar = varpool_node::get (cdecl);
 709
 710   if (!var->alias)
 711     {
 712       /* Make sure the COMMON block control variable gets initialized.
 713          Note that there's no point in doing this for aliases; we only
 714          need to do this once for the main variable.  */
 715       emutls_common_1 (var->decl, cdecl, (tree *)data);
 716     }
 717   if (var->alias && !var->analyzed)
 718     cvar->alias = true;
 719
 720   /* Indicate that the value of the TLS variable may be found elsewhere,
 721      preventing the variable from re-appearing in the GIMPLE.  We cheat
 722      and use the control variable here (rather than a full call_expr),
 723      which is special-cased inside the DWARF2 output routines.  */
 724   SET_DECL_VALUE_EXPR (var->decl, cdecl);
 725   DECL_HAS_VALUE_EXPR_P (var->decl) = 1;
 726
 727   value.control_var = cvar;
 728   tls_map->put (var, value);
 729
 730   return false;
 731 }
 732
 733 /* Main entry point to the tls lowering pass.  */
 734
 735 static unsigned int
 736 ipa_lower_emutls (void)
 737 {
 738   varpool_node *var;
 739   cgraph_node *func;
 740   bool any_aliases = false;
 741   tree ctor_body = NULL;
 742   hash_set <varpool_node *> visited;
 743   auto_vec <varpool_node *> tls_vars;
 744
 745   /* Examine all global variables for TLS variables.  */
 746   FOR_EACH_VARIABLE (var)
 747     if (DECL_THREAD_LOCAL_P (var->decl)
 748         && !visited.add (var))
 749       {
 750         gcc_checking_assert (TREE_STATIC (var->decl)
 751                              || DECL_EXTERNAL (var->decl));
 752         tls_vars.safe_push (var);
 753         if (var->alias && var->definition
 754             && !visited.add (var->ultimate_alias_target ()))
 755           tls_vars.safe_push (var->ultimate_alias_target ());
 756       }
 757
 758   /* If we found no TLS variables, then there is no further work to do.  */
 759   if (tls_vars.is_empty ())
 760     {
 761       if (dump_file)
 762         fprintf (dump_file, "No TLS variables found.\n");
 763       return 0;
 764     }
 765
 766   tls_map = new hash_map <varpool_node *, tls_var_data> ();
 767
 768   /* Create the control variables for each TLS variable.  */
 769   for (unsigned i = 0; i < tls_vars.length (); i++)
 770     {
 771       var = tls_vars[i];
 772
 773       if (var->alias && !var->analyzed)
 774         any_aliases = true;
 775       else if (!var->alias)
 776         var->call_for_symbol_and_aliases (create_emultls_var, &ctor_body, true);
 777     }
 778
 779   /* If there were any aliases, then frob the alias_pairs vector.  */
 780   if (any_aliases)
 781     {
 782       alias_pair *p;
 783       unsigned int i;
 784       FOR_EACH_VEC_SAFE_ELT (alias_pairs, i, p)
 785         if (DECL_THREAD_LOCAL_P (p->decl))
 786           {
 787             p->decl = tls_map->get
 788               (varpool_node::get (p->decl))->control_var->decl;
 789             p->target = get_emutls_object_name (p->target);
 790           }
 791     }
 792
 793   /* Adjust all uses of TLS variables within the function bodies.  */
 794   FOR_EACH_DEFINED_FUNCTION (func)
 795     if (func->lowered)
 796       lower_emutls_function_body (func);
 797
 798   /* Generate the constructor for any COMMON control variables created.  */
 799   if (ctor_body)
 800     cgraph_build_static_cdtor ('I', ctor_body, DEFAULT_INIT_PRIORITY);
 801
 802   delete tls_map;
 803
 804   return 0;
 805 }
 806
 807 namespace {
 808
 809 const pass_data pass_data_ipa_lower_emutls =
 810 {
 811   SIMPLE_IPA_PASS, /* type */
 812   "emutls", /* name */
 813   OPTGROUP_NONE, /* optinfo_flags */
 814   TV_IPA_OPT, /* tv_id */
 815   ( PROP_cfg | PROP_ssa ), /* properties_required */
 816   0, /* properties_provided */
 817   0, /* properties_destroyed */
 818   0, /* todo_flags_start */
 819   0, /* todo_flags_finish */
 820 };
 821
 822 class pass_ipa_lower_emutls : public simple_ipa_opt_pass
 823 {
 824 public:
 825   pass_ipa_lower_emutls (gcc::context *ctxt)
 826     : simple_ipa_opt_pass (pass_data_ipa_lower_emutls, ctxt)
 827   {}
 828
 829   /* opt_pass methods: */
 830   virtual bool gate (function *)
 831     {
 832       /* If the target supports TLS natively, we need do nothing here.  */
 833       return !targetm.have_tls;
 834     }
 835
 836   virtual unsigned int execute (function *) { return ipa_lower_emutls (); }
 837
 838 }; // class pass_ipa_lower_emutls
 839
 840 } // anon namespace
 841
 842 simple_ipa_opt_pass *
 843 make_pass_ipa_lower_emutls (gcc::context *ctxt)
 844 {
 845   return new pass_ipa_lower_emutls (ctxt);
 846 }