1 /* Lower TLS operations to emulation functions.
2 Copyright (C) 2006, 2007, 2008, 2009, 2010
3 Free Software Foundation, Inc.
5 This file is part of GCC.
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
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
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/>. */
23 #include "coretypes.h"
26 #include "tree-pass.h"
27 #include "tree-flow.h"
29 #include "langhooks.h"
31 #include "targhooks.h"
32 #include "tree-iterator.h"
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.
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.
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
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. */
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
61 static varpool_node_set tls_vars
;
62 static VEC(varpool_node_ptr
, heap
) *control_vars
;
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
;
68 /* The type of the control structure, shared with the emutls.c runtime. */
69 static tree emutls_object_type
;
71 #if !defined (NO_DOT_IN_LABEL)
72 # define EMUTLS_SEPARATOR "."
73 #elif !defined (NO_DOLLAR_IN_LABEL)
74 # define EMUTLS_SEPARATOR "$"
76 # define EMUTLS_SEPARATOR "_"
79 /* Create an IDENTIFIER_NODE by prefixing PREFIX to the
80 IDENTIFIER_NODE NAME's name. */
83 prefix_name (const char *prefix
, tree name
)
85 unsigned plen
= strlen (prefix
);
86 unsigned nlen
= strlen (IDENTIFIER_POINTER (name
));
87 char *toname
= (char *) alloca (plen
+ nlen
+ 1);
89 memcpy (toname
, prefix
, plen
);
90 memcpy (toname
+ plen
, IDENTIFIER_POINTER (name
), nlen
+ 1);
92 return get_identifier (toname
);
95 /* Create an identifier for the struct __emutls_object, given an identifier
96 of the DECL_ASSEMBLY_NAME of the original object. */
99 get_emutls_object_name (tree name
)
101 const char *prefix
= (targetm
.emutls
.var_prefix
102 ? targetm
.emutls
.var_prefix
103 : "__emutls_v" EMUTLS_SEPARATOR
);
104 return prefix_name (prefix
, name
);
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. */
112 default_emutls_var_fields (tree type
, tree
*name ATTRIBUTE_UNUSED
)
114 tree word_type_node
, field
, next_field
;
116 field
= build_decl (UNKNOWN_LOCATION
,
117 FIELD_DECL
, get_identifier ("__templ"), ptr_type_node
);
118 DECL_CONTEXT (field
) = type
;
121 field
= build_decl (UNKNOWN_LOCATION
,
122 FIELD_DECL
, get_identifier ("__offset"),
124 DECL_CONTEXT (field
) = type
;
125 DECL_CHAIN (field
) = next_field
;
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"),
132 DECL_CONTEXT (field
) = type
;
133 DECL_CHAIN (field
) = next_field
;
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
;
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. */
149 default_emutls_var_init (tree to
, tree decl
, tree proxy
)
151 VEC(constructor_elt
,gc
) *v
= VEC_alloc (constructor_elt
, gc
, 4);
153 tree type
= TREE_TYPE (to
);
154 tree field
= TYPE_FIELDS (type
);
157 elt
.value
= fold_convert (TREE_TYPE (field
), DECL_SIZE_UNIT (decl
));
158 VEC_quick_push (constructor_elt
, v
, elt
);
160 field
= DECL_CHAIN (field
);
162 elt
.value
= build_int_cst (TREE_TYPE (field
),
163 DECL_ALIGN_UNIT (decl
));
164 VEC_quick_push (constructor_elt
, v
, elt
);
166 field
= DECL_CHAIN (field
);
168 elt
.value
= null_pointer_node
;
169 VEC_quick_push (constructor_elt
, v
, elt
);
171 field
= DECL_CHAIN (field
);
174 VEC_quick_push (constructor_elt
, v
, elt
);
176 return build_constructor (type
, v
);
179 /* Create the structure for struct __emutls_object. This should match the
180 structure at the top of emutls.c, modulo the union there. */
183 get_emutls_object_type (void)
185 tree type
, type_name
, field
;
187 type
= emutls_object_type
;
191 emutls_object_type
= type
= lang_hooks
.types
.make_type (RECORD_TYPE
);
193 field
= targetm
.emutls
.var_fields (type
, &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
;
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. */
209 get_emutls_init_templ_addr (tree decl
)
213 if (targetm
.emutls
.register_common
&& !DECL_INITIAL (decl
)
214 && !DECL_SECTION_NAME (decl
))
215 return null_pointer_node
;
217 name
= DECL_ASSEMBLER_NAME (decl
);
218 if (!targetm
.emutls
.tmpl_prefix
|| targetm
.emutls
.tmpl_prefix
[0])
220 const char *prefix
= (targetm
.emutls
.tmpl_prefix
221 ? targetm
.emutls
.tmpl_prefix
222 : "__emutls_t" EMUTLS_SEPARATOR
);
223 name
= prefix_name (prefix
, name
);
226 to
= build_decl (DECL_SOURCE_LOCATION (decl
),
227 VAR_DECL
, name
, TREE_TYPE (decl
));
228 SET_DECL_ASSEMBLER_NAME (to
, DECL_NAME (to
));
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
);
238 DECL_WEAK (to
) = DECL_WEAK (decl
);
239 if (DECL_ONE_ONLY (decl
))
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
);
247 TREE_STATIC (to
) = 1;
249 DECL_VISIBILITY_SPECIFIED (to
) = DECL_VISIBILITY_SPECIFIED (decl
);
250 DECL_INITIAL (to
) = DECL_INITIAL (decl
);
251 DECL_INITIAL (decl
) = NULL
;
253 if (targetm
.emutls
.tmpl_section
)
255 DECL_SECTION_NAME (to
)
256 = build_string (strlen (targetm
.emutls
.tmpl_section
),
257 targetm
.emutls
.tmpl_section
);
260 /* Create varpool node for the new variable and finalize it if it is
262 if (DECL_EXTERNAL (to
))
263 varpool_node_for_decl (to
);
265 varpool_add_new_variable (to
);
266 return build_fold_addr_expr (to
);
269 /* Create and return the control variable for the TLS variable DECL. */
272 new_emutls_decl (tree decl
, tree alias_of
)
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 ());
281 SET_DECL_ASSEMBLER_NAME (to
, DECL_NAME (to
));
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;
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
);
301 DECL_ATTRIBUTES (to
) = targetm
.merge_decl_attributes (decl
, to
);
303 if (DECL_ONE_ONLY (decl
))
304 make_decl_one_only (to
, DECL_ASSEMBLER_NAME (to
));
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;
311 /* If the target wants the control variables grouped, do so. */
312 if (!DECL_COMMON (to
) && targetm
.emutls
.var_section
)
314 DECL_SECTION_NAME (to
)
315 = build_string (strlen (targetm
.emutls
.var_section
),
316 targetm
.emutls
.var_section
);
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
)))
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);
332 /* Create varpool node for the new variable and finalize it if it is
334 if (DECL_EXTERNAL (to
))
335 varpool_node_for_decl (to
);
337 varpool_add_new_variable (to
);
339 varpool_create_variable_alias (to
,
341 (DECL_ASSEMBLER_NAME (DECL_VALUE_EXPR (alias_of
)))->symbol
.decl
);
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. */
349 emutls_index (tree decl
)
351 varpool_node_set_iterator i
;
353 i
= varpool_node_set_find (tls_vars
, varpool_get_node (decl
));
354 gcc_assert (i
.index
!= ~0u);
359 /* Look up the control variable for the TLS variable DECL. */
362 emutls_decl (tree decl
)
364 struct varpool_node
*var
;
367 i
= emutls_index (decl
);
368 var
= VEC_index (varpool_node_ptr
, control_vars
, i
);
369 return var
->symbol
.decl
;
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. */
378 emutls_common_1 (tree tls_decl
, tree control_decl
, tree
*pstmts
)
383 if (! DECL_COMMON (tls_decl
)
384 || (DECL_INITIAL (tls_decl
)
385 && DECL_INITIAL (tls_decl
) != error_mark_node
))
388 word_type_node
= lang_hooks
.types
.type_for_mode (word_mode
, 1);
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
));
398 append_to_statement_list (x
, pstmts
);
401 struct lower_emutls_data
403 struct cgraph_node
*cfun_node
;
404 struct cgraph_node
*builtin_node
;
412 /* Given a TLS variable DECL, return an SSA_NAME holding its address.
413 Append any new computation statements required to D->SEQ. */
416 gen_emutls_addr (tree decl
, struct lower_emutls_data
*d
)
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
);
426 struct varpool_node
*cvar
;
430 cvar
= VEC_index (varpool_node_ptr
, control_vars
, index
);
431 cdecl = cvar
->symbol
.decl
;
432 TREE_ADDRESSABLE (cdecl) = 1;
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
);
438 addr
= make_ssa_name (addr
, x
);
439 gimple_call_set_lhs (x
, addr
);
441 gimple_seq_add_stmt (&d
->seq
, x
);
443 cgraph_create_edge (d
->cfun_node
, d
->builtin_node
, x
,
444 d
->bb
->count
, d
->bb_freq
);
446 /* We may be adding a new reference to a new variable to the function.
447 This means we have to play with the ipa-reference web. */
448 ipa_record_reference ((symtab_node
)d
->cfun_node
, (symtab_node
)cvar
, IPA_REF_ADDR
, x
);
450 /* Record this ssa_name for possible use later in the basic block. */
451 VEC_replace (tree
, access_vars
, index
, addr
);
457 /* Callback for walk_gimple_op. D = WI->INFO is a struct lower_emutls_data.
458 Given an operand *PTR within D->STMT, if the operand references a TLS
459 variable, then lower the reference to a call to the runtime. Insert
460 any new statements required into D->SEQ; the caller is responsible for
461 placing those appropriately. */
464 lower_emutls_1 (tree
*ptr
, int *walk_subtrees
, void *cb_data
)
466 struct walk_stmt_info
*wi
= (struct walk_stmt_info
*) cb_data
;
467 struct lower_emutls_data
*d
= (struct lower_emutls_data
*) wi
->info
;
469 bool is_addr
= false;
474 switch (TREE_CODE (t
))
477 /* If this is not a straight-forward "&var", but rather something
478 like "&var.a", then we may need special handling. */
479 if (TREE_CODE (TREE_OPERAND (t
, 0)) != VAR_DECL
)
483 /* If we're allowed more than just is_gimple_val, continue. */
490 /* See if any substitution would be made. */
491 save_changed
= wi
->changed
;
493 wi
->val_only
= false;
494 walk_tree (&TREE_OPERAND (t
, 0), lower_emutls_1
, wi
, NULL
);
497 /* If so, then extract this entire sub-expression "&p->a" into a
498 new assignment statement, and substitute yet another SSA_NAME. */
503 addr
= create_tmp_var (TREE_TYPE (t
), NULL
);
504 x
= gimple_build_assign (addr
, t
);
505 gimple_set_location (x
, d
->loc
);
507 addr
= make_ssa_name (addr
, x
);
508 gimple_assign_set_lhs (x
, addr
);
510 gimple_seq_add_stmt (&d
->seq
, x
);
515 wi
->changed
= save_changed
;
520 t
= TREE_OPERAND (t
, 0);
525 if (!DECL_THREAD_LOCAL_P (t
))
530 /* We're not interested in other decls or types, only subexpressions. */
536 /* Special-case the return of SSA_NAME, since it's so common. */
540 addr
= gen_emutls_addr (t
, d
);
543 /* Replace "&var" with "addr" in the statement. */
548 /* Replace "var" with "*addr" in the statement. */
549 t
= build2 (MEM_REF
, TREE_TYPE (t
), addr
,
550 build_int_cst (TREE_TYPE (addr
), 0));
558 /* Lower all of the operands of STMT. */
561 lower_emutls_stmt (gimple stmt
, struct lower_emutls_data
*d
)
563 struct walk_stmt_info wi
;
565 d
->loc
= gimple_location (stmt
);
567 memset (&wi
, 0, sizeof (wi
));
570 walk_gimple_op (stmt
, lower_emutls_1
, &wi
);
576 /* Lower the I'th operand of PHI. */
579 lower_emutls_phi_arg (gimple phi
, unsigned int i
, struct lower_emutls_data
*d
)
581 struct walk_stmt_info wi
;
582 struct phi_arg_d
*pd
= gimple_phi_arg (phi
, i
);
584 /* Early out for a very common case we don't care about. */
585 if (TREE_CODE (pd
->def
) == SSA_NAME
)
590 memset (&wi
, 0, sizeof (wi
));
593 walk_tree (&pd
->def
, lower_emutls_1
, &wi
, NULL
);
595 /* For normal statements, we let update_stmt do its job. But for phi
596 nodes, we have to manipulate the immediate use list by hand. */
599 gcc_assert (TREE_CODE (pd
->def
) == SSA_NAME
);
600 link_imm_use_stmt (&pd
->imm_use
, pd
->def
, phi
);
604 /* Clear the ACCESS_VARS array, in order to begin a new block. */
607 clear_access_vars (void)
609 memset (VEC_address (tree
, access_vars
), 0,
610 VEC_length (tree
, access_vars
) * sizeof(tree
));
613 /* Lower the entire function NODE. */
616 lower_emutls_function_body (struct cgraph_node
*node
)
618 struct lower_emutls_data d
;
619 bool any_edge_inserts
= false;
621 push_cfun (DECL_STRUCT_FUNCTION (node
->symbol
.decl
));
624 d
.builtin_decl
= builtin_decl_explicit (BUILT_IN_EMUTLS_GET_ADDRESS
);
625 /* This is where we introduce the declaration to the IL and so we have to
626 create a node for it. */
627 d
.builtin_node
= cgraph_get_create_node (d
.builtin_decl
);
631 gimple_stmt_iterator gsi
;
632 unsigned int i
, nedge
;
634 /* Lower each of the PHI nodes of the block, as we may have
635 propagated &tlsvar into a PHI argument. These loops are
636 arranged so that we process each edge at once, and each
637 PHI argument for that edge. */
638 if (!gimple_seq_empty_p (phi_nodes (d
.bb
)))
640 /* The calls will be inserted on the edges, and the frequencies
641 will be computed during the commit process. */
644 nedge
= EDGE_COUNT (d
.bb
->preds
);
645 for (i
= 0; i
< nedge
; ++i
)
647 edge e
= EDGE_PRED (d
.bb
, i
);
649 /* We can re-use any SSA_NAME created on this edge. */
650 clear_access_vars ();
653 for (gsi
= gsi_start_phis (d
.bb
);
656 lower_emutls_phi_arg (gsi_stmt (gsi
), i
, &d
);
658 /* Insert all statements generated by all phi nodes for this
659 particular edge all at once. */
662 gsi_insert_seq_on_edge (e
, d
.seq
);
663 any_edge_inserts
= true;
668 d
.bb_freq
= compute_call_stmt_bb_frequency (current_function_decl
, d
.bb
);
670 /* We can re-use any SSA_NAME created during this basic block. */
671 clear_access_vars ();
673 /* Lower each of the statements of the block. */
674 for (gsi
= gsi_start_bb (d
.bb
); !gsi_end_p (gsi
); gsi_next (&gsi
))
677 lower_emutls_stmt (gsi_stmt (gsi
), &d
);
679 /* If any new statements were created, insert them immediately
680 before the first use. This prevents variable lifetimes from
681 becoming unnecessarily long. */
683 gsi_insert_seq_before (&gsi
, d
.seq
, GSI_SAME_STMT
);
687 if (any_edge_inserts
)
688 gsi_commit_edge_inserts ();
693 /* Create emutls variable for VAR, DATA is pointer to static
694 ctor body we can add constructors to.
695 Callback for varpool_for_variable_and_aliases. */
698 create_emultls_var (struct varpool_node
*var
, void *data
)
701 struct varpool_node
*cvar
;
703 cdecl = new_emutls_decl (var
->symbol
.decl
, var
->alias_of
);
705 cvar
= varpool_get_node (cdecl);
706 VEC_quick_push (varpool_node_ptr
, control_vars
, cvar
);
710 /* Make sure the COMMON block control variable gets initialized.
711 Note that there's no point in doing this for aliases; we only
712 need to do this once for the main variable. */
713 emutls_common_1 (var
->symbol
.decl
, cdecl, (tree
*)data
);
715 if (var
->alias
&& !var
->alias_of
)
718 /* Indicate that the value of the TLS variable may be found elsewhere,
719 preventing the variable from re-appearing in the GIMPLE. We cheat
720 and use the control variable here (rather than a full call_expr),
721 which is special-cased inside the DWARF2 output routines. */
722 SET_DECL_VALUE_EXPR (var
->symbol
.decl
, cdecl);
723 DECL_HAS_VALUE_EXPR_P (var
->symbol
.decl
) = 1;
727 /* Main entry point to the tls lowering pass. */
730 ipa_lower_emutls (void)
732 struct varpool_node
*var
;
733 struct cgraph_node
*func
;
734 bool any_aliases
= false;
735 tree ctor_body
= NULL
;
736 unsigned int i
, n_tls
;
738 tls_vars
= varpool_node_set_new ();
740 /* Examine all global variables for TLS variables. */
741 FOR_EACH_VARIABLE (var
)
742 if (DECL_THREAD_LOCAL_P (var
->symbol
.decl
))
744 gcc_checking_assert (TREE_STATIC (var
->symbol
.decl
)
745 || DECL_EXTERNAL (var
->symbol
.decl
));
746 varpool_node_set_add (tls_vars
, var
);
747 if (var
->alias
&& var
->analyzed
)
748 varpool_node_set_add (tls_vars
, varpool_variable_node (var
, NULL
));
751 /* If we found no TLS variables, then there is no further work to do. */
752 if (tls_vars
->nodes
== NULL
)
756 fprintf (dump_file
, "No TLS variables found.\n");
760 /* Allocate the on-the-side arrays that share indicies with the TLS vars. */
761 n_tls
= VEC_length (varpool_node_ptr
, tls_vars
->nodes
);
762 control_vars
= VEC_alloc (varpool_node_ptr
, heap
, n_tls
);
763 access_vars
= VEC_alloc (tree
, heap
, n_tls
);
764 VEC_safe_grow (tree
, heap
, access_vars
, n_tls
);
766 /* Create the control variables for each TLS variable. */
767 FOR_EACH_VEC_ELT (varpool_node_ptr
, tls_vars
->nodes
, i
, var
)
769 var
= VEC_index (varpool_node_ptr
, tls_vars
->nodes
, i
);
771 if (var
->alias
&& !var
->alias_of
)
773 else if (!var
->alias
)
774 varpool_for_node_and_aliases (var
, create_emultls_var
, &ctor_body
, true);
777 /* If there were any aliases, then frob the alias_pairs vector. */
781 FOR_EACH_VEC_ELT (alias_pair
, alias_pairs
, i
, p
)
782 if (DECL_THREAD_LOCAL_P (p
->decl
))
784 p
->decl
= emutls_decl (p
->decl
);
785 p
->target
= get_emutls_object_name (p
->target
);
789 /* Adjust all uses of TLS variables within the function bodies. */
790 FOR_EACH_DEFINED_FUNCTION (func
)
792 lower_emutls_function_body (func
);
794 /* Generate the constructor for any COMMON control variables created. */
796 cgraph_build_static_cdtor ('I', ctor_body
, DEFAULT_INIT_PRIORITY
);
798 VEC_free (varpool_node_ptr
, heap
, control_vars
);
799 VEC_free (tree
, heap
, access_vars
);
800 free_varpool_node_set (tls_vars
);
802 return TODO_ggc_collect
| TODO_verify_all
;
805 /* If the target supports TLS natively, we need do nothing here. */
810 return !targetm
.have_tls
;
813 struct simple_ipa_opt_pass pass_ipa_lower_emutls
=
818 gate_emutls
, /* gate */
819 ipa_lower_emutls
, /* execute */
822 0, /* static_pass_number */
823 TV_IPA_OPT
, /* tv_id */
824 PROP_cfg
| PROP_ssa
, /* properties_required */
825 0, /* properties_provided */
826 0, /* properties_destroyed */
827 0, /* todo_flags_start */
828 0, /* todo_flags_finish */