OSDN Git Service

* configure.ac (i[34567]86-*-*): Handle Solaris 2/x86 TLS support
[pf3gnuchains/gcc-fork.git] / gcc / varasm.c
1 /* Output variables, constants and external declarations, for GNU compiler.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4    2010  Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22
23 /* This file handles generation of all the assembler code
24    *except* the instructions of a function.
25    This includes declarations of variables and their initial values.
26
27    We also output the assembler code for constants stored in memory
28    and are responsible for combining constants with the same value.  */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "rtl.h"
35 #include "tree.h"
36 #include "flags.h"
37 #include "function.h"
38 #include "expr.h"
39 #include "hard-reg-set.h"
40 #include "regs.h"
41 #include "real.h"
42 #include "output.h"
43 #include "toplev.h"
44 #include "hashtab.h"
45 #include "ggc.h"
46 #include "langhooks.h"
47 #include "tm_p.h"
48 #include "debug.h"
49 #include "target.h"
50 #include "targhooks.h"
51 #include "tree-mudflap.h"
52 #include "cgraph.h"
53 #include "cfglayout.h"
54 #include "basic-block.h"
55 #include "tree-iterator.h"
56
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h"           /* Needed for external data
59                                    declarations for e.g. AIX 4.x.  */
60 #endif
61
62 /* The (assembler) name of the first globally-visible object output.  */
63 extern GTY(()) const char *first_global_object_name;
64 extern GTY(()) const char *weak_global_object_name;
65
66 const char *first_global_object_name;
67 const char *weak_global_object_name;
68
69 struct addr_const;
70 struct constant_descriptor_rtx;
71 struct rtx_constant_pool;
72
73 #define n_deferred_constants (crtl->varasm.deferred_constants)
74
75 /* Number for making the label on the next
76    constant that is stored in memory.  */
77
78 static GTY(()) int const_labelno;
79
80 /* Carry information from ASM_DECLARE_OBJECT_NAME
81    to ASM_FINISH_DECLARE_OBJECT.  */
82
83 int size_directive_output;
84
85 /* The last decl for which assemble_variable was called,
86    if it did ASM_DECLARE_OBJECT_NAME.
87    If the last call to assemble_variable didn't do that,
88    this holds 0.  */
89
90 tree last_assemble_variable_decl;
91
92 /* The following global variable indicates if the first basic block
93    in a function belongs to the cold partition or not.  */
94
95 bool first_function_block_is_cold;
96
97 /* We give all constants their own alias set.  Perhaps redundant with
98    MEM_READONLY_P, but pre-dates it.  */
99
100 static alias_set_type const_alias_set;
101
102 static const char *strip_reg_name (const char *);
103 static int contains_pointers_p (tree);
104 #ifdef ASM_OUTPUT_EXTERNAL
105 static bool incorporeal_function_p (tree);
106 #endif
107 static void decode_addr_const (tree, struct addr_const *);
108 static hashval_t const_desc_hash (const void *);
109 static int const_desc_eq (const void *, const void *);
110 static hashval_t const_hash_1 (const tree);
111 static int compare_constant (const tree, const tree);
112 static tree copy_constant (tree);
113 static void output_constant_def_contents (rtx);
114 static void output_addressed_constants (tree);
115 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
116 static unsigned min_align (unsigned, unsigned);
117 static void globalize_decl (tree);
118 #ifdef BSS_SECTION_ASM_OP
119 #ifdef ASM_OUTPUT_BSS
120 static void asm_output_bss (FILE *, tree, const char *,
121                             unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
122 #endif
123 #ifdef ASM_OUTPUT_ALIGNED_BSS
124 static void asm_output_aligned_bss (FILE *, tree, const char *,
125                                     unsigned HOST_WIDE_INT, int)
126      ATTRIBUTE_UNUSED;
127 #endif
128 #endif /* BSS_SECTION_ASM_OP */
129 static void mark_weak (tree);
130 static void output_constant_pool (const char *, tree);
131 \f
132 /* Well-known sections, each one associated with some sort of *_ASM_OP.  */
133 section *text_section;
134 section *data_section;
135 section *readonly_data_section;
136 section *sdata_section;
137 section *ctors_section;
138 section *dtors_section;
139 section *bss_section;
140 section *sbss_section;
141
142 /* Various forms of common section.  All are guaranteed to be nonnull.  */
143 section *tls_comm_section;
144 section *comm_section;
145 section *lcomm_section;
146
147 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
148    May be null.  */
149 section *bss_noswitch_section;
150
151 /* The section that holds the main exception table, when known.  The section
152    is set either by the target's init_sections hook or by the first call to
153    switch_to_exception_section.  */
154 section *exception_section;
155
156 /* The section that holds the DWARF2 frame unwind information, when known.
157    The section is set either by the target's init_sections hook or by the
158    first call to switch_to_eh_frame_section.  */
159 section *eh_frame_section;
160
161 /* asm_out_file's current section.  This is NULL if no section has yet
162    been selected or if we lose track of what the current section is.  */
163 section *in_section;
164
165 /* True if code for the current function is currently being directed
166    at the cold section.  */
167 bool in_cold_section_p;
168
169 /* A linked list of all the unnamed sections.  */
170 static GTY(()) section *unnamed_sections;
171
172 /* Return a nonzero value if DECL has a section attribute.  */
173 #ifndef IN_NAMED_SECTION
174 #define IN_NAMED_SECTION(DECL) \
175   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
176    && DECL_SECTION_NAME (DECL) != NULL_TREE)
177 #endif
178
179 /* Hash table of named sections.  */
180 static GTY((param_is (section))) htab_t section_htab;
181
182 /* A table of object_blocks, indexed by section.  */
183 static GTY((param_is (struct object_block))) htab_t object_block_htab;
184
185 /* The next number to use for internal anchor labels.  */
186 static GTY(()) int anchor_labelno;
187
188 /* A pool of constants that can be shared between functions.  */
189 static GTY(()) struct rtx_constant_pool *shared_constant_pool;
190
191 /* TLS emulation.  */
192
193 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
194      htab_t emutls_htab;
195 static GTY (()) tree emutls_object_type;
196 /* Emulated TLS objects have the TLS model TLS_MODEL_EMULATED.  This
197    macro can be used on them to distinguish the control variable from
198    the initialization template.  */
199 #define DECL_EMUTLS_VAR_P(D)  (TREE_TYPE (D) == emutls_object_type)
200
201 #if !defined (NO_DOT_IN_LABEL)
202 # define EMUTLS_SEPARATOR       "."
203 #elif !defined (NO_DOLLAR_IN_LABEL)
204 # define EMUTLS_SEPARATOR       "$"
205 #else
206 # define EMUTLS_SEPARATOR       "_"
207 #endif
208
209 /* Create an IDENTIFIER_NODE by prefixing PREFIX to the
210    IDENTIFIER_NODE NAME's name.  */
211
212 static tree
213 prefix_name (const char *prefix, tree name)
214 {
215   unsigned plen = strlen (prefix);
216   unsigned nlen = strlen (IDENTIFIER_POINTER (name));
217   char *toname = (char *) alloca (plen + nlen + 1);
218
219   memcpy (toname, prefix, plen);
220   memcpy (toname + plen, IDENTIFIER_POINTER (name), nlen + 1);
221
222   return get_identifier (toname);
223 }
224
225 /* Create an identifier for the struct __emutls_object, given an identifier
226    of the DECL_ASSEMBLY_NAME of the original object.  */
227
228 static tree
229 get_emutls_object_name (tree name)
230 {
231   const char *prefix = (targetm.emutls.var_prefix
232                         ? targetm.emutls.var_prefix
233                         : "__emutls_v" EMUTLS_SEPARATOR);
234   return prefix_name (prefix, name);
235 }
236
237 tree
238 default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED)
239 {
240   tree word_type_node, field, next_field;
241
242   field = build_decl (UNKNOWN_LOCATION,
243                       FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
244   DECL_CONTEXT (field) = type;
245   next_field = field;
246
247   field = build_decl (UNKNOWN_LOCATION,
248                       FIELD_DECL, get_identifier ("__offset"),
249                       ptr_type_node);
250   DECL_CONTEXT (field) = type;
251   TREE_CHAIN (field) = next_field;
252   next_field = field;
253
254   word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
255   field = build_decl (UNKNOWN_LOCATION,
256                       FIELD_DECL, get_identifier ("__align"),
257                       word_type_node);
258   DECL_CONTEXT (field) = type;
259   TREE_CHAIN (field) = next_field;
260   next_field = field;
261
262   field = build_decl (UNKNOWN_LOCATION,
263                       FIELD_DECL, get_identifier ("__size"), word_type_node);
264   DECL_CONTEXT (field) = type;
265   TREE_CHAIN (field) = next_field;
266
267   return field;
268 }
269
270 /* Create the structure for struct __emutls_object.  This should match the
271    structure at the top of emutls.c, modulo the union there.  */
272
273 static tree
274 get_emutls_object_type (void)
275 {
276   tree type, type_name, field;
277
278   type = emutls_object_type;
279   if (type)
280     return type;
281
282   emutls_object_type = type = lang_hooks.types.make_type (RECORD_TYPE);
283   type_name = NULL;
284   field = targetm.emutls.var_fields (type, &type_name);
285   if (!type_name)
286     type_name = get_identifier ("__emutls_object");
287   type_name = build_decl (UNKNOWN_LOCATION,
288                           TYPE_DECL, type_name, type);
289   TYPE_NAME (type) = type_name;
290   TYPE_FIELDS (type) = field;
291   layout_type (type);
292
293   return type;
294 }
295
296 /* Create a read-only variable like DECL, with the same DECL_INITIAL.
297    This will be used for initializing the emulated tls data area.  */
298
299 static tree
300 get_emutls_init_templ_addr (tree decl)
301 {
302   tree name, to;
303
304   if (targetm.emutls.register_common && !DECL_INITIAL (decl)
305       && !DECL_SECTION_NAME (decl))
306     return null_pointer_node;
307
308   name = DECL_ASSEMBLER_NAME (decl);
309   if (!targetm.emutls.tmpl_prefix || targetm.emutls.tmpl_prefix[0])
310     {
311       const char *prefix = (targetm.emutls.tmpl_prefix
312                             ? targetm.emutls.tmpl_prefix
313                             : "__emutls_t" EMUTLS_SEPARATOR);
314       name = prefix_name (prefix, name);
315     }
316
317   to = build_decl (DECL_SOURCE_LOCATION (decl),
318                    VAR_DECL, name, TREE_TYPE (decl));
319   SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
320   DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
321   DECL_ARTIFICIAL (to) = 1;
322   TREE_USED (to) = TREE_USED (decl);
323   TREE_READONLY (to) = 1;
324   DECL_IGNORED_P (to) = 1;
325   DECL_CONTEXT (to) = DECL_CONTEXT (decl);
326   DECL_SECTION_NAME (to) = DECL_SECTION_NAME (decl);
327
328   DECL_WEAK (to) = DECL_WEAK (decl);
329   if (DECL_ONE_ONLY (decl))
330     {
331       make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
332       TREE_STATIC (to) = TREE_STATIC (decl);
333       TREE_PUBLIC (to) = TREE_PUBLIC (decl);
334       DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
335     }
336   else
337     TREE_STATIC (to) = 1;
338
339   DECL_INITIAL (to) = DECL_INITIAL (decl);
340   DECL_INITIAL (decl) = NULL;
341
342   varpool_finalize_decl (to);
343   return build_fold_addr_expr (to);
344 }
345
346 /* When emulating tls, we use a control structure for use by the runtime.
347    Create and return this structure.  */
348
349 tree
350 emutls_decl (tree decl)
351 {
352   tree name, to;
353   struct tree_map *h, in;
354   void **loc;
355
356   if (targetm.have_tls || decl == NULL || decl == error_mark_node
357       || TREE_CODE (decl) != VAR_DECL || ! DECL_THREAD_LOCAL_P (decl))
358     return decl;
359
360   /* Look up the object in the hash; return the control structure if
361      it has already been created.  */
362   if (! emutls_htab)
363     emutls_htab = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
364
365   name = DECL_ASSEMBLER_NAME (decl);
366
367   /* Note that we use the hash of the decl's name, rather than a hash
368      of the decl's pointer.  In emutls_finish we iterate through the
369      hash table, and we want this traversal to be predictable.  */
370   in.hash = htab_hash_string (IDENTIFIER_POINTER (name));
371   in.base.from = decl;
372   loc = htab_find_slot_with_hash (emutls_htab, &in, in.hash, INSERT);
373   h = (struct tree_map *) *loc;
374   if (h != NULL)
375     to = h->to;
376   else
377     {
378       to = build_decl (DECL_SOURCE_LOCATION (decl),
379                        VAR_DECL, get_emutls_object_name (name),
380                        get_emutls_object_type ());
381
382       h = GGC_NEW (struct tree_map);
383       h->hash = in.hash;
384       h->base.from = decl;
385       h->to = to;
386       *(struct tree_map **) loc = h;
387
388       DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
389       DECL_ARTIFICIAL (to) = 1;
390       DECL_IGNORED_P (to) = 1;
391       TREE_READONLY (to) = 0;
392       SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
393       if (DECL_ONE_ONLY (decl))
394         make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
395       DECL_CONTEXT (to) = DECL_CONTEXT (decl);
396       if (targetm.emutls.var_align_fixed)
397         /* If we're not allowed to change the proxy object's
398            alignment, pretend it's been set by the user.  */
399         DECL_USER_ALIGN (to) = 1;
400     }
401
402   /* Note that these fields may need to be updated from time to time from
403      the original decl.  Consider:
404         extern __thread int i;
405         int foo() { return i; }
406         __thread int i = 1;
407      in which I goes from external to locally defined and initialized.  */
408
409   TREE_STATIC (to) = TREE_STATIC (decl);
410   TREE_USED (to) = TREE_USED (decl);
411   TREE_PUBLIC (to) = TREE_PUBLIC (decl);
412   DECL_EXTERNAL (to) = DECL_EXTERNAL (decl);
413   DECL_COMMON (to) = DECL_COMMON (decl);
414   DECL_WEAK (to) = DECL_WEAK (decl);
415   DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
416
417   return to;
418 }
419
420 static int
421 emutls_common_1 (void **loc, void *xstmts)
422 {
423   struct tree_map *h = *(struct tree_map **) loc;
424   tree args, x, *pstmts = (tree *) xstmts;
425   tree word_type_node;
426
427   if (! DECL_COMMON (h->base.from)
428       || (DECL_INITIAL (h->base.from)
429           && DECL_INITIAL (h->base.from) != error_mark_node))
430     return 1;
431
432   word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
433
434   /* The idea was to call get_emutls_init_templ_addr here, but if we
435      do this and there is an initializer, -fanchor_section loses,
436      because it would be too late to ensure the template is
437      output.  */
438   x = null_pointer_node;
439   args = tree_cons (NULL, x, NULL);
440   x = build_int_cst (word_type_node, DECL_ALIGN_UNIT (h->base.from));
441   args = tree_cons (NULL, x, args);
442   x = fold_convert (word_type_node, DECL_SIZE_UNIT (h->base.from));
443   args = tree_cons (NULL, x, args);
444   x = build_fold_addr_expr (h->to);
445   args = tree_cons (NULL, x, args);
446
447   x = built_in_decls[BUILT_IN_EMUTLS_REGISTER_COMMON];
448   x = build_function_call_expr (UNKNOWN_LOCATION, x, args);
449
450   append_to_statement_list (x, pstmts);
451   return 1;
452 }
453
454 void
455 emutls_finish (void)
456 {
457   if (targetm.emutls.register_common)
458     {
459       tree body = NULL_TREE;
460
461       if (emutls_htab == NULL)
462         return;
463
464       htab_traverse_noresize (emutls_htab, emutls_common_1, &body);
465       if (body == NULL_TREE)
466         return;
467
468       cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
469     }
470 }
471
472 /* Helper routines for maintaining section_htab.  */
473
474 static int
475 section_entry_eq (const void *p1, const void *p2)
476 {
477   const section *old = (const section *) p1;
478   const char *new_name = (const char *) p2;
479
480   return strcmp (old->named.name, new_name) == 0;
481 }
482
483 static hashval_t
484 section_entry_hash (const void *p)
485 {
486   const section *old = (const section *) p;
487   return htab_hash_string (old->named.name);
488 }
489
490 /* Return a hash value for section SECT.  */
491
492 static hashval_t
493 hash_section (section *sect)
494 {
495   if (sect->common.flags & SECTION_NAMED)
496     return htab_hash_string (sect->named.name);
497   return sect->common.flags;
498 }
499
500 /* Helper routines for maintaining object_block_htab.  */
501
502 static int
503 object_block_entry_eq (const void *p1, const void *p2)
504 {
505   const struct object_block *old = (const struct object_block *) p1;
506   const section *new_section = (const section *) p2;
507
508   return old->sect == new_section;
509 }
510
511 static hashval_t
512 object_block_entry_hash (const void *p)
513 {
514   const struct object_block *old = (const struct object_block *) p;
515   return hash_section (old->sect);
516 }
517
518 /* Return a new unnamed section with the given fields.  */
519
520 section *
521 get_unnamed_section (unsigned int flags, void (*callback) (const void *),
522                      const void *data)
523 {
524   section *sect;
525
526   sect = GGC_NEW (section);
527   sect->unnamed.common.flags = flags | SECTION_UNNAMED;
528   sect->unnamed.callback = callback;
529   sect->unnamed.data = data;
530   sect->unnamed.next = unnamed_sections;
531
532   unnamed_sections = sect;
533   return sect;
534 }
535
536 /* Return a SECTION_NOSWITCH section with the given fields.  */
537
538 static section *
539 get_noswitch_section (unsigned int flags, noswitch_section_callback callback)
540 {
541   section *sect;
542
543   sect = GGC_NEW (section);
544   sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
545   sect->noswitch.callback = callback;
546
547   return sect;
548 }
549
550 /* Return the named section structure associated with NAME.  Create
551    a new section with the given fields if no such structure exists.  */
552
553 section *
554 get_section (const char *name, unsigned int flags, tree decl)
555 {
556   section *sect, **slot;
557
558   slot = (section **)
559     htab_find_slot_with_hash (section_htab, name,
560                               htab_hash_string (name), INSERT);
561   flags |= SECTION_NAMED;
562   if (*slot == NULL)
563     {
564       sect = GGC_NEW (section);
565       sect->named.common.flags = flags;
566       sect->named.name = ggc_strdup (name);
567       sect->named.decl = decl;
568       *slot = sect;
569     }
570   else
571     {
572       sect = *slot;
573       if ((sect->common.flags & ~SECTION_DECLARED) != flags
574           && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
575         {
576           /* Sanity check user variables for flag changes.  */
577           if (decl == 0)
578             decl = sect->named.decl;
579           gcc_assert (decl);
580           error ("%+D causes a section type conflict", decl);
581         }
582     }
583   return sect;
584 }
585
586 /* Return true if the current compilation mode benefits from having
587    objects grouped into blocks.  */
588
589 static bool
590 use_object_blocks_p (void)
591 {
592   return flag_section_anchors;
593 }
594
595 /* Return the object_block structure for section SECT.  Create a new
596    structure if we haven't created one already.  Return null if SECT
597    itself is null.  */
598
599 static struct object_block *
600 get_block_for_section (section *sect)
601 {
602   struct object_block *block;
603   void **slot;
604
605   if (sect == NULL)
606     return NULL;
607
608   slot = htab_find_slot_with_hash (object_block_htab, sect,
609                                    hash_section (sect), INSERT);
610   block = (struct object_block *) *slot;
611   if (block == NULL)
612     {
613       block = (struct object_block *)
614         ggc_alloc_cleared (sizeof (struct object_block));
615       block->sect = sect;
616       *slot = block;
617     }
618   return block;
619 }
620
621 /* Create a symbol with label LABEL and place it at byte offset
622    OFFSET in BLOCK.  OFFSET can be negative if the symbol's offset
623    is not yet known.  LABEL must be a garbage-collected string.  */
624
625 static rtx
626 create_block_symbol (const char *label, struct object_block *block,
627                      HOST_WIDE_INT offset)
628 {
629   rtx symbol;
630   unsigned int size;
631
632   /* Create the extended SYMBOL_REF.  */
633   size = RTX_HDR_SIZE + sizeof (struct block_symbol);
634   symbol = (rtx) ggc_alloc_zone (size, &rtl_zone);
635
636   /* Initialize the normal SYMBOL_REF fields.  */
637   memset (symbol, 0, size);
638   PUT_CODE (symbol, SYMBOL_REF);
639   PUT_MODE (symbol, Pmode);
640   XSTR (symbol, 0) = label;
641   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
642
643   /* Initialize the block_symbol stuff.  */
644   SYMBOL_REF_BLOCK (symbol) = block;
645   SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
646
647   return symbol;
648 }
649
650 static void
651 initialize_cold_section_name (void)
652 {
653   const char *stripped_name;
654   char *name, *buffer;
655   tree dsn;
656
657   gcc_assert (cfun && current_function_decl);
658   if (crtl->subsections.unlikely_text_section_name)
659     return;
660
661   dsn = DECL_SECTION_NAME (current_function_decl);
662   if (flag_function_sections && dsn)
663     {
664       name = (char *) alloca (TREE_STRING_LENGTH (dsn) + 1);
665       memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
666
667       stripped_name = targetm.strip_name_encoding (name);
668
669       buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
670       crtl->subsections.unlikely_text_section_name = ggc_strdup (buffer);
671     }
672   else
673     crtl->subsections.unlikely_text_section_name =  UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
674 }
675
676 /* Tell assembler to switch to unlikely-to-be-executed text section.  */
677
678 section *
679 unlikely_text_section (void)
680 {
681   if (cfun)
682     {
683       if (!crtl->subsections.unlikely_text_section_name)
684         initialize_cold_section_name ();
685
686       return get_named_section (NULL, crtl->subsections.unlikely_text_section_name, 0);
687     }
688   else
689     return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
690 }
691
692 /* When called within a function context, return true if the function
693    has been assigned a cold text section and if SECT is that section.
694    When called outside a function context, return true if SECT is the
695    default cold section.  */
696
697 bool
698 unlikely_text_section_p (section *sect)
699 {
700   const char *name;
701
702   if (cfun)
703     name = crtl->subsections.unlikely_text_section_name;
704   else
705     name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
706
707   return (name
708           && sect
709           && SECTION_STYLE (sect) == SECTION_NAMED
710           && strcmp (name, sect->named.name) == 0);
711 }
712
713 /* Return a section with a particular name and with whatever SECTION_*
714    flags section_type_flags deems appropriate.  The name of the section
715    is taken from NAME if nonnull, otherwise it is taken from DECL's
716    DECL_SECTION_NAME.  DECL is the decl associated with the section
717    (see the section comment for details) and RELOC is as for
718    section_type_flags.  */
719
720 section *
721 get_named_section (tree decl, const char *name, int reloc)
722 {
723   unsigned int flags;
724
725   gcc_assert (!decl || DECL_P (decl));
726   if (name == NULL)
727     name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
728
729   flags = targetm.section_type_flags (decl, name, reloc);
730
731   return get_section (name, flags, decl);
732 }
733
734 /* If required, set DECL_SECTION_NAME to a unique name.  */
735
736 void
737 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
738                         int flag_function_or_data_sections)
739 {
740   if (DECL_SECTION_NAME (decl) == NULL_TREE
741       && targetm.have_named_sections
742       && (flag_function_or_data_sections
743           || DECL_ONE_ONLY (decl)))
744     targetm.asm_out.unique_section (decl, reloc);
745 }
746
747 #ifdef BSS_SECTION_ASM_OP
748
749 #ifdef ASM_OUTPUT_BSS
750
751 /* Utility function for ASM_OUTPUT_BSS for targets to use if
752    they don't support alignments in .bss.
753    ??? It is believed that this function will work in most cases so such
754    support is localized here.  */
755
756 static void
757 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
758                 const char *name,
759                 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
760                 unsigned HOST_WIDE_INT rounded)
761 {
762   gcc_assert (strcmp (XSTR (XEXP (DECL_RTL (decl), 0), 0), name) == 0);
763   targetm.asm_out.globalize_decl_name (file, decl);
764   switch_to_section (bss_section);
765 #ifdef ASM_DECLARE_OBJECT_NAME
766   last_assemble_variable_decl = decl;
767   ASM_DECLARE_OBJECT_NAME (file, name, decl);
768 #else
769   /* Standard thing is just output label for the object.  */
770   ASM_OUTPUT_LABEL (file, name);
771 #endif /* ASM_DECLARE_OBJECT_NAME */
772   ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
773 }
774
775 #endif
776
777 #ifdef ASM_OUTPUT_ALIGNED_BSS
778
779 /* Utility function for targets to use in implementing
780    ASM_OUTPUT_ALIGNED_BSS.
781    ??? It is believed that this function will work in most cases so such
782    support is localized here.  */
783
784 static void
785 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
786                         const char *name, unsigned HOST_WIDE_INT size,
787                         int align)
788 {
789   switch_to_section (bss_section);
790   ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
791 #ifdef ASM_DECLARE_OBJECT_NAME
792   last_assemble_variable_decl = decl;
793   ASM_DECLARE_OBJECT_NAME (file, name, decl);
794 #else
795   /* Standard thing is just output label for the object.  */
796   ASM_OUTPUT_LABEL (file, name);
797 #endif /* ASM_DECLARE_OBJECT_NAME */
798   ASM_OUTPUT_SKIP (file, size ? size : 1);
799 }
800
801 #endif
802
803 #endif /* BSS_SECTION_ASM_OP */
804
805 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
806 /* Return the hot section for function DECL.  Return text_section for
807    null DECLs.  */
808
809 static section *
810 hot_function_section (tree decl)
811 {
812   if (decl != NULL_TREE
813       && DECL_SECTION_NAME (decl) != NULL_TREE
814       && targetm.have_named_sections)
815     return get_named_section (decl, NULL, 0);
816   else
817     return text_section;
818 }
819 #endif
820
821 /* Return the section for function DECL.
822
823    If DECL is NULL_TREE, return the text section.  We can be passed
824    NULL_TREE under some circumstances by dbxout.c at least.  */
825
826 section *
827 function_section (tree decl)
828 {
829   int reloc = 0;
830
831   if (first_function_block_is_cold)
832     reloc = 1;
833
834 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
835   if (decl != NULL_TREE
836       && DECL_SECTION_NAME (decl) != NULL_TREE)
837     return reloc ? unlikely_text_section ()
838                  : get_named_section (decl, NULL, 0);
839   else
840     return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
841 #else
842   return reloc ? unlikely_text_section () : hot_function_section (decl);
843 #endif
844 }
845
846 section *
847 current_function_section (void)
848 {
849 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
850   if (current_function_decl != NULL_TREE
851       && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
852     return in_cold_section_p ? unlikely_text_section ()
853                              : get_named_section (current_function_decl,
854                                                   NULL, 0);
855   else
856     return targetm.asm_out.select_section (current_function_decl,
857                                            in_cold_section_p,
858                                            DECL_ALIGN (current_function_decl));
859 #else
860   return (in_cold_section_p
861           ? unlikely_text_section ()
862           : hot_function_section (current_function_decl));
863 #endif
864 }
865
866 /* Return the read-only data section associated with function DECL.  */
867
868 section *
869 default_function_rodata_section (tree decl)
870 {
871   if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
872     {
873       const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
874
875       if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
876         {
877           const char *dot;
878           size_t len;
879           char* rname;
880
881           dot = strchr (name + 1, '.');
882           if (!dot)
883             dot = name;
884           len = strlen (dot) + 8;
885           rname = (char *) alloca (len);
886
887           strcpy (rname, ".rodata");
888           strcat (rname, dot);
889           return get_section (rname, SECTION_LINKONCE, decl);
890         }
891       /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo.  */
892       else if (DECL_ONE_ONLY (decl)
893                && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
894         {
895           size_t len = strlen (name) + 1;
896           char *rname = (char *) alloca (len);
897
898           memcpy (rname, name, len);
899           rname[14] = 'r';
900           return get_section (rname, SECTION_LINKONCE, decl);
901         }
902       /* For .text.foo we want to use .rodata.foo.  */
903       else if (flag_function_sections && flag_data_sections
904                && strncmp (name, ".text.", 6) == 0)
905         {
906           size_t len = strlen (name) + 1;
907           char *rname = (char *) alloca (len + 2);
908
909           memcpy (rname, ".rodata", 7);
910           memcpy (rname + 7, name + 5, len - 5);
911           return get_section (rname, 0, decl);
912         }
913     }
914
915   return readonly_data_section;
916 }
917
918 /* Return the read-only data section associated with function DECL
919    for targets where that section should be always the single
920    readonly data section.  */
921
922 section *
923 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
924 {
925   return readonly_data_section;
926 }
927
928 /* Return the section to use for string merging.  */
929
930 static section *
931 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
932                           unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
933                           unsigned int flags ATTRIBUTE_UNUSED)
934 {
935   HOST_WIDE_INT len;
936
937   if (HAVE_GAS_SHF_MERGE && flag_merge_constants
938       && TREE_CODE (decl) == STRING_CST
939       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
940       && align <= 256
941       && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0
942       && TREE_STRING_LENGTH (decl) >= len)
943     {
944       enum machine_mode mode;
945       unsigned int modesize;
946       const char *str;
947       HOST_WIDE_INT i;
948       int j, unit;
949       char name[30];
950
951       mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
952       modesize = GET_MODE_BITSIZE (mode);
953       if (modesize >= 8 && modesize <= 256
954           && (modesize & (modesize - 1)) == 0)
955         {
956           if (align < modesize)
957             align = modesize;
958
959           str = TREE_STRING_POINTER (decl);
960           unit = GET_MODE_SIZE (mode);
961
962           /* Check for embedded NUL characters.  */
963           for (i = 0; i < len; i += unit)
964             {
965               for (j = 0; j < unit; j++)
966                 if (str[i + j] != '\0')
967                   break;
968               if (j == unit)
969                 break;
970             }
971           if (i == len - unit)
972             {
973               sprintf (name, ".rodata.str%d.%d", modesize / 8,
974                        (int) (align / 8));
975               flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
976               return get_section (name, flags, NULL);
977             }
978         }
979     }
980
981   return readonly_data_section;
982 }
983
984 /* Return the section to use for constant merging.  */
985
986 section *
987 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
988                             unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
989                             unsigned int flags ATTRIBUTE_UNUSED)
990 {
991   unsigned int modesize = GET_MODE_BITSIZE (mode);
992
993   if (HAVE_GAS_SHF_MERGE && flag_merge_constants
994       && mode != VOIDmode
995       && mode != BLKmode
996       && modesize <= align
997       && align >= 8
998       && align <= 256
999       && (align & (align - 1)) == 0)
1000     {
1001       char name[24];
1002
1003       sprintf (name, ".rodata.cst%d", (int) (align / 8));
1004       flags |= (align / 8) | SECTION_MERGE;
1005       return get_section (name, flags, NULL);
1006     }
1007   return readonly_data_section;
1008 }
1009 \f
1010 /* Given NAME, a putative register name, discard any customary prefixes.  */
1011
1012 static const char *
1013 strip_reg_name (const char *name)
1014 {
1015 #ifdef REGISTER_PREFIX
1016   if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
1017     name += strlen (REGISTER_PREFIX);
1018 #endif
1019   if (name[0] == '%' || name[0] == '#')
1020     name++;
1021   return name;
1022 }
1023 \f
1024 /* The user has asked for a DECL to have a particular name.  Set (or
1025    change) it in such a way that we don't prefix an underscore to
1026    it.  */
1027 void
1028 set_user_assembler_name (tree decl, const char *name)
1029 {
1030   char *starred = (char *) alloca (strlen (name) + 2);
1031   starred[0] = '*';
1032   strcpy (starred + 1, name);
1033   change_decl_assembler_name (decl, get_identifier (starred));
1034   SET_DECL_RTL (decl, NULL_RTX);
1035 }
1036 \f
1037 /* Decode an `asm' spec for a declaration as a register name.
1038    Return the register number, or -1 if nothing specified,
1039    or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
1040    or -3 if ASMSPEC is `cc' and is not recognized,
1041    or -4 if ASMSPEC is `memory' and is not recognized.
1042    Accept an exact spelling or a decimal number.
1043    Prefixes such as % are optional.  */
1044
1045 int
1046 decode_reg_name (const char *asmspec)
1047 {
1048   if (asmspec != 0)
1049     {
1050       int i;
1051
1052       /* Get rid of confusing prefixes.  */
1053       asmspec = strip_reg_name (asmspec);
1054
1055       /* Allow a decimal number as a "register name".  */
1056       for (i = strlen (asmspec) - 1; i >= 0; i--)
1057         if (! ISDIGIT (asmspec[i]))
1058           break;
1059       if (asmspec[0] != 0 && i < 0)
1060         {
1061           i = atoi (asmspec);
1062           if (i < FIRST_PSEUDO_REGISTER && i >= 0)
1063             return i;
1064           else
1065             return -2;
1066         }
1067
1068       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1069         if (reg_names[i][0]
1070             && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
1071           return i;
1072
1073 #ifdef ADDITIONAL_REGISTER_NAMES
1074       {
1075         static const struct { const char *const name; const int number; } table[]
1076           = ADDITIONAL_REGISTER_NAMES;
1077
1078         for (i = 0; i < (int) ARRAY_SIZE (table); i++)
1079           if (table[i].name[0]
1080               && ! strcmp (asmspec, table[i].name))
1081             return table[i].number;
1082       }
1083 #endif /* ADDITIONAL_REGISTER_NAMES */
1084
1085       if (!strcmp (asmspec, "memory"))
1086         return -4;
1087
1088       if (!strcmp (asmspec, "cc"))
1089         return -3;
1090
1091       return -2;
1092     }
1093
1094   return -1;
1095 }
1096 \f
1097 /* Return true if DECL's initializer is suitable for a BSS section.  */
1098
1099 static bool
1100 bss_initializer_p (const_tree decl)
1101 {
1102   return (DECL_INITIAL (decl) == NULL
1103           || DECL_INITIAL (decl) == error_mark_node
1104           || (flag_zero_initialized_in_bss
1105               /* Leave constant zeroes in .rodata so they
1106                  can be shared.  */
1107               && !TREE_READONLY (decl)
1108               && initializer_zerop (DECL_INITIAL (decl))));
1109 }
1110
1111 /* Compute the alignment of variable specified by DECL.
1112    DONT_OUTPUT_DATA is from assemble_variable.  */
1113
1114 void
1115 align_variable (tree decl, bool dont_output_data)
1116 {
1117   unsigned int align = DECL_ALIGN (decl);
1118
1119   /* In the case for initialing an array whose length isn't specified,
1120      where we have not yet been able to do the layout,
1121      figure out the proper alignment now.  */
1122   if (dont_output_data && DECL_SIZE (decl) == 0
1123       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1124     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1125
1126   /* Some object file formats have a maximum alignment which they support.
1127      In particular, a.out format supports a maximum alignment of 4.  */
1128   if (align > MAX_OFILE_ALIGNMENT)
1129     {
1130       warning (0, "alignment of %q+D is greater than maximum object "
1131                "file alignment.  Using %d", decl,
1132                MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1133       align = MAX_OFILE_ALIGNMENT;
1134     }
1135
1136   /* On some machines, it is good to increase alignment sometimes.  */
1137   if (! DECL_USER_ALIGN (decl))
1138     {
1139 #ifdef DATA_ALIGNMENT
1140       unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1141       /* Don't increase alignment too much for TLS variables - TLS space
1142          is too precious.  */
1143       if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD)
1144         align = data_align;
1145 #endif
1146 #ifdef CONSTANT_ALIGNMENT
1147       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1148         {
1149           unsigned int const_align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl),
1150                                                          align);
1151           /* Don't increase alignment too much for TLS variables - TLS space
1152              is too precious.  */
1153           if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD)
1154             align = const_align;
1155         }
1156 #endif
1157     }
1158
1159   /* Reset the alignment in case we have made it tighter, so we can benefit
1160      from it in get_pointer_alignment.  */
1161   DECL_ALIGN (decl) = align;
1162 }
1163
1164 /* Return the section into which the given VAR_DECL or CONST_DECL
1165    should be placed.  PREFER_NOSWITCH_P is true if a noswitch
1166    section should be used wherever possible.  */
1167
1168 static section *
1169 get_variable_section (tree decl, bool prefer_noswitch_p)
1170 {
1171   addr_space_t as = ADDR_SPACE_GENERIC;
1172   int reloc;
1173
1174   if (TREE_TYPE (decl) != error_mark_node)
1175     as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
1176
1177   if (DECL_COMMON (decl))
1178     {
1179       /* If the decl has been given an explicit section name, or it resides
1180          in a non-generic address space, then it isn't common, and shouldn't
1181          be handled as such.  */
1182       gcc_assert (DECL_SECTION_NAME (decl) == NULL
1183                   && ADDR_SPACE_GENERIC_P (as));
1184       if (DECL_THREAD_LOCAL_P (decl))
1185         return tls_comm_section;
1186       /* This cannot be common bss for an emulated TLS object without
1187          a register_common hook.  */
1188       else if (DECL_TLS_MODEL (decl) == TLS_MODEL_EMULATED
1189                && !targetm.emutls.register_common)
1190         ;
1191       else if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
1192         return comm_section;
1193     }
1194
1195   if (DECL_INITIAL (decl) == error_mark_node)
1196     reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1197   else if (DECL_INITIAL (decl))
1198     reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1199   else
1200     reloc = 0;
1201
1202   resolve_unique_section (decl, reloc, flag_data_sections);
1203   if (IN_NAMED_SECTION (decl))
1204     return get_named_section (decl, NULL, reloc);
1205
1206   if (ADDR_SPACE_GENERIC_P (as)
1207       && !DECL_THREAD_LOCAL_P (decl)
1208       && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
1209       && bss_initializer_p (decl))
1210     {
1211       if (!TREE_PUBLIC (decl))
1212         return lcomm_section;
1213       if (bss_noswitch_section)
1214         return bss_noswitch_section;
1215     }
1216
1217   return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
1218 }
1219
1220 /* Return the block into which object_block DECL should be placed.  */
1221
1222 static struct object_block *
1223 get_block_for_decl (tree decl)
1224 {
1225   section *sect;
1226
1227   if (TREE_CODE (decl) == VAR_DECL)
1228     {
1229       /* The object must be defined in this translation unit.  */
1230       if (DECL_EXTERNAL (decl))
1231         return NULL;
1232
1233       /* There's no point using object blocks for something that is
1234          isolated by definition.  */
1235       if (DECL_ONE_ONLY (decl))
1236         return NULL;
1237     }
1238
1239   /* We can only calculate block offsets if the decl has a known
1240      constant size.  */
1241   if (DECL_SIZE_UNIT (decl) == NULL)
1242     return NULL;
1243   if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
1244     return NULL;
1245
1246   /* Find out which section should contain DECL.  We cannot put it into
1247      an object block if it requires a standalone definition.  */
1248   if (TREE_CODE (decl) == VAR_DECL)
1249       align_variable (decl, 0);
1250   sect = get_variable_section (decl, true);
1251   if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1252     return NULL;
1253
1254   return get_block_for_section (sect);
1255 }
1256
1257 /* Make sure block symbol SYMBOL is in block BLOCK.  */
1258
1259 static void
1260 change_symbol_block (rtx symbol, struct object_block *block)
1261 {
1262   if (block != SYMBOL_REF_BLOCK (symbol))
1263     {
1264       gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
1265       SYMBOL_REF_BLOCK (symbol) = block;
1266     }
1267 }
1268
1269 /* Return true if it is possible to put DECL in an object_block.  */
1270
1271 static bool
1272 use_blocks_for_decl_p (tree decl)
1273 {
1274   /* Only data DECLs can be placed into object blocks.  */
1275   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
1276     return false;
1277
1278   /* Detect decls created by dw2_force_const_mem.  Such decls are
1279      special because DECL_INITIAL doesn't specify the decl's true value.
1280      dw2_output_indirect_constants will instead call assemble_variable
1281      with dont_output_data set to 1 and then print the contents itself.  */
1282   if (DECL_INITIAL (decl) == decl)
1283     return false;
1284
1285   /* If this decl is an alias, then we don't want to emit a definition.  */
1286   if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
1287     return false;
1288
1289   return true;
1290 }
1291
1292 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL.  DECL should
1293    have static storage duration.  In other words, it should not be an
1294    automatic variable, including PARM_DECLs.
1295
1296    There is, however, one exception: this function handles variables
1297    explicitly placed in a particular register by the user.
1298
1299    This is never called for PARM_DECL nodes.  */
1300
1301 void
1302 make_decl_rtl (tree decl)
1303 {
1304   const char *name = 0;
1305   int reg_number;
1306   rtx x;
1307
1308   /* Check that we are not being given an automatic variable.  */
1309   gcc_assert (TREE_CODE (decl) != PARM_DECL
1310               && TREE_CODE (decl) != RESULT_DECL);
1311
1312   /* A weak alias has TREE_PUBLIC set but not the other bits.  */
1313   gcc_assert (TREE_CODE (decl) != VAR_DECL
1314               || TREE_STATIC (decl)
1315               || TREE_PUBLIC (decl)
1316               || DECL_EXTERNAL (decl)
1317               || DECL_REGISTER (decl));
1318
1319   /* And that we were not given a type or a label.  */
1320   gcc_assert (TREE_CODE (decl) != TYPE_DECL
1321               && TREE_CODE (decl) != LABEL_DECL);
1322
1323   /* For a duplicate declaration, we can be called twice on the
1324      same DECL node.  Don't discard the RTL already made.  */
1325   if (DECL_RTL_SET_P (decl))
1326     {
1327       /* If the old RTL had the wrong mode, fix the mode.  */
1328       x = DECL_RTL (decl);
1329       if (GET_MODE (x) != DECL_MODE (decl))
1330         SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
1331
1332       if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1333         return;
1334
1335       /* ??? Another way to do this would be to maintain a hashed
1336          table of such critters.  Instead of adding stuff to a DECL
1337          to give certain attributes to it, we could use an external
1338          hash map from DECL to set of attributes.  */
1339
1340       /* Let the target reassign the RTL if it wants.
1341          This is necessary, for example, when one machine specific
1342          decl attribute overrides another.  */
1343       targetm.encode_section_info (decl, DECL_RTL (decl), false);
1344
1345       /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1346          on the new decl information.  */
1347       if (MEM_P (x)
1348           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1349           && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
1350         change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
1351
1352       /* Make this function static known to the mudflap runtime.  */
1353       if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1354         mudflap_enqueue_decl (decl);
1355
1356       return;
1357     }
1358
1359   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1360
1361   if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1362       && DECL_REGISTER (decl))
1363     {
1364       error ("register name not specified for %q+D", decl);
1365     }
1366   else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1367     {
1368       const char *asmspec = name+1;
1369       reg_number = decode_reg_name (asmspec);
1370       /* First detect errors in declaring global registers.  */
1371       if (reg_number == -1)
1372         error ("register name not specified for %q+D", decl);
1373       else if (reg_number < 0)
1374         error ("invalid register name for %q+D", decl);
1375       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1376         error ("data type of %q+D isn%'t suitable for a register",
1377                decl);
1378       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1379         error ("register specified for %q+D isn%'t suitable for data type",
1380                decl);
1381       /* Now handle properly declared static register variables.  */
1382       else
1383         {
1384           int nregs;
1385
1386           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1387             {
1388               DECL_INITIAL (decl) = 0;
1389               error ("global register variable has initial value");
1390             }
1391           if (TREE_THIS_VOLATILE (decl))
1392             warning (OPT_Wvolatile_register_var,
1393                      "optimization may eliminate reads and/or "
1394                      "writes to register variables");
1395
1396           /* If the user specified one of the eliminables registers here,
1397              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1398              confused with that register and be eliminated.  This usage is
1399              somewhat suspect...  */
1400
1401           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1402           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1403           REG_USERVAR_P (DECL_RTL (decl)) = 1;
1404
1405           if (TREE_STATIC (decl))
1406             {
1407               /* Make this register global, so not usable for anything
1408                  else.  */
1409 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1410               name = IDENTIFIER_POINTER (DECL_NAME (decl));
1411               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1412 #endif
1413               nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1414               while (nregs > 0)
1415                 globalize_reg (reg_number + --nregs);
1416             }
1417
1418           /* As a register variable, it has no section.  */
1419           return;
1420         }
1421     }
1422   /* Now handle ordinary static variables and functions (in memory).
1423      Also handle vars declared register invalidly.  */
1424   else if (name[0] == '*')
1425   {
1426 #ifdef REGISTER_PREFIX
1427     if (strlen (REGISTER_PREFIX) != 0)
1428       {
1429         reg_number = decode_reg_name (name);
1430         if (reg_number >= 0 || reg_number == -3)
1431           error ("register name given for non-register variable %q+D", decl);
1432       }
1433 #endif
1434   }
1435
1436   /* Specifying a section attribute on a variable forces it into a
1437      non-.bss section, and thus it cannot be common.  */
1438   gcc_assert (!(TREE_CODE (decl) == VAR_DECL
1439               && DECL_SECTION_NAME (decl) != NULL_TREE
1440               && DECL_INITIAL (decl) == NULL_TREE
1441               && DECL_COMMON (decl))
1442               || !DECL_COMMON (decl));
1443
1444   /* Variables can't be both common and weak.  */
1445   gcc_assert (TREE_CODE (decl) != VAR_DECL
1446               || !DECL_WEAK (decl)
1447               || !DECL_COMMON (decl));
1448
1449   if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1450     x = create_block_symbol (name, get_block_for_decl (decl), -1);
1451   else
1452     {
1453       enum machine_mode address_mode = Pmode;
1454       if (TREE_TYPE (decl) != error_mark_node)
1455         {
1456           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
1457           address_mode = targetm.addr_space.address_mode (as);
1458         }
1459       x = gen_rtx_SYMBOL_REF (address_mode, name);
1460     }
1461   SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1462   SET_SYMBOL_REF_DECL (x, decl);
1463
1464   x = gen_rtx_MEM (DECL_MODE (decl), x);
1465   if (TREE_CODE (decl) != FUNCTION_DECL)
1466     set_mem_attributes (x, decl, 1);
1467   SET_DECL_RTL (decl, x);
1468
1469   /* Optionally set flags or add text to the name to record information
1470      such as that it is a function name.
1471      If the name is changed, the macro ASM_OUTPUT_LABELREF
1472      will have to know how to strip this information.  */
1473   targetm.encode_section_info (decl, DECL_RTL (decl), true);
1474
1475   /* Make this function static known to the mudflap runtime.  */
1476   if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1477     mudflap_enqueue_decl (decl);
1478 }
1479
1480 /* Like make_decl_rtl, but inhibit creation of new alias sets when
1481    calling make_decl_rtl.  Also, reset DECL_RTL before returning the
1482    rtl.  */
1483
1484 rtx
1485 make_decl_rtl_for_debug (tree decl)
1486 {
1487   unsigned int save_aliasing_flag, save_mudflap_flag;
1488   rtx rtl;
1489
1490   if (DECL_RTL_SET_P (decl))
1491     return DECL_RTL (decl);
1492
1493   /* Kludge alert!  Somewhere down the call chain, make_decl_rtl will
1494      call new_alias_set.  If running with -fcompare-debug, sometimes
1495      we do not want to create alias sets that will throw the alias
1496      numbers off in the comparison dumps.  So... clearing
1497      flag_strict_aliasing will keep new_alias_set() from creating a
1498      new set.  It is undesirable to register decl with mudflap
1499      in this case as well.  */
1500   save_aliasing_flag = flag_strict_aliasing;
1501   flag_strict_aliasing = 0;
1502   save_mudflap_flag = flag_mudflap;
1503   flag_mudflap = 0;
1504
1505   rtl = DECL_RTL (decl);
1506   /* Reset DECL_RTL back, as various parts of the compiler expects
1507      DECL_RTL set meaning it is actually going to be output.  */
1508   SET_DECL_RTL (decl, NULL);
1509
1510   flag_strict_aliasing = save_aliasing_flag;
1511   flag_mudflap = save_mudflap_flag;
1512
1513   return rtl;
1514 }
1515 \f
1516 /* Output a string of literal assembler code
1517    for an `asm' keyword used between functions.  */
1518
1519 void
1520 assemble_asm (tree string)
1521 {
1522   app_enable ();
1523
1524   if (TREE_CODE (string) == ADDR_EXPR)
1525     string = TREE_OPERAND (string, 0);
1526
1527   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1528 }
1529
1530 /* Record an element in the table of global destructors.  SYMBOL is
1531    a SYMBOL_REF of the function to be called; PRIORITY is a number
1532    between 0 and MAX_INIT_PRIORITY.  */
1533
1534 void
1535 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1536                                   int priority ATTRIBUTE_UNUSED)
1537 {
1538 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1539   /* Tell GNU LD that this is part of the static destructor set.
1540      This will work for any system that uses stabs, most usefully
1541      aout systems.  */
1542   dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1543   dbxout_stab_value_label (XSTR (symbol, 0));
1544 #else
1545   sorry ("global destructors not supported on this target");
1546 #endif
1547 }
1548
1549 /* Write the address of the entity given by SYMBOL to SEC.  */
1550 void
1551 assemble_addr_to_section (rtx symbol, section *sec)
1552 {
1553   switch_to_section (sec);
1554   assemble_align (POINTER_SIZE);
1555   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1556 }
1557
1558 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1559    not) section for PRIORITY.  */
1560 section *
1561 get_cdtor_priority_section (int priority, bool constructor_p)
1562 {
1563   char buf[16];
1564
1565   /* ??? This only works reliably with the GNU linker.  */
1566   sprintf (buf, "%s.%.5u",
1567            constructor_p ? ".ctors" : ".dtors",
1568            /* Invert the numbering so the linker puts us in the proper
1569               order; constructors are run from right to left, and the
1570               linker sorts in increasing order.  */
1571            MAX_INIT_PRIORITY - priority);
1572   return get_section (buf, SECTION_WRITE, NULL);
1573 }
1574
1575 void
1576 default_named_section_asm_out_destructor (rtx symbol, int priority)
1577 {
1578   section *sec;
1579
1580   if (priority != DEFAULT_INIT_PRIORITY)
1581     sec = get_cdtor_priority_section (priority,
1582                                       /*constructor_p=*/false);
1583   else
1584     sec = get_section (".dtors", SECTION_WRITE, NULL);
1585
1586   assemble_addr_to_section (symbol, sec);
1587 }
1588
1589 #ifdef DTORS_SECTION_ASM_OP
1590 void
1591 default_dtor_section_asm_out_destructor (rtx symbol,
1592                                          int priority ATTRIBUTE_UNUSED)
1593 {
1594   assemble_addr_to_section (symbol, dtors_section);
1595 }
1596 #endif
1597
1598 /* Likewise for global constructors.  */
1599
1600 void
1601 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1602                                    int priority ATTRIBUTE_UNUSED)
1603 {
1604 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1605   /* Tell GNU LD that this is part of the static destructor set.
1606      This will work for any system that uses stabs, most usefully
1607      aout systems.  */
1608   dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1609   dbxout_stab_value_label (XSTR (symbol, 0));
1610 #else
1611   sorry ("global constructors not supported on this target");
1612 #endif
1613 }
1614
1615 void
1616 default_named_section_asm_out_constructor (rtx symbol, int priority)
1617 {
1618   section *sec;
1619
1620   if (priority != DEFAULT_INIT_PRIORITY)
1621     sec = get_cdtor_priority_section (priority,
1622                                       /*constructor_p=*/true);
1623   else
1624     sec = get_section (".ctors", SECTION_WRITE, NULL);
1625
1626   assemble_addr_to_section (symbol, sec);
1627 }
1628
1629 #ifdef CTORS_SECTION_ASM_OP
1630 void
1631 default_ctor_section_asm_out_constructor (rtx symbol,
1632                                           int priority ATTRIBUTE_UNUSED)
1633 {
1634   assemble_addr_to_section (symbol, ctors_section);
1635 }
1636 #endif
1637 \f
1638 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1639    a nonzero value if the constant pool should be output before the
1640    start of the function, or a zero value if the pool should output
1641    after the end of the function.  The default is to put it before the
1642    start.  */
1643
1644 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1645 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1646 #endif
1647
1648 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1649    to be output to assembler.
1650    Set first_global_object_name and weak_global_object_name as appropriate.  */
1651
1652 void
1653 notice_global_symbol (tree decl)
1654 {
1655   const char **type = &first_global_object_name;
1656
1657   if (first_global_object_name
1658       || !TREE_PUBLIC (decl)
1659       || DECL_EXTERNAL (decl)
1660       || !DECL_NAME (decl)
1661       || (TREE_CODE (decl) != FUNCTION_DECL
1662           && (TREE_CODE (decl) != VAR_DECL
1663               || (DECL_COMMON (decl)
1664                   && (DECL_INITIAL (decl) == 0
1665                       || DECL_INITIAL (decl) == error_mark_node))))
1666       || !MEM_P (DECL_RTL (decl)))
1667     return;
1668
1669   /* We win when global object is found, but it is useful to know about weak
1670      symbol as well so we can produce nicer unique names.  */
1671   if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib)
1672     type = &weak_global_object_name;
1673
1674   if (!*type)
1675     {
1676       const char *p;
1677       const char *name;
1678       rtx decl_rtl = DECL_RTL (decl);
1679
1680       p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1681       name = ggc_strdup (p);
1682
1683       *type = name;
1684     }
1685 }
1686
1687 /* Output assembler code for the constant pool of a function and associated
1688    with defining the name of the function.  DECL describes the function.
1689    NAME is the function's name.  For the constant pool, we use the current
1690    constant pool data.  */
1691
1692 void
1693 assemble_start_function (tree decl, const char *fnname)
1694 {
1695   int align;
1696   char tmp_label[100];
1697   bool hot_label_written = false;
1698
1699   crtl->subsections.unlikely_text_section_name = NULL;
1700
1701   first_function_block_is_cold = false;
1702   if (flag_reorder_blocks_and_partition)
1703     {
1704       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1705       crtl->subsections.hot_section_label = ggc_strdup (tmp_label);
1706       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1707       crtl->subsections.cold_section_label = ggc_strdup (tmp_label);
1708       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1709       crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label);
1710       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1711       crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label);
1712       const_labelno++;
1713     }
1714   else
1715     {
1716       crtl->subsections.hot_section_label = NULL;
1717       crtl->subsections.cold_section_label = NULL;
1718       crtl->subsections.hot_section_end_label = NULL;
1719       crtl->subsections.cold_section_end_label = NULL;
1720     }
1721
1722   /* The following code does not need preprocessing in the assembler.  */
1723
1724   app_disable ();
1725
1726   if (CONSTANT_POOL_BEFORE_FUNCTION)
1727     output_constant_pool (fnname, decl);
1728
1729   resolve_unique_section (decl, 0, flag_function_sections);
1730
1731   /* Make sure the not and cold text (code) sections are properly
1732      aligned.  This is necessary here in the case where the function
1733      has both hot and cold sections, because we don't want to re-set
1734      the alignment when the section switch happens mid-function.  */
1735
1736   if (flag_reorder_blocks_and_partition)
1737     {
1738       switch_to_section (unlikely_text_section ());
1739       assemble_align (DECL_ALIGN (decl));
1740       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label);
1741
1742       /* When the function starts with a cold section, we need to explicitly
1743          align the hot section and write out the hot section label.
1744          But if the current function is a thunk, we do not have a CFG.  */
1745       if (!cfun->is_thunk
1746           && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1747         {
1748           switch_to_section (text_section);
1749           assemble_align (DECL_ALIGN (decl));
1750           ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1751           hot_label_written = true;
1752           first_function_block_is_cold = true;
1753         }
1754     }
1755   else if (DECL_SECTION_NAME (decl))
1756     {
1757       /* Calls to function_section rely on first_function_block_is_cold
1758          being accurate.  The first block may be cold even if we aren't
1759          doing partitioning, if the entire function was decided by
1760          choose_function_section (predict.c) to be cold.  */
1761
1762       initialize_cold_section_name ();
1763
1764       if (crtl->subsections.unlikely_text_section_name
1765           && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1766                      crtl->subsections.unlikely_text_section_name) == 0)
1767         first_function_block_is_cold = true;
1768     }
1769
1770   in_cold_section_p = first_function_block_is_cold;
1771
1772   /* Switch to the correct text section for the start of the function.  */
1773
1774   switch_to_section (function_section (decl));
1775   if (flag_reorder_blocks_and_partition
1776       && !hot_label_written)
1777     ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1778
1779   /* Tell assembler to move to target machine's alignment for functions.  */
1780   align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT);
1781   if (align > 0)
1782     {
1783       ASM_OUTPUT_ALIGN (asm_out_file, align);
1784     }
1785
1786   /* Handle a user-specified function alignment.
1787      Note that we still need to align to DECL_ALIGN, as above,
1788      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1789   if (! DECL_USER_ALIGN (decl)
1790       && align_functions_log > align
1791       && optimize_function_for_speed_p (cfun))
1792     {
1793 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1794       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1795                                  align_functions_log, align_functions - 1);
1796 #else
1797       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1798 #endif
1799     }
1800
1801 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1802   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1803 #endif
1804
1805   if (!DECL_IGNORED_P (decl))
1806     (*debug_hooks->begin_function) (decl);
1807
1808   /* Make function name accessible from other files, if appropriate.  */
1809
1810   if (TREE_PUBLIC (decl))
1811     {
1812       notice_global_symbol (decl);
1813
1814       globalize_decl (decl);
1815
1816       maybe_assemble_visibility (decl);
1817     }
1818
1819   if (DECL_PRESERVE_P (decl))
1820     targetm.asm_out.mark_decl_preserved (fnname);
1821
1822   /* Do any machine/system dependent processing of the function name.  */
1823 #ifdef ASM_DECLARE_FUNCTION_NAME
1824   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1825 #else
1826   /* Standard thing is just output label for the function.  */
1827   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1828 #endif /* ASM_DECLARE_FUNCTION_NAME */
1829 }
1830
1831 /* Output assembler code associated with defining the size of the
1832    function.  DECL describes the function.  NAME is the function's name.  */
1833
1834 void
1835 assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1836 {
1837 #ifdef ASM_DECLARE_FUNCTION_SIZE
1838   /* We could have switched section in the middle of the function.  */
1839   if (flag_reorder_blocks_and_partition)
1840     switch_to_section (function_section (decl));
1841   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1842 #endif
1843   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1844     {
1845       output_constant_pool (fnname, decl);
1846       switch_to_section (function_section (decl)); /* need to switch back */
1847     }
1848   /* Output labels for end of hot/cold text sections (to be used by
1849      debug info.)  */
1850   if (flag_reorder_blocks_and_partition)
1851     {
1852       section *save_text_section;
1853
1854       save_text_section = in_section;
1855       switch_to_section (unlikely_text_section ());
1856       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label);
1857       if (first_function_block_is_cold)
1858         switch_to_section (text_section);
1859       else
1860         switch_to_section (function_section (decl));
1861       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label);
1862       switch_to_section (save_text_section);
1863     }
1864 }
1865 \f
1866 /* Assemble code to leave SIZE bytes of zeros.  */
1867
1868 void
1869 assemble_zeros (unsigned HOST_WIDE_INT size)
1870 {
1871   /* Do no output if -fsyntax-only.  */
1872   if (flag_syntax_only)
1873     return;
1874
1875 #ifdef ASM_NO_SKIP_IN_TEXT
1876   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1877      so we must output 0s explicitly in the text section.  */
1878   if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1879     {
1880       unsigned HOST_WIDE_INT i;
1881       for (i = 0; i < size; i++)
1882         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1883     }
1884   else
1885 #endif
1886     if (size > 0)
1887       ASM_OUTPUT_SKIP (asm_out_file, size);
1888 }
1889
1890 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1891
1892 void
1893 assemble_align (int align)
1894 {
1895   if (align > BITS_PER_UNIT)
1896     {
1897       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1898     }
1899 }
1900
1901 /* Assemble a string constant with the specified C string as contents.  */
1902
1903 void
1904 assemble_string (const char *p, int size)
1905 {
1906   int pos = 0;
1907   int maximum = 2000;
1908
1909   /* If the string is very long, split it up.  */
1910
1911   while (pos < size)
1912     {
1913       int thissize = size - pos;
1914       if (thissize > maximum)
1915         thissize = maximum;
1916
1917       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1918
1919       pos += thissize;
1920       p += thissize;
1921     }
1922 }
1923
1924 \f
1925 /* A noswitch_section_callback for lcomm_section.  */
1926
1927 static bool
1928 emit_local (tree decl ATTRIBUTE_UNUSED,
1929             const char *name ATTRIBUTE_UNUSED,
1930             unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1931             unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1932 {
1933 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1934   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1935                                  size, DECL_ALIGN (decl));
1936   return true;
1937 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1938   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1939   return true;
1940 #else
1941   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1942   return false;
1943 #endif
1944 }
1945
1946 /* A noswitch_section_callback for bss_noswitch_section.  */
1947
1948 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1949 static bool
1950 emit_bss (tree decl ATTRIBUTE_UNUSED,
1951           const char *name ATTRIBUTE_UNUSED,
1952           unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1953           unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1954 {
1955 #if defined ASM_OUTPUT_ALIGNED_BSS
1956   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1957   return true;
1958 #else
1959   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1960   return false;
1961 #endif
1962 }
1963 #endif
1964
1965 /* A noswitch_section_callback for comm_section.  */
1966
1967 static bool
1968 emit_common (tree decl ATTRIBUTE_UNUSED,
1969              const char *name ATTRIBUTE_UNUSED,
1970              unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1971              unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1972 {
1973 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1974   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1975                                   size, DECL_ALIGN (decl));
1976   return true;
1977 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1978   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1979   return true;
1980 #else
1981   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1982   return false;
1983 #endif
1984 }
1985
1986 /* A noswitch_section_callback for tls_comm_section.  */
1987
1988 static bool
1989 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1990                  const char *name ATTRIBUTE_UNUSED,
1991                  unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1992                  unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1993 {
1994 #ifdef ASM_OUTPUT_TLS_COMMON
1995   ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1996   return true;
1997 #else
1998   sorry ("thread-local COMMON data not implemented");
1999   return true;
2000 #endif
2001 }
2002
2003 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
2004    NAME is the name of DECL's SYMBOL_REF.  */
2005
2006 static void
2007 assemble_noswitch_variable (tree decl, const char *name, section *sect)
2008 {
2009   unsigned HOST_WIDE_INT size, rounded;
2010
2011   size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
2012   rounded = size;
2013
2014   /* Don't allocate zero bytes of common,
2015      since that means "undefined external" in the linker.  */
2016   if (size == 0)
2017     rounded = 1;
2018
2019   /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2020      so that each uninitialized object starts on such a boundary.  */
2021   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
2022   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2023              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2024
2025   if (!sect->noswitch.callback (decl, name, size, rounded)
2026       && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
2027     warning (0, "requested alignment for %q+D is greater than "
2028              "implemented alignment of %wu", decl, rounded);
2029 }
2030
2031 /* A subroutine of assemble_variable.  Output the label and contents of
2032    DECL, whose address is a SYMBOL_REF with name NAME.  DONT_OUTPUT_DATA
2033    is as for assemble_variable.  */
2034
2035 static void
2036 assemble_variable_contents (tree decl, const char *name,
2037                             bool dont_output_data)
2038 {
2039   /* Do any machine/system dependent processing of the object.  */
2040 #ifdef ASM_DECLARE_OBJECT_NAME
2041   last_assemble_variable_decl = decl;
2042   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
2043 #else
2044   /* Standard thing is just output label for the object.  */
2045   ASM_OUTPUT_LABEL (asm_out_file, name);
2046 #endif /* ASM_DECLARE_OBJECT_NAME */
2047
2048   if (!dont_output_data)
2049     {
2050       if (DECL_INITIAL (decl)
2051           && DECL_INITIAL (decl) != error_mark_node
2052           && !initializer_zerop (DECL_INITIAL (decl)))
2053         /* Output the actual data.  */
2054         output_constant (DECL_INITIAL (decl),
2055                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
2056                          DECL_ALIGN (decl));
2057       else
2058         /* Leave space for it.  */
2059         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
2060     }
2061 }
2062
2063 /* Initialize emulated tls object TO, which refers to TLS variable
2064    DECL and is initialized by PROXY.  */
2065
2066 tree
2067 default_emutls_var_init (tree to, tree decl, tree proxy)
2068 {
2069   VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 4);
2070   constructor_elt *elt;
2071   tree type = TREE_TYPE (to);
2072   tree field = TYPE_FIELDS (type);
2073
2074   elt = VEC_quick_push (constructor_elt, v, NULL);
2075   elt->index = field;
2076   elt->value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
2077
2078   elt = VEC_quick_push (constructor_elt, v, NULL);
2079   field = TREE_CHAIN (field);
2080   elt->index = field;
2081   elt->value = build_int_cst (TREE_TYPE (field),
2082                               DECL_ALIGN_UNIT (decl));
2083
2084   elt = VEC_quick_push (constructor_elt, v, NULL);
2085   field = TREE_CHAIN (field);
2086   elt->index = field;
2087   elt->value = null_pointer_node;
2088
2089   elt = VEC_quick_push (constructor_elt, v, NULL);
2090   field = TREE_CHAIN (field);
2091   elt->index = field;
2092   elt->value = proxy;
2093
2094   return build_constructor (type, v);
2095 }
2096
2097 /* Assemble everything that is needed for a variable or function declaration.
2098    Not used for automatic variables, and not used for function definitions.
2099    Should not be called for variables of incomplete structure type.
2100
2101    TOP_LEVEL is nonzero if this variable has file scope.
2102    AT_END is nonzero if this is the special handling, at end of compilation,
2103    to define things that have had only tentative definitions.
2104    DONT_OUTPUT_DATA if nonzero means don't actually output the
2105    initial value (that will be done by the caller).  */
2106
2107 void
2108 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
2109                    int at_end ATTRIBUTE_UNUSED, int dont_output_data)
2110 {
2111   const char *name;
2112   rtx decl_rtl, symbol;
2113   section *sect;
2114
2115   if (! targetm.have_tls
2116       && TREE_CODE (decl) == VAR_DECL
2117       && DECL_THREAD_LOCAL_P (decl))
2118     {
2119       tree to = emutls_decl (decl);
2120
2121       /* If this variable is defined locally, then we need to initialize the
2122          control structure with size and alignment information.  We do this
2123          at the last moment because tentative definitions can take a locally
2124          defined but uninitialized variable and initialize it later, which
2125          would result in incorrect contents.  */
2126       if (! DECL_EXTERNAL (to)
2127           && (! DECL_COMMON (to)
2128               || (DECL_INITIAL (decl)
2129                   && DECL_INITIAL (decl) != error_mark_node)))
2130         {
2131           DECL_INITIAL (to) = targetm.emutls.var_init
2132             (to, decl, get_emutls_init_templ_addr (decl));
2133
2134           /* Make sure the template is marked as needed early enough.
2135              Without this, if the variable is placed in a
2136              section-anchored block, the template will only be marked
2137              when it's too late.  */
2138           record_references_in_initializer (to, false);
2139         }
2140
2141       decl = to;
2142     }
2143
2144   last_assemble_variable_decl = 0;
2145
2146   /* Normally no need to say anything here for external references,
2147      since assemble_external is called by the language-specific code
2148      when a declaration is first seen.  */
2149
2150   if (DECL_EXTERNAL (decl))
2151     return;
2152
2153   /* Output no assembler code for a function declaration.
2154      Only definitions of functions output anything.  */
2155
2156   if (TREE_CODE (decl) == FUNCTION_DECL)
2157     return;
2158
2159   /* Do nothing for global register variables.  */
2160   if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
2161     {
2162       TREE_ASM_WRITTEN (decl) = 1;
2163       return;
2164     }
2165
2166   /* If type was incomplete when the variable was declared,
2167      see if it is complete now.  */
2168
2169   if (DECL_SIZE (decl) == 0)
2170     layout_decl (decl, 0);
2171
2172   /* Still incomplete => don't allocate it; treat the tentative defn
2173      (which is what it must have been) as an `extern' reference.  */
2174
2175   if (!dont_output_data && DECL_SIZE (decl) == 0)
2176     {
2177       error ("storage size of %q+D isn%'t known", decl);
2178       TREE_ASM_WRITTEN (decl) = 1;
2179       return;
2180     }
2181
2182   /* The first declaration of a variable that comes through this function
2183      decides whether it is global (in C, has external linkage)
2184      or local (in C, has internal linkage).  So do nothing more
2185      if this function has already run.  */
2186
2187   if (TREE_ASM_WRITTEN (decl))
2188     return;
2189
2190   /* Make sure targetm.encode_section_info is invoked before we set
2191      ASM_WRITTEN.  */
2192   decl_rtl = DECL_RTL (decl);
2193
2194   TREE_ASM_WRITTEN (decl) = 1;
2195
2196   /* Do no output if -fsyntax-only.  */
2197   if (flag_syntax_only)
2198     return;
2199
2200   app_disable ();
2201
2202   if (! dont_output_data
2203       && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
2204     {
2205       error ("size of variable %q+D is too large", decl);
2206       return;
2207     }
2208
2209   gcc_assert (MEM_P (decl_rtl));
2210   gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
2211   symbol = XEXP (decl_rtl, 0);
2212   name = XSTR (symbol, 0);
2213   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
2214     notice_global_symbol (decl);
2215
2216   /* Compute the alignment of this data.  */
2217
2218   align_variable (decl, dont_output_data);
2219   set_mem_align (decl_rtl, DECL_ALIGN (decl));
2220
2221   if (TREE_PUBLIC (decl))
2222     maybe_assemble_visibility (decl);
2223
2224   if (DECL_PRESERVE_P (decl))
2225     targetm.asm_out.mark_decl_preserved (name);
2226
2227   /* First make the assembler name(s) global if appropriate.  */
2228   sect = get_variable_section (decl, false);
2229   if (TREE_PUBLIC (decl)
2230       && (sect->common.flags & SECTION_COMMON) == 0)
2231     globalize_decl (decl);
2232
2233   /* Output any data that we will need to use the address of.  */
2234   if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
2235     output_addressed_constants (DECL_INITIAL (decl));
2236
2237   /* dbxout.c needs to know this.  */
2238   if (sect && (sect->common.flags & SECTION_CODE) != 0)
2239     DECL_IN_TEXT_SECTION (decl) = 1;
2240
2241   /* If the decl is part of an object_block, make sure that the decl
2242      has been positioned within its block, but do not write out its
2243      definition yet.  output_object_blocks will do that later.  */
2244   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2245     {
2246       gcc_assert (!dont_output_data);
2247       place_block_symbol (symbol);
2248     }
2249   else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
2250     assemble_noswitch_variable (decl, name, sect);
2251   else
2252     {
2253       switch_to_section (sect);
2254       if (DECL_ALIGN (decl) > BITS_PER_UNIT)
2255         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
2256       assemble_variable_contents (decl, name, dont_output_data);
2257     }
2258 }
2259
2260 /* Return 1 if type TYPE contains any pointers.  */
2261
2262 static int
2263 contains_pointers_p (tree type)
2264 {
2265   switch (TREE_CODE (type))
2266     {
2267     case POINTER_TYPE:
2268     case REFERENCE_TYPE:
2269       /* I'm not sure whether OFFSET_TYPE needs this treatment,
2270          so I'll play safe and return 1.  */
2271     case OFFSET_TYPE:
2272       return 1;
2273
2274     case RECORD_TYPE:
2275     case UNION_TYPE:
2276     case QUAL_UNION_TYPE:
2277       {
2278         tree fields;
2279         /* For a type that has fields, see if the fields have pointers.  */
2280         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2281           if (TREE_CODE (fields) == FIELD_DECL
2282               && contains_pointers_p (TREE_TYPE (fields)))
2283             return 1;
2284         return 0;
2285       }
2286
2287     case ARRAY_TYPE:
2288       /* An array type contains pointers if its element type does.  */
2289       return contains_pointers_p (TREE_TYPE (type));
2290
2291     default:
2292       return 0;
2293     }
2294 }
2295
2296 /* We delay assemble_external processing until
2297    the compilation unit is finalized.  This is the best we can do for
2298    right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2299    it all the way to final.  See PR 17982 for further discussion.  */
2300 static GTY(()) tree pending_assemble_externals;
2301
2302 #ifdef ASM_OUTPUT_EXTERNAL
2303 /* True if DECL is a function decl for which no out-of-line copy exists.
2304    It is assumed that DECL's assembler name has been set.  */
2305
2306 static bool
2307 incorporeal_function_p (tree decl)
2308 {
2309   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
2310     {
2311       const char *name;
2312
2313       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2314           && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
2315         return true;
2316
2317       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2318       if (is_builtin_name (name))
2319         return true;
2320     }
2321   return false;
2322 }
2323
2324 /* Actually do the tests to determine if this is necessary, and invoke
2325    ASM_OUTPUT_EXTERNAL.  */
2326 static void
2327 assemble_external_real (tree decl)
2328 {
2329   rtx rtl = DECL_RTL (decl);
2330
2331   if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
2332       && !SYMBOL_REF_USED (XEXP (rtl, 0))
2333       && !incorporeal_function_p (decl))
2334     {
2335       /* Some systems do require some output.  */
2336       SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
2337       ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
2338     }
2339 }
2340 #endif
2341
2342 void
2343 process_pending_assemble_externals (void)
2344 {
2345 #ifdef ASM_OUTPUT_EXTERNAL
2346   tree list;
2347   for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
2348     assemble_external_real (TREE_VALUE (list));
2349
2350   pending_assemble_externals = 0;
2351 #endif
2352 }
2353
2354 /* This TREE_LIST contains any weak symbol declarations waiting
2355    to be emitted.  */
2356 static GTY(()) tree weak_decls;
2357
2358 /* Output something to declare an external symbol to the assembler,
2359    and qualifiers such as weakness.  (Most assemblers don't need
2360    extern declaration, so we normally output nothing.)  Do nothing if
2361    DECL is not external.  */
2362
2363 void
2364 assemble_external (tree decl ATTRIBUTE_UNUSED)
2365 {
2366   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
2367      main body of this code is only rarely exercised.  To provide some
2368      testing, on all platforms, we make sure that the ASM_OUT_FILE is
2369      open.  If it's not, we should not be calling this function.  */
2370   gcc_assert (asm_out_file);
2371
2372   if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
2373     return;
2374
2375   /* We want to output annotation for weak and external symbols at
2376      very last to check if they are references or not.  */
2377
2378   if (SUPPORTS_WEAK
2379       && DECL_WEAK (decl)
2380       /* TREE_STATIC is a weird and abused creature which is not
2381          generally the right test for whether an entity has been
2382          locally emitted, inlined or otherwise not-really-extern, but
2383          for declarations that can be weak, it happens to be
2384          match.  */
2385       && !TREE_STATIC (decl)
2386       && lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
2387       && value_member (decl, weak_decls) == NULL_TREE)
2388     weak_decls = tree_cons (NULL, decl, weak_decls);
2389
2390 #ifdef ASM_OUTPUT_EXTERNAL
2391   if (value_member (decl, pending_assemble_externals) == NULL_TREE)
2392     pending_assemble_externals = tree_cons (NULL, decl,
2393                                             pending_assemble_externals);
2394 #endif
2395 }
2396
2397 /* Similar, for calling a library function FUN.  */
2398
2399 void
2400 assemble_external_libcall (rtx fun)
2401 {
2402   /* Declare library function name external when first used, if nec.  */
2403   if (! SYMBOL_REF_USED (fun))
2404     {
2405       SYMBOL_REF_USED (fun) = 1;
2406       targetm.asm_out.external_libcall (fun);
2407     }
2408 }
2409
2410 /* Assemble a label named NAME.  */
2411
2412 void
2413 assemble_label (const char *name)
2414 {
2415   ASM_OUTPUT_LABEL (asm_out_file, name);
2416 }
2417
2418 /* Set the symbol_referenced flag for ID.  */
2419 void
2420 mark_referenced (tree id)
2421 {
2422   TREE_SYMBOL_REFERENCED (id) = 1;
2423 }
2424
2425 /* Set the symbol_referenced flag for DECL and notify callgraph.  */
2426 void
2427 mark_decl_referenced (tree decl)
2428 {
2429   if (TREE_CODE (decl) == FUNCTION_DECL)
2430     {
2431       /* Extern inline functions don't become needed when referenced.
2432          If we know a method will be emitted in other TU and no new
2433          functions can be marked reachable, just use the external
2434          definition.  */
2435       struct cgraph_node *node = cgraph_node (decl);
2436       if (!DECL_EXTERNAL (decl)
2437           && (!node->local.vtable_method || !cgraph_global_info_ready
2438               || !node->local.finalized))
2439         cgraph_mark_needed_node (node);
2440     }
2441   else if (TREE_CODE (decl) == VAR_DECL)
2442     {
2443       struct varpool_node *node = varpool_node (decl);
2444       varpool_mark_needed_node (node);
2445       /* C++ frontend use mark_decl_references to force COMDAT variables
2446          to be output that might appear dead otherwise.  */
2447       node->force_output = true;
2448     }
2449   /* else do nothing - we can get various sorts of CST nodes here,
2450      which do not need to be marked.  */
2451 }
2452
2453
2454 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2455    until we find an identifier that is not itself a transparent alias.
2456    Modify the alias passed to it by reference (and all aliases on the
2457    way to the ultimate target), such that they do not have to be
2458    followed again, and return the ultimate target of the alias
2459    chain.  */
2460
2461 static inline tree
2462 ultimate_transparent_alias_target (tree *alias)
2463 {
2464   tree target = *alias;
2465
2466   if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2467     {
2468       gcc_assert (TREE_CHAIN (target));
2469       target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2470       gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2471                   && ! TREE_CHAIN (target));
2472       *alias = target;
2473     }
2474
2475   return target;
2476 }
2477
2478 /* Output to FILE (an assembly file) a reference to NAME.  If NAME
2479    starts with a *, the rest of NAME is output verbatim.  Otherwise
2480    NAME is transformed in a target-specific way (usually by the
2481    addition of an underscore).  */
2482
2483 void
2484 assemble_name_raw (FILE *file, const char *name)
2485 {
2486   if (name[0] == '*')
2487     fputs (&name[1], file);
2488   else
2489     ASM_OUTPUT_LABELREF (file, name);
2490 }
2491
2492 /* Like assemble_name_raw, but should be used when NAME might refer to
2493    an entity that is also represented as a tree (like a function or
2494    variable).  If NAME does refer to such an entity, that entity will
2495    be marked as referenced.  */
2496
2497 void
2498 assemble_name (FILE *file, const char *name)
2499 {
2500   const char *real_name;
2501   tree id;
2502
2503   real_name = targetm.strip_name_encoding (name);
2504
2505   id = maybe_get_identifier (real_name);
2506   if (id)
2507     {
2508       tree id_orig = id;
2509
2510       mark_referenced (id);
2511       ultimate_transparent_alias_target (&id);
2512       if (id != id_orig)
2513         name = IDENTIFIER_POINTER (id);
2514       gcc_assert (! TREE_CHAIN (id));
2515     }
2516
2517   assemble_name_raw (file, name);
2518 }
2519
2520 /* Allocate SIZE bytes writable static space with a gensym name
2521    and return an RTX to refer to its address.  */
2522
2523 rtx
2524 assemble_static_space (unsigned HOST_WIDE_INT size)
2525 {
2526   char name[12];
2527   const char *namestring;
2528   rtx x;
2529
2530   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2531   ++const_labelno;
2532   namestring = ggc_strdup (name);
2533
2534   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2535   SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2536
2537 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2538   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2539                                  BIGGEST_ALIGNMENT);
2540 #else
2541 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2542   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2543 #else
2544   {
2545     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2546        so that each uninitialized object starts on such a boundary.  */
2547     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
2548     unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2549       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2550          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2551          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2552     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2553   }
2554 #endif
2555 #endif
2556   return x;
2557 }
2558
2559 /* Assemble the static constant template for function entry trampolines.
2560    This is done at most once per compilation.
2561    Returns an RTX for the address of the template.  */
2562
2563 static GTY(()) rtx initial_trampoline;
2564
2565 rtx
2566 assemble_trampoline_template (void)
2567 {
2568   char label[256];
2569   const char *name;
2570   int align;
2571   rtx symbol;
2572
2573   gcc_assert (targetm.asm_out.trampoline_template != NULL);
2574
2575   if (initial_trampoline)
2576     return initial_trampoline;
2577
2578   /* By default, put trampoline templates in read-only data section.  */
2579
2580 #ifdef TRAMPOLINE_SECTION
2581   switch_to_section (TRAMPOLINE_SECTION);
2582 #else
2583   switch_to_section (readonly_data_section);
2584 #endif
2585
2586   /* Write the assembler code to define one.  */
2587   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2588   if (align > 0)
2589     ASM_OUTPUT_ALIGN (asm_out_file, align);
2590
2591   targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2592   targetm.asm_out.trampoline_template (asm_out_file);
2593
2594   /* Record the rtl to refer to it.  */
2595   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2596   name = ggc_strdup (label);
2597   symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2598   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2599
2600   initial_trampoline = gen_const_mem (BLKmode, symbol);
2601   set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2602   set_mem_size (initial_trampoline, GEN_INT (TRAMPOLINE_SIZE));
2603
2604   return initial_trampoline;
2605 }
2606 \f
2607 /* A and B are either alignments or offsets.  Return the minimum alignment
2608    that may be assumed after adding the two together.  */
2609
2610 static inline unsigned
2611 min_align (unsigned int a, unsigned int b)
2612 {
2613   return (a | b) & -(a | b);
2614 }
2615
2616 /* Return the assembler directive for creating a given kind of integer
2617    object.  SIZE is the number of bytes in the object and ALIGNED_P
2618    indicates whether it is known to be aligned.  Return NULL if the
2619    assembly dialect has no such directive.
2620
2621    The returned string should be printed at the start of a new line and
2622    be followed immediately by the object's initial value.  */
2623
2624 const char *
2625 integer_asm_op (int size, int aligned_p)
2626 {
2627   struct asm_int_op *ops;
2628
2629   if (aligned_p)
2630     ops = &targetm.asm_out.aligned_op;
2631   else
2632     ops = &targetm.asm_out.unaligned_op;
2633
2634   switch (size)
2635     {
2636     case 1:
2637       return targetm.asm_out.byte_op;
2638     case 2:
2639       return ops->hi;
2640     case 4:
2641       return ops->si;
2642     case 8:
2643       return ops->di;
2644     case 16:
2645       return ops->ti;
2646     default:
2647       return NULL;
2648     }
2649 }
2650
2651 /* Use directive OP to assemble an integer object X.  Print OP at the
2652    start of the line, followed immediately by the value of X.  */
2653
2654 void
2655 assemble_integer_with_op (const char *op, rtx x)
2656 {
2657   fputs (op, asm_out_file);
2658   output_addr_const (asm_out_file, x);
2659   fputc ('\n', asm_out_file);
2660 }
2661
2662 /* The default implementation of the asm_out.integer target hook.  */
2663
2664 bool
2665 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2666                           unsigned int size ATTRIBUTE_UNUSED,
2667                           int aligned_p ATTRIBUTE_UNUSED)
2668 {
2669   const char *op = integer_asm_op (size, aligned_p);
2670   /* Avoid GAS bugs for large values.  Specifically negative values whose
2671      absolute value fits in a bfd_vma, but not in a bfd_signed_vma.  */
2672   if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2673     return false;
2674   return op && (assemble_integer_with_op (op, x), true);
2675 }
2676
2677 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
2678    the alignment of the integer in bits.  Return 1 if we were able to output
2679    the constant, otherwise 0.  We must be able to output the constant,
2680    if FORCE is nonzero.  */
2681
2682 bool
2683 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2684 {
2685   int aligned_p;
2686
2687   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2688
2689   /* See if the target hook can handle this kind of object.  */
2690   if (targetm.asm_out.integer (x, size, aligned_p))
2691     return true;
2692
2693   /* If the object is a multi-byte one, try splitting it up.  Split
2694      it into words it if is multi-word, otherwise split it into bytes.  */
2695   if (size > 1)
2696     {
2697       enum machine_mode omode, imode;
2698       unsigned int subalign;
2699       unsigned int subsize, i;
2700       enum mode_class mclass;
2701
2702       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2703       subalign = MIN (align, subsize * BITS_PER_UNIT);
2704       if (GET_CODE (x) == CONST_FIXED)
2705         mclass = GET_MODE_CLASS (GET_MODE (x));
2706       else
2707         mclass = MODE_INT;
2708
2709       omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0);
2710       imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0);
2711
2712       for (i = 0; i < size; i += subsize)
2713         {
2714           rtx partial = simplify_subreg (omode, x, imode, i);
2715           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2716             break;
2717         }
2718       if (i == size)
2719         return true;
2720
2721       /* If we've printed some of it, but not all of it, there's no going
2722          back now.  */
2723       gcc_assert (!i);
2724     }
2725
2726   gcc_assert (!force);
2727
2728   return false;
2729 }
2730 \f
2731 void
2732 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2733 {
2734   long data[4] = {0, 0, 0, 0};
2735   int i;
2736   int bitsize, nelts, nunits, units_per;
2737
2738   /* This is hairy.  We have a quantity of known size.  real_to_target
2739      will put it into an array of *host* longs, 32 bits per element
2740      (even if long is more than 32 bits).  We need to determine the
2741      number of array elements that are occupied (nelts) and the number
2742      of *target* min-addressable units that will be occupied in the
2743      object file (nunits).  We cannot assume that 32 divides the
2744      mode's bitsize (size * BITS_PER_UNIT) evenly.
2745
2746      size * BITS_PER_UNIT is used here to make sure that padding bits
2747      (which might appear at either end of the value; real_to_target
2748      will include the padding bits in its output array) are included.  */
2749
2750   nunits = GET_MODE_SIZE (mode);
2751   bitsize = nunits * BITS_PER_UNIT;
2752   nelts = CEIL (bitsize, 32);
2753   units_per = 32 / BITS_PER_UNIT;
2754
2755   real_to_target (data, &d, mode);
2756
2757   /* Put out the first word with the specified alignment.  */
2758   assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2759   nunits -= units_per;
2760
2761   /* Subsequent words need only 32-bit alignment.  */
2762   align = min_align (align, 32);
2763
2764   for (i = 1; i < nelts; i++)
2765     {
2766       assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2767       nunits -= units_per;
2768     }
2769 }
2770 \f
2771 /* Given an expression EXP with a constant value,
2772    reduce it to the sum of an assembler symbol and an integer.
2773    Store them both in the structure *VALUE.
2774    EXP must be reducible.  */
2775
2776 struct GTY(()) addr_const {
2777   rtx base;
2778   HOST_WIDE_INT offset;
2779 };
2780
2781 static void
2782 decode_addr_const (tree exp, struct addr_const *value)
2783 {
2784   tree target = TREE_OPERAND (exp, 0);
2785   int offset = 0;
2786   rtx x;
2787
2788   while (1)
2789     {
2790       if (TREE_CODE (target) == COMPONENT_REF
2791           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2792
2793         {
2794           offset += int_byte_position (TREE_OPERAND (target, 1));
2795           target = TREE_OPERAND (target, 0);
2796         }
2797       else if (TREE_CODE (target) == ARRAY_REF
2798                || TREE_CODE (target) == ARRAY_RANGE_REF)
2799         {
2800           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2801                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2802           target = TREE_OPERAND (target, 0);
2803         }
2804       else
2805         break;
2806     }
2807
2808   switch (TREE_CODE (target))
2809     {
2810     case VAR_DECL:
2811     case FUNCTION_DECL:
2812       x = DECL_RTL (target);
2813       break;
2814
2815     case LABEL_DECL:
2816       x = gen_rtx_MEM (FUNCTION_MODE,
2817                        gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2818       break;
2819
2820     case REAL_CST:
2821     case FIXED_CST:
2822     case STRING_CST:
2823     case COMPLEX_CST:
2824     case CONSTRUCTOR:
2825     case INTEGER_CST:
2826       x = output_constant_def (target, 1);
2827       break;
2828
2829     default:
2830       gcc_unreachable ();
2831     }
2832
2833   gcc_assert (MEM_P (x));
2834   x = XEXP (x, 0);
2835
2836   value->base = x;
2837   value->offset = offset;
2838 }
2839 \f
2840
2841 static GTY((param_is (struct constant_descriptor_tree)))
2842      htab_t const_desc_htab;
2843
2844 static struct constant_descriptor_tree * build_constant_desc (tree);
2845 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2846
2847 /* Constant pool accessor function.  */
2848
2849 htab_t
2850 constant_pool_htab (void)
2851 {
2852   return const_desc_htab;
2853 }
2854
2855 /* Compute a hash code for a constant expression.  */
2856
2857 static hashval_t
2858 const_desc_hash (const void *ptr)
2859 {
2860   return ((const struct constant_descriptor_tree *)ptr)->hash;
2861 }
2862
2863 static hashval_t
2864 const_hash_1 (const tree exp)
2865 {
2866   const char *p;
2867   hashval_t hi;
2868   int len, i;
2869   enum tree_code code = TREE_CODE (exp);
2870
2871   /* Either set P and LEN to the address and len of something to hash and
2872      exit the switch or return a value.  */
2873
2874   switch (code)
2875     {
2876     case INTEGER_CST:
2877       p = (char *) &TREE_INT_CST (exp);
2878       len = sizeof TREE_INT_CST (exp);
2879       break;
2880
2881     case REAL_CST:
2882       return real_hash (TREE_REAL_CST_PTR (exp));
2883
2884     case FIXED_CST:
2885       return fixed_hash (TREE_FIXED_CST_PTR (exp));
2886
2887     case STRING_CST:
2888       p = TREE_STRING_POINTER (exp);
2889       len = TREE_STRING_LENGTH (exp);
2890       break;
2891
2892     case COMPLEX_CST:
2893       return (const_hash_1 (TREE_REALPART (exp)) * 5
2894               + const_hash_1 (TREE_IMAGPART (exp)));
2895
2896     case CONSTRUCTOR:
2897       {
2898         unsigned HOST_WIDE_INT idx;
2899         tree value;
2900
2901         hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2902
2903         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2904           if (value)
2905             hi = hi * 603 + const_hash_1 (value);
2906
2907         return hi;
2908       }
2909
2910     case ADDR_EXPR:
2911     case FDESC_EXPR:
2912       {
2913         struct addr_const value;
2914
2915         decode_addr_const (exp, &value);
2916         switch (GET_CODE (value.base))
2917           {
2918           case SYMBOL_REF:
2919             /* Don't hash the address of the SYMBOL_REF;
2920                only use the offset and the symbol name.  */
2921             hi = value.offset;
2922             p = XSTR (value.base, 0);
2923             for (i = 0; p[i] != 0; i++)
2924               hi = ((hi * 613) + (unsigned) (p[i]));
2925             break;
2926
2927           case LABEL_REF:
2928             hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2929             break;
2930
2931           default:
2932             gcc_unreachable ();
2933           }
2934       }
2935       return hi;
2936
2937     case PLUS_EXPR:
2938     case POINTER_PLUS_EXPR:
2939     case MINUS_EXPR:
2940       return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2941               + const_hash_1 (TREE_OPERAND (exp, 1)));
2942
2943     CASE_CONVERT:
2944       return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2945
2946     default:
2947       /* A language specific constant. Just hash the code.  */
2948       return code;
2949     }
2950
2951   /* Compute hashing function.  */
2952   hi = len;
2953   for (i = 0; i < len; i++)
2954     hi = ((hi * 613) + (unsigned) (p[i]));
2955
2956   return hi;
2957 }
2958
2959 /* Wrapper of compare_constant, for the htab interface.  */
2960 static int
2961 const_desc_eq (const void *p1, const void *p2)
2962 {
2963   const struct constant_descriptor_tree *const c1
2964     = (const struct constant_descriptor_tree *) p1;
2965   const struct constant_descriptor_tree *const c2
2966     = (const struct constant_descriptor_tree *) p2;
2967   if (c1->hash != c2->hash)
2968     return 0;
2969   return compare_constant (c1->value, c2->value);
2970 }
2971
2972 /* Compare t1 and t2, and return 1 only if they are known to result in
2973    the same bit pattern on output.  */
2974
2975 static int
2976 compare_constant (const tree t1, const tree t2)
2977 {
2978   enum tree_code typecode;
2979
2980   if (t1 == NULL_TREE)
2981     return t2 == NULL_TREE;
2982   if (t2 == NULL_TREE)
2983     return 0;
2984
2985   if (TREE_CODE (t1) != TREE_CODE (t2))
2986     return 0;
2987
2988   switch (TREE_CODE (t1))
2989     {
2990     case INTEGER_CST:
2991       /* Integer constants are the same only if the same width of type.  */
2992       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2993         return 0;
2994       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2995         return 0;
2996       return tree_int_cst_equal (t1, t2);
2997
2998     case REAL_CST:
2999       /* Real constants are the same only if the same width of type.  */
3000       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3001         return 0;
3002
3003       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3004
3005     case FIXED_CST:
3006       /* Fixed constants are the same only if the same width of type.  */
3007       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3008         return 0;
3009
3010       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
3011
3012     case STRING_CST:
3013       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3014         return 0;
3015
3016       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3017               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3018                          TREE_STRING_LENGTH (t1)));
3019
3020     case COMPLEX_CST:
3021       return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
3022               && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
3023
3024     case CONSTRUCTOR:
3025       {
3026         VEC(constructor_elt, gc) *v1, *v2;
3027         unsigned HOST_WIDE_INT idx;
3028
3029         typecode = TREE_CODE (TREE_TYPE (t1));
3030         if (typecode != TREE_CODE (TREE_TYPE (t2)))
3031           return 0;
3032
3033         if (typecode == ARRAY_TYPE)
3034           {
3035             HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
3036             /* For arrays, check that the sizes all match.  */
3037             if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
3038                 || size_1 == -1
3039                 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
3040               return 0;
3041           }
3042         else
3043           {
3044             /* For record and union constructors, require exact type
3045                equality.  */
3046             if (TREE_TYPE (t1) != TREE_TYPE (t2))
3047               return 0;
3048           }
3049
3050         v1 = CONSTRUCTOR_ELTS (t1);
3051         v2 = CONSTRUCTOR_ELTS (t2);
3052         if (VEC_length (constructor_elt, v1)
3053             != VEC_length (constructor_elt, v2))
3054             return 0;
3055
3056         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
3057           {
3058             constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
3059             constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
3060
3061             /* Check that each value is the same...  */
3062             if (!compare_constant (c1->value, c2->value))
3063               return 0;
3064             /* ... and that they apply to the same fields!  */
3065             if (typecode == ARRAY_TYPE)
3066               {
3067                 if (!compare_constant (c1->index, c2->index))
3068                   return 0;
3069               }
3070             else
3071               {
3072                 if (c1->index != c2->index)
3073                   return 0;
3074               }
3075           }
3076
3077         return 1;
3078       }
3079
3080     case ADDR_EXPR:
3081     case FDESC_EXPR:
3082       {
3083         struct addr_const value1, value2;
3084
3085         decode_addr_const (t1, &value1);
3086         decode_addr_const (t2, &value2);
3087         return (value1.offset == value2.offset
3088                 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
3089       }
3090
3091     case PLUS_EXPR:
3092     case POINTER_PLUS_EXPR:
3093     case MINUS_EXPR:
3094     case RANGE_EXPR:
3095       return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3096               && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3097
3098     CASE_CONVERT:
3099     case VIEW_CONVERT_EXPR:
3100       return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3101
3102     default:
3103       return 0;
3104     }
3105
3106   gcc_unreachable ();
3107 }
3108 \f
3109 /* Make a copy of the whole tree structure for a constant.  This
3110    handles the same types of nodes that compare_constant handles.  */
3111
3112 static tree
3113 copy_constant (tree exp)
3114 {
3115   switch (TREE_CODE (exp))
3116     {
3117     case ADDR_EXPR:
3118       /* For ADDR_EXPR, we do not want to copy the decl whose address
3119          is requested.  We do want to copy constants though.  */
3120       if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
3121         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3122                        copy_constant (TREE_OPERAND (exp, 0)));
3123       else
3124         return copy_node (exp);
3125
3126     case INTEGER_CST:
3127     case REAL_CST:
3128     case FIXED_CST:
3129     case STRING_CST:
3130       return copy_node (exp);
3131
3132     case COMPLEX_CST:
3133       return build_complex (TREE_TYPE (exp),
3134                             copy_constant (TREE_REALPART (exp)),
3135                             copy_constant (TREE_IMAGPART (exp)));
3136
3137     case PLUS_EXPR:
3138     case POINTER_PLUS_EXPR:
3139     case MINUS_EXPR:
3140       return build2 (TREE_CODE (exp), TREE_TYPE (exp),
3141                      copy_constant (TREE_OPERAND (exp, 0)),
3142                      copy_constant (TREE_OPERAND (exp, 1)));
3143
3144     CASE_CONVERT:
3145     case VIEW_CONVERT_EXPR:
3146       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3147                      copy_constant (TREE_OPERAND (exp, 0)));
3148
3149     case CONSTRUCTOR:
3150       {
3151         tree copy = copy_node (exp);
3152         VEC(constructor_elt, gc) *v;
3153         unsigned HOST_WIDE_INT idx;
3154         tree purpose, value;
3155
3156         v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
3157                                                       CONSTRUCTOR_ELTS (exp)));
3158         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
3159           {
3160             constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
3161             ce->index = purpose;
3162             ce->value = copy_constant (value);
3163           }
3164         CONSTRUCTOR_ELTS (copy) = v;
3165         return copy;
3166       }
3167
3168     default:
3169       gcc_unreachable ();
3170     }
3171 }
3172 \f
3173 /* Return the alignment of constant EXP in bits.  */
3174
3175 static unsigned int
3176 get_constant_alignment (tree exp)
3177 {
3178   unsigned int align;
3179
3180   align = TYPE_ALIGN (TREE_TYPE (exp));
3181 #ifdef CONSTANT_ALIGNMENT
3182   align = CONSTANT_ALIGNMENT (exp, align);
3183 #endif
3184   return align;
3185 }
3186
3187 /* Return the section into which constant EXP should be placed.  */
3188
3189 static section *
3190 get_constant_section (tree exp)
3191 {
3192   if (IN_NAMED_SECTION (exp))
3193     return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
3194   else
3195     return targetm.asm_out.select_section (exp,
3196                                            compute_reloc_for_constant (exp),
3197                                            get_constant_alignment (exp));
3198 }
3199
3200 /* Return the size of constant EXP in bytes.  */
3201
3202 static HOST_WIDE_INT
3203 get_constant_size (tree exp)
3204 {
3205   HOST_WIDE_INT size;
3206
3207   size = int_size_in_bytes (TREE_TYPE (exp));
3208   if (TREE_CODE (exp) == STRING_CST)
3209     size = MAX (TREE_STRING_LENGTH (exp), size);
3210   return size;
3211 }
3212
3213 /* Subroutine of output_constant_def:
3214    No constant equal to EXP is known to have been output.
3215    Make a constant descriptor to enter EXP in the hash table.
3216    Assign the label number and construct RTL to refer to the
3217    constant's location in memory.
3218    Caller is responsible for updating the hash table.  */
3219
3220 static struct constant_descriptor_tree *
3221 build_constant_desc (tree exp)
3222 {
3223   rtx symbol;
3224   rtx rtl;
3225   char label[256];
3226   int labelno;
3227   struct constant_descriptor_tree *desc;
3228
3229   desc = GGC_NEW (struct constant_descriptor_tree);
3230   desc->value = copy_constant (exp);
3231
3232   /* Propagate marked-ness to copied constant.  */
3233   if (flag_mudflap && mf_marked_p (exp))
3234     mf_mark (desc->value);
3235
3236   /* Create a string containing the label name, in LABEL.  */
3237   labelno = const_labelno++;
3238   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3239
3240   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
3241   if (use_object_blocks_p ())
3242     {
3243       section *sect = get_constant_section (exp);
3244       symbol = create_block_symbol (ggc_strdup (label),
3245                                     get_block_for_section (sect), -1);
3246     }
3247   else
3248     symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3249   SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3250   SET_SYMBOL_REF_DECL (symbol, desc->value);
3251   TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3252
3253   rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
3254   set_mem_attributes (rtl, exp, 1);
3255   set_mem_alias_set (rtl, 0);
3256   set_mem_alias_set (rtl, const_alias_set);
3257
3258   /* We cannot share RTX'es in pool entries.
3259      Mark this piece of RTL as required for unsharing.  */
3260   RTX_FLAG (rtl, used) = 1;
3261
3262   /* Set flags or add text to the name to record information, such as
3263      that it is a local symbol.  If the name is changed, the macro
3264      ASM_OUTPUT_LABELREF will have to know how to strip this
3265      information.  This call might invalidate our local variable
3266      SYMBOL; we can't use it afterward.  */
3267
3268   targetm.encode_section_info (exp, rtl, true);
3269
3270   desc->rtl = rtl;
3271
3272   return desc;
3273 }
3274
3275 /* Return an rtx representing a reference to constant data in memory
3276    for the constant expression EXP.
3277
3278    If assembler code for such a constant has already been output,
3279    return an rtx to refer to it.
3280    Otherwise, output such a constant in memory
3281    and generate an rtx for it.
3282
3283    If DEFER is nonzero, this constant can be deferred and output only
3284    if referenced in the function after all optimizations.
3285
3286    `const_desc_table' records which constants already have label strings.  */
3287
3288 rtx
3289 output_constant_def (tree exp, int defer)
3290 {
3291   struct constant_descriptor_tree *desc;
3292   struct constant_descriptor_tree key;
3293   void **loc;
3294
3295   /* Look up EXP in the table of constant descriptors.  If we didn't find
3296      it, create a new one.  */
3297   key.value = exp;
3298   key.hash = const_hash_1 (exp);
3299   loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
3300
3301   desc = (struct constant_descriptor_tree *) *loc;
3302   if (desc == 0)
3303     {
3304       desc = build_constant_desc (exp);
3305       desc->hash = key.hash;
3306       *loc = desc;
3307     }
3308
3309   maybe_output_constant_def_contents (desc, defer);
3310   return desc->rtl;
3311 }
3312
3313 /* Subroutine of output_constant_def: Decide whether or not we need to
3314    output the constant DESC now, and if so, do it.  */
3315 static void
3316 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
3317                                     int defer)
3318 {
3319   rtx symbol = XEXP (desc->rtl, 0);
3320   tree exp = desc->value;
3321
3322   if (flag_syntax_only)
3323     return;
3324
3325   if (TREE_ASM_WRITTEN (exp))
3326     /* Already output; don't do it again.  */
3327     return;
3328
3329   /* We can always defer constants as long as the context allows
3330      doing so.  */
3331   if (defer)
3332     {
3333       /* Increment n_deferred_constants if it exists.  It needs to be at
3334          least as large as the number of constants actually referred to
3335          by the function.  If it's too small we'll stop looking too early
3336          and fail to emit constants; if it's too large we'll only look
3337          through the entire function when we could have stopped earlier.  */
3338       if (cfun)
3339         n_deferred_constants++;
3340       return;
3341     }
3342
3343   output_constant_def_contents (symbol);
3344 }
3345
3346 /* Subroutine of output_constant_def_contents.  Output the definition
3347    of constant EXP, which is pointed to by label LABEL.  ALIGN is the
3348    constant's alignment in bits.  */
3349
3350 static void
3351 assemble_constant_contents (tree exp, const char *label, unsigned int align)
3352 {
3353   HOST_WIDE_INT size;
3354
3355   size = get_constant_size (exp);
3356
3357   /* Do any machine/system dependent processing of the constant.  */
3358 #ifdef ASM_DECLARE_CONSTANT_NAME
3359   ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
3360 #else
3361   /* Standard thing is just output label for the constant.  */
3362   ASM_OUTPUT_LABEL (asm_out_file, label);
3363 #endif /* ASM_DECLARE_CONSTANT_NAME */
3364
3365   /* Output the value of EXP.  */
3366   output_constant (exp, size, align);
3367 }
3368
3369 /* We must output the constant data referred to by SYMBOL; do so.  */
3370
3371 static void
3372 output_constant_def_contents (rtx symbol)
3373 {
3374   tree exp = SYMBOL_REF_DECL (symbol);
3375   unsigned int align;
3376
3377   /* Make sure any other constants whose addresses appear in EXP
3378      are assigned label numbers.  */
3379   output_addressed_constants (exp);
3380
3381   /* We are no longer deferring this constant.  */
3382   TREE_ASM_WRITTEN (exp) = 1;
3383
3384   /* If the constant is part of an object block, make sure that the
3385      decl has been positioned within its block, but do not write out
3386      its definition yet.  output_object_blocks will do that later.  */
3387   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
3388     place_block_symbol (symbol);
3389   else
3390     {
3391       switch_to_section (get_constant_section (exp));
3392       align = get_constant_alignment (exp);
3393       if (align > BITS_PER_UNIT)
3394         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3395       assemble_constant_contents (exp, XSTR (symbol, 0), align);
3396     }
3397   if (flag_mudflap)
3398     mudflap_enqueue_constant (exp);
3399 }
3400
3401 /* Look up EXP in the table of constant descriptors.  Return the rtl
3402    if it has been emitted, else null.  */
3403
3404 rtx
3405 lookup_constant_def (tree exp)
3406 {
3407   struct constant_descriptor_tree *desc;
3408   struct constant_descriptor_tree key;
3409
3410   key.value = exp;
3411   key.hash = const_hash_1 (exp);
3412   desc = (struct constant_descriptor_tree *)
3413     htab_find_with_hash (const_desc_htab, &key, key.hash);
3414
3415   return (desc ? desc->rtl : NULL_RTX);
3416 }
3417 \f
3418 /* Used in the hash tables to avoid outputting the same constant
3419    twice.  Unlike 'struct constant_descriptor_tree', RTX constants
3420    are output once per function, not once per file.  */
3421 /* ??? Only a few targets need per-function constant pools.  Most
3422    can use one per-file pool.  Should add a targetm bit to tell the
3423    difference.  */
3424
3425 struct GTY(()) rtx_constant_pool {
3426   /* Pointers to first and last constant in pool, as ordered by offset.  */
3427   struct constant_descriptor_rtx *first;
3428   struct constant_descriptor_rtx *last;
3429
3430   /* Hash facility for making memory-constants from constant rtl-expressions.
3431      It is used on RISC machines where immediate integer arguments and
3432      constant addresses are restricted so that such constants must be stored
3433      in memory.  */
3434   htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3435
3436   /* Current offset in constant pool (does not include any
3437      machine-specific header).  */
3438   HOST_WIDE_INT offset;
3439 };
3440
3441 struct GTY((chain_next ("%h.next"))) constant_descriptor_rtx {
3442   struct constant_descriptor_rtx *next;
3443   rtx mem;
3444   rtx sym;
3445   rtx constant;
3446   HOST_WIDE_INT offset;
3447   hashval_t hash;
3448   enum machine_mode mode;
3449   unsigned int align;
3450   int labelno;
3451   int mark;
3452 };
3453
3454 /* Hash and compare functions for const_rtx_htab.  */
3455
3456 static hashval_t
3457 const_desc_rtx_hash (const void *ptr)
3458 {
3459   const struct constant_descriptor_rtx *const desc
3460     = (const struct constant_descriptor_rtx *) ptr;
3461   return desc->hash;
3462 }
3463
3464 static int
3465 const_desc_rtx_eq (const void *a, const void *b)
3466 {
3467   const struct constant_descriptor_rtx *const x
3468     = (const struct constant_descriptor_rtx *) a;
3469   const struct constant_descriptor_rtx *const y
3470     = (const struct constant_descriptor_rtx *) b;
3471
3472   if (x->mode != y->mode)
3473     return 0;
3474   return rtx_equal_p (x->constant, y->constant);
3475 }
3476
3477 /* This is the worker function for const_rtx_hash, called via for_each_rtx.  */
3478
3479 static int
3480 const_rtx_hash_1 (rtx *xp, void *data)
3481 {
3482   unsigned HOST_WIDE_INT hwi;
3483   enum machine_mode mode;
3484   enum rtx_code code;
3485   hashval_t h, *hp;
3486   rtx x;
3487
3488   x = *xp;
3489   code = GET_CODE (x);
3490   mode = GET_MODE (x);
3491   h = (hashval_t) code * 1048573 + mode;
3492
3493   switch (code)
3494     {
3495     case CONST_INT:
3496       hwi = INTVAL (x);
3497     fold_hwi:
3498       {
3499         int shift = sizeof (hashval_t) * CHAR_BIT;
3500         const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3501         int i;
3502
3503         h ^= (hashval_t) hwi;
3504         for (i = 1; i < n; ++i)
3505           {
3506             hwi >>= shift;
3507             h ^= (hashval_t) hwi;
3508           }
3509       }
3510       break;
3511
3512     case CONST_DOUBLE:
3513       if (mode == VOIDmode)
3514         {
3515           hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3516           goto fold_hwi;
3517         }
3518       else
3519         h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3520       break;
3521
3522     case CONST_FIXED:
3523       h ^= fixed_hash (CONST_FIXED_VALUE (x));
3524       break;
3525
3526     case CONST_VECTOR:
3527       {
3528         int i;
3529         for (i = XVECLEN (x, 0); i-- > 0; )
3530           h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3531       }
3532       break;
3533
3534     case SYMBOL_REF:
3535       h ^= htab_hash_string (XSTR (x, 0));
3536       break;
3537
3538     case LABEL_REF:
3539       h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3540       break;
3541
3542     case UNSPEC:
3543     case UNSPEC_VOLATILE:
3544       h = h * 251 + XINT (x, 1);
3545       break;
3546
3547     default:
3548       break;
3549     }
3550
3551   hp = (hashval_t *) data;
3552   *hp = *hp * 509 + h;
3553   return 0;
3554 }
3555
3556 /* Compute a hash value for X, which should be a constant.  */
3557
3558 static hashval_t
3559 const_rtx_hash (rtx x)
3560 {
3561   hashval_t h = 0;
3562   for_each_rtx (&x, const_rtx_hash_1, &h);
3563   return h;
3564 }
3565
3566 \f
3567 /* Create and return a new rtx constant pool.  */
3568
3569 static struct rtx_constant_pool *
3570 create_constant_pool (void)
3571 {
3572   struct rtx_constant_pool *pool;
3573
3574   pool = GGC_NEW (struct rtx_constant_pool);
3575   pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3576                                           const_desc_rtx_eq, NULL);
3577   pool->first = NULL;
3578   pool->last = NULL;
3579   pool->offset = 0;
3580   return pool;
3581 }
3582
3583 /* Initialize constant pool hashing for a new function.  */
3584
3585 void
3586 init_varasm_status (void)
3587 {
3588   crtl->varasm.pool = create_constant_pool ();
3589   crtl->varasm.deferred_constants = 0;
3590 }
3591 \f
3592 /* Given a MINUS expression, simplify it if both sides
3593    include the same symbol.  */
3594
3595 rtx
3596 simplify_subtraction (rtx x)
3597 {
3598   rtx r = simplify_rtx (x);
3599   return r ? r : x;
3600 }
3601 \f
3602 /* Given a constant rtx X, make (or find) a memory constant for its value
3603    and return a MEM rtx to refer to it in memory.  */
3604
3605 rtx
3606 force_const_mem (enum machine_mode mode, rtx x)
3607 {
3608   struct constant_descriptor_rtx *desc, tmp;
3609   struct rtx_constant_pool *pool;
3610   char label[256];
3611   rtx def, symbol;
3612   hashval_t hash;
3613   unsigned int align;
3614   void **slot;
3615
3616   /* If we're not allowed to drop X into the constant pool, don't.  */
3617   if (targetm.cannot_force_const_mem (x))
3618     return NULL_RTX;
3619
3620   /* Record that this function has used a constant pool entry.  */
3621   crtl->uses_const_pool = 1;
3622
3623   /* Decide which pool to use.  */
3624   pool = (targetm.use_blocks_for_constant_p (mode, x)
3625           ? shared_constant_pool
3626           : crtl->varasm.pool);
3627
3628   /* Lookup the value in the hashtable.  */
3629   tmp.constant = x;
3630   tmp.mode = mode;
3631   hash = const_rtx_hash (x);
3632   slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3633   desc = (struct constant_descriptor_rtx *) *slot;
3634
3635   /* If the constant was already present, return its memory.  */
3636   if (desc)
3637     return copy_rtx (desc->mem);
3638
3639   /* Otherwise, create a new descriptor.  */
3640   desc = GGC_NEW (struct constant_descriptor_rtx);
3641   *slot = desc;
3642
3643   /* Align the location counter as required by EXP's data type.  */
3644   align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3645 #ifdef CONSTANT_ALIGNMENT
3646   {
3647     tree type = lang_hooks.types.type_for_mode (mode, 0);
3648     if (type != NULL_TREE)
3649       align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3650   }
3651 #endif
3652
3653   pool->offset += (align / BITS_PER_UNIT) - 1;
3654   pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3655
3656   desc->next = NULL;
3657   desc->constant = tmp.constant;
3658   desc->offset = pool->offset;
3659   desc->hash = hash;
3660   desc->mode = mode;
3661   desc->align = align;
3662   desc->labelno = const_labelno;
3663   desc->mark = 0;
3664
3665   pool->offset += GET_MODE_SIZE (mode);
3666   if (pool->last)
3667     pool->last->next = desc;
3668   else
3669     pool->first = pool->last = desc;
3670   pool->last = desc;
3671
3672   /* Create a string containing the label name, in LABEL.  */
3673   ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3674   ++const_labelno;
3675
3676   /* Construct the SYMBOL_REF.  Make sure to mark it as belonging to
3677      the constants pool.  */
3678   if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3679     {
3680       section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3681       symbol = create_block_symbol (ggc_strdup (label),
3682                                     get_block_for_section (sect), -1);
3683     }
3684   else
3685     symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3686   desc->sym = symbol;
3687   SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3688   CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3689   SET_SYMBOL_REF_CONSTANT (symbol, desc);
3690
3691   /* Construct the MEM.  */
3692   desc->mem = def = gen_const_mem (mode, symbol);
3693   set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3694   set_mem_align (def, align);
3695
3696   /* If we're dropping a label to the constant pool, make sure we
3697      don't delete it.  */
3698   if (GET_CODE (x) == LABEL_REF)
3699     LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3700
3701   return copy_rtx (def);
3702 }
3703 \f
3704 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3705
3706 rtx
3707 get_pool_constant (rtx addr)
3708 {
3709   return SYMBOL_REF_CONSTANT (addr)->constant;
3710 }
3711
3712 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3713    and whether it has been output or not.  */
3714
3715 rtx
3716 get_pool_constant_mark (rtx addr, bool *pmarked)
3717 {
3718   struct constant_descriptor_rtx *desc;
3719
3720   desc = SYMBOL_REF_CONSTANT (addr);
3721   *pmarked = (desc->mark != 0);
3722   return desc->constant;
3723 }
3724
3725 /* Similar, return the mode.  */
3726
3727 enum machine_mode
3728 get_pool_mode (const_rtx addr)
3729 {
3730   return SYMBOL_REF_CONSTANT (addr)->mode;
3731 }
3732
3733 /* Return the size of the constant pool.  */
3734
3735 int