OSDN Git Service

2010-05-21 Kai Tietz <kai.tietz@onevision.com>
[pf3gnuchains/gcc-fork.git] / gcc / varasm.c
1 /* Output variables, constants and external declarations, for GNU compiler.
2    Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3    1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009,
4    2010  Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3.  If not see
20 <http://www.gnu.org/licenses/>.  */
21
22
23 /* This file handles generation of all the assembler code
24    *except* the instructions of a function.
25    This includes declarations of variables and their initial values.
26
27    We also output the assembler code for constants stored in memory
28    and are responsible for combining constants with the same value.  */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "rtl.h"
35 #include "tree.h"
36 #include "flags.h"
37 #include "function.h"
38 #include "expr.h"
39 #include "hard-reg-set.h"
40 #include "regs.h"
41 #include "real.h"
42 #include "output.h"
43 #include "toplev.h"
44 #include "hashtab.h"
45 #include "ggc.h"
46 #include "langhooks.h"
47 #include "tm_p.h"
48 #include "debug.h"
49 #include "target.h"
50 #include "targhooks.h"
51 #include "tree-mudflap.h"
52 #include "cgraph.h"
53 #include "cfglayout.h"
54 #include "basic-block.h"
55 #include "tree-iterator.h"
56
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h"           /* Needed for external data
59                                    declarations for e.g. AIX 4.x.  */
60 #endif
61
62 /* The (assembler) name of the first globally-visible object output.  */
63 extern GTY(()) const char *first_global_object_name;
64 extern GTY(()) const char *weak_global_object_name;
65
66 const char *first_global_object_name;
67 const char *weak_global_object_name;
68
69 struct addr_const;
70 struct constant_descriptor_rtx;
71 struct rtx_constant_pool;
72
73 #define n_deferred_constants (crtl->varasm.deferred_constants)
74
75 /* Number for making the label on the next
76    constant that is stored in memory.  */
77
78 static GTY(()) int const_labelno;
79
80 /* Carry information from ASM_DECLARE_OBJECT_NAME
81    to ASM_FINISH_DECLARE_OBJECT.  */
82
83 int size_directive_output;
84
85 /* The last decl for which assemble_variable was called,
86    if it did ASM_DECLARE_OBJECT_NAME.
87    If the last call to assemble_variable didn't do that,
88    this holds 0.  */
89
90 tree last_assemble_variable_decl;
91
92 /* The following global variable indicates if the first basic block
93    in a function belongs to the cold partition or not.  */
94
95 bool first_function_block_is_cold;
96
97 /* We give all constants their own alias set.  Perhaps redundant with
98    MEM_READONLY_P, but pre-dates it.  */
99
100 static alias_set_type const_alias_set;
101
102 static const char *strip_reg_name (const char *);
103 static int contains_pointers_p (tree);
104 #ifdef ASM_OUTPUT_EXTERNAL
105 static bool incorporeal_function_p (tree);
106 #endif
107 static void decode_addr_const (tree, struct addr_const *);
108 static hashval_t const_desc_hash (const void *);
109 static int const_desc_eq (const void *, const void *);
110 static hashval_t const_hash_1 (const tree);
111 static int compare_constant (const tree, const tree);
112 static tree copy_constant (tree);
113 static void output_constant_def_contents (rtx);
114 static void output_addressed_constants (tree);
115 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
116 static unsigned min_align (unsigned, unsigned);
117 static void globalize_decl (tree);
118 #ifdef BSS_SECTION_ASM_OP
119 #ifdef ASM_OUTPUT_BSS
120 static void asm_output_bss (FILE *, tree, const char *,
121                             unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
122 #endif
123 #ifdef ASM_OUTPUT_ALIGNED_BSS
124 static void asm_output_aligned_bss (FILE *, tree, const char *,
125                                     unsigned HOST_WIDE_INT, int)
126      ATTRIBUTE_UNUSED;
127 #endif
128 #endif /* BSS_SECTION_ASM_OP */
129 static void mark_weak (tree);
130 static void output_constant_pool (const char *, tree);
131 \f
132 /* Well-known sections, each one associated with some sort of *_ASM_OP.  */
133 section *text_section;
134 section *data_section;
135 section *readonly_data_section;
136 section *sdata_section;
137 section *ctors_section;
138 section *dtors_section;
139 section *bss_section;
140 section *sbss_section;
141
142 /* Various forms of common section.  All are guaranteed to be nonnull.  */
143 section *tls_comm_section;
144 section *comm_section;
145 section *lcomm_section;
146
147 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
148    May be null.  */
149 section *bss_noswitch_section;
150
151 /* The section that holds the main exception table, when known.  The section
152    is set either by the target's init_sections hook or by the first call to
153    switch_to_exception_section.  */
154 section *exception_section;
155
156 /* The section that holds the DWARF2 frame unwind information, when known.
157    The section is set either by the target's init_sections hook or by the
158    first call to switch_to_eh_frame_section.  */
159 section *eh_frame_section;
160
161 /* asm_out_file's current section.  This is NULL if no section has yet
162    been selected or if we lose track of what the current section is.  */
163 section *in_section;
164
165 /* True if code for the current function is currently being directed
166    at the cold section.  */
167 bool in_cold_section_p;
168
169 /* A linked list of all the unnamed sections.  */
170 static GTY(()) section *unnamed_sections;
171
172 /* Return a nonzero value if DECL has a section attribute.  */
173 #define IN_NAMED_SECTION(DECL) \
174   ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
175    && DECL_SECTION_NAME (DECL) != NULL_TREE)
176
177 /* Hash table of named sections.  */
178 static GTY((param_is (section))) htab_t section_htab;
179
180 /* A table of object_blocks, indexed by section.  */
181 static GTY((param_is (struct object_block))) htab_t object_block_htab;
182
183 /* The next number to use for internal anchor labels.  */
184 static GTY(()) int anchor_labelno;
185
186 /* A pool of constants that can be shared between functions.  */
187 static GTY(()) struct rtx_constant_pool *shared_constant_pool;
188
189 /* TLS emulation.  */
190
191 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
192      htab_t emutls_htab;
193 static GTY (()) tree emutls_object_type;
194 /* Emulated TLS objects have the TLS model TLS_MODEL_EMULATED.  This
195    macro can be used on them to distinguish the control variable from
196    the initialization template.  */
197 #define DECL_EMUTLS_VAR_P(D)  (TREE_TYPE (D) == emutls_object_type)
198
199 #if !defined (NO_DOT_IN_LABEL)
200 # define EMUTLS_SEPARATOR       "."
201 #elif !defined (NO_DOLLAR_IN_LABEL)
202 # define EMUTLS_SEPARATOR       "$"
203 #else
204 # define EMUTLS_SEPARATOR       "_"
205 #endif
206
207 /* Create an IDENTIFIER_NODE by prefixing PREFIX to the
208    IDENTIFIER_NODE NAME's name.  */
209
210 static tree
211 prefix_name (const char *prefix, tree name)
212 {
213   unsigned plen = strlen (prefix);
214   unsigned nlen = strlen (IDENTIFIER_POINTER (name));
215   char *toname = (char *) alloca (plen + nlen + 1);
216
217   memcpy (toname, prefix, plen);
218   memcpy (toname + plen, IDENTIFIER_POINTER (name), nlen + 1);
219
220   return get_identifier (toname);
221 }
222
223 /* Create an identifier for the struct __emutls_object, given an identifier
224    of the DECL_ASSEMBLY_NAME of the original object.  */
225
226 static tree
227 get_emutls_object_name (tree name)
228 {
229   const char *prefix = (targetm.emutls.var_prefix
230                         ? targetm.emutls.var_prefix
231                         : "__emutls_v" EMUTLS_SEPARATOR);
232   return prefix_name (prefix, name);
233 }
234
235 tree
236 default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED)
237 {
238   tree word_type_node, field, next_field;
239
240   field = build_decl (UNKNOWN_LOCATION,
241                       FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
242   DECL_CONTEXT (field) = type;
243   next_field = field;
244
245   field = build_decl (UNKNOWN_LOCATION,
246                       FIELD_DECL, get_identifier ("__offset"),
247                       ptr_type_node);
248   DECL_CONTEXT (field) = type;
249   TREE_CHAIN (field) = next_field;
250   next_field = field;
251
252   word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
253   field = build_decl (UNKNOWN_LOCATION,
254                       FIELD_DECL, get_identifier ("__align"),
255                       word_type_node);
256   DECL_CONTEXT (field) = type;
257   TREE_CHAIN (field) = next_field;
258   next_field = field;
259
260   field = build_decl (UNKNOWN_LOCATION,
261                       FIELD_DECL, get_identifier ("__size"), word_type_node);
262   DECL_CONTEXT (field) = type;
263   TREE_CHAIN (field) = next_field;
264
265   return field;
266 }
267
268 /* Create the structure for struct __emutls_object.  This should match the
269    structure at the top of emutls.c, modulo the union there.  */
270
271 static tree
272 get_emutls_object_type (void)
273 {
274   tree type, type_name, field;
275
276   type = emutls_object_type;
277   if (type)
278     return type;
279
280   emutls_object_type = type = lang_hooks.types.make_type (RECORD_TYPE);
281   type_name = NULL;
282   field = targetm.emutls.var_fields (type, &type_name);
283   if (!type_name)
284     type_name = get_identifier ("__emutls_object");
285   type_name = build_decl (UNKNOWN_LOCATION,
286                           TYPE_DECL, type_name, type);
287   TYPE_NAME (type) = type_name;
288   TYPE_FIELDS (type) = field;
289   layout_type (type);
290
291   return type;
292 }
293
294 /* Create a read-only variable like DECL, with the same DECL_INITIAL.
295    This will be used for initializing the emulated tls data area.  */
296
297 static tree
298 get_emutls_init_templ_addr (tree decl)
299 {
300   tree name, to;
301
302   if (targetm.emutls.register_common && !DECL_INITIAL (decl)
303       && !DECL_SECTION_NAME (decl))
304     return null_pointer_node;
305
306   name = DECL_ASSEMBLER_NAME (decl);
307   if (!targetm.emutls.tmpl_prefix || targetm.emutls.tmpl_prefix[0])
308     {
309       const char *prefix = (targetm.emutls.tmpl_prefix
310                             ? targetm.emutls.tmpl_prefix
311                             : "__emutls_t" EMUTLS_SEPARATOR);
312       name = prefix_name (prefix, name);
313     }
314
315   to = build_decl (DECL_SOURCE_LOCATION (decl),
316                    VAR_DECL, name, TREE_TYPE (decl));
317   SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
318   DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
319   DECL_ARTIFICIAL (to) = 1;
320   TREE_USED (to) = TREE_USED (decl);
321   TREE_READONLY (to) = 1;
322   DECL_IGNORED_P (to) = 1;
323   DECL_CONTEXT (to) = DECL_CONTEXT (decl);
324   DECL_SECTION_NAME (to) = DECL_SECTION_NAME (decl);
325
326   DECL_WEAK (to) = DECL_WEAK (decl);
327   if (DECL_ONE_ONLY (decl))
328     {
329       make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
330       TREE_STATIC (to) = TREE_STATIC (decl);
331       TREE_PUBLIC (to) = TREE_PUBLIC (decl);
332       DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
333     }
334   else
335     TREE_STATIC (to) = 1;
336
337   DECL_INITIAL (to) = DECL_INITIAL (decl);
338   DECL_INITIAL (decl) = NULL;
339
340   varpool_finalize_decl (to);
341   return build_fold_addr_expr (to);
342 }
343
344 /* When emulating tls, we use a control structure for use by the runtime.
345    Create and return this structure.  */
346
347 tree
348 emutls_decl (tree decl)
349 {
350   tree name, to;
351   struct tree_map *h, in;
352   void **loc;
353
354   if (targetm.have_tls || decl == NULL || decl == error_mark_node
355       || TREE_CODE (decl) != VAR_DECL || ! DECL_THREAD_LOCAL_P (decl))
356     return decl;
357
358   /* Look up the object in the hash; return the control structure if
359      it has already been created.  */
360   if (! emutls_htab)
361     emutls_htab = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
362
363   name = DECL_ASSEMBLER_NAME (decl);
364
365   /* Note that we use the hash of the decl's name, rather than a hash
366      of the decl's pointer.  In emutls_finish we iterate through the
367      hash table, and we want this traversal to be predictable.  */
368   in.hash = IDENTIFIER_HASH_VALUE (name);
369   in.base.from = decl;
370   loc = htab_find_slot_with_hash (emutls_htab, &in, in.hash, INSERT);
371   h = (struct tree_map *) *loc;
372   if (h != NULL)
373     to = h->to;
374   else
375     {
376       to = build_decl (DECL_SOURCE_LOCATION (decl),
377                        VAR_DECL, get_emutls_object_name (name),
378                        get_emutls_object_type ());
379
380       h = GGC_NEW (struct tree_map);
381       h->hash = in.hash;
382       h->base.from = decl;
383       h->to = to;
384       *(struct tree_map **) loc = h;
385
386       DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
387       DECL_ARTIFICIAL (to) = 1;
388       DECL_IGNORED_P (to) = 1;
389       TREE_READONLY (to) = 0;
390       SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
391       if (DECL_ONE_ONLY (decl))
392         make_decl_one_only (to, DECL_ASSEMBLER_NAME (to));
393       DECL_CONTEXT (to) = DECL_CONTEXT (decl);
394       if (targetm.emutls.var_align_fixed)
395         /* If we're not allowed to change the proxy object's
396            alignment, pretend it's been set by the user.  */
397         DECL_USER_ALIGN (to) = 1;
398     }
399
400   /* Note that these fields may need to be updated from time to time from
401      the original decl.  Consider:
402         extern __thread int i;
403         int foo() { return i; }
404         __thread int i = 1;
405      in which I goes from external to locally defined and initialized.  */
406   DECL_DLLIMPORT_P (to) = DECL_DLLIMPORT_P (decl);
407   DECL_ATTRIBUTES (to) = targetm.merge_decl_attributes (decl, to);
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   /* If this variable belongs to the global constant pool, retrieve the
1360      pre-computed RTL or recompute it in LTO mode.  */
1361   if (TREE_CODE (decl) == VAR_DECL && DECL_IN_CONSTANT_POOL (decl))
1362     {
1363       SET_DECL_RTL (decl, output_constant_def (DECL_INITIAL (decl), 1));
1364       return;
1365     }
1366
1367   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1368
1369   if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1370       && DECL_REGISTER (decl))
1371     {
1372       error ("register name not specified for %q+D", decl);
1373     }
1374   else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1375     {
1376       const char *asmspec = name+1;
1377       reg_number = decode_reg_name (asmspec);
1378       /* First detect errors in declaring global registers.  */
1379       if (reg_number == -1)
1380         error ("register name not specified for %q+D", decl);
1381       else if (reg_number < 0)
1382         error ("invalid register name for %q+D", decl);
1383       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1384         error ("data type of %q+D isn%'t suitable for a register",
1385                decl);
1386       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1387         error ("register specified for %q+D isn%'t suitable for data type",
1388                decl);
1389       /* Now handle properly declared static register variables.  */
1390       else
1391         {
1392           int nregs;
1393
1394           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1395             {
1396               DECL_INITIAL (decl) = 0;
1397               error ("global register variable has initial value");
1398             }
1399           if (TREE_THIS_VOLATILE (decl))
1400             warning (OPT_Wvolatile_register_var,
1401                      "optimization may eliminate reads and/or "
1402                      "writes to register variables");
1403
1404           /* If the user specified one of the eliminables registers here,
1405              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1406              confused with that register and be eliminated.  This usage is
1407              somewhat suspect...  */
1408
1409           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1410           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1411           REG_USERVAR_P (DECL_RTL (decl)) = 1;
1412
1413           if (TREE_STATIC (decl))
1414             {
1415               /* Make this register global, so not usable for anything
1416                  else.  */
1417 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1418               name = IDENTIFIER_POINTER (DECL_NAME (decl));
1419               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1420 #endif
1421               nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1422               while (nregs > 0)
1423                 globalize_reg (reg_number + --nregs);
1424             }
1425
1426           /* As a register variable, it has no section.  */
1427           return;
1428         }
1429     }
1430   /* Now handle ordinary static variables and functions (in memory).
1431      Also handle vars declared register invalidly.  */
1432   else if (name[0] == '*')
1433   {
1434 #ifdef REGISTER_PREFIX
1435     if (strlen (REGISTER_PREFIX) != 0)
1436       {
1437         reg_number = decode_reg_name (name);
1438         if (reg_number >= 0 || reg_number == -3)
1439           error ("register name given for non-register variable %q+D", decl);
1440       }
1441 #endif
1442   }
1443
1444   /* Specifying a section attribute on a variable forces it into a
1445      non-.bss section, and thus it cannot be common.  */
1446   /* FIXME: In general this code should not be necessary because
1447      visibility pass is doing the same work.  But notice_global_symbol
1448      is called early and it needs to make DECL_RTL to get the name.
1449      we take care of recomputing the DECL_RTL after visibility is changed.  */
1450   if (TREE_CODE (decl) == VAR_DECL
1451       && DECL_SECTION_NAME (decl) != NULL_TREE
1452       && DECL_INITIAL (decl) == NULL_TREE
1453       && DECL_COMMON (decl))
1454     DECL_COMMON (decl) = 0;
1455
1456   /* Variables can't be both common and weak.  */
1457   if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1458     DECL_COMMON (decl) = 0;
1459
1460   if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1461     x = create_block_symbol (name, get_block_for_decl (decl), -1);
1462   else
1463     {
1464       enum machine_mode address_mode = Pmode;
1465       if (TREE_TYPE (decl) != error_mark_node)
1466         {
1467           addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (decl));
1468           address_mode = targetm.addr_space.address_mode (as);
1469         }
1470       x = gen_rtx_SYMBOL_REF (address_mode, name);
1471     }
1472   SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1473   SET_SYMBOL_REF_DECL (x, decl);
1474
1475   x = gen_rtx_MEM (DECL_MODE (decl), x);
1476   if (TREE_CODE (decl) != FUNCTION_DECL)
1477     set_mem_attributes (x, decl, 1);
1478   SET_DECL_RTL (decl, x);
1479
1480   /* Optionally set flags or add text to the name to record information
1481      such as that it is a function name.
1482      If the name is changed, the macro ASM_OUTPUT_LABELREF
1483      will have to know how to strip this information.  */
1484   targetm.encode_section_info (decl, DECL_RTL (decl), true);
1485
1486   /* Make this function static known to the mudflap runtime.  */
1487   if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1488     mudflap_enqueue_decl (decl);
1489 }
1490
1491 /* Like make_decl_rtl, but inhibit creation of new alias sets when
1492    calling make_decl_rtl.  Also, reset DECL_RTL before returning the
1493    rtl.  */
1494
1495 rtx
1496 make_decl_rtl_for_debug (tree decl)
1497 {
1498   unsigned int save_aliasing_flag, save_mudflap_flag;
1499   rtx rtl;
1500
1501   if (DECL_RTL_SET_P (decl))
1502     return DECL_RTL (decl);
1503
1504   /* Kludge alert!  Somewhere down the call chain, make_decl_rtl will
1505      call new_alias_set.  If running with -fcompare-debug, sometimes
1506      we do not want to create alias sets that will throw the alias
1507      numbers off in the comparison dumps.  So... clearing
1508      flag_strict_aliasing will keep new_alias_set() from creating a
1509      new set.  It is undesirable to register decl with mudflap
1510      in this case as well.  */
1511   save_aliasing_flag = flag_strict_aliasing;
1512   flag_strict_aliasing = 0;
1513   save_mudflap_flag = flag_mudflap;
1514   flag_mudflap = 0;
1515
1516   rtl = DECL_RTL (decl);
1517   /* Reset DECL_RTL back, as various parts of the compiler expects
1518      DECL_RTL set meaning it is actually going to be output.  */
1519   SET_DECL_RTL (decl, NULL);
1520
1521   flag_strict_aliasing = save_aliasing_flag;
1522   flag_mudflap = save_mudflap_flag;
1523
1524   return rtl;
1525 }
1526 \f
1527 /* Output a string of literal assembler code
1528    for an `asm' keyword used between functions.  */
1529
1530 void
1531 assemble_asm (tree string)
1532 {
1533   app_enable ();
1534
1535   if (TREE_CODE (string) == ADDR_EXPR)
1536     string = TREE_OPERAND (string, 0);
1537
1538   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1539 }
1540
1541 /* Record an element in the table of global destructors.  SYMBOL is
1542    a SYMBOL_REF of the function to be called; PRIORITY is a number
1543    between 0 and MAX_INIT_PRIORITY.  */
1544
1545 void
1546 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1547                                   int priority ATTRIBUTE_UNUSED)
1548 {
1549 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1550   /* Tell GNU LD that this is part of the static destructor set.
1551      This will work for any system that uses stabs, most usefully
1552      aout systems.  */
1553   dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1554   dbxout_stab_value_label (XSTR (symbol, 0));
1555 #else
1556   sorry ("global destructors not supported on this target");
1557 #endif
1558 }
1559
1560 /* Write the address of the entity given by SYMBOL to SEC.  */
1561 void
1562 assemble_addr_to_section (rtx symbol, section *sec)
1563 {
1564   switch_to_section (sec);
1565   assemble_align (POINTER_SIZE);
1566   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1567 }
1568
1569 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1570    not) section for PRIORITY.  */
1571 section *
1572 get_cdtor_priority_section (int priority, bool constructor_p)
1573 {
1574   char buf[16];
1575
1576   /* ??? This only works reliably with the GNU linker.  */
1577   sprintf (buf, "%s.%.5u",
1578            constructor_p ? ".ctors" : ".dtors",
1579            /* Invert the numbering so the linker puts us in the proper
1580               order; constructors are run from right to left, and the
1581               linker sorts in increasing order.  */
1582            MAX_INIT_PRIORITY - priority);
1583   return get_section (buf, SECTION_WRITE, NULL);
1584 }
1585
1586 void
1587 default_named_section_asm_out_destructor (rtx symbol, int priority)
1588 {
1589   section *sec;
1590
1591   if (priority != DEFAULT_INIT_PRIORITY)
1592     sec = get_cdtor_priority_section (priority,
1593                                       /*constructor_p=*/false);
1594   else
1595     sec = get_section (".dtors", SECTION_WRITE, NULL);
1596
1597   assemble_addr_to_section (symbol, sec);
1598 }
1599
1600 #ifdef DTORS_SECTION_ASM_OP
1601 void
1602 default_dtor_section_asm_out_destructor (rtx symbol,
1603                                          int priority ATTRIBUTE_UNUSED)
1604 {
1605   assemble_addr_to_section (symbol, dtors_section);
1606 }
1607 #endif
1608
1609 /* Likewise for global constructors.  */
1610
1611 void
1612 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1613                                    int priority ATTRIBUTE_UNUSED)
1614 {
1615 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1616   /* Tell GNU LD that this is part of the static destructor set.
1617      This will work for any system that uses stabs, most usefully
1618      aout systems.  */
1619   dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1620   dbxout_stab_value_label (XSTR (symbol, 0));
1621 #else
1622   sorry ("global constructors not supported on this target");
1623 #endif
1624 }
1625
1626 void
1627 default_named_section_asm_out_constructor (rtx symbol, int priority)
1628 {
1629   section *sec;
1630
1631   if (priority != DEFAULT_INIT_PRIORITY)
1632     sec = get_cdtor_priority_section (priority,
1633                                       /*constructor_p=*/true);
1634   else
1635     sec = get_section (".ctors", SECTION_WRITE, NULL);
1636
1637   assemble_addr_to_section (symbol, sec);
1638 }
1639
1640 #ifdef CTORS_SECTION_ASM_OP
1641 void
1642 default_ctor_section_asm_out_constructor (rtx symbol,
1643                                           int priority ATTRIBUTE_UNUSED)
1644 {
1645   assemble_addr_to_section (symbol, ctors_section);
1646 }
1647 #endif
1648 \f
1649 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1650    a nonzero value if the constant pool should be output before the
1651    start of the function, or a zero value if the pool should output
1652    after the end of the function.  The default is to put it before the
1653    start.  */
1654
1655 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1656 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1657 #endif
1658
1659 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1660    to be output to assembler.
1661    Set first_global_object_name and weak_global_object_name as appropriate.  */
1662
1663 void
1664 notice_global_symbol (tree decl)
1665 {
1666   const char **type = &first_global_object_name;
1667
1668   if (first_global_object_name
1669       || !TREE_PUBLIC (decl)
1670       || DECL_EXTERNAL (decl)
1671       || !DECL_NAME (decl)
1672       || (TREE_CODE (decl) != FUNCTION_DECL
1673           && (TREE_CODE (decl) != VAR_DECL
1674               || (DECL_COMMON (decl)
1675                   && (DECL_INITIAL (decl) == 0
1676                       || DECL_INITIAL (decl) == error_mark_node))))
1677       || !MEM_P (DECL_RTL (decl)))
1678     return;
1679
1680   /* We win when global object is found, but it is useful to know about weak
1681      symbol as well so we can produce nicer unique names.  */
1682   if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib)
1683     type = &weak_global_object_name;
1684
1685   if (!*type)
1686     {
1687       const char *p;
1688       const char *name;
1689       rtx decl_rtl = DECL_RTL (decl);
1690
1691       p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1692       name = ggc_strdup (p);
1693
1694       *type = name;
1695     }
1696 }
1697
1698 /* Output assembler code for the constant pool of a function and associated
1699    with defining the name of the function.  DECL describes the function.
1700    NAME is the function's name.  For the constant pool, we use the current
1701    constant pool data.  */
1702
1703 void
1704 assemble_start_function (tree decl, const char *fnname)
1705 {
1706   int align;
1707   char tmp_label[100];
1708   bool hot_label_written = false;
1709
1710   crtl->subsections.unlikely_text_section_name = NULL;
1711
1712   first_function_block_is_cold = false;
1713   if (flag_reorder_blocks_and_partition)
1714     {
1715       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1716       crtl->subsections.hot_section_label = ggc_strdup (tmp_label);
1717       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1718       crtl->subsections.cold_section_label = ggc_strdup (tmp_label);
1719       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1720       crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label);
1721       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1722       crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label);
1723       const_labelno++;
1724     }
1725   else
1726     {
1727       crtl->subsections.hot_section_label = NULL;
1728       crtl->subsections.cold_section_label = NULL;
1729       crtl->subsections.hot_section_end_label = NULL;
1730       crtl->subsections.cold_section_end_label = NULL;
1731     }
1732
1733   /* The following code does not need preprocessing in the assembler.  */
1734
1735   app_disable ();
1736
1737   if (CONSTANT_POOL_BEFORE_FUNCTION)
1738     output_constant_pool (fnname, decl);
1739
1740   resolve_unique_section (decl, 0, flag_function_sections);
1741
1742   /* Make sure the not and cold text (code) sections are properly
1743      aligned.  This is necessary here in the case where the function
1744      has both hot and cold sections, because we don't want to re-set
1745      the alignment when the section switch happens mid-function.  */
1746
1747   if (flag_reorder_blocks_and_partition)
1748     {
1749       switch_to_section (unlikely_text_section ());
1750       assemble_align (DECL_ALIGN (decl));
1751       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label);
1752
1753       /* When the function starts with a cold section, we need to explicitly
1754          align the hot section and write out the hot section label.
1755          But if the current function is a thunk, we do not have a CFG.  */
1756       if (!cfun->is_thunk
1757           && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1758         {
1759           switch_to_section (text_section);
1760           assemble_align (DECL_ALIGN (decl));
1761           ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1762           hot_label_written = true;
1763           first_function_block_is_cold = true;
1764         }
1765     }
1766   else if (DECL_SECTION_NAME (decl))
1767     {
1768       /* Calls to function_section rely on first_function_block_is_cold
1769          being accurate.  The first block may be cold even if we aren't
1770          doing partitioning, if the entire function was decided by
1771          choose_function_section (predict.c) to be cold.  */
1772
1773       initialize_cold_section_name ();
1774
1775       if (crtl->subsections.unlikely_text_section_name
1776           && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1777                      crtl->subsections.unlikely_text_section_name) == 0)
1778         first_function_block_is_cold = true;
1779     }
1780
1781   in_cold_section_p = first_function_block_is_cold;
1782
1783   /* Switch to the correct text section for the start of the function.  */
1784
1785   switch_to_section (function_section (decl));
1786   if (flag_reorder_blocks_and_partition
1787       && !hot_label_written)
1788     ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1789
1790   /* Tell assembler to move to target machine's alignment for functions.  */
1791   align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT);
1792   if (align > 0)
1793     {
1794       ASM_OUTPUT_ALIGN (asm_out_file, align);
1795     }
1796
1797   /* Handle a user-specified function alignment.
1798      Note that we still need to align to DECL_ALIGN, as above,
1799      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1800   if (! DECL_USER_ALIGN (decl)
1801       && align_functions_log > align
1802       && optimize_function_for_speed_p (cfun))
1803     {
1804 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1805       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1806                                  align_functions_log, align_functions - 1);
1807 #else
1808       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1809 #endif
1810     }
1811
1812 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1813   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1814 #endif
1815
1816   if (!DECL_IGNORED_P (decl))
1817     (*debug_hooks->begin_function) (decl);
1818
1819   /* Make function name accessible from other files, if appropriate.  */
1820
1821   if (TREE_PUBLIC (decl))
1822     {
1823       notice_global_symbol (decl);
1824
1825       globalize_decl (decl);
1826
1827       maybe_assemble_visibility (decl);
1828     }
1829
1830   if (DECL_PRESERVE_P (decl))
1831     targetm.asm_out.mark_decl_preserved (fnname);
1832
1833   /* Do any machine/system dependent processing of the function name.  */
1834 #ifdef ASM_DECLARE_FUNCTION_NAME
1835   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1836 #else
1837   /* Standard thing is just output label for the function.  */
1838   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1839 #endif /* ASM_DECLARE_FUNCTION_NAME */
1840 }
1841
1842 /* Output assembler code associated with defining the size of the
1843    function.  DECL describes the function.  NAME is the function's name.  */
1844
1845 void
1846 assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1847 {
1848 #ifdef ASM_DECLARE_FUNCTION_SIZE
1849   /* We could have switched section in the middle of the function.  */
1850   if (flag_reorder_blocks_and_partition)
1851     switch_to_section (function_section (decl));
1852   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1853 #endif
1854   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1855     {
1856       output_constant_pool (fnname, decl);
1857       switch_to_section (function_section (decl)); /* need to switch back */
1858     }
1859   /* Output labels for end of hot/cold text sections (to be used by
1860      debug info.)  */
1861   if (flag_reorder_blocks_and_partition)
1862     {
1863       section *save_text_section;
1864
1865       save_text_section = in_section;
1866       switch_to_section (unlikely_text_section ());
1867       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label);
1868       if (first_function_block_is_cold)
1869         switch_to_section (text_section);
1870       else
1871         switch_to_section (function_section (decl));
1872       ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label);
1873       switch_to_section (save_text_section);
1874     }
1875 }
1876 \f
1877 /* Assemble code to leave SIZE bytes of zeros.  */
1878
1879 void
1880 assemble_zeros (unsigned HOST_WIDE_INT size)
1881 {
1882   /* Do no output if -fsyntax-only.  */
1883   if (flag_syntax_only)
1884     return;
1885
1886 #ifdef ASM_NO_SKIP_IN_TEXT
1887   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1888      so we must output 0s explicitly in the text section.  */
1889   if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1890     {
1891       unsigned HOST_WIDE_INT i;
1892       for (i = 0; i < size; i++)
1893         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1894     }
1895   else
1896 #endif
1897     if (size > 0)
1898       ASM_OUTPUT_SKIP (asm_out_file, size);
1899 }
1900
1901 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1902
1903 void
1904 assemble_align (int align)
1905 {
1906   if (align > BITS_PER_UNIT)
1907     {
1908       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1909     }
1910 }
1911
1912 /* Assemble a string constant with the specified C string as contents.  */
1913
1914 void
1915 assemble_string (const char *p, int size)
1916 {
1917   int pos = 0;
1918   int maximum = 2000;
1919
1920   /* If the string is very long, split it up.  */
1921
1922   while (pos < size)
1923     {
1924       int thissize = size - pos;
1925       if (thissize > maximum)
1926         thissize = maximum;
1927
1928       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1929
1930       pos += thissize;
1931       p += thissize;
1932     }
1933 }
1934
1935 \f
1936 /* A noswitch_section_callback for lcomm_section.  */
1937
1938 static bool
1939 emit_local (tree decl ATTRIBUTE_UNUSED,
1940             const char *name ATTRIBUTE_UNUSED,
1941             unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1942             unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1943 {
1944 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1945   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1946                                  size, DECL_ALIGN (decl));
1947   return true;
1948 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1949   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1950   return true;
1951 #else
1952   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1953   return false;
1954 #endif
1955 }
1956
1957 /* A noswitch_section_callback for bss_noswitch_section.  */
1958
1959 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1960 static bool
1961 emit_bss (tree decl ATTRIBUTE_UNUSED,
1962           const char *name ATTRIBUTE_UNUSED,
1963           unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1964           unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1965 {
1966 #if defined ASM_OUTPUT_ALIGNED_BSS
1967   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1968   return true;
1969 #else
1970   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1971   return false;
1972 #endif
1973 }
1974 #endif
1975
1976 /* A noswitch_section_callback for comm_section.  */
1977
1978 static bool
1979 emit_common (tree decl ATTRIBUTE_UNUSED,
1980              const char *name ATTRIBUTE_UNUSED,
1981              unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1982              unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1983 {
1984 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1985   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1986                                   size, DECL_ALIGN (decl));
1987   return true;
1988 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1989   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1990   return true;
1991 #else
1992   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1993   return false;
1994 #endif
1995 }
1996
1997 /* A noswitch_section_callback for tls_comm_section.  */
1998
1999 static bool
2000 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
2001                  const char *name ATTRIBUTE_UNUSED,
2002                  unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
2003                  unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
2004 {
2005 #ifdef ASM_OUTPUT_TLS_COMMON
2006   ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
2007   return true;
2008 #else
2009   sorry ("thread-local COMMON data not implemented");
2010   return true;
2011 #endif
2012 }
2013
2014 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
2015    NAME is the name of DECL's SYMBOL_REF.  */
2016
2017 static void
2018 assemble_noswitch_variable (tree decl, const char *name, section *sect)
2019 {
2020   unsigned HOST_WIDE_INT size, rounded;
2021
2022   size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
2023   rounded = size;
2024
2025   /* Don't allocate zero bytes of common,
2026      since that means "undefined external" in the linker.  */
2027   if (size == 0)
2028     rounded = 1;
2029
2030   /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2031      so that each uninitialized object starts on such a boundary.  */
2032   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
2033   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2034              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2035
2036   if (!sect->noswitch.callback (decl, name, size, rounded)
2037       && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
2038     warning (0, "requested alignment for %q+D is greater than "
2039              "implemented alignment of %wu", decl, rounded);
2040 }
2041
2042 /* A subroutine of assemble_variable.  Output the label and contents of
2043    DECL, whose address is a SYMBOL_REF with name NAME.  DONT_OUTPUT_DATA
2044    is as for assemble_variable.  */
2045
2046 static void
2047 assemble_variable_contents (tree decl, const char *name,
2048                             bool dont_output_data)
2049 {
2050   /* Do any machine/system dependent processing of the object.  */
2051 #ifdef ASM_DECLARE_OBJECT_NAME
2052   last_assemble_variable_decl = decl;
2053   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
2054 #else
2055   /* Standard thing is just output label for the object.  */
2056   ASM_OUTPUT_LABEL (asm_out_file, name);
2057 #endif /* ASM_DECLARE_OBJECT_NAME */
2058
2059   if (!dont_output_data)
2060     {
2061       if (DECL_INITIAL (decl)
2062           && DECL_INITIAL (decl) != error_mark_node
2063           && !initializer_zerop (DECL_INITIAL (decl)))
2064         /* Output the actual data.  */
2065         output_constant (DECL_INITIAL (decl),
2066                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
2067                          DECL_ALIGN (decl));
2068       else
2069         /* Leave space for it.  */
2070         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
2071     }
2072 }
2073
2074 /* Initialize emulated tls object TO, which refers to TLS variable
2075    DECL and is initialized by PROXY.  */
2076
2077 tree
2078 default_emutls_var_init (tree to, tree decl, tree proxy)
2079 {
2080   VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 4);
2081   constructor_elt *elt;
2082   tree type = TREE_TYPE (to);
2083   tree field = TYPE_FIELDS (type);
2084
2085   elt = VEC_quick_push (constructor_elt, v, NULL);
2086   elt->index = field;
2087   elt->value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
2088
2089   elt = VEC_quick_push (constructor_elt, v, NULL);
2090   field = TREE_CHAIN (field);
2091   elt->index = field;
2092   elt->value = build_int_cst (TREE_TYPE (field),
2093                               DECL_ALIGN_UNIT (decl));
2094
2095   elt = VEC_quick_push (constructor_elt, v, NULL);
2096   field = TREE_CHAIN (field);
2097   elt->index = field;
2098   elt->value = null_pointer_node;
2099
2100   elt = VEC_quick_push (constructor_elt, v, NULL);
2101   field = TREE_CHAIN (field);
2102   elt->index = field;
2103   elt->value = proxy;
2104
2105   return build_constructor (type, v);
2106 }
2107
2108 /* Assemble everything that is needed for a variable or function declaration.
2109    Not used for automatic variables, and not used for function definitions.
2110    Should not be called for variables of incomplete structure type.
2111
2112    TOP_LEVEL is nonzero if this variable has file scope.
2113    AT_END is nonzero if this is the special handling, at end of compilation,
2114    to define things that have had only tentative definitions.
2115    DONT_OUTPUT_DATA if nonzero means don't actually output the
2116    initial value (that will be done by the caller).  */
2117
2118 void
2119 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
2120                    int at_end ATTRIBUTE_UNUSED, int dont_output_data)
2121 {
2122   const char *name;
2123   rtx decl_rtl, symbol;
2124   section *sect;
2125
2126   if (! targetm.have_tls
2127       && TREE_CODE (decl) == VAR_DECL
2128       && DECL_THREAD_LOCAL_P (decl))
2129     {
2130       tree to = emutls_decl (decl);
2131
2132       /* If this variable is defined locally, then we need to initialize the
2133          control structure with size and alignment information.  We do this
2134          at the last moment because tentative definitions can take a locally
2135          defined but uninitialized variable and initialize it later, which
2136          would result in incorrect contents.  */
2137       if (! DECL_EXTERNAL (to)
2138           && (! DECL_COMMON (to)
2139               || (DECL_INITIAL (decl)
2140                   && DECL_INITIAL (decl) != error_mark_node)))
2141         {
2142           DECL_INITIAL (to) = targetm.emutls.var_init
2143             (to, decl, get_emutls_init_templ_addr (decl));
2144
2145           /* Make sure the template is marked as needed early enough.
2146              Without this, if the variable is placed in a
2147              section-anchored block, the template will only be marked
2148              when it's too late.  */
2149           record_references_in_initializer (to, false);
2150         }
2151
2152       decl = to;
2153     }
2154
2155   last_assemble_variable_decl = 0;
2156
2157   /* Normally no need to say anything here for external references,
2158      since assemble_external is called by the language-specific code
2159      when a declaration is first seen.  */
2160
2161   if (DECL_EXTERNAL (decl))
2162     return;
2163
2164   /* Output no assembler code for a function declaration.
2165      Only definitions of functions output anything.  */
2166
2167   if (TREE_CODE (decl) == FUNCTION_DECL)
2168     return;
2169
2170   /* Do nothing for global register variables.  */
2171   if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
2172     {
2173       TREE_ASM_WRITTEN (decl) = 1;
2174       return;
2175     }
2176
2177   /* If type was incomplete when the variable was declared,
2178      see if it is complete now.  */
2179
2180   if (DECL_SIZE (decl) == 0)
2181     layout_decl (decl, 0);
2182
2183   /* Still incomplete => don't allocate it; treat the tentative defn
2184      (which is what it must have been) as an `extern' reference.  */
2185
2186   if (!dont_output_data && DECL_SIZE (decl) == 0)
2187     {
2188       error ("storage size of %q+D isn%'t known", decl);
2189       TREE_ASM_WRITTEN (decl) = 1;
2190       return;
2191     }
2192
2193   /* The first declaration of a variable that comes through this function
2194      decides whether it is global (in C, has external linkage)
2195      or local (in C, has internal linkage).  So do nothing more
2196      if this function has already run.  */
2197
2198   if (TREE_ASM_WRITTEN (decl))
2199     return;
2200
2201   /* Make sure targetm.encode_section_info is invoked before we set
2202      ASM_WRITTEN.  */
2203   decl_rtl = DECL_RTL (decl);
2204
2205   TREE_ASM_WRITTEN (decl) = 1;
2206
2207   /* Do no output if -fsyntax-only.  */
2208   if (flag_syntax_only)
2209     return;
2210
2211   if (! dont_output_data
2212       && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
2213     {
2214       error ("size of variable %q+D is too large", decl);
2215       return;
2216     }
2217
2218   gcc_assert (MEM_P (decl_rtl));
2219   gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
2220   symbol = XEXP (decl_rtl, 0);
2221
2222   /* If this symbol belongs to the tree constant pool, output the constant
2223      if it hasn't already been written.  */
2224   if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
2225     {
2226       tree decl = SYMBOL_REF_DECL (symbol);
2227       if (!TREE_ASM_WRITTEN (DECL_INITIAL (decl)))
2228         output_constant_def_contents (symbol);
2229       return;
2230     }
2231
2232   app_disable ();
2233
2234   name = XSTR (symbol, 0);
2235   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
2236     notice_global_symbol (decl);
2237
2238   /* Compute the alignment of this data.  */
2239
2240   align_variable (decl, dont_output_data);
2241   set_mem_align (decl_rtl, DECL_ALIGN (decl));
2242
2243   if (TREE_PUBLIC (decl))
2244     maybe_assemble_visibility (decl);
2245
2246   if (DECL_PRESERVE_P (decl))
2247     targetm.asm_out.mark_decl_preserved (name);
2248
2249   /* First make the assembler name(s) global if appropriate.  */
2250   sect = get_variable_section (decl, false);
2251   if (TREE_PUBLIC (decl)
2252       && (sect->common.flags & SECTION_COMMON) == 0)
2253     globalize_decl (decl);
2254
2255   /* Output any data that we will need to use the address of.  */
2256   if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
2257     output_addressed_constants (DECL_INITIAL (decl));
2258
2259   /* dbxout.c needs to know this.  */
2260   if (sect && (sect->common.flags & SECTION_CODE) != 0)
2261     DECL_IN_TEXT_SECTION (decl) = 1;
2262
2263   /* If the decl is part of an object_block, make sure that the decl
2264      has been positioned within its block, but do not write out its
2265      definition yet.  output_object_blocks will do that later.  */
2266   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2267     {
2268       gcc_assert (!dont_output_data);
2269       place_block_symbol (symbol);
2270     }
2271   else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
2272     assemble_noswitch_variable (decl, name, sect);
2273   else
2274     {
2275       switch_to_section (sect);
2276       if (DECL_ALIGN (decl) > BITS_PER_UNIT)
2277         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
2278       assemble_variable_contents (decl, name, dont_output_data);
2279     }
2280 }
2281
2282 /* Return 1 if type TYPE contains any pointers.  */
2283
2284 static int
2285 contains_pointers_p (tree type)
2286 {
2287   switch (TREE_CODE (type))
2288     {
2289     case POINTER_TYPE:
2290     case REFERENCE_TYPE:
2291       /* I'm not sure whether OFFSET_TYPE needs this treatment,
2292          so I'll play safe and return 1.  */
2293     case OFFSET_TYPE:
2294       return 1;
2295
2296     case RECORD_TYPE:
2297     case UNION_TYPE:
2298     case QUAL_UNION_TYPE:
2299       {
2300         tree fields;
2301         /* For a type that has fields, see if the fields have pointers.  */
2302         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2303           if (TREE_CODE (fields) == FIELD_DECL
2304               && contains_pointers_p (TREE_TYPE (fields)))
2305             return 1;
2306         return 0;
2307       }
2308
2309     case ARRAY_TYPE:
2310       /* An array type contains pointers if its element type does.  */
2311       return contains_pointers_p (TREE_TYPE (type));
2312
2313     default:
2314       return 0;
2315     }
2316 }
2317
2318 /* We delay assemble_external processing until
2319    the compilation unit is finalized.  This is the best we can do for
2320    right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2321    it all the way to final.  See PR 17982 for further discussion.  */
2322 static GTY(()) tree pending_assemble_externals;
2323
2324 #ifdef ASM_OUTPUT_EXTERNAL
2325 /* True if DECL is a function decl for which no out-of-line copy exists.
2326    It is assumed that DECL's assembler name has been set.  */
2327
2328 static bool
2329 incorporeal_function_p (tree decl)
2330 {
2331   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
2332     {
2333       const char *name;
2334
2335       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2336           && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
2337         return true;
2338
2339       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2340       if (is_builtin_name (name))
2341         return true;
2342     }
2343   return false;
2344 }
2345
2346 /* Actually do the tests to determine if this is necessary, and invoke
2347    ASM_OUTPUT_EXTERNAL.  */
2348 static void
2349 assemble_external_real (tree decl)
2350 {
2351   rtx rtl = DECL_RTL (decl);
2352
2353   if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
2354       && !SYMBOL_REF_USED (XEXP (rtl, 0))
2355       && !incorporeal_function_p (decl))
2356     {
2357       /* Some systems do require some output.  */
2358       SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
2359       ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
2360     }
2361 }
2362 #endif
2363
2364 void
2365 process_pending_assemble_externals (void)
2366 {
2367 #ifdef ASM_OUTPUT_EXTERNAL
2368   tree list;
2369   for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
2370     assemble_external_real (TREE_VALUE (list));
2371
2372   pending_assemble_externals = 0;
2373 #endif
2374 }
2375
2376 /* This TREE_LIST contains any weak symbol declarations waiting
2377    to be emitted.  */
2378 static GTY(()) tree weak_decls;
2379
2380 /* Output something to declare an external symbol to the assembler,
2381    and qualifiers such as weakness.  (Most assemblers don't need
2382    extern declaration, so we normally output nothing.)  Do nothing if
2383    DECL is not external.  */
2384
2385 void
2386 assemble_external (tree decl ATTRIBUTE_UNUSED)
2387 {
2388   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
2389      main body of this code is only rarely exercised.  To provide some
2390      testing, on all platforms, we make sure that the ASM_OUT_FILE is
2391      open.  If it's not, we should not be calling this function.  */
2392   gcc_assert (asm_out_file);
2393
2394   if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
2395     return;
2396
2397   /* We want to output annotation for weak and external symbols at
2398      very last to check if they are references or not.  */
2399
2400   if (SUPPORTS_WEAK
2401       && DECL_WEAK (decl)
2402       /* TREE_STATIC is a weird and abused creature which is not
2403          generally the right test for whether an entity has been
2404          locally emitted, inlined or otherwise not-really-extern, but
2405          for declarations that can be weak, it happens to be
2406          match.  */
2407       && !TREE_STATIC (decl)
2408       && lookup_attribute ("weak", DECL_ATTRIBUTES (decl))
2409       && value_member (decl, weak_decls) == NULL_TREE)
2410     weak_decls = tree_cons (NULL, decl, weak_decls);
2411
2412 #ifdef ASM_OUTPUT_EXTERNAL
2413   if (value_member (decl, pending_assemble_externals) == NULL_TREE)
2414     pending_assemble_externals = tree_cons (NULL, decl,
2415                                             pending_assemble_externals);
2416 #endif
2417 }
2418
2419 /* Similar, for calling a library function FUN.  */
2420
2421 void
2422 assemble_external_libcall (rtx fun)
2423 {
2424   /* Declare library function name external when first used, if nec.  */
2425   if (! SYMBOL_REF_USED (fun))
2426     {
2427       SYMBOL_REF_USED (fun) = 1;
2428       targetm.asm_out.external_libcall (fun);
2429     }
2430 }
2431
2432 /* Assemble a label named NAME.  */
2433
2434 void
2435 assemble_label (const char *name)
2436 {
2437   ASM_OUTPUT_LABEL (asm_out_file, name);
2438 }
2439
2440 /* Set the symbol_referenced flag for ID.  */
2441 void
2442 mark_referenced (tree id)
2443 {
2444   TREE_SYMBOL_REFERENCED (id) = 1;
2445 }
2446
2447 /* Set the symbol_referenced flag for DECL and notify callgraph.  */
2448 void
2449 mark_decl_referenced (tree decl)
2450 {
2451   if (TREE_CODE (decl) == FUNCTION_DECL)
2452     {
2453       /* Extern inline functions don't become needed when referenced.
2454          If we know a method will be emitted in other TU and no new
2455          functions can be marked reachable, just use the external
2456          definition.  */
2457       struct cgraph_node *node = cgraph_node (decl);
2458       if (!DECL_EXTERNAL (decl)
2459           && (!node->local.vtable_method || !cgraph_global_info_ready
2460               || !node->local.finalized))
2461         cgraph_mark_needed_node (node);
2462     }
2463   else if (TREE_CODE (decl) == VAR_DECL)
2464     {
2465       struct varpool_node *node = varpool_node (decl);
2466       varpool_mark_needed_node (node);
2467       /* C++ frontend use mark_decl_references to force COMDAT variables
2468          to be output that might appear dead otherwise.  */
2469       node->force_output = true;
2470     }
2471   /* else do nothing - we can get various sorts of CST nodes here,
2472      which do not need to be marked.  */
2473 }
2474
2475
2476 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2477    until we find an identifier that is not itself a transparent alias.
2478    Modify the alias passed to it by reference (and all aliases on the
2479    way to the ultimate target), such that they do not have to be
2480    followed again, and return the ultimate target of the alias
2481    chain.  */
2482
2483 static inline tree
2484 ultimate_transparent_alias_target (tree *alias)
2485 {
2486   tree target = *alias;
2487
2488   if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2489     {
2490       gcc_assert (TREE_CHAIN (target));
2491       target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2492       gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2493                   && ! TREE_CHAIN (target));
2494       *alias = target;
2495     }
2496
2497   return target;
2498 }
2499
2500 /* Output to FILE (an assembly file) a reference to NAME.  If NAME
2501    starts with a *, the rest of NAME is output verbatim.  Otherwise
2502    NAME is transformed in a target-specific way (usually by the
2503    addition of an underscore).  */
2504
2505 void
2506 assemble_name_raw (FILE *file, const char *name)
2507 {
2508   if (name[0] == '*')
2509     fputs (&name[1], file);
2510   else
2511     ASM_OUTPUT_LABELREF (file, name);
2512 }
2513
2514 /* Like assemble_name_raw, but should be used when NAME might refer to
2515    an entity that is also represented as a tree (like a function or
2516    variable).  If NAME does refer to such an entity, that entity will
2517    be marked as referenced.  */
2518
2519 void
2520 assemble_name (FILE *file, const char *name)
2521 {
2522   const char *real_name;
2523   tree id;
2524
2525   real_name = targetm.strip_name_encoding (name);
2526
2527   id = maybe_get_identifier (real_name);
2528   if (id)
2529     {
2530       tree id_orig = id;
2531
2532       mark_referenced (id);
2533       ultimate_transparent_alias_target (&id);
2534       if (id != id_orig)
2535         name = IDENTIFIER_POINTER (id);
2536       gcc_assert (! TREE_CHAIN (id));
2537     }
2538
2539   assemble_name_raw (file, name);
2540 }
2541
2542 /* Allocate SIZE bytes writable static space with a gensym name
2543    and return an RTX to refer to its address.  */
2544
2545 rtx
2546 assemble_static_space (unsigned HOST_WIDE_INT size)
2547 {
2548   char name[12];
2549   const char *namestring;
2550   rtx x;
2551
2552   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2553   ++const_labelno;
2554   namestring = ggc_strdup (name);
2555
2556   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2557   SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2558
2559 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2560   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2561                                  BIGGEST_ALIGNMENT);
2562 #else
2563 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2564   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2565 #else
2566   {
2567     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2568        so that each uninitialized object starts on such a boundary.  */
2569     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
2570     unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2571       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2572          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2573          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2574     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2575   }
2576 #endif
2577 #endif
2578   return x;
2579 }
2580
2581 /* Assemble the static constant template for function entry trampolines.
2582    This is done at most once per compilation.
2583    Returns an RTX for the address of the template.  */
2584
2585 static GTY(()) rtx initial_trampoline;
2586
2587 rtx
2588 assemble_trampoline_template (void)
2589 {
2590   char label[256];
2591   const char *name;
2592   int align;
2593   rtx symbol;
2594
2595   gcc_assert (targetm.asm_out.trampoline_template != NULL);
2596
2597   if (initial_trampoline)
2598     return initial_trampoline;
2599
2600   /* By default, put trampoline templates in read-only data section.  */
2601
2602 #ifdef TRAMPOLINE_SECTION
2603   switch_to_section (TRAMPOLINE_SECTION);
2604 #else
2605   switch_to_section (readonly_data_section);
2606 #endif
2607
2608   /* Write the assembler code to define one.  */
2609   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2610   if (align > 0)
2611     ASM_OUTPUT_ALIGN (asm_out_file, align);
2612
2613   targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2614   targetm.asm_out.trampoline_template (asm_out_file);
2615
2616   /* Record the rtl to refer to it.  */
2617   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2618   name = ggc_strdup (label);
2619   symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2620   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2621
2622   initial_trampoline = gen_const_mem (BLKmode, symbol);
2623   set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2624   set_mem_size (initial_trampoline, GEN_INT (TRAMPOLINE_SIZE));
2625
2626   return initial_trampoline;
2627 }
2628 \f
2629 /* A and B are either alignments or offsets.  Return the minimum alignment
2630    that may be assumed after adding the two together.  */
2631
2632 static inline unsigned
2633 min_align (unsigned int a, unsigned int b)
2634 {
2635   return (a | b) & -(a | b);
2636 }
2637
2638 /* Return the assembler directive for creating a given kind of integer
2639    object.  SIZE is the number of bytes in the object and ALIGNED_P
2640    indicates whether it is known to be aligned.  Return NULL if the
2641    assembly dialect has no such directive.
2642
2643    The returned string should be printed at the start of a new line and
2644    be followed immediately by the object's initial value.  */
2645
2646 const char *
2647 integer_asm_op (int size, int aligned_p)
2648 {
2649   struct asm_int_op *ops;
2650
2651   if (aligned_p)
2652     ops = &targetm.asm_out.aligned_op;
2653   else
2654     ops = &targetm.asm_out.unaligned_op;
2655
2656   switch (size)
2657     {
2658     case 1:
2659       return targetm.asm_out.byte_op;
2660     case 2:
2661       return ops->hi;
2662     case 4:
2663       return ops->si;
2664     case 8:
2665       return ops->di;
2666     case 16:
2667       return ops->ti;
2668     default:
2669       return NULL;
2670     }
2671 }
2672
2673 /* Use directive OP to assemble an integer object X.  Print OP at the
2674    start of the line, followed immediately by the value of X.  */
2675
2676 void
2677 assemble_integer_with_op (const char *op, rtx x)
2678 {
2679   fputs (op, asm_out_file);
2680   output_addr_const (asm_out_file, x);
2681   fputc ('\n', asm_out_file);
2682 }
2683
2684 /* The default implementation of the asm_out.integer target hook.  */
2685
2686 bool
2687 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2688                           unsigned int size ATTRIBUTE_UNUSED,
2689                           int aligned_p ATTRIBUTE_UNUSED)
2690 {
2691   const char *op = integer_asm_op (size, aligned_p);
2692   /* Avoid GAS bugs for large values.  Specifically negative values whose
2693      absolute value fits in a bfd_vma, but not in a bfd_signed_vma.  */
2694   if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2695     return false;
2696   return op && (assemble_integer_with_op (op, x), true);
2697 }
2698
2699 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
2700    the alignment of the integer in bits.  Return 1 if we were able to output
2701    the constant, otherwise 0.  We must be able to output the constant,
2702    if FORCE is nonzero.  */
2703
2704 bool
2705 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2706 {
2707   int aligned_p;
2708
2709   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2710
2711   /* See if the target hook can handle this kind of object.  */
2712   if (targetm.asm_out.integer (x, size, aligned_p))
2713     return true;
2714
2715   /* If the object is a multi-byte one, try splitting it up.  Split
2716      it into words it if is multi-word, otherwise split it into bytes.  */
2717   if (size > 1)
2718     {
2719       enum machine_mode omode, imode;
2720       unsigned int subalign;
2721       unsigned int subsize, i;
2722       enum mode_class mclass;
2723
2724       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2725       subalign = MIN (align, subsize * BITS_PER_UNIT);
2726       if (GET_CODE (x) == CONST_FIXED)
2727         mclass = GET_MODE_CLASS (GET_MODE (x));
2728       else
2729         mclass = MODE_INT;
2730
2731       omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0);
2732       imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0);
2733
2734       for (i = 0; i < size; i += subsize)
2735         {
2736           rtx partial = simplify_subreg (omode, x, imode, i);
2737           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2738             break;
2739         }
2740       if (i == size)
2741         return true;
2742
2743       /* If we've printed some of it, but not all of it, there's no going
2744          back now.  */
2745       gcc_assert (!i);
2746     }
2747
2748   gcc_assert (!force);
2749
2750   return false;
2751 }
2752 \f
2753 void
2754 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2755 {
2756   long data[4] = {0, 0, 0, 0};
2757   int i;
2758   int bitsize, nelts, nunits, units_per;
2759
2760   /* This is hairy.  We have a quantity of known size.  real_to_target
2761      will put it into an array of *host* longs, 32 bits per element
2762      (even if long is more than 32 bits).  We need to determine the
2763      number of array elements that are occupied (nelts) and the number
2764      of *target* min-addressable units that will be occupied in the
2765      object file (nunits).  We cannot assume that 32 divides the
2766      mode's bitsize (size * BITS_PER_UNIT) evenly.
2767
2768      size * BITS_PER_UNIT is used here to make sure that padding bits
2769      (which might appear at either end of the value; real_to_target
2770      will include the padding bits in its output array) are included.  */
2771
2772   nunits = GET_MODE_SIZE (mode);
2773   bitsize = nunits * BITS_PER_UNIT;
2774   nelts = CEIL (bitsize, 32);
2775   units_per = 32 / BITS_PER_UNIT;
2776
2777   real_to_target (data, &d, mode);
2778
2779   /* Put out the first word with the specified alignment.  */
2780   assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2781   nunits -= units_per;
2782
2783   /* Subsequent words need only 32-bit alignment.  */
2784   align = min_align (align, 32);
2785
2786   for (i = 1; i < nelts; i++)
2787     {
2788       assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2789       nunits -= units_per;
2790     }
2791 }
2792 \f
2793 /* Given an expression EXP with a constant value,
2794    reduce it to the sum of an assembler symbol and an integer.
2795    Store them both in the structure *VALUE.
2796    EXP must be reducible.  */
2797
2798 struct GTY(()) addr_const {
2799   rtx base;
2800   HOST_WIDE_INT offset;
2801 };
2802
2803 static void
2804 decode_addr_const (tree exp, struct addr_const *value)
2805 {
2806   tree target = TREE_OPERAND (exp, 0);
2807   int offset = 0;
2808   rtx x;
2809
2810   while (1)
2811     {
2812       if (TREE_CODE (target) == COMPONENT_REF
2813           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2814         {
2815           offset += int_byte_position (TREE_OPERAND (target, 1));
2816           target = TREE_OPERAND (target, 0);
2817         }
2818       else if (TREE_CODE (target) == ARRAY_REF
2819                || TREE_CODE (target) == ARRAY_RANGE_REF)
2820         {
2821           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2822                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2823           target = TREE_OPERAND (target, 0);
2824         }
2825       else if (TREE_CODE (target) == INDIRECT_REF
2826                && TREE_CODE (TREE_OPERAND (target, 0)) == NOP_EXPR
2827                && TREE_CODE (TREE_OPERAND (TREE_OPERAND (target, 0), 0))
2828                   == ADDR_EXPR)
2829         target = TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (target, 0), 0), 0);
2830       else
2831         break;
2832     }
2833
2834   switch (TREE_CODE (target))
2835     {
2836     case VAR_DECL:
2837     case FUNCTION_DECL:
2838       x = DECL_RTL (target);
2839       break;
2840
2841     case LABEL_DECL:
2842       x = gen_rtx_MEM (FUNCTION_MODE,
2843                        gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2844       break;
2845
2846     case REAL_CST:
2847     case FIXED_CST:
2848     case STRING_CST:
2849     case COMPLEX_CST:
2850     case CONSTRUCTOR:
2851     case INTEGER_CST:
2852       x = output_constant_def (target, 1);
2853       break;
2854
2855     default:
2856       gcc_unreachable ();
2857     }
2858
2859   gcc_assert (MEM_P (x));
2860   x = XEXP (x, 0);
2861
2862   value->base = x;
2863   value->offset = offset;
2864 }
2865 \f
2866
2867 static GTY((param_is (struct constant_descriptor_tree)))
2868      htab_t const_desc_htab;
2869
2870 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2871
2872 /* Constant pool accessor function.  */
2873
2874 htab_t
2875 constant_pool_htab (void)
2876 {
2877   return const_desc_htab;
2878 }
2879
2880 /* Compute a hash code for a constant expression.  */
2881
2882 static hashval_t
2883 const_desc_hash (const void *ptr)
2884 {
2885   return ((const struct constant_descriptor_tree *)ptr)->hash;
2886 }
2887
2888 static hashval_t
2889 const_hash_1 (const tree exp)
2890 {
2891   const char *p;
2892   hashval_t hi;
2893   int len, i;
2894   enum tree_code code = TREE_CODE (exp);
2895
2896   /* Either set P and LEN to the address and len of something to hash and
2897      exit the switch or return a value.  */
2898
2899   switch (code)
2900     {
2901     case INTEGER_CST:
2902       p = (char *) &TREE_INT_CST (exp);
2903       len = sizeof TREE_INT_CST (exp);
2904       break;
2905
2906     case REAL_CST:
2907       return real_hash (TREE_REAL_CST_PTR (exp));
2908
2909     case FIXED_CST:
2910       return fixed_hash (TREE_FIXED_CST_PTR (exp));
2911
2912     case STRING_CST:
2913       p = TREE_STRING_POINTER (exp);
2914       len = TREE_STRING_LENGTH (exp);
2915       break;
2916
2917     case COMPLEX_CST:
2918       return (const_hash_1 (TREE_REALPART (exp)) * 5
2919               + const_hash_1 (TREE_IMAGPART (exp)));
2920
2921     case VECTOR_CST:
2922       {
2923         tree link;
2924
2925         hi = 7 + TYPE_VECTOR_SUBPARTS (TREE_TYPE (exp));
2926
2927         for (link = TREE_VECTOR_CST_ELTS (exp); link; link = TREE_CHAIN (link))
2928             hi = hi * 563 + const_hash_1 (TREE_VALUE (link));
2929
2930         return hi;
2931       }
2932
2933     case CONSTRUCTOR:
2934       {
2935         unsigned HOST_WIDE_INT idx;
2936         tree value;
2937
2938         hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2939
2940         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2941           if (value)
2942             hi = hi * 603 + const_hash_1 (value);
2943
2944         return hi;
2945       }
2946
2947     case ADDR_EXPR:
2948     case FDESC_EXPR:
2949       {
2950         struct addr_const value;
2951
2952         decode_addr_const (exp, &value);
2953         switch (GET_CODE (value.base))
2954           {
2955           case SYMBOL_REF:
2956             /* Don't hash the address of the SYMBOL_REF;
2957                only use the offset and the symbol name.  */
2958             hi = value.offset;
2959             p = XSTR (value.base, 0);
2960             for (i = 0; p[i] != 0; i++)
2961               hi = ((hi * 613) + (unsigned) (p[i]));
2962             break;
2963
2964           case LABEL_REF:
2965             hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2966             break;
2967
2968           default:
2969             gcc_unreachable ();
2970           }
2971       }
2972       return hi;
2973
2974     case PLUS_EXPR:
2975     case POINTER_PLUS_EXPR:
2976     case MINUS_EXPR:
2977       return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2978               + const_hash_1 (TREE_OPERAND (exp, 1)));
2979
2980     CASE_CONVERT:
2981       return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2982
2983     default:
2984       /* A language specific constant. Just hash the code.  */
2985       return code;
2986     }
2987
2988   /* Compute hashing function.  */
2989   hi = len;
2990   for (i = 0; i < len; i++)
2991     hi = ((hi * 613) + (unsigned) (p[i]));
2992
2993   return hi;
2994 }
2995
2996 /* Wrapper of compare_constant, for the htab interface.  */
2997 static int
2998 const_desc_eq (const void *p1, const void *p2)
2999 {
3000   const struct constant_descriptor_tree *const c1
3001     = (const struct constant_descriptor_tree *) p1;
3002   const struct constant_descriptor_tree *const c2
3003     = (const struct constant_descriptor_tree *) p2;
3004   if (c1->hash != c2->hash)
3005     return 0;
3006   return compare_constant (c1->value, c2->value);
3007 }
3008
3009 /* Compare t1 and t2, and return 1 only if they are known to result in
3010    the same bit pattern on output.  */
3011
3012 static int
3013 compare_constant (const tree t1, const tree t2)
3014 {
3015   enum tree_code typecode;
3016
3017   if (t1 == NULL_TREE)
3018     return t2 == NULL_TREE;
3019   if (t2 == NULL_TREE)
3020     return 0;
3021
3022   if (TREE_CODE (t1) != TREE_CODE (t2))
3023     return 0;
3024
3025   switch (TREE_CODE (t1))
3026     {
3027     case INTEGER_CST:
3028       /* Integer constants are the same only if the same width of type.  */
3029       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3030         return 0;
3031       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3032         return 0;
3033       return tree_int_cst_equal (t1, t2);
3034
3035     case REAL_CST:
3036       /* Real constants are the same only if the same width of type.  */
3037       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3038         return 0;
3039
3040       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
3041
3042     case FIXED_CST:
3043       /* Fixed constants are the same only if the same width of type.  */
3044       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
3045         return 0;
3046
3047       return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
3048
3049     case STRING_CST:
3050       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
3051         return 0;
3052
3053       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
3054               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
3055                          TREE_STRING_LENGTH (t1)));
3056
3057     case COMPLEX_CST:
3058       return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
3059               && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
3060
3061     case VECTOR_CST:
3062       {
3063         tree link1, link2;
3064
3065         if (TYPE_VECTOR_SUBPARTS (TREE_TYPE (t1))
3066             != TYPE_VECTOR_SUBPARTS (TREE_TYPE (t2)))
3067           return 0;
3068
3069         link2 = TREE_VECTOR_CST_ELTS (t2);
3070         for (link1 = TREE_VECTOR_CST_ELTS (t1);
3071              link1;
3072              link1 = TREE_CHAIN (link1))
3073           {
3074             if (!compare_constant (TREE_VALUE (link1), TREE_VALUE (link2)))
3075               return 0;
3076             link2 = TREE_CHAIN (link2);
3077           }
3078         
3079         return 1;
3080       }
3081
3082     case CONSTRUCTOR:
3083       {
3084         VEC(constructor_elt, gc) *v1, *v2;
3085         unsigned HOST_WIDE_INT idx;
3086
3087         typecode = TREE_CODE (TREE_TYPE (t1));
3088         if (typecode != TREE_CODE (TREE_TYPE (t2)))
3089           return 0;
3090
3091         if (typecode == ARRAY_TYPE)
3092           {
3093             HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
3094             /* For arrays, check that the sizes all match.  */
3095             if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
3096                 || size_1 == -1
3097                 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
3098               return 0;
3099           }
3100         else
3101           {
3102             /* For record and union constructors, require exact type
3103                equality.  */
3104             if (TREE_TYPE (t1) != TREE_TYPE (t2))
3105               return 0;
3106           }
3107
3108         v1 = CONSTRUCTOR_ELTS (t1);
3109         v2 = CONSTRUCTOR_ELTS (t2);
3110         if (VEC_length (constructor_elt, v1)
3111             != VEC_length (constructor_elt, v2))
3112             return 0;
3113
3114         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
3115           {
3116             constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
3117             constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
3118
3119             /* Check that each value is the same...  */
3120             if (!compare_constant (c1->value, c2->value))
3121               return 0;
3122             /* ... and that they apply to the same fields!  */
3123             if (typecode == ARRAY_TYPE)
3124               {
3125                 if (!compare_constant (c1->index, c2->index))
3126                   return 0;
3127               }
3128             else
3129               {
3130                 if (c1->index != c2->index)
3131                   return 0;
3132               }
3133           }
3134
3135         return 1;
3136       }
3137
3138     case ADDR_EXPR:
3139     case FDESC_EXPR:
3140       {
3141         struct addr_const value1, value2;
3142         enum rtx_code code;
3143         int ret;
3144
3145         decode_addr_const (t1, &value1);
3146         decode_addr_const (t2, &value2);
3147
3148         if (value1.offset != value2.offset)
3149           return 0;
3150
3151         code = GET_CODE (value1.base);
3152         if (code != GET_CODE (value2.base))
3153           return 0;
3154
3155         switch (code)
3156           {
3157           case SYMBOL_REF:
3158             ret = (strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
3159             break;
3160
3161           case LABEL_REF:
3162             ret = (CODE_LABEL_NUMBER (XEXP (value1.base, 0))
3163                    == CODE_LABEL_NUMBER (XEXP (value2.base, 0)));
3164             break;
3165
3166           default:
3167             gcc_unreachable ();
3168           }
3169         return ret;
3170       }
3171
3172     case PLUS_EXPR:
3173     case POINTER_PLUS_EXPR:
3174     case MINUS_EXPR:
3175     case RANGE_EXPR:
3176       return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3177               && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3178
3179     CASE_CONVERT:
3180     case VIEW_CONVERT_EXPR:
3181       return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3182
3183     default:
3184       return 0;
3185     }
3186
3187   gcc_unreachable ();
3188 }
3189 \f
3190 /* Make a copy of the whole tree structure for a constant.  This
3191    handles the same types of nodes that compare_constant handles.  */
3192
3193 static tree
3194 copy_constant (tree exp)
3195 {
3196   switch (TREE_CODE (exp))
3197     {
3198     case ADDR_EXPR:
3199       /* For ADDR_EXPR, we do not want to copy the decl whose address
3200          is requested.  We do want to copy constants though.  */
3201       if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
3202         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3203                        copy_constant (TREE_OPERAND (exp, 0)));
3204       else
3205         return copy_node (exp);
3206
3207     case INTEGER_CST:
3208     case REAL_CST:
3209     case FIXED_CST:
3210     case STRING_CST:
3211       return copy_node (exp);
3212
3213     case COMPLEX_CST:
3214       return build_complex (TREE_TYPE (exp),
3215                             copy_constant (TREE_REALPART (exp)),
3216                             copy_constant (TREE_IMAGPART (exp)));
3217
3218     case PLUS_EXPR:
3219     case POINTER_PLUS_EXPR:
3220     case MINUS_EXPR:
3221       return build2 (TREE_CODE (exp), TREE_TYPE (exp),
3222                      copy_constant (TREE_OPERAND (exp, 0)),
3223                      copy_constant (TREE_OPERAND (exp, 1)));
3224
3225     CASE_CONVERT:
3226     case VIEW_CONVERT_EXPR:
3227       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3228                      copy_constant (TREE_OPERAND (exp, 0)));
3229
3230     case VECTOR_CST:
3231       return build_vector (TREE_TYPE (exp),
3232                            copy_list (TREE_VECTOR_CST_ELTS (exp)));
3233
3234     case CONSTRUCTOR:
3235       {
3236         tree copy = copy_node (exp);
3237         VEC(constructor_elt, gc) *v;
3238         unsigned HOST_WIDE_INT idx;
3239         tree purpose, value;
3240
3241         v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
3242                                                       CONSTRUCTOR_ELTS (exp)));
3243         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
3244           {
3245             constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
3246             ce->index = purpose;
3247             ce->value = copy_constant (value);
3248           }
3249         CONSTRUCTOR_ELTS (copy) = v;
3250         return copy;
3251       }
3252
3253     default:
3254       gcc_unreachable ();
3255     }
3256 }
3257 \f
3258 /* Return the section into which constant EXP should be placed.  */
3259
3260 static section *
3261 get_constant_section (tree exp, unsigned int align)
3262 {
3263   return targetm.asm_out.select_section (exp,
3264                                          compute_reloc_for_constant (exp),
3265                                          align);
3266 }
3267
3268 /* Return the size of constant EXP in bytes.  */
3269
3270 static HOST_WIDE_INT
3271 get_constant_size (tree exp)
3272 {
3273   HOST_WIDE_INT size;
3274
3275   size = int_size_in_bytes (TREE_TYPE (exp));
3276   if (TREE_CODE (exp) == STRING_CST)
3277     size = MAX (TREE_STRING_LENGTH (exp), size);
3278   return size;
3279 }
3280
3281 /* Subroutine of output_constant_def:
3282    No constant equal to EXP is known to have been output.
3283    Make a constant descriptor to enter EXP in the hash table.
3284    Assign the label number and construct RTL to refer to the
3285    constant's location in memory.
3286    Caller is responsible for updating the hash table.  */
3287
3288 static struct constant_descriptor_tree *
3289 build_constant_desc (tree exp)
3290 {
3291   struct constant_descriptor_tree *desc;
3292   rtx symbol, rtl;
3293   char label[256];
3294   int labelno;
3295   tree decl;
3296
3297   desc = GGC_NEW (struct constant_descriptor_tree);
3298   desc->value = copy_constant (exp);
3299
3300   /* Propagate marked-ness to copied constant.  */
3301   if (flag_mudflap && mf_marked_p (exp))
3302     mf_mark (desc->value);
3303
3304   /* Create a string containing the label name, in LABEL.  */
3305   labelno = const_labelno++;
3306   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3307
3308   /* Construct the VAR_DECL associated with the constant.  */
3309   decl = build_decl (UNKNOWN_LOCATION, VAR_DECL, get_identifier (label),
3310                      TREE_TYPE (exp));
3311   DECL_ARTIFICIAL (decl) = 1;
3312   DECL_IGNORED_P (decl) = 1;
3313   TREE_READONLY (decl) = 1;
3314   TREE_STATIC (decl) = 1;
3315   TREE_ADDRESSABLE (decl) = 1;
3316   /* We don't set the RTL yet as this would cause varpool to assume that the
3317      variable is referenced.  Moreover, it would just be dropped in LTO mode.
3318      Instead we set the flag that will be recognized in make_decl_rtl.  */
3319   DECL_IN_CONSTANT_POOL (decl) = 1;
3320   DECL_INITIAL (decl) = desc->value;
3321   /* ??? CONSTANT_ALIGNMENT hasn't been updated for vector types on most
3322      architectures so use DATA_ALIGNMENT as well, except for strings.  */
3323   if (TREE_CODE (exp) == STRING_CST)
3324     {
3325 #ifdef CONSTANT_ALIGNMENT
3326       DECL_ALIGN (decl) = CONSTANT_ALIGNMENT (exp, DECL_ALIGN (decl));
3327 #endif
3328     }
3329   else
3330     align_variable (decl, 0);
3331
3332   /* Now construct the SYMBOL_REF and the MEM.  */
3333   if (use_object_blocks_p ())
3334     {
3335       section *sect = get_constant_section (exp, DECL_ALIGN (decl));
3336       symbol = create_block_symbol (ggc_strdup (label),
3337                                     get_block_for_section (sect), -1);
3338     }
3339   else
3340     symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3341   SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3342   SET_SYMBOL_REF_DECL (symbol, decl);
3343   TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3344
3345   rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
3346   set_mem_attributes (rtl, exp, 1);
3347   set_mem_alias_set (rtl, 0);
3348   set_mem_alias_set (rtl, const_alias_set);
3349
3350   /* We cannot share RTX'es in pool entries.
3351      Mark this piece of RTL as required for unsharing.  */
3352   RTX_FLAG (rtl, used) = 1;
3353
3354   /* Set flags or add text to the name to record information, such as
3355      that it is a local symbol.  If the name is changed, the macro
3356      ASM_OUTPUT_LABELREF will have to know how to strip this
3357      information.  This call might invalidate our local variable
3358      SYMBOL; we can't use it afterward.  */
3359   targetm.encode_section_info (exp, rtl, true);
3360
3361   desc->rtl = rtl;
3362
3363   return desc;
3364 }
3365
3366 /* Return an rtx representing a reference to constant data in memory
3367    for the constant expression EXP.
3368
3369    If assembler code for such a constant has already been output,
3370    return an rtx to refer to it.
3371    Otherwise, output such a constant in memory
3372    and generate an rtx for it.
3373
3374    If DEFER is nonzero, this constant can be deferred and output only
3375    if referenced in the function after all optimizations.
3376
3377    `const_desc_table' records which constants already have label strings.  */
3378
3379 rtx
3380 output_constant_def (tree exp, int defer)
3381 {
3382   struct constant_descriptor_tree *desc;
3383   struct constant_descriptor_tree key;
3384   void **loc;
3385
3386   /* Look up EXP in the table of constant descriptors.  If we didn't find
3387      it, create a new one.  */
3388   key.value = exp;
3389   key.hash = const_hash_1 (exp);
3390   loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
3391
3392   desc = (struct constant_descriptor_tree *) *loc;
3393   if (desc == 0)
3394     {
3395       desc = build_constant_desc (exp);
3396       desc->hash = key.hash;
3397       *loc = desc;
3398     }
3399
3400   maybe_output_constant_def_contents (desc, defer);
3401   return desc->rtl;
3402 }
3403
3404 /* Subroutine of output_constant_def: Decide whether or not we need to
3405    output the constant DESC now, and if so, do it.  */
3406 static void
3407 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
3408                                     int defer)
3409 {
3410   rtx symbol = XEXP (desc->rtl, 0);
3411   tree exp = desc->value;
3412
3413   if (flag_syntax_only)
3414     return;
3415
3416   if (TREE_ASM_WRITTEN (exp))
3417     /* Already output; don't do it again.  */
3418     return;
3419
3420   /* We can always defer constants as long as the context allows
3421      doing so.  */
3422   if (defer)
3423     {
3424       /* Increment n_deferred_constants if it exists.  It needs to be at
3425          least as large as the number of constants actually referred to
3426          by the function.  If it's too small we'll stop looking too early
3427          and fail to emit constants; if it's too large we'll only look
3428          through the entire function when we could have stopped earlier.  */
3429       if (cfun)
3430         n_deferred_constants++;
3431       return;
3432     }
3433
3434   output_constant_def_contents (symbol);
3435 }
3436
3437 /* Subroutine of output_constant_def_contents.  Output the definition
3438    of constant EXP, which is pointed to by label LABEL.  ALIGN is the
3439    constant's alignment in bits.  */
3440
3441 static void
3442 assemble_constant_contents (tree exp, const char *label, unsigned int align)
3443 {
3444   HOST_WIDE_INT size;
3445
3446   size = get_constant_size (exp);
3447
3448   /* Do any machine/system dependent processing of the constant.  */
3449 #ifdef ASM_DECLARE_CONSTANT_NAME
3450   ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
3451 #else
3452   /* Standard thing is just output label for the constant.  */
3453   ASM_OUTPUT_LABEL (asm_out_file, label);
3454 #endif /* ASM_DECLARE_CONSTANT_NAME */
3455
3456   /* Output the value of EXP.  */
3457   output_constant (exp, size, align);
3458 }
3459
3460 /* We must output the constant data referred to by SYMBOL; do so.  */
3461
3462 static void
3463 output_constant_def_contents (rtx symbol)
3464 {
3465   tree decl = SYMBOL_REF_DECL (symbol);
3466   tree exp = DECL_INITIAL (decl);
3467   unsigned int align;
3468
3469   /* Make sure any other constants whose addresses appear in EXP
3470      are assigned label numbers.  */
3471   output_addressed_constants (exp);
3472
3473   /* We are no longer deferring this constant.  */
3474   TREE_ASM_WRITTEN (exp) = 1;
3475
3476   /* If the constant is part of an object block, make sure that the
3477      decl has been positioned within its block, but do not write out
3478      its definition yet.  output_object_blocks will do that later.  */
3479   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
3480     place_block_symbol (symbol);
3481   else
3482     {
3483       align = DECL_ALIGN (decl);
3484       switch_to_section (get_constant_section (exp, align));
3485       if (align > BITS_PER_UNIT)
3486         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3487       assemble_constant_contents (exp, XSTR (symbol, 0), align);
3488     }
3489   if (flag_mudflap)
3490     mudflap_enqueue_constant (exp);
3491 }
3492
3493 /* Look up EXP in the table of constant descriptors.  Return the rtl
3494    if it has been emitted, else null.  */
3495
3496 rtx
3497 lookup_constant_def (tree exp)
3498 {
3499   struct constant_descriptor_tree *desc;
3500   struct constant_descriptor_tree key;
3501
3502   key.value = exp;
3503   key.hash = const_hash_1 (exp);
3504   desc = (struct constant_descriptor_tree *)
3505     htab_find_with_hash (const_desc_htab, &key, key.hash);
3506
3507   return (desc ? desc->rtl : NULL_RTX);
3508 }
3509
3510 /* Return a tree representing a reference to constant data in memory
3511    for the constant expression EXP.
3512
3513    This is the counterpart of output_constant_def at the Tree level.  */
3514
3515 tree
3516 tree_output_constant_def (tree exp)
3517 {
3518   struct constant_descriptor_tree *desc, key;
3519   void **loc;
3520   tree decl;
3521
3522   /* Look up EXP in the table of constant descriptors.  If we didn't find
3523      it, create a new one.  */
3524   key.value = exp;
3525   key.hash = const_hash_1 (exp);
3526   loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
3527
3528   desc = (struct constant_descriptor_tree *) *loc;
3529   if (desc == 0)
3530     {
3531       desc = build_constant_desc (exp);
3532       desc->hash = key.hash;
3533       *loc = desc;
3534     }
3535
3536   decl = SYMBOL_REF_DECL (XEXP (desc->rtl, 0));
3537   varpool_finalize_decl (decl);
3538   return decl;
3539 }
3540 \f
3541 /* Used in the hash tables to avoid outputting the same constant
3542    twice.  Unlike 'struct constant_descriptor_tree', RTX constants
3543    are output once per function, not once per file.  */
3544 /* ??? Only a few targets need per-function constant pools.  Most
3545    can use one per-file pool.  Should add a targetm bit to tell the
3546    difference.  */
3547
3548 struct GTY(()) rtx_constant_pool {
3549   /* Pointers to first and last constant in pool, as ordered by offset.  */
3550   struct constant_descriptor_rtx *first;
3551   struct constant_descriptor_rtx *last;
3552
3553   /* Hash facility for making memory-constants from constant rtl-expressions.
3554      It is used on RISC machines where immediate integer arguments and
3555      constant addresses are restricted so that such constants must be stored
3556      in memory.  */
3557   htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3558
3559   /* Current offset in constant pool (does not include any
3560      machine-specific header).  */
3561   HOST_WIDE_INT offset;
3562 };
3563
3564 struct GTY((chain_next ("%h.next"))) constant_descriptor_rtx {
3565   struct constant_descriptor_rtx *next;
3566   rtx mem;
3567   rtx sym;
3568   rtx constant;
3569   HOST_WIDE_INT offset;
3570   hashval_t hash;
3571   enum machine_mode mode;
3572   unsigned int align;
3573   int labelno;
3574   int mark;
3575 };
3576
3577 /* Hash and compare functions for const_rtx_htab.  */
3578
3579 static hashval_t
3580 const_desc_rtx_hash (const void *ptr)
3581 {
3582   const struct constant_descriptor_rtx *const desc
3583     = (const struct constant_descriptor_rtx *) ptr;
3584   return desc->hash;
3585 }
3586
3587 static int
3588 const_desc_rtx_eq (const void *a, const void *b)
3589 {
3590   const struct constant_descriptor_rtx *const x
3591     = (const struct constant_descriptor_rtx *) a;
3592   const struct constant_descriptor_rtx *const y
3593     = (const struct constant_descriptor_rtx *) b;
3594
3595   if (x->mode != y->mode)
3596     return 0;
3597   return rtx_equal_p (x->constant, y->constant);
3598 }
3599
3600 /* This is the worker function for const_rtx_hash, called via for_each_rtx.  */
3601
3602 static int
3603 const_rtx_hash_1 (rtx *xp, void *data)
3604 {
3605   unsigned HOST_WIDE_INT hwi;
3606   enum machine_mode mode;
3607   enum rtx_code code;
3608   hashval_t h, *hp;
3609   rtx x;
3610
3611   x = *xp;
3612   code = GET_CODE (x);
3613   mode = GET_MODE (x);
3614   h = (hashval_t) code * 1048573 + mode;
3615
3616   switch (code)
3617     {
3618     case CONST_INT:
3619       hwi = INTVAL (x);
3620     fold_hwi:
3621       {
3622         int shift = sizeof (hashval_t) * CHAR_BIT;
3623         const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3624         int i;
3625
3626         h ^= (hashval_t) hwi;
3627         for (i = 1; i < n; ++i)
3628           {
3629             hwi >>= shift;
3630             h ^= (hashval_t) hwi;
3631           }
3632       }
3633       break;
3634
3635     case CONST_DOUBLE:
3636       if (mode == VOIDmode)
3637         {
3638           hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3639           goto fold_hwi;
3640         }
3641       else
3642         h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3643       break;
3644
3645     case CONST_FIXED:
3646       h ^= fixed_hash (CONST_FIXED_VALUE (x));
3647       break;
3648
3649     case CONST_VECTOR:
3650       {
3651         int i;
3652         for (i = XVECLEN (x, 0); i-- > 0; )
3653           h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3654       }
3655       break;
3656
3657     case SYMBOL_REF:
3658       h ^= htab_hash_string (XSTR (x, 0));
3659       break;
3660
3661     case LABEL_REF:
3662       h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3663       break;
3664
3665     case UNSPEC:
3666     case UNSPEC_VOLATILE:
3667       h = h * 251 + XINT (x, 1);
3668       break;
3669
3670     default:
3671       break;
3672     }
3673
3674   hp = (hashval_t *) data;
3675   *hp = *hp * 509 + h;
3676   return 0;
3677 }
3678
3679 /* Compute a hash value for X, which should be a constant.  */
3680
3681 static hashval_t
3682 const_rtx_hash (rtx x)
3683 {
3684   hashval_t h = 0;
3685   for_each_rtx (&x, const_rtx_hash_1, &h);
3686   return h;
3687 }
3688
3689 \f
3690 /* Create and return a new rtx constant pool.  */
3691
3692 static struct rtx_constant_pool *
3693 create_constant_pool (void)
3694 {
3695   struct rtx_constant_pool *pool;
3696
3697   pool = GGC_NEW (struct rtx_constant_pool);
3698   pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3699                                           const_desc_rtx_eq, NULL);
3700   pool->first = NULL;
3701   pool->last = NULL;
3702   pool->offset = 0;
3703   return pool;
3704 }
3705
3706 /* Initialize constant pool hashing for a new function.  */
3707
3708 void
3709 init_varasm_status (void)
3710 {
3711   crtl->varasm.pool = create_constant_pool ();
3712   crtl->varasm.deferred_constants = 0;
3713 }
3714 \f
3715 /* Given a MINUS expression, simplify it if both sides
3716    include the same symbol.  */
3717
3718 rtx
3719 simplify_subtraction (rtx x)
3720 {
3721   rtx r = simplify_rtx (x);
3722   return r ? r : x;
3723 }
3724 \f
3725 /* Given a constant rtx X, make (or find) a memory constant for its value