OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [gcc/] [tree-emutls.c] - Blame information for rev 684

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 684 jeremybenn
/* 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
};

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.