OSDN Git Service

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