OSDN Git Service

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