OSDN Git Service

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