OSDN Git Service

2d8a6bfe81aa35ef2e7326878f12ae77ee227c18
[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 /* Return the section into which the given VAR_DECL or CONST_DECL
832    should be placed.  PREFER_NOSWITCH_P is true if a noswitch
833    section should be used wherever possible.  */
834
835 static section *
836 get_variable_section (tree decl, bool prefer_noswitch_p)
837 {
838   int reloc;
839
840   /* If the decl has been given an explicit section name, then it
841      isn't common, and shouldn't be handled as such.  */
842   if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
843     {
844       if (DECL_THREAD_LOCAL_P (decl))
845         return tls_comm_section;
846       if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
847         return comm_section;
848     }
849
850   if (DECL_INITIAL (decl) == error_mark_node)
851     reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
852   else if (DECL_INITIAL (decl))
853     reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
854   else
855     reloc = 0;
856
857   resolve_unique_section (decl, reloc, flag_data_sections);
858   if (IN_NAMED_SECTION (decl))
859     return get_named_section (decl, NULL, reloc);
860
861   if (!DECL_THREAD_LOCAL_P (decl)
862       && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
863       && bss_initializer_p (decl))
864     {
865       if (!TREE_PUBLIC (decl))
866         return lcomm_section;
867       if (bss_noswitch_section)
868         return bss_noswitch_section;
869     }
870
871   return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
872 }
873
874 /* Return the block into which object_block DECL should be placed.  */
875
876 static struct object_block *
877 get_block_for_decl (tree decl)
878 {
879   section *sect;
880
881   if (TREE_CODE (decl) == VAR_DECL)
882     {
883       /* The object must be defined in this translation unit.  */
884       if (DECL_EXTERNAL (decl))
885         return NULL;
886
887       /* There's no point using object blocks for something that is
888          isolated by definition.  */
889       if (DECL_ONE_ONLY (decl))
890         return NULL;
891     }
892
893   /* We can only calculate block offsets if the decl has a known
894      constant size.  */
895   if (DECL_SIZE_UNIT (decl) == NULL)
896     return NULL;
897   if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
898     return NULL;
899
900   /* Find out which section should contain DECL.  We cannot put it into
901      an object block if it requires a standalone definition.  */
902   sect = get_variable_section (decl, true);
903   if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
904     return NULL;
905
906   return get_block_for_section (sect);
907 }
908
909 /* Make sure block symbol SYMBOL is in block BLOCK.  */
910
911 static void
912 change_symbol_block (rtx symbol, struct object_block *block)
913 {
914   if (block != SYMBOL_REF_BLOCK (symbol))
915     {
916       gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
917       SYMBOL_REF_BLOCK (symbol) = block;
918     }
919 }
920
921 /* Return true if it is possible to put DECL in an object_block.  */
922
923 static bool
924 use_blocks_for_decl_p (tree decl)
925 {
926   /* Only data DECLs can be placed into object blocks.  */
927   if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
928     return false;
929
930   /* Detect decls created by dw2_force_const_mem.  Such decls are
931      special because DECL_INITIAL doesn't specify the decl's true value.
932      dw2_output_indirect_constants will instead call assemble_variable
933      with dont_output_data set to 1 and then print the contents itself.  */
934   if (DECL_INITIAL (decl) == decl)
935     return false;
936
937   return true;
938 }
939
940 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL.  DECL should
941    have static storage duration.  In other words, it should not be an
942    automatic variable, including PARM_DECLs.
943
944    There is, however, one exception: this function handles variables
945    explicitly placed in a particular register by the user.
946
947    This is never called for PARM_DECL nodes.  */
948
949 void
950 make_decl_rtl (tree decl)
951 {
952   const char *name = 0;
953   int reg_number;
954   rtx x;
955
956   /* Check that we are not being given an automatic variable.  */
957   gcc_assert (TREE_CODE (decl) != PARM_DECL
958               && TREE_CODE (decl) != RESULT_DECL);
959
960   /* A weak alias has TREE_PUBLIC set but not the other bits.  */
961   gcc_assert (TREE_CODE (decl) != VAR_DECL
962               || TREE_STATIC (decl)
963               || TREE_PUBLIC (decl)
964               || DECL_EXTERNAL (decl)
965               || DECL_REGISTER (decl));
966
967   /* And that we were not given a type or a label.  */
968   gcc_assert (TREE_CODE (decl) != TYPE_DECL
969               && TREE_CODE (decl) != LABEL_DECL);
970
971   /* For a duplicate declaration, we can be called twice on the
972      same DECL node.  Don't discard the RTL already made.  */
973   if (DECL_RTL_SET_P (decl))
974     {
975       /* If the old RTL had the wrong mode, fix the mode.  */
976       x = DECL_RTL (decl);
977       if (GET_MODE (x) != DECL_MODE (decl))
978         SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
979
980       if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
981         return;
982
983       /* ??? Another way to do this would be to maintain a hashed
984          table of such critters.  Instead of adding stuff to a DECL
985          to give certain attributes to it, we could use an external
986          hash map from DECL to set of attributes.  */
987
988       /* Let the target reassign the RTL if it wants.
989          This is necessary, for example, when one machine specific
990          decl attribute overrides another.  */
991       targetm.encode_section_info (decl, DECL_RTL (decl), false);
992
993       /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
994          on the new decl information.  */
995       if (MEM_P (x)
996           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
997           && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
998         change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
999
1000       /* Make this function static known to the mudflap runtime.  */
1001       if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1002         mudflap_enqueue_decl (decl);
1003
1004       return;
1005     }
1006
1007   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1008
1009   if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1010       && DECL_REGISTER (decl))
1011     {
1012       error ("register name not specified for %q+D", decl);
1013     }
1014   else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1015     {
1016       const char *asmspec = name+1;
1017       reg_number = decode_reg_name (asmspec);
1018       /* First detect errors in declaring global registers.  */
1019       if (reg_number == -1)
1020         error ("register name not specified for %q+D", decl);
1021       else if (reg_number < 0)
1022         error ("invalid register name for %q+D", decl);
1023       else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1024         error ("data type of %q+D isn%'t suitable for a register",
1025                decl);
1026       else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1027         error ("register specified for %q+D isn%'t suitable for data type",
1028                decl);
1029       /* Now handle properly declared static register variables.  */
1030       else
1031         {
1032           int nregs;
1033
1034           if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1035             {
1036               DECL_INITIAL (decl) = 0;
1037               error ("global register variable has initial value");
1038             }
1039           if (TREE_THIS_VOLATILE (decl))
1040             warning (OPT_Wvolatile_register_var,
1041                      "optimization may eliminate reads and/or "
1042                      "writes to register variables");
1043
1044           /* If the user specified one of the eliminables registers here,
1045              e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1046              confused with that register and be eliminated.  This usage is
1047              somewhat suspect...  */
1048
1049           SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1050           ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1051           REG_USERVAR_P (DECL_RTL (decl)) = 1;
1052
1053           if (TREE_STATIC (decl))
1054             {
1055               /* Make this register global, so not usable for anything
1056                  else.  */
1057 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1058               name = IDENTIFIER_POINTER (DECL_NAME (decl));
1059               ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1060 #endif
1061               nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1062               while (nregs > 0)
1063                 globalize_reg (reg_number + --nregs);
1064             }
1065
1066           /* As a register variable, it has no section.  */
1067           return;
1068         }
1069     }
1070   /* Now handle ordinary static variables and functions (in memory).
1071      Also handle vars declared register invalidly.  */
1072   else if (name[0] == '*')
1073   {
1074 #ifdef REGISTER_PREFIX
1075     if (strlen (REGISTER_PREFIX) != 0)
1076       {
1077         reg_number = decode_reg_name (name);
1078         if (reg_number >= 0 || reg_number == -3)
1079           error ("register name given for non-register variable %q+D", decl);
1080       }
1081 #endif
1082   }
1083
1084   /* Specifying a section attribute on a variable forces it into a
1085      non-.bss section, and thus it cannot be common.  */
1086   if (TREE_CODE (decl) == VAR_DECL
1087       && DECL_SECTION_NAME (decl) != NULL_TREE
1088       && DECL_INITIAL (decl) == NULL_TREE
1089       && DECL_COMMON (decl))
1090     DECL_COMMON (decl) = 0;
1091
1092   /* Variables can't be both common and weak.  */
1093   if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1094     DECL_COMMON (decl) = 0;
1095
1096   if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1097     x = create_block_symbol (name, get_block_for_decl (decl), -1);
1098   else
1099     x = gen_rtx_SYMBOL_REF (Pmode, name);
1100   SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1101   SET_SYMBOL_REF_DECL (x, decl);
1102
1103   x = gen_rtx_MEM (DECL_MODE (decl), x);
1104   if (TREE_CODE (decl) != FUNCTION_DECL)
1105     set_mem_attributes (x, decl, 1);
1106   SET_DECL_RTL (decl, x);
1107
1108   /* Optionally set flags or add text to the name to record information
1109      such as that it is a function name.
1110      If the name is changed, the macro ASM_OUTPUT_LABELREF
1111      will have to know how to strip this information.  */
1112   targetm.encode_section_info (decl, DECL_RTL (decl), true);
1113
1114   /* Make this function static known to the mudflap runtime.  */
1115   if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1116     mudflap_enqueue_decl (decl);
1117 }
1118
1119 /* Make the rtl for variable VAR be volatile.
1120    Use this only for static variables.  */
1121
1122 void
1123 make_var_volatile (tree var)
1124 {
1125   gcc_assert (MEM_P (DECL_RTL (var)));
1126
1127   MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1128 }
1129 \f
1130 /* Output a string of literal assembler code
1131    for an `asm' keyword used between functions.  */
1132
1133 void
1134 assemble_asm (tree string)
1135 {
1136   app_enable ();
1137
1138   if (TREE_CODE (string) == ADDR_EXPR)
1139     string = TREE_OPERAND (string, 0);
1140
1141   fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1142 }
1143
1144 /* Record an element in the table of global destructors.  SYMBOL is
1145    a SYMBOL_REF of the function to be called; PRIORITY is a number
1146    between 0 and MAX_INIT_PRIORITY.  */
1147
1148 void
1149 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1150                                   int priority ATTRIBUTE_UNUSED)
1151 {
1152 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1153   /* Tell GNU LD that this is part of the static destructor set.
1154      This will work for any system that uses stabs, most usefully
1155      aout systems.  */
1156   dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1157   dbxout_stab_value_label (XSTR (symbol, 0));
1158 #else
1159   sorry ("global destructors not supported on this target");
1160 #endif
1161 }
1162
1163 void
1164 default_named_section_asm_out_destructor (rtx symbol, int priority)
1165 {
1166   const char *section = ".dtors";
1167   char buf[16];
1168
1169   /* ??? This only works reliably with the GNU linker.  */
1170   if (priority != DEFAULT_INIT_PRIORITY)
1171     {
1172       sprintf (buf, ".dtors.%.5u",
1173                /* Invert the numbering so the linker puts us in the proper
1174                   order; constructors are run from right to left, and the
1175                   linker sorts in increasing order.  */
1176                MAX_INIT_PRIORITY - priority);
1177       section = buf;
1178     }
1179
1180   switch_to_section (get_section (section, SECTION_WRITE, NULL));
1181   assemble_align (POINTER_SIZE);
1182   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1183 }
1184
1185 #ifdef DTORS_SECTION_ASM_OP
1186 void
1187 default_dtor_section_asm_out_destructor (rtx symbol,
1188                                          int priority ATTRIBUTE_UNUSED)
1189 {
1190   switch_to_section (dtors_section);
1191   assemble_align (POINTER_SIZE);
1192   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1193 }
1194 #endif
1195
1196 /* Likewise for global constructors.  */
1197
1198 void
1199 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1200                                    int priority ATTRIBUTE_UNUSED)
1201 {
1202 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1203   /* Tell GNU LD that this is part of the static destructor set.
1204      This will work for any system that uses stabs, most usefully
1205      aout systems.  */
1206   dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1207   dbxout_stab_value_label (XSTR (symbol, 0));
1208 #else
1209   sorry ("global constructors not supported on this target");
1210 #endif
1211 }
1212
1213 void
1214 default_named_section_asm_out_constructor (rtx symbol, int priority)
1215 {
1216   const char *section = ".ctors";
1217   char buf[16];
1218
1219   /* ??? This only works reliably with the GNU linker.  */
1220   if (priority != DEFAULT_INIT_PRIORITY)
1221     {
1222       sprintf (buf, ".ctors.%.5u",
1223                /* Invert the numbering so the linker puts us in the proper
1224                   order; constructors are run from right to left, and the
1225                   linker sorts in increasing order.  */
1226                MAX_INIT_PRIORITY - priority);
1227       section = buf;
1228     }
1229
1230   switch_to_section (get_section (section, SECTION_WRITE, NULL));
1231   assemble_align (POINTER_SIZE);
1232   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1233 }
1234
1235 #ifdef CTORS_SECTION_ASM_OP
1236 void
1237 default_ctor_section_asm_out_constructor (rtx symbol,
1238                                           int priority ATTRIBUTE_UNUSED)
1239 {
1240   switch_to_section (ctors_section);
1241   assemble_align (POINTER_SIZE);
1242   assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1243 }
1244 #endif
1245 \f
1246 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1247    a nonzero value if the constant pool should be output before the
1248    start of the function, or a zero value if the pool should output
1249    after the end of the function.  The default is to put it before the
1250    start.  */
1251
1252 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1253 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1254 #endif
1255
1256 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1257    to be output to assembler.
1258    Set first_global_object_name and weak_global_object_name as appropriate.  */
1259
1260 void
1261 notice_global_symbol (tree decl)
1262 {
1263   const char **type = &first_global_object_name;
1264
1265   if (first_global_object_name
1266       || !TREE_PUBLIC (decl)
1267       || DECL_EXTERNAL (decl)
1268       || !DECL_NAME (decl)
1269       || (TREE_CODE (decl) != FUNCTION_DECL
1270           && (TREE_CODE (decl) != VAR_DECL
1271               || (DECL_COMMON (decl)
1272                   && (DECL_INITIAL (decl) == 0
1273                       || DECL_INITIAL (decl) == error_mark_node))))
1274       || !MEM_P (DECL_RTL (decl)))
1275     return;
1276
1277   /* We win when global object is found, but it is useful to know about weak
1278      symbol as well so we can produce nicer unique names.  */
1279   if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl))
1280     type = &weak_global_object_name;
1281
1282   if (!*type)
1283     {
1284       const char *p;
1285       const char *name;
1286       rtx decl_rtl = DECL_RTL (decl);
1287
1288       p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1289       name = ggc_strdup (p);
1290
1291       *type = name;
1292     }
1293 }
1294
1295 /* Output assembler code for the constant pool of a function and associated
1296    with defining the name of the function.  DECL describes the function.
1297    NAME is the function's name.  For the constant pool, we use the current
1298    constant pool data.  */
1299
1300 void
1301 assemble_start_function (tree decl, const char *fnname)
1302 {
1303   int align;
1304   char tmp_label[100];
1305   bool hot_label_written = false;
1306
1307   cfun->unlikely_text_section_name = NULL;
1308
1309   first_function_block_is_cold = false;
1310   if (flag_reorder_blocks_and_partition)
1311     {
1312       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1313       cfun->hot_section_label = ggc_strdup (tmp_label);
1314       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1315       cfun->cold_section_label = ggc_strdup (tmp_label);
1316       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1317       cfun->hot_section_end_label = ggc_strdup (tmp_label);
1318       ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1319       cfun->cold_section_end_label = ggc_strdup (tmp_label);
1320       const_labelno++;
1321     }
1322   else
1323     {
1324       cfun->hot_section_label = NULL;
1325       cfun->cold_section_label = NULL;
1326       cfun->hot_section_end_label = NULL;
1327       cfun->cold_section_end_label = NULL;
1328     }
1329
1330   /* The following code does not need preprocessing in the assembler.  */
1331
1332   app_disable ();
1333
1334   if (CONSTANT_POOL_BEFORE_FUNCTION)
1335     output_constant_pool (fnname, decl);
1336
1337   resolve_unique_section (decl, 0, flag_function_sections);
1338
1339   /* Make sure the not and cold text (code) sections are properly
1340      aligned.  This is necessary here in the case where the function
1341      has both hot and cold sections, because we don't want to re-set
1342      the alignment when the section switch happens mid-function.  */
1343
1344   if (flag_reorder_blocks_and_partition)
1345     {
1346       switch_to_section (unlikely_text_section ());
1347       assemble_align (FUNCTION_BOUNDARY);
1348       ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_label);
1349
1350       /* When the function starts with a cold section, we need to explicitly
1351          align the hot section and write out the hot section label.
1352          But if the current function is a thunk, we do not have a CFG.  */
1353       if (!current_function_is_thunk
1354           && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1355         {
1356           switch_to_section (text_section);
1357           assemble_align (FUNCTION_BOUNDARY);
1358           ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1359           hot_label_written = true;
1360           first_function_block_is_cold = true;
1361         }
1362     }
1363   else if (DECL_SECTION_NAME (decl))
1364     {
1365       /* Calls to function_section rely on first_function_block_is_cold
1366          being accurate.  The first block may be cold even if we aren't
1367          doing partitioning, if the entire function was decided by
1368          choose_function_section (predict.c) to be cold.  */
1369
1370       initialize_cold_section_name ();
1371
1372       if (cfun->unlikely_text_section_name
1373           && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1374                      cfun->unlikely_text_section_name) == 0)
1375         first_function_block_is_cold = true;
1376     }
1377
1378   in_cold_section_p = first_function_block_is_cold;
1379
1380   /* Switch to the correct text section for the start of the function.  */
1381
1382   switch_to_section (function_section (decl));
1383   if (flag_reorder_blocks_and_partition
1384       && !hot_label_written)
1385     ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_label);
1386
1387   /* Tell assembler to move to target machine's alignment for functions.  */
1388   align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1389   if (align < force_align_functions_log)
1390     align = force_align_functions_log;
1391   if (align > 0)
1392     {
1393       ASM_OUTPUT_ALIGN (asm_out_file, align);
1394     }
1395
1396   /* Handle a user-specified function alignment.
1397      Note that we still need to align to FUNCTION_BOUNDARY, as above,
1398      because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all.  */
1399   if (align_functions_log > align
1400       && cfun->function_frequency != FUNCTION_FREQUENCY_UNLIKELY_EXECUTED)
1401     {
1402 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1403       ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1404                                  align_functions_log, align_functions - 1);
1405 #else
1406       ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1407 #endif
1408     }
1409
1410 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1411   ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1412 #endif
1413
1414   (*debug_hooks->begin_function) (decl);
1415
1416   /* Make function name accessible from other files, if appropriate.  */
1417
1418   if (TREE_PUBLIC (decl))
1419     {
1420       notice_global_symbol (decl);
1421
1422       globalize_decl (decl);
1423
1424       maybe_assemble_visibility (decl);
1425     }
1426
1427   if (DECL_PRESERVE_P (decl))
1428     targetm.asm_out.mark_decl_preserved (fnname);
1429
1430   /* Do any machine/system dependent processing of the function name.  */
1431 #ifdef ASM_DECLARE_FUNCTION_NAME
1432   ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1433 #else
1434   /* Standard thing is just output label for the function.  */
1435   ASM_OUTPUT_LABEL (asm_out_file, fnname);
1436 #endif /* ASM_DECLARE_FUNCTION_NAME */
1437 }
1438
1439 /* Output assembler code associated with defining the size of the
1440    function.  DECL describes the function.  NAME is the function's name.  */
1441
1442 void
1443 assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1444 {
1445 #ifdef ASM_DECLARE_FUNCTION_SIZE
1446   /* We could have switched section in the middle of the function.  */
1447   if (flag_reorder_blocks_and_partition)
1448     switch_to_section (function_section (decl));
1449   ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1450 #endif
1451   if (! CONSTANT_POOL_BEFORE_FUNCTION)
1452     {
1453       output_constant_pool (fnname, decl);
1454       switch_to_section (function_section (decl)); /* need to switch back */
1455     }
1456   /* Output labels for end of hot/cold text sections (to be used by
1457      debug info.)  */
1458   if (flag_reorder_blocks_and_partition)
1459     {
1460       section *save_text_section;
1461
1462       save_text_section = in_section;
1463       switch_to_section (unlikely_text_section ());
1464       ASM_OUTPUT_LABEL (asm_out_file, cfun->cold_section_end_label);
1465       if (first_function_block_is_cold)
1466         switch_to_section (text_section);
1467       else
1468         switch_to_section (function_section (decl));
1469       ASM_OUTPUT_LABEL (asm_out_file, cfun->hot_section_end_label);
1470       switch_to_section (save_text_section);
1471     }
1472 }
1473 \f
1474 /* Assemble code to leave SIZE bytes of zeros.  */
1475
1476 void
1477 assemble_zeros (unsigned HOST_WIDE_INT size)
1478 {
1479   /* Do no output if -fsyntax-only.  */
1480   if (flag_syntax_only)
1481     return;
1482
1483 #ifdef ASM_NO_SKIP_IN_TEXT
1484   /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1485      so we must output 0s explicitly in the text section.  */
1486   if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1487     {
1488       unsigned HOST_WIDE_INT i;
1489       for (i = 0; i < size; i++)
1490         assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1491     }
1492   else
1493 #endif
1494     if (size > 0)
1495       ASM_OUTPUT_SKIP (asm_out_file, size);
1496 }
1497
1498 /* Assemble an alignment pseudo op for an ALIGN-bit boundary.  */
1499
1500 void
1501 assemble_align (int align)
1502 {
1503   if (align > BITS_PER_UNIT)
1504     {
1505       ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1506     }
1507 }
1508
1509 /* Assemble a string constant with the specified C string as contents.  */
1510
1511 void
1512 assemble_string (const char *p, int size)
1513 {
1514   int pos = 0;
1515   int maximum = 2000;
1516
1517   /* If the string is very long, split it up.  */
1518
1519   while (pos < size)
1520     {
1521       int thissize = size - pos;
1522       if (thissize > maximum)
1523         thissize = maximum;
1524
1525       ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1526
1527       pos += thissize;
1528       p += thissize;
1529     }
1530 }
1531
1532 \f
1533 /* A noswitch_section_callback for lcomm_section.  */
1534
1535 static bool
1536 emit_local (tree decl ATTRIBUTE_UNUSED,
1537             const char *name ATTRIBUTE_UNUSED,
1538             unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1539             unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1540 {
1541 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1542   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1543                                  size, DECL_ALIGN (decl));
1544   return true;
1545 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1546   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1547   return true;
1548 #else
1549   ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1550   return false;
1551 #endif
1552 }
1553
1554 /* A noswitch_section_callback for bss_noswitch_section.  */
1555
1556 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1557 static bool
1558 emit_bss (tree decl ATTRIBUTE_UNUSED,
1559           const char *name ATTRIBUTE_UNUSED,
1560           unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1561           unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1562 {
1563 #if defined ASM_OUTPUT_ALIGNED_BSS
1564   ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1565   return true;
1566 #else
1567   ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1568   return false;
1569 #endif
1570 }
1571 #endif
1572
1573 /* A noswitch_section_callback for comm_section.  */
1574
1575 static bool
1576 emit_common (tree decl ATTRIBUTE_UNUSED,
1577              const char *name ATTRIBUTE_UNUSED,
1578              unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1579              unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1580 {
1581 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1582   ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1583                                   size, DECL_ALIGN (decl));
1584   return true;
1585 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1586   ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1587   return true;
1588 #else
1589   ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1590   return false;
1591 #endif
1592 }
1593
1594 /* A noswitch_section_callback for tls_comm_section.  */
1595
1596 static bool
1597 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1598                  const char *name ATTRIBUTE_UNUSED,
1599                  unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1600                  unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1601 {
1602 #ifdef ASM_OUTPUT_TLS_COMMON
1603   ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1604   return true;
1605 #else
1606   sorry ("thread-local COMMON data not implemented");
1607   return true;
1608 #endif
1609 }
1610
1611 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1612    NAME is the name of DECL's SYMBOL_REF.  */
1613
1614 static void
1615 assemble_noswitch_variable (tree decl, const char *name, section *sect)
1616 {
1617   unsigned HOST_WIDE_INT size, rounded;
1618
1619   size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1620   rounded = size;
1621
1622   /* Don't allocate zero bytes of common,
1623      since that means "undefined external" in the linker.  */
1624   if (size == 0)
1625     rounded = 1;
1626
1627   /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1628      so that each uninitialized object starts on such a boundary.  */
1629   rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1630   rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1631              * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1632
1633   if (!sect->noswitch.callback (decl, name, size, rounded)
1634       && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1635     warning (0, "requested alignment for %q+D is greater than "
1636              "implemented alignment of %wu", decl, rounded);
1637 }
1638
1639 /* A subroutine of assemble_variable.  Output the label and contents of
1640    DECL, whose address is a SYMBOL_REF with name NAME.  DONT_OUTPUT_DATA
1641    is as for assemble_variable.  */
1642
1643 static void
1644 assemble_variable_contents (tree decl, const char *name,
1645                             bool dont_output_data)
1646 {
1647   /* Do any machine/system dependent processing of the object.  */
1648 #ifdef ASM_DECLARE_OBJECT_NAME
1649   last_assemble_variable_decl = decl;
1650   ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1651 #else
1652   /* Standard thing is just output label for the object.  */
1653   ASM_OUTPUT_LABEL (asm_out_file, name);
1654 #endif /* ASM_DECLARE_OBJECT_NAME */
1655
1656   if (!dont_output_data)
1657     {
1658       if (DECL_INITIAL (decl)
1659           && DECL_INITIAL (decl) != error_mark_node
1660           && !initializer_zerop (DECL_INITIAL (decl)))
1661         /* Output the actual data.  */
1662         output_constant (DECL_INITIAL (decl),
1663                          tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1664                          DECL_ALIGN (decl));
1665       else
1666         /* Leave space for it.  */
1667         assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1668     }
1669 }
1670
1671 /* Assemble everything that is needed for a variable or function declaration.
1672    Not used for automatic variables, and not used for function definitions.
1673    Should not be called for variables of incomplete structure type.
1674
1675    TOP_LEVEL is nonzero if this variable has file scope.
1676    AT_END is nonzero if this is the special handling, at end of compilation,
1677    to define things that have had only tentative definitions.
1678    DONT_OUTPUT_DATA if nonzero means don't actually output the
1679    initial value (that will be done by the caller).  */
1680
1681 void
1682 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
1683                    int at_end ATTRIBUTE_UNUSED, int dont_output_data)
1684 {
1685   const char *name;
1686   unsigned int align;
1687   rtx decl_rtl, symbol;
1688   section *sect;
1689
1690   if (lang_hooks.decls.prepare_assemble_variable)
1691     lang_hooks.decls.prepare_assemble_variable (decl);
1692
1693   last_assemble_variable_decl = 0;
1694
1695   /* Normally no need to say anything here for external references,
1696      since assemble_external is called by the language-specific code
1697      when a declaration is first seen.  */
1698
1699   if (DECL_EXTERNAL (decl))
1700     return;
1701
1702   /* Output no assembler code for a function declaration.
1703      Only definitions of functions output anything.  */
1704
1705   if (TREE_CODE (decl) == FUNCTION_DECL)
1706     return;
1707
1708   /* Do nothing for global register variables.  */
1709   if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
1710     {
1711       TREE_ASM_WRITTEN (decl) = 1;
1712       return;
1713     }
1714
1715   /* If type was incomplete when the variable was declared,
1716      see if it is complete now.  */
1717
1718   if (DECL_SIZE (decl) == 0)
1719     layout_decl (decl, 0);
1720
1721   /* Still incomplete => don't allocate it; treat the tentative defn
1722      (which is what it must have been) as an `extern' reference.  */
1723
1724   if (!dont_output_data && DECL_SIZE (decl) == 0)
1725     {
1726       error ("storage size of %q+D isn%'t known", decl);
1727       TREE_ASM_WRITTEN (decl) = 1;
1728       return;
1729     }
1730
1731   /* The first declaration of a variable that comes through this function
1732      decides whether it is global (in C, has external linkage)
1733      or local (in C, has internal linkage).  So do nothing more
1734      if this function has already run.  */
1735
1736   if (TREE_ASM_WRITTEN (decl))
1737     return;
1738
1739   /* Make sure targetm.encode_section_info is invoked before we set
1740      ASM_WRITTEN.  */
1741   decl_rtl = DECL_RTL (decl);
1742
1743   TREE_ASM_WRITTEN (decl) = 1;
1744
1745   /* Do no output if -fsyntax-only.  */
1746   if (flag_syntax_only)
1747     return;
1748
1749   app_disable ();
1750
1751   if (! dont_output_data
1752       && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1753     {
1754       error ("size of variable %q+D is too large", decl);
1755       return;
1756     }
1757
1758   gcc_assert (MEM_P (decl_rtl));
1759   gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
1760   symbol = XEXP (decl_rtl, 0);
1761   name = XSTR (symbol, 0);
1762   if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1763     notice_global_symbol (decl);
1764
1765   /* Compute the alignment of this data.  */
1766
1767   align = DECL_ALIGN (decl);
1768
1769   /* In the case for initialing an array whose length isn't specified,
1770      where we have not yet been able to do the layout,
1771      figure out the proper alignment now.  */
1772   if (dont_output_data && DECL_SIZE (decl) == 0
1773       && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1774     align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1775
1776   /* Some object file formats have a maximum alignment which they support.
1777      In particular, a.out format supports a maximum alignment of 4.  */
1778   if (align > MAX_OFILE_ALIGNMENT)
1779     {
1780       warning (0, "alignment of %q+D is greater than maximum object "
1781                "file alignment.  Using %d", decl,
1782                MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1783       align = MAX_OFILE_ALIGNMENT;
1784     }
1785
1786   /* On some machines, it is good to increase alignment sometimes.  */
1787   if (! DECL_USER_ALIGN (decl))
1788     {
1789 #ifdef DATA_ALIGNMENT
1790       align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1791 #endif
1792 #ifdef CONSTANT_ALIGNMENT
1793       if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1794         align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1795 #endif
1796     }
1797
1798   /* Reset the alignment in case we have made it tighter, so we can benefit
1799      from it in get_pointer_alignment.  */
1800   DECL_ALIGN (decl) = align;
1801   set_mem_align (decl_rtl, align);
1802
1803   if (TREE_PUBLIC (decl))
1804     maybe_assemble_visibility (decl);
1805
1806   if (DECL_PRESERVE_P (decl))
1807     targetm.asm_out.mark_decl_preserved (name);
1808
1809   /* First make the assembler name(s) global if appropriate.  */
1810   sect = get_variable_section (decl, false);
1811   if (TREE_PUBLIC (decl)
1812       && DECL_NAME (decl)
1813       && (sect->common.flags & SECTION_COMMON) == 0)
1814     globalize_decl (decl);
1815
1816   /* Output any data that we will need to use the address of.  */
1817   if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
1818     output_addressed_constants (DECL_INITIAL (decl));
1819
1820   /* dbxout.c needs to know this.  */
1821   if (sect && (sect->common.flags & SECTION_CODE) != 0)
1822     DECL_IN_TEXT_SECTION (decl) = 1;
1823
1824   /* If the decl is part of an object_block, make sure that the decl
1825      has been positioned within its block, but do not write out its
1826      definition yet.  output_object_blocks will do that later.  */
1827   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
1828     {
1829       gcc_assert (!dont_output_data);
1830       place_block_symbol (symbol);
1831     }
1832   else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1833     assemble_noswitch_variable (decl, name, sect);
1834   else
1835     {
1836       switch_to_section (sect);
1837       if (align > BITS_PER_UNIT)
1838         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
1839       assemble_variable_contents (decl, name, dont_output_data);
1840     }
1841 }
1842
1843 /* Return 1 if type TYPE contains any pointers.  */
1844
1845 static int
1846 contains_pointers_p (tree type)
1847 {
1848   switch (TREE_CODE (type))
1849     {
1850     case POINTER_TYPE:
1851     case REFERENCE_TYPE:
1852       /* I'm not sure whether OFFSET_TYPE needs this treatment,
1853          so I'll play safe and return 1.  */
1854     case OFFSET_TYPE:
1855       return 1;
1856
1857     case RECORD_TYPE:
1858     case UNION_TYPE:
1859     case QUAL_UNION_TYPE:
1860       {
1861         tree fields;
1862         /* For a type that has fields, see if the fields have pointers.  */
1863         for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1864           if (TREE_CODE (fields) == FIELD_DECL
1865               && contains_pointers_p (TREE_TYPE (fields)))
1866             return 1;
1867         return 0;
1868       }
1869
1870     case ARRAY_TYPE:
1871       /* An array type contains pointers if its element type does.  */
1872       return contains_pointers_p (TREE_TYPE (type));
1873
1874     default:
1875       return 0;
1876     }
1877 }
1878
1879 /* In unit-at-a-time mode, we delay assemble_external processing until
1880    the compilation unit is finalized.  This is the best we can do for
1881    right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1882    it all the way to final.  See PR 17982 for further discussion.  */
1883 static GTY(()) tree pending_assemble_externals;
1884
1885 #ifdef ASM_OUTPUT_EXTERNAL
1886 /* True if DECL is a function decl for which no out-of-line copy exists.
1887    It is assumed that DECL's assembler name has been set.  */
1888
1889 static bool
1890 incorporeal_function_p (tree decl)
1891 {
1892   if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
1893     {
1894       const char *name;
1895
1896       if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
1897           && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
1898         return true;
1899
1900       name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1901       if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
1902         return true;
1903     }
1904   return false;
1905 }
1906
1907 /* Actually do the tests to determine if this is necessary, and invoke
1908    ASM_OUTPUT_EXTERNAL.  */
1909 static void
1910 assemble_external_real (tree decl)
1911 {
1912   rtx rtl = DECL_RTL (decl);
1913
1914   if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1915       && !SYMBOL_REF_USED (XEXP (rtl, 0))
1916       && !incorporeal_function_p (decl))
1917     {
1918       /* Some systems do require some output.  */
1919       SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1920       ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1921     }
1922 }
1923 #endif
1924
1925 void
1926 process_pending_assemble_externals (void)
1927 {
1928 #ifdef ASM_OUTPUT_EXTERNAL
1929   tree list;
1930   for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
1931     assemble_external_real (TREE_VALUE (list));
1932
1933   pending_assemble_externals = 0;
1934 #endif
1935 }
1936
1937 /* Output something to declare an external symbol to the assembler.
1938    (Most assemblers don't need this, so we normally output nothing.)
1939    Do nothing if DECL is not external.  */
1940
1941 void
1942 assemble_external (tree decl ATTRIBUTE_UNUSED)
1943 {
1944   /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1945      main body of this code is only rarely exercised.  To provide some
1946      testing, on all platforms, we make sure that the ASM_OUT_FILE is
1947      open.  If it's not, we should not be calling this function.  */
1948   gcc_assert (asm_out_file);
1949
1950 #ifdef ASM_OUTPUT_EXTERNAL
1951   if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
1952     return;
1953
1954   if (flag_unit_at_a_time)
1955     pending_assemble_externals = tree_cons (0, decl,
1956                                             pending_assemble_externals);
1957   else
1958     assemble_external_real (decl);
1959 #endif
1960 }
1961
1962 /* Similar, for calling a library function FUN.  */
1963
1964 void
1965 assemble_external_libcall (rtx fun)
1966 {
1967   /* Declare library function name external when first used, if nec.  */
1968   if (! SYMBOL_REF_USED (fun))
1969     {
1970       SYMBOL_REF_USED (fun) = 1;
1971       targetm.asm_out.external_libcall (fun);
1972     }
1973 }
1974
1975 /* Assemble a label named NAME.  */
1976
1977 void
1978 assemble_label (const char *name)
1979 {
1980   ASM_OUTPUT_LABEL (asm_out_file, name);
1981 }
1982
1983 /* Set the symbol_referenced flag for ID.  */
1984 void
1985 mark_referenced (tree id)
1986 {
1987   TREE_SYMBOL_REFERENCED (id) = 1;
1988 }
1989
1990 /* Set the symbol_referenced flag for DECL and notify callgraph.  */
1991 void
1992 mark_decl_referenced (tree decl)
1993 {
1994   if (TREE_CODE (decl) == FUNCTION_DECL)
1995     {
1996       /* Extern inline functions don't become needed when referenced.
1997          If we know a method will be emitted in other TU and no new
1998          functions can be marked reachable, just use the external
1999          definition.  */
2000       struct cgraph_node *node = cgraph_node (decl);
2001       if (!DECL_EXTERNAL (decl)
2002           && (!node->local.vtable_method || !cgraph_global_info_ready
2003               || !node->local.finalized))
2004         cgraph_mark_needed_node (node);
2005     }
2006   else if (TREE_CODE (decl) == VAR_DECL)
2007     {
2008       struct cgraph_varpool_node *node = cgraph_varpool_node (decl);
2009       cgraph_varpool_mark_needed_node (node);
2010       /* C++ frontend use mark_decl_references to force COMDAT variables
2011          to be output that might appear dead otherwise.  */
2012       node->force_output = true;
2013     }
2014   /* else do nothing - we can get various sorts of CST nodes here,
2015      which do not need to be marked.  */
2016 }
2017
2018
2019 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2020    until we find an identifier that is not itself a transparent alias.
2021    Modify the alias passed to it by reference (and all aliases on the
2022    way to the ultimate target), such that they do not have to be
2023    followed again, and return the ultimate target of the alias
2024    chain.  */
2025
2026 static inline tree
2027 ultimate_transparent_alias_target (tree *alias)
2028 {
2029   tree target = *alias;
2030
2031   if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2032     {
2033       gcc_assert (TREE_CHAIN (target));
2034       target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2035       gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2036                   && ! TREE_CHAIN (target));
2037       *alias = target;
2038     }
2039
2040   return target;
2041 }
2042
2043 /* Output to FILE (an assembly file) a reference to NAME.  If NAME
2044    starts with a *, the rest of NAME is output verbatim.  Otherwise
2045    NAME is transformed in a target-specific way (usually by the
2046    addition of an underscore).  */
2047
2048 void
2049 assemble_name_raw (FILE *file, const char *name)
2050 {
2051   if (name[0] == '*')
2052     fputs (&name[1], file);
2053   else
2054     ASM_OUTPUT_LABELREF (file, name);
2055 }
2056
2057 /* Like assemble_name_raw, but should be used when NAME might refer to
2058    an entity that is also represented as a tree (like a function or
2059    variable).  If NAME does refer to such an entity, that entity will
2060    be marked as referenced.  */
2061
2062 void
2063 assemble_name (FILE *file, const char *name)
2064 {
2065   const char *real_name;
2066   tree id;
2067
2068   real_name = targetm.strip_name_encoding (name);
2069
2070   id = maybe_get_identifier (real_name);
2071   if (id)
2072     {
2073       tree id_orig = id;
2074
2075       mark_referenced (id);
2076       ultimate_transparent_alias_target (&id);
2077       if (id != id_orig)
2078         name = IDENTIFIER_POINTER (id);
2079       gcc_assert (! TREE_CHAIN (id));
2080     }
2081
2082   assemble_name_raw (file, name);
2083 }
2084
2085 /* Allocate SIZE bytes writable static space with a gensym name
2086    and return an RTX to refer to its address.  */
2087
2088 rtx
2089 assemble_static_space (unsigned HOST_WIDE_INT size)
2090 {
2091   char name[12];
2092   const char *namestring;
2093   rtx x;
2094
2095   ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2096   ++const_labelno;
2097   namestring = ggc_strdup (name);
2098
2099   x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2100   SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2101
2102 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2103   ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2104                                  BIGGEST_ALIGNMENT);
2105 #else
2106 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2107   ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2108 #else
2109   {
2110     /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2111        so that each uninitialized object starts on such a boundary.  */
2112     /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL.  */
2113     unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2114       = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2115          / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2116          * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2117     ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2118   }
2119 #endif
2120 #endif
2121   return x;
2122 }
2123
2124 /* Assemble the static constant template for function entry trampolines.
2125    This is done at most once per compilation.
2126    Returns an RTX for the address of the template.  */
2127
2128 static GTY(()) rtx initial_trampoline;
2129
2130 #ifdef TRAMPOLINE_TEMPLATE
2131 rtx
2132 assemble_trampoline_template (void)
2133 {
2134   char label[256];
2135   const char *name;
2136   int align;
2137   rtx symbol;
2138
2139   if (initial_trampoline)
2140     return initial_trampoline;
2141
2142   /* By default, put trampoline templates in read-only data section.  */
2143
2144 #ifdef TRAMPOLINE_SECTION
2145   switch_to_section (TRAMPOLINE_SECTION);
2146 #else
2147   switch_to_section (readonly_data_section);
2148 #endif
2149
2150   /* Write the assembler code to define one.  */
2151   align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2152   if (align > 0)
2153     {
2154       ASM_OUTPUT_ALIGN (asm_out_file, align);
2155     }
2156
2157   targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2158   TRAMPOLINE_TEMPLATE (asm_out_file);
2159
2160   /* Record the rtl to refer to it.  */
2161   ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2162   name = ggc_strdup (label);
2163   symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2164   SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2165
2166   initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2167   set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2168
2169   return initial_trampoline;
2170 }
2171 #endif
2172 \f
2173 /* A and B are either alignments or offsets.  Return the minimum alignment
2174    that may be assumed after adding the two together.  */
2175
2176 static inline unsigned
2177 min_align (unsigned int a, unsigned int b)
2178 {
2179   return (a | b) & -(a | b);
2180 }
2181
2182 /* Return the assembler directive for creating a given kind of integer
2183    object.  SIZE is the number of bytes in the object and ALIGNED_P
2184    indicates whether it is known to be aligned.  Return NULL if the
2185    assembly dialect has no such directive.
2186
2187    The returned string should be printed at the start of a new line and
2188    be followed immediately by the object's initial value.  */
2189
2190 const char *
2191 integer_asm_op (int size, int aligned_p)
2192 {
2193   struct asm_int_op *ops;
2194
2195   if (aligned_p)
2196     ops = &targetm.asm_out.aligned_op;
2197   else
2198     ops = &targetm.asm_out.unaligned_op;
2199
2200   switch (size)
2201     {
2202     case 1:
2203       return targetm.asm_out.byte_op;
2204     case 2:
2205       return ops->hi;
2206     case 4:
2207       return ops->si;
2208     case 8:
2209       return ops->di;
2210     case 16:
2211       return ops->ti;
2212     default:
2213       return NULL;
2214     }
2215 }
2216
2217 /* Use directive OP to assemble an integer object X.  Print OP at the
2218    start of the line, followed immediately by the value of X.  */
2219
2220 void
2221 assemble_integer_with_op (const char *op, rtx x)
2222 {
2223   fputs (op, asm_out_file);
2224   output_addr_const (asm_out_file, x);
2225   fputc ('\n', asm_out_file);
2226 }
2227
2228 /* The default implementation of the asm_out.integer target hook.  */
2229
2230 bool
2231 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2232                           unsigned int size ATTRIBUTE_UNUSED,
2233                           int aligned_p ATTRIBUTE_UNUSED)
2234 {
2235   const char *op = integer_asm_op (size, aligned_p);
2236   /* Avoid GAS bugs for large values.  Specifically negative values whose
2237      absolute value fits in a bfd_vma, but not in a bfd_signed_vma.  */
2238   if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2239     return false;
2240   return op && (assemble_integer_with_op (op, x), true);
2241 }
2242
2243 /* Assemble the integer constant X into an object of SIZE bytes.  ALIGN is
2244    the alignment of the integer in bits.  Return 1 if we were able to output
2245    the constant, otherwise 0.  We must be able to output the constant,
2246    if FORCE is nonzero.  */
2247
2248 bool
2249 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2250 {
2251   int aligned_p;
2252
2253   aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2254
2255   /* See if the target hook can handle this kind of object.  */
2256   if (targetm.asm_out.integer (x, size, aligned_p))
2257     return true;
2258
2259   /* If the object is a multi-byte one, try splitting it up.  Split
2260      it into words it if is multi-word, otherwise split it into bytes.  */
2261   if (size > 1)
2262     {
2263       enum machine_mode omode, imode;
2264       unsigned int subalign;
2265       unsigned int subsize, i;
2266
2267       subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2268       subalign = MIN (align, subsize * BITS_PER_UNIT);
2269       omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2270       imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2271
2272       for (i = 0; i < size; i += subsize)
2273         {
2274           rtx partial = simplify_subreg (omode, x, imode, i);
2275           if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2276             break;
2277         }
2278       if (i == size)
2279         return true;
2280
2281       /* If we've printed some of it, but not all of it, there's no going
2282          back now.  */
2283       gcc_assert (!i);
2284     }
2285
2286   gcc_assert (!force);
2287
2288   return false;
2289 }
2290 \f
2291 void
2292 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2293 {
2294   long data[4] = {0, 0, 0, 0};
2295   int i;
2296   int bitsize, nelts, nunits, units_per;
2297
2298   /* This is hairy.  We have a quantity of known size.  real_to_target
2299      will put it into an array of *host* longs, 32 bits per element
2300      (even if long is more than 32 bits).  We need to determine the
2301      number of array elements that are occupied (nelts) and the number
2302      of *target* min-addressable units that will be occupied in the
2303      object file (nunits).  We cannot assume that 32 divides the
2304      mode's bitsize (size * BITS_PER_UNIT) evenly.
2305
2306      size * BITS_PER_UNIT is used here to make sure that padding bits
2307      (which might appear at either end of the value; real_to_target
2308      will include the padding bits in its output array) are included.  */
2309
2310   nunits = GET_MODE_SIZE (mode);
2311   bitsize = nunits * BITS_PER_UNIT;
2312   nelts = CEIL (bitsize, 32);
2313   units_per = 32 / BITS_PER_UNIT;
2314
2315   real_to_target (data, &d, mode);
2316
2317   /* Put out the first word with the specified alignment.  */
2318   assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2319   nunits -= units_per;
2320
2321   /* Subsequent words need only 32-bit alignment.  */
2322   align = min_align (align, 32);
2323
2324   for (i = 1; i < nelts; i++)
2325     {
2326       assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2327       nunits -= units_per;
2328     }
2329 }
2330 \f
2331 /* Given an expression EXP with a constant value,
2332    reduce it to the sum of an assembler symbol and an integer.
2333    Store them both in the structure *VALUE.
2334    EXP must be reducible.  */
2335
2336 struct addr_const GTY(())
2337 {
2338   rtx base;
2339   HOST_WIDE_INT offset;
2340 };
2341
2342 static void
2343 decode_addr_const (tree exp, struct addr_const *value)
2344 {
2345   tree target = TREE_OPERAND (exp, 0);
2346   int offset = 0;
2347   rtx x;
2348
2349   while (1)
2350     {
2351       if (TREE_CODE (target) == COMPONENT_REF
2352           && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2353
2354         {
2355           offset += int_byte_position (TREE_OPERAND (target, 1));
2356           target = TREE_OPERAND (target, 0);
2357         }
2358       else if (TREE_CODE (target) == ARRAY_REF
2359                || TREE_CODE (target) == ARRAY_RANGE_REF)
2360         {
2361           offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2362                      * tree_low_cst (TREE_OPERAND (target, 1), 0));
2363           target = TREE_OPERAND (target, 0);
2364         }
2365       else
2366         break;
2367     }
2368
2369   switch (TREE_CODE (target))
2370     {
2371     case VAR_DECL:
2372     case FUNCTION_DECL:
2373       x = DECL_RTL (target);
2374       break;
2375
2376     case LABEL_DECL:
2377       x = gen_rtx_MEM (FUNCTION_MODE,
2378                        gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2379       break;
2380
2381     case REAL_CST:
2382     case STRING_CST:
2383     case COMPLEX_CST:
2384     case CONSTRUCTOR:
2385     case INTEGER_CST:
2386       x = output_constant_def (target, 1);
2387       break;
2388
2389     default:
2390       gcc_unreachable ();
2391     }
2392
2393   gcc_assert (MEM_P (x));
2394   x = XEXP (x, 0);
2395
2396   value->base = x;
2397   value->offset = offset;
2398 }
2399 \f
2400 /* Uniquize all constants that appear in memory.
2401    Each constant in memory thus far output is recorded
2402    in `const_desc_table'.  */
2403
2404 struct constant_descriptor_tree GTY(())
2405 {
2406   /* A MEM for the constant.  */
2407   rtx rtl;
2408
2409   /* The value of the constant.  */
2410   tree value;
2411
2412   /* Hash of value.  Computing the hash from value each time
2413      hashfn is called can't work properly, as that means recursive
2414      use of the hash table during hash table expansion.  */
2415   hashval_t hash;
2416 };
2417
2418 static GTY((param_is (struct constant_descriptor_tree)))
2419      htab_t const_desc_htab;
2420
2421 static struct constant_descriptor_tree * build_constant_desc (tree);
2422 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2423
2424 /* Compute a hash code for a constant expression.  */
2425
2426 static hashval_t
2427 const_desc_hash (const void *ptr)
2428 {
2429   return ((struct constant_descriptor_tree *)ptr)->hash;
2430 }
2431
2432 static hashval_t
2433 const_hash_1 (const tree exp)
2434 {
2435   const char *p;
2436   hashval_t hi;
2437   int len, i;
2438   enum tree_code code = TREE_CODE (exp);
2439
2440   /* Either set P and LEN to the address and len of something to hash and
2441      exit the switch or return a value.  */
2442
2443   switch (code)
2444     {
2445     case INTEGER_CST:
2446       p = (char *) &TREE_INT_CST (exp);
2447       len = sizeof TREE_INT_CST (exp);
2448       break;
2449
2450     case REAL_CST:
2451       return real_hash (TREE_REAL_CST_PTR (exp));
2452
2453     case STRING_CST:
2454       p = TREE_STRING_POINTER (exp);
2455       len = TREE_STRING_LENGTH (exp);
2456       break;
2457
2458     case COMPLEX_CST:
2459       return (const_hash_1 (TREE_REALPART (exp)) * 5
2460               + const_hash_1 (TREE_IMAGPART (exp)));
2461
2462     case CONSTRUCTOR:
2463       {
2464         unsigned HOST_WIDE_INT idx;
2465         tree value;
2466
2467         hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2468
2469         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2470           if (value)
2471             hi = hi * 603 + const_hash_1 (value);
2472
2473         return hi;
2474       }
2475
2476     case ADDR_EXPR:
2477     case FDESC_EXPR:
2478       {
2479         struct addr_const value;
2480
2481         decode_addr_const (exp, &value);
2482         switch (GET_CODE (value.base))
2483           {
2484           case SYMBOL_REF:
2485             /* Don't hash the address of the SYMBOL_REF;
2486                only use the offset and the symbol name.  */
2487             hi = value.offset;
2488             p = XSTR (value.base, 0);
2489             for (i = 0; p[i] != 0; i++)
2490               hi = ((hi * 613) + (unsigned) (p[i]));
2491             break;
2492
2493           case LABEL_REF:
2494             hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2495             break;
2496
2497           default:
2498             gcc_unreachable ();
2499           }
2500       }
2501       return hi;
2502
2503     case PLUS_EXPR:
2504     case MINUS_EXPR:
2505       return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2506               + const_hash_1 (TREE_OPERAND (exp, 1)));
2507
2508     case NOP_EXPR:
2509     case CONVERT_EXPR:
2510     case NON_LVALUE_EXPR:
2511       return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2512
2513     default:
2514       /* A language specific constant. Just hash the code.  */
2515       return code;
2516     }
2517
2518   /* Compute hashing function.  */
2519   hi = len;
2520   for (i = 0; i < len; i++)
2521     hi = ((hi * 613) + (unsigned) (p[i]));
2522
2523   return hi;
2524 }
2525
2526 /* Wrapper of compare_constant, for the htab interface.  */
2527 static int
2528 const_desc_eq (const void *p1, const void *p2)
2529 {
2530   const struct constant_descriptor_tree *c1 = p1;
2531   const struct constant_descriptor_tree *c2 = p2;
2532   if (c1->hash != c2->hash)
2533     return 0;
2534   return compare_constant (c1->value, c2->value);
2535 }
2536
2537 /* Compare t1 and t2, and return 1 only if they are known to result in
2538    the same bit pattern on output.  */
2539
2540 static int
2541 compare_constant (const tree t1, const tree t2)
2542 {
2543   enum tree_code typecode;
2544
2545   if (t1 == NULL_TREE)
2546     return t2 == NULL_TREE;
2547   if (t2 == NULL_TREE)
2548     return 0;
2549
2550   if (TREE_CODE (t1) != TREE_CODE (t2))
2551     return 0;
2552
2553   switch (TREE_CODE (t1))
2554     {
2555     case INTEGER_CST:
2556       /* Integer constants are the same only if the same width of type.  */
2557       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2558         return 0;
2559       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2560         return 0;
2561       return tree_int_cst_equal (t1, t2);
2562
2563     case REAL_CST:
2564       /* Real constants are the same only if the same width of type.  */
2565       if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2566         return 0;
2567
2568       return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2569
2570     case STRING_CST:
2571       if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2572         return 0;
2573
2574       return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2575               && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2576                          TREE_STRING_LENGTH (t1)));
2577
2578     case COMPLEX_CST:
2579       return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2580               && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2581
2582     case CONSTRUCTOR:
2583       {
2584         VEC(constructor_elt, gc) *v1, *v2;
2585         unsigned HOST_WIDE_INT idx;
2586
2587         typecode = TREE_CODE (TREE_TYPE (t1));
2588         if (typecode != TREE_CODE (TREE_TYPE (t2)))
2589           return 0;
2590
2591         if (typecode == ARRAY_TYPE)
2592           {
2593             HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2594             /* For arrays, check that the sizes all match.  */
2595             if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2596                 || size_1 == -1
2597                 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2598               return 0;
2599           }
2600         else
2601           {
2602             /* For record and union constructors, require exact type
2603                equality.  */
2604             if (TREE_TYPE (t1) != TREE_TYPE (t2))
2605               return 0;
2606           }
2607
2608         v1 = CONSTRUCTOR_ELTS (t1);
2609         v2 = CONSTRUCTOR_ELTS (t2);
2610         if (VEC_length (constructor_elt, v1)
2611             != VEC_length (constructor_elt, v2))
2612             return 0;
2613
2614         for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2615           {
2616             constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2617             constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2618
2619             /* Check that each value is the same...  */
2620             if (!compare_constant (c1->value, c2->value))
2621               return 0;
2622             /* ... and that they apply to the same fields!  */
2623             if (typecode == ARRAY_TYPE)
2624               {
2625                 if (!compare_constant (c1->index, c2->index))
2626                   return 0;
2627               }
2628             else
2629               {
2630                 if (c1->index != c2->index)
2631                   return 0;
2632               }
2633           }
2634
2635         return 1;
2636       }
2637
2638     case ADDR_EXPR:
2639     case FDESC_EXPR:
2640       {
2641         struct addr_const value1, value2;
2642
2643         decode_addr_const (t1, &value1);
2644         decode_addr_const (t2, &value2);
2645         return (value1.offset == value2.offset
2646                 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
2647       }
2648
2649     case PLUS_EXPR:
2650     case MINUS_EXPR:
2651     case RANGE_EXPR:
2652       return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
2653               && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
2654
2655     case NOP_EXPR:
2656     case CONVERT_EXPR:
2657     case NON_LVALUE_EXPR:
2658     case VIEW_CONVERT_EXPR:
2659       return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
2660
2661     default:
2662       {
2663         tree nt1, nt2;
2664         nt1 = lang_hooks.expand_constant (t1);
2665         nt2 = lang_hooks.expand_constant (t2);
2666         if (nt1 != t1 || nt2 != t2)
2667           return compare_constant (nt1, nt2);
2668         else
2669           return 0;
2670       }
2671     }
2672
2673   gcc_unreachable ();
2674 }
2675 \f
2676 /* Make a copy of the whole tree structure for a constant.  This
2677    handles the same types of nodes that compare_constant handles.  */
2678
2679 static tree
2680 copy_constant (tree exp)
2681 {
2682   switch (TREE_CODE (exp))
2683     {
2684     case ADDR_EXPR:
2685       /* For ADDR_EXPR, we do not want to copy the decl whose address
2686          is requested.  We do want to copy constants though.  */
2687       if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
2688         return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2689                        copy_constant (TREE_OPERAND (exp, 0)));
2690       else
2691         return copy_node (exp);
2692
2693     case INTEGER_CST:
2694     case REAL_CST:
2695     case STRING_CST:
2696       return copy_node (exp);
2697
2698     case COMPLEX_CST:
2699       return build_complex (TREE_TYPE (exp),
2700                             copy_constant (TREE_REALPART (exp)),
2701                             copy_constant (TREE_IMAGPART (exp)));
2702
2703     case PLUS_EXPR:
2704     case MINUS_EXPR:
2705       return build2 (TREE_CODE (exp), TREE_TYPE (exp),
2706                      copy_constant (TREE_OPERAND (exp, 0)),
2707                      copy_constant (TREE_OPERAND (exp, 1)));
2708
2709     case NOP_EXPR:
2710     case CONVERT_EXPR:
2711     case NON_LVALUE_EXPR:
2712     case VIEW_CONVERT_EXPR:
2713       return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2714                      copy_constant (TREE_OPERAND (exp, 0)));
2715
2716     case CONSTRUCTOR:
2717       {
2718         tree copy = copy_node (exp);
2719         VEC(constructor_elt, gc) *v;
2720         unsigned HOST_WIDE_INT idx;
2721         tree purpose, value;
2722
2723         v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
2724                                                       CONSTRUCTOR_ELTS (exp)));
2725         FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
2726           {
2727             constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
2728             ce->index = purpose;
2729             ce->value = copy_constant (value);
2730           }
2731         CONSTRUCTOR_ELTS (copy) = v;
2732         return copy;
2733       }
2734
2735     default:
2736       {
2737         tree t = lang_hooks.expand_constant (exp);
2738
2739         gcc_assert (t == exp);
2740         return copy_constant (t);
2741       }
2742     }
2743 }
2744 \f
2745 /* Return the alignment of constant EXP in bits.  */
2746
2747 static unsigned int
2748 get_constant_alignment (tree exp)
2749 {
2750   unsigned int align;
2751
2752   align = TYPE_ALIGN (TREE_TYPE (exp));
2753 #ifdef CONSTANT_ALIGNMENT
2754   align = CONSTANT_ALIGNMENT (exp, align);
2755 #endif
2756   return align;
2757 }
2758
2759 /* Return the section into which constant EXP should be placed.  */
2760
2761 static section *
2762 get_constant_section (tree exp)
2763 {
2764   if (IN_NAMED_SECTION (exp))
2765     return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
2766   else
2767     return targetm.asm_out.select_section (exp,
2768                                            compute_reloc_for_constant (exp),
2769                                            get_constant_alignment (exp));
2770 }
2771
2772 /* Return the size of constant EXP in bytes.  */
2773
2774 static HOST_WIDE_INT
2775 get_constant_size (tree exp)
2776 {
2777   HOST_WIDE_INT size;
2778
2779   size = int_size_in_bytes (TREE_TYPE (exp));
2780   if (TREE_CODE (exp) == STRING_CST)
2781     size = MAX (TREE_STRING_LENGTH (exp), size);
2782   return size;
2783 }
2784
2785 /* Subroutine of output_constant_def:
2786    No constant equal to EXP is known to have been output.
2787    Make a constant descriptor to enter EXP in the hash table.
2788    Assign the label number and construct RTL to refer to the
2789    constant's location in memory.
2790    Caller is responsible for updating the hash table.  */
2791
2792 static struct constant_descriptor_tree *
2793 build_constant_desc (tree exp)
2794 {
2795   rtx symbol;
2796   rtx rtl;
2797   char label[256];
2798   int labelno;
2799   struct constant_descriptor_tree *desc;
2800
2801   desc = ggc_alloc (sizeof (*desc));
2802   desc->value = copy_constant (exp);
2803
2804   /* Propagate marked-ness to copied constant.  */
2805   if (flag_mudflap && mf_marked_p (exp))
2806     mf_mark (desc->value);
2807
2808   /* Create a string containing the label name, in LABEL.  */
2809   labelno = const_labelno++;
2810   ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
2811
2812   /* We have a symbol name; construct the SYMBOL_REF and the MEM.  */
2813   if (use_object_blocks_p ())
2814     {
2815       section *sect = get_constant_section (exp);
2816       symbol = create_block_symbol (ggc_strdup (label),
2817                                     get_block_for_section (sect), -1);
2818     }
2819   else
2820     symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
2821   SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
2822   SET_SYMBOL_REF_DECL (symbol, desc->value);
2823   TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
2824
2825   rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
2826   set_mem_attributes (rtl, exp, 1);
2827   set_mem_alias_set (rtl, 0);
2828   set_mem_alias_set (rtl, const_alias_set);
2829
2830   /* Set flags or add text to the name to record information, such as
2831      that it is a local symbol.  If the name is changed, the macro
2832      ASM_OUTPUT_LABELREF will have to know how to strip this
2833      information.  This call might invalidate our local variable
2834      SYMBOL; we can't use it afterward.  */
2835
2836   targetm.encode_section_info (exp, rtl, true);
2837
2838   desc->rtl = rtl;
2839
2840   return desc;
2841 }
2842
2843 /* Return an rtx representing a reference to constant data in memory
2844    for the constant expression EXP.
2845
2846    If assembler code for such a constant has already been output,
2847    return an rtx to refer to it.
2848    Otherwise, output such a constant in memory
2849    and generate an rtx for it.
2850
2851    If DEFER is nonzero, this constant can be deferred and output only
2852    if referenced in the function after all optimizations.
2853
2854    `const_desc_table' records which constants already have label strings.  */
2855
2856 rtx
2857 output_constant_def (tree exp, int defer)
2858 {
2859   struct constant_descriptor_tree *desc;
2860   struct constant_descriptor_tree key;
2861   void **loc;
2862
2863   /* Look up EXP in the table of constant descriptors.  If we didn't find
2864      it, create a new one.  */
2865   key.value = exp;
2866   key.hash = const_hash_1 (exp);
2867   loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
2868
2869   desc = *loc;
2870   if (desc == 0)
2871     {
2872       desc = build_constant_desc (exp);
2873       desc->hash = key.hash;
2874       *loc = desc;
2875     }
2876
2877   maybe_output_constant_def_contents (desc, defer);
2878   return desc->rtl;
2879 }
2880
2881 /* Subroutine of output_constant_def: Decide whether or not we need to
2882    output the constant DESC now, and if so, do it.  */
2883 static void
2884 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
2885                                     int defer)
2886 {
2887   rtx symbol = XEXP (desc->rtl, 0);
2888   tree exp = desc->value;
2889
2890   if (flag_syntax_only)
2891     return;
2892
2893   if (TREE_ASM_WRITTEN (exp))
2894     /* Already output; don't do it again.  */
2895     return;
2896
2897   /* We can always defer constants as long as the context allows
2898      doing so.  */
2899   if (defer)
2900     {
2901       /* Increment n_deferred_constants if it exists.  It needs to be at
2902          least as large as the number of constants actually referred to
2903          by the function.  If it's too small we'll stop looking too early
2904          and fail to emit constants; if it's too large we'll only look
2905          through the entire function when we could have stopped earlier.  */
2906       if (cfun)
2907         n_deferred_constants++;
2908       return;
2909     }
2910
2911   output_constant_def_contents (symbol);
2912 }
2913
2914 /* Subroutine of output_constant_def_contents.  Output the definition
2915    of constant EXP, which is pointed to by label LABEL.  ALIGN is the
2916    constant's alignment in bits.  */
2917
2918 static void
2919 assemble_constant_contents (tree exp, const char *label, unsigned int align)
2920 {
2921   HOST_WIDE_INT size;
2922
2923   size = get_constant_size (exp);
2924
2925   /* Do any machine/system dependent processing of the constant.  */
2926 #ifdef ASM_DECLARE_CONSTANT_NAME
2927   ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
2928 #else
2929   /* Standard thing is just output label for the constant.  */
2930   ASM_OUTPUT_LABEL (asm_out_file, label);
2931 #endif /* ASM_DECLARE_CONSTANT_NAME */
2932
2933   /* Output the value of EXP.  */
2934   output_constant (exp, size, align);
2935 }
2936
2937 /* We must output the constant data referred to by SYMBOL; do so.  */
2938
2939 static void
2940 output_constant_def_contents (rtx symbol)
2941 {
2942   tree exp = SYMBOL_REF_DECL (symbol);
2943   unsigned int align;
2944
2945   /* Make sure any other constants whose addresses appear in EXP
2946      are assigned label numbers.  */
2947   output_addressed_constants (exp);
2948
2949   /* We are no longer deferring this constant.  */
2950   TREE_ASM_WRITTEN (exp) = 1;
2951
2952   /* If the constant is part of an object block, make sure that the
2953      decl has been positioned within its block, but do not write out
2954      its definition yet.  output_object_blocks will do that later.  */
2955   if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2956     place_block_symbol (symbol);
2957   else
2958     {
2959       switch_to_section (get_constant_section (exp));
2960       align = get_constant_alignment (exp);
2961       if (align > BITS_PER_UNIT)
2962         ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2963       assemble_constant_contents (exp, XSTR (symbol, 0), align);
2964     }
2965   if (flag_mudflap)
2966     mudflap_enqueue_constant (exp);
2967 }
2968
2969 /* Look up EXP in the table of constant descriptors.  Return the rtl
2970    if it has been emitted, else null.  */
2971
2972 rtx
2973 lookup_constant_def (tree exp)
2974 {
2975   struct constant_descriptor_tree *desc;
2976   struct constant_descriptor_tree key;
2977
2978   key.value = exp;
2979   key.hash = const_hash_1 (exp);
2980   desc = htab_find_with_hash (const_desc_htab, &key, key.hash);
2981
2982   return (desc ? desc->rtl : NULL_RTX);
2983 }
2984 \f
2985 /* Used in the hash tables to avoid outputting the same constant
2986    twice.  Unlike 'struct constant_descriptor_tree', RTX constants
2987    are output once per function, not once per file.  */
2988 /* ??? Only a few targets need per-function constant pools.  Most
2989    can use one per-file pool.  Should add a targetm bit to tell the
2990    difference.  */
2991
2992 struct rtx_constant_pool GTY(())
2993 {
2994   /* Pointers to first and last constant in pool, as ordered by offset.  */
2995   struct constant_descriptor_rtx *first;
2996   struct constant_descriptor_rtx *last;
2997
2998   /* Hash facility for making memory-constants from constant rtl-expressions.
2999      It is used on RISC machines where immediate integer arguments and
3000      constant addresses are restricted so that such constants must be stored
3001      in memory.  */
3002   htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3003
3004   /* Current offset in constant pool (does not include any
3005      machine-specific header).  */
3006   HOST_WIDE_INT offset;
3007 };
3008
3009 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
3010 {
3011   struct constant_descriptor_rtx *next;
3012   rtx mem;
3013   rtx sym;
3014   rtx constant;
3015   HOST_WIDE_INT offset;
3016   hashval_t hash;
3017   enum machine_mode mode;
3018   unsigned int align;
3019   int labelno;
3020   int mark;
3021 };
3022
3023 /* Hash and compare functions for const_rtx_htab.  */
3024
3025 static hashval_t
3026 const_desc_rtx_hash (const void *ptr)
3027 {
3028   const struct constant_descriptor_rtx *desc = ptr;
3029   return desc->hash;
3030 }
3031
3032 static int
3033 const_desc_rtx_eq (const void *a, const void *b)
3034 {
3035   const struct constant_descriptor_rtx *x = a;
3036   const struct constant_descriptor_rtx *y = b;
3037
3038   if (x->mode != y->mode)
3039     return 0;
3040   return rtx_equal_p (x->constant, y->constant);
3041 }
3042
3043 /* This is the worker function for const_rtx_hash, called via for_each_rtx.  */
3044
3045 static int
3046 const_rtx_hash_1 (rtx *xp, void *data)
3047 {
3048   unsigned HOST_WIDE_INT hwi;
3049   enum machine_mode mode;
3050   enum rtx_code code;
3051   hashval_t h, *hp;
3052   rtx x;
3053
3054   x = *xp;
3055   code = GET_CODE (x);
3056   mode = GET_MODE (x);
3057   h = (hashval_t) code * 1048573 + mode;
3058
3059   switch (code)
3060     {
3061     case CONST_INT:
3062       hwi = INTVAL (x);
3063     fold_hwi:
3064       {
3065         const int shift = sizeof (hashval_t) * CHAR_BIT;
3066         const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3067         int i;
3068
3069         h ^= (hashval_t) hwi;
3070         for (i = 1; i < n; ++i)
3071           {
3072             hwi >>= shift;
3073             h ^= (hashval_t) hwi;
3074           }
3075       }
3076       break;
3077
3078     case CONST_DOUBLE:
3079       if (mode == VOIDmode)
3080         {
3081           hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3082           goto fold_hwi;
3083         }
3084       else
3085         h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3086       break;
3087
3088     case CONST_VECTOR:
3089       {
3090         int i;
3091         for (i = XVECLEN (x, 0); i-- > 0; )
3092           h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3093       }
3094       break;
3095
3096     case SYMBOL_REF:
3097       h ^= htab_hash_string (XSTR (x, 0));
3098       break;
3099
3100     case LABEL_REF:
3101       h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3102       break;
3103
3104     case UNSPEC:
3105     case UNSPEC_VOLATILE:
3106       h = h * 251 + XINT (x, 1);
3107       break;
3108
3109     default:
3110       break;
3111     }
3112
3113   hp = data;
3114   *hp = *hp * 509 + h;
3115   return 0;
3116 }
3117
3118 /* Compute a hash value for X, which should be a constant.  */
3119
3120 static hashval_t
3121 const_rtx_hash (rtx x)
3122 {
3123   hashval_t h = 0;
3124   for_each_rtx (&x, const_rtx_hash_1, &h);
3125   return h;
3126 }
3127
3128 \f
3129 /* Create and return a new rtx constant pool.  */
3130
3131 static struct rtx_constant_pool *
3132 create_constant_pool (void)
3133 {
3134   struct rtx_constant_pool *pool;
3135
3136   pool = ggc_alloc (sizeof (struct rtx_constant_pool));
3137   pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3138                                           const_desc_rtx_eq, NULL);
3139   pool->first = NULL;
3140   pool->last = NULL;
3141   pool->offset = 0;
3142   return pool;
3143 }
3144
3145 /* Initialize constant pool hashing for a new function.  */
3146
3147 void
3148 init_varasm_status (struct function *f)
3149 {
3150   struct varasm_status *p;
3151
3152   p = ggc_alloc (sizeof (struct varasm_status));
3153   f->varasm = p;
3154
3155   p->pool = create_constant_pool ();
3156   p->deferred_constants = 0;
3157 }
3158 \f
3159 /* Given a MINUS expression, simplify it if both sides
3160    include the same symbol.  */
3161
3162 rtx
3163 simplify_subtraction (rtx x)
3164 {
3165   rtx r = simplify_rtx (x);
3166   return r ? r : x;
3167 }
3168 \f
3169 /* Given a constant rtx X, make (or find) a memory constant for its value
3170    and return a MEM rtx to refer to it in memory.  */
3171
3172 rtx
3173 force_const_mem (enum machine_mode mode, rtx x)
3174 {
3175   struct constant_descriptor_rtx *desc, tmp;
3176   struct rtx_constant_pool *pool;
3177   char label[256];
3178   rtx def, symbol;
3179   hashval_t hash;
3180   unsigned int align;
3181   void **slot;
3182
3183   /* If we're not allowed to drop X into the constant pool, don't.  */
3184   if (targetm.cannot_force_const_mem (x))
3185     return NULL_RTX;
3186
3187   /* Record that this function has used a constant pool entry.  */
3188   current_function_uses_const_pool = 1;
3189
3190   /* Decide which pool to use.  */
3191   pool = (targetm.use_blocks_for_constant_p (mode, x)
3192           ? shared_constant_pool
3193           : cfun->varasm->pool);
3194
3195   /* Lookup the value in the hashtable.  */
3196   tmp.constant = x;
3197   tmp.mode = mode;
3198   hash = const_rtx_hash (x);
3199   slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3200   desc = *slot;
3201
3202   /* If the constant was already present, return its memory.  */
3203   if (desc)
3204     return copy_rtx (desc->mem);
3205
3206   /* Otherwise, create a new descriptor.  */
3207   desc = ggc_alloc (sizeof (*desc));
3208   *slot = desc;
3209
3210   /* Align the location counter as required by EXP's data type.  */
3211   align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3212 #ifdef CONSTANT_ALIGNMENT
3213   {
3214     tree type = lang_hooks.types.type_for_mode (mode, 0);
3215     if (type != NULL_TREE)
3216       align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3217   }
3218 #endif
3219
3220   pool->offset += (align / BITS_PER_UNIT) - 1;
3221   pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3222
3223   desc->next = NULL;
3224   desc->constant = tmp.constant;
3225   desc->offset = pool->offset;
3226   desc->hash = hash;
3227   desc->mode = mode;
3228   desc->align = align;
3229   desc->labelno = const_labelno;
3230   desc->mark = 0;
3231
3232   pool->offset += GET_MODE_SIZE (mode);
3233   if (pool->last)
3234     pool->last->next = desc;
3235   else
3236     pool->first = pool->last = desc;
3237   pool->last = desc;
3238
3239   /* Create a string containing the label name, in LABEL.  */
3240   ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3241   ++const_labelno;
3242
3243   /* Construct the SYMBOL_REF.  Make sure to mark it as belonging to
3244      the constants pool.  */
3245   if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3246     {
3247       section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3248       symbol = create_block_symbol (ggc_strdup (label),
3249                                     get_block_for_section (sect), -1);
3250     }
3251   else
3252     symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3253   desc->sym = symbol;
3254   SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3255   CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3256   SET_SYMBOL_REF_CONSTANT (symbol, desc);
3257
3258   /* Construct the MEM.  */
3259   desc->mem = def = gen_const_mem (mode, symbol);
3260   set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3261   set_mem_align (def, align);
3262
3263   /* If we're dropping a label to the constant pool, make sure we
3264      don't delete it.  */
3265   if (GET_CODE (x) == LABEL_REF)
3266     LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3267
3268   return copy_rtx (def);
3269 }
3270 \f
3271 /* Given a constant pool SYMBOL_REF, return the corresponding constant.  */
3272
3273 rtx
3274 get_pool_constant (rtx addr)
3275 {
3276   return SYMBOL_REF_CONSTANT (addr)->constant;
3277 }
3278
3279 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3280    and whether it has been output or not.  */
3281
3282 rtx
3283 get_pool_constant_mark (rtx addr, bool *pmarked)
3284 {
3285   struct constant_descriptor_rtx *desc;
3286
3287   desc = SYMBOL_REF_CONSTANT (addr);
3288   *pmarked = (desc->mark != 0);
3289   return desc->constant;
3290 }
3291
3292 /* Similar, return the mode.  */
3293
3294 enum machine_mode
3295 get_pool_mode (rtx addr)
3296 {
3297   return SYMBOL_REF_CONSTANT (addr)->mode;
3298 }
3299
3300 /* Return the size of the constant pool.  */
3301
3302 int
3303 get_pool_size (void)
3304 {
3305   return cfun->varasm->pool->offset;
3306 }
3307 \f
3308 /* Worker function for output_constant_pool_1.  Emit assembly for X
3309    in MODE with known alignment ALIGN.  */
3310
3311 static void
3312 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3313 {
3314   switch (GET_MODE_CLASS (mode))
3315     {
3316     case MODE_FLOAT:
3317     case MODE_DECIMAL_FLOAT:
3318       {
3319         REAL_VALUE_TYPE r;
3320
3321         gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3322         REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3323         assemble_real (r, mode, align);
3324         break;
3325       }
3326
3327     case MODE_INT:
3328     case MODE_PARTIAL_INT:
3329       assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3330       break;
3331
3332     case MODE_VECTOR_FLOAT:
3333     case MODE_VECTOR_INT:
3334       {
3335         int i, units;
3336         enum machine_mode submode = GET_MODE_INNER (mode);
3337         unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3338
3339         gcc_assert (GET_CODE (x) == CONST_VECTOR);
3340         units = CONST_VECTOR_NUNITS (x);
3341
3342         for (i = 0; i < units; i++)
3343           {
3344             rtx elt = CONST_VECTOR_ELT (x, i);
3345             output_constant_pool_2 (submode, elt, i ? subalign : align);
3346           }
3347       }
3348       break;
3349
3350     default:
3351       gcc_unreachable ();
3352     }
3353 }
3354
3355 /* Worker function for output_constant_pool.  Emit constant DESC,
3356    giving it ALIGN bits of alignment.  */
3357
3358 static void
3359 output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3360                         unsigned int align)
3361 {
3362   rtx x, tmp;
3363
3364   x = desc->constant;
3365
3366   /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3367      whose CODE_LABEL has been deleted.  This can occur if a jump table
3368      is eliminated by optimization.  If so, write a constant of zero
3369      instead.  Note that this can also happen by turning the
3370      CODE_LABEL into a NOTE.  */
3371   /* ??? This seems completely and utterly wrong.  Certainly it's
3372      not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3373      functioning even with INSN_DELETED_P and friends.  */
3374
3375   tmp = x;
3376   switch (GET_CODE (x))
3377     {
3378     case CONST:
3379       if (GET_CODE (XEXP (x, 0)) != PLUS
3380           || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3381         break;
3382       tmp = XEXP (XEXP (x, 0), 0);
3383       /* FALLTHRU  */
3384
3385     case LABEL_REF:
3386       tmp = XEXP (x, 0);
3387       gcc_assert (!INSN_DELETED_P (tmp));
3388       gcc_assert (!NOTE_P (tmp)
3389                   || NOTE_LINE_NUMBER (tmp) != NOTE_INSN_DELETED);
3390       break;
3391
3392     default:
3393       break;
3394     }
3395
3396 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3397   ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3398                                  align, desc->labelno, done);
3399 #endif
3400
3401   assemble_align (align);
3402
3403   /* Output the label.  */
3404   targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3405
3406   /* Output the data.  */
3407   output_constant_pool_2 (desc->mode, x, align);
3408
3409   /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3410      sections have proper size.  */
3411   if (align > GET_MODE_BITSIZE (desc->mode)
3412       && in_section
3413       && (in_section->common.flags & SECTION_MERGE))
3414     assemble_align (align);
3415
3416 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3417  done:
3418 #endif
3419   return;
3420 }
3421
3422 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3423    to as used.  Emit referenced deferred strings.  This function can
3424    be used with for_each_rtx to mark all SYMBOL_REFs in an rtx.  */
3425
3426 static int
3427 mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED)
3428 {
3429   rtx x = *current_rtx;
3430
3431   if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3432     return 0;
3433
3434   if (CONSTANT_POOL_ADDRESS_P (x))
3435     {
3436       struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
3437       if (desc->mark == 0)
3438         {
3439           desc->mark = 1;
3440           for_each_rtx (&desc->constant, mark_constant, NULL);
3441         }
3442     }
3443   else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3444     {
3445       tree exp = SYMBOL_REF_DECL (x);
3446       if (!TREE_ASM_WRITTEN (exp))
3447         {
3448           n_deferred_constants--;
3449           output_constant_def_contents (x);
3450         }
3451     }
3452
3453   return -1;
3454 }
3455
3456 /* Look through appropriate parts of INSN, marking all entries in the
3457    constant pool which are actually being used.  Entries that are only
3458    referenced by other constants are also marked as used.  Emit
3459    deferred strings that are used.  */
3460
3461 static void
3462 mark_constants (rtx insn)
3463 {
3464   if (!INSN_P (insn))
3465     return;
3466
3467   /* Insns may appear inside a SEQUENCE.  Only check the patterns of
3468      insns, not any notes that may be attached.  We don't want to mark
3469      a constant just because it happens to appear in a REG_EQUIV note.  */
3470   if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3471     {
3472       rtx seq = PATTERN (insn);
3473       int i, n = XVECLEN (seq, 0);
3474       for (i = 0; i < n; ++i)
3475         {
3476           rtx subinsn = XVECEXP (seq, 0, i);
3477           if (INSN_P (subinsn))
3478             for_each_rtx (&PATTERN (subinsn), mark_constant, NULL);
3479         }
3480     }
3481   else
3482     for_each_rtx (&PATTERN (insn), mark_constant, NULL);
3483 }
3484
3485 /* Look through the instructions for this function, and mark all the
3486    entries in POOL which are actually being used.  Emit deferred constants
3487    which have indeed been used.  */
3488
3489 static void
3490 mark_constant_pool (void)
3491 {
3492   rtx insn, link;
3493
3494   if (!current_function_uses_const_pool && n_deferred_constants == 0)
3495     return;
3496
3497   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3498     mark_constants (insn);
3499
3500   for (link = current_function_epilogue_delay_list;
3501        link;
3502        link = XEXP (link, 1))
3503     mark_constants (XEXP (link, 0));
3504 }
3505
3506 /* Write all the constants in POOL.  */
3507
3508 static void
3509 output_constant_pool_contents (struct rtx_constant_pool *pool)
3510 {
3511   struct constant_descriptor_rtx *desc;
3512
3513   for (desc = pool->first; desc ; desc = desc->next)
3514     if (desc->mark)
3515       {
3516         /* If the constant is part of an object_block, make sure that
3517            the constant has been positioned within its block, but do not
3518            write out its definition yet.  output_object_blocks will do
3519            that later.  */
3520         if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
3521             && SYMBOL_REF_BLOCK (desc->sym))
3522           place_block_symbol (desc->sym);
3523         else
3524           {
3525             switch_to_section (targetm.asm_out.select_rtx_section
3526                                (desc->mode, desc->constant, desc->align));
3527             output_constant_pool_1 (desc, desc->align);
3528           }
3529       }
3530 }
3531
3532 /* Mark all constants that are used in the current function, then write
3533    out the function's private constant pool.  */
3534
3535 static void
3536 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3537                       tree fndecl ATTRIBUTE_UNUSED)
3538 {
3539   struct rtx_constant_pool *pool = cfun->varasm->pool;
3540
3541   /* It is possible for gcc to call force_const_mem and then to later
3542      discard the instructions which refer to the constant.  In such a
3543      case we do not need to output the constant.  */
3544   mark_constant_pool ();
3545
3546 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3547   ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3548 #endif
3549
3550   output_constant_pool_contents (pool);
3551
3552 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3553   ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3554 #endif
3555 }
3556 \f
3557 /* Write the contents of the shared constant pool.  */
3558
3559 void
3560 output_shared_constant_pool (void)
3561 {
3562   output_constant_pool_contents (shared_constant_pool);
3563 }
3564 \f
3565 /* Determine what kind of relocations EXP may need.  */
3566
3567 int
3568 compute_reloc_for_constant (tree exp)
3569 {
3570   int reloc = 0, reloc2;
3571   tree tem;
3572
3573   /* Give the front-end a chance to convert VALUE to something that
3574      looks more like a constant to the back-end.  */
3575   exp = lang_hooks.expand_constant (exp);
3576
3577   switch (TREE_CODE (exp))
3578     {
3579     case ADDR_EXPR:
3580     case FDESC_EXPR:
3581       /* Go inside any operations that get_inner_reference can handle and see
3582          if what's inside is a constant: no need to do anything here for
3583          addresses of variables or functions.  */
3584       for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3585            tem = TREE_OPERAND (tem, 0))
3586         ;
3587
3588       if (TREE_PUBLIC (tem))
3589         reloc |= 2;
3590       else
3591         reloc |= 1;
3592       break;
3593
3594     case PLUS_EXPR:
3595       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3596       reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3597       break;
3598
3599     case MINUS_EXPR:
3600       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3601       reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3602       /* The difference of two local labels is computable at link time.  */
3603       if (reloc == 1 && reloc2 == 1)
3604         reloc = 0;
3605       else
3606         reloc |= reloc2;
3607       break;
3608
3609     case NOP_EXPR:
3610     case CONVERT_EXPR:
3611     case NON_LVALUE_EXPR:
3612     case VIEW_CONVERT_EXPR:
3613       reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3614       break;
3615
3616     case CONSTRUCTOR:
3617       {
3618         unsigned HOST_WIDE_INT idx;
3619         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3620           if (tem != 0)
3621             reloc |= compute_reloc_for_constant (tem);
3622       }
3623       break;
3624
3625     default:
3626       break;
3627     }
3628   return reloc;
3629 }
3630
3631 /* Find all the constants whose addresses are referenced inside of EXP,
3632    and make sure assembler code with a label has been output for each one.
3633    Indicate whether an ADDR_EXPR has been encountered.  */
3634
3635 static void
3636 output_addressed_constants (tree exp)
3637 {
3638   tree tem;
3639
3640   /* Give the front-end a chance to convert VALUE to something that
3641      looks more like a constant to the back-end.  */
3642   exp = lang_hooks.expand_constant (exp);
3643
3644   switch (TREE_CODE (exp))
3645     {
3646     case ADDR_EXPR:
3647     case FDESC_EXPR:
3648       /* Go inside any operations that get_inner_reference can handle and see
3649          if what's inside is a constant: no need to do anything here for
3650          addresses of variables or functions.  */
3651       for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3652            tem = TREE_OPERAND (tem, 0))
3653         ;
3654
3655       /* If we have an initialized CONST_DECL, retrieve the initializer.  */
3656       if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
3657         tem = DECL_INITIAL (tem);
3658
3659       if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
3660         output_constant_def (tem, 0);
3661       break;
3662
3663     case PLUS_EXPR:
3664     case MINUS_EXPR:
3665       output_addressed_constants (TREE_OPERAND (exp, 1));
3666       /* Fall through.  */
3667
3668     case NOP_EXPR:
3669     case CONVERT_EXPR:
3670     case NON_LVALUE_EXPR:
3671     case VIEW_CONVERT_EXPR:
3672       output_addressed_constants (TREE_OPERAND (exp, 0));
3673       break;
3674
3675     case CONSTRUCTOR:
3676       {
3677         unsigned HOST_WIDE_INT idx;
3678         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3679           if (tem != 0)
3680             output_addressed_constants (tem);
3681       }
3682       break;
3683
3684     default:
3685       break;
3686     }
3687 }
3688 \f
3689 /* Return nonzero if VALUE is a valid constant-valued expression
3690    for use in initializing a static variable; one that can be an
3691    element of a "constant" initializer.
3692
3693    Return null_pointer_node if the value is absolute;
3694    if it is relocatable, return the variable that determines the relocation.
3695    We assume that VALUE has been folded as much as possible;
3696    therefore, we do not need to check for such things as
3697    arithmetic-combinations of integers.  */
3698
3699 tree
3700 initializer_constant_valid_p (tree value, tree endtype)
3701 {
3702   /* Give the front-end a chance to convert VALUE to something that
3703      looks more like a constant to the back-end.  */
3704   value = lang_hooks.expand_constant (value);
3705
3706   switch (TREE_CODE (value))
3707     {
3708     case CONSTRUCTOR:
3709       if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
3710            || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
3711           && TREE_CONSTANT (value)
3712           && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (value)))
3713         {
3714           unsigned HOST_WIDE_INT idx;
3715           tree elt;
3716           bool absolute = true;
3717
3718           FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
3719             {
3720               tree reloc;
3721               reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
3722               if (!reloc)
3723                 return NULL_TREE;
3724               if (reloc != null_pointer_node)
3725                 absolute = false;
3726             }
3727           /* For a non-absolute relocation, there is no single
3728              variable that can be "the variable that determines the
3729              relocation."  */
3730           return absolute ? null_pointer_node : error_mark_node;
3731         }
3732
3733       return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
3734
3735     case INTEGER_CST:
3736     case VECTOR_CST:
3737     case REAL_CST:
3738     case STRING_CST:
3739     case COMPLEX_CST:
3740       return null_pointer_node;
3741
3742     case ADDR_EXPR:
3743     case FDESC_EXPR:
3744       value = staticp (TREE_OPERAND (value, 0));
3745       if (value)
3746         {
3747           /* "&(*a).f" is like unto pointer arithmetic.  If "a" turns out to
3748              be a constant, this is old-skool offsetof-like nonsense.  */
3749           if (TREE_CODE (value) == INDIRECT_REF
3750               && TREE_CONSTANT (TREE_OPERAND (value, 0)))
3751             return null_pointer_node;
3752           /* Taking the address of a nested function involves a trampoline.  */
3753           if (TREE_CODE (value) == FUNCTION_DECL
3754               && ((decl_function_context (value)
3755                    && !DECL_NO_STATIC_CHAIN (value))
3756                   || DECL_DLLIMPORT_P (value)))
3757             return NULL_TREE;
3758           /* "&{...}" requires a temporary to hold the constructed
3759              object.  */
3760           if (TREE_CODE (value) == CONSTRUCTOR)
3761             return NULL_TREE;
3762         }
3763       return value;
3764
3765     case VIEW_CONVERT_EXPR:
3766     case NON_LVALUE_EXPR:
3767       return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
3768
3769     case CONVERT_EXPR:
3770     case NOP_EXPR:
3771       {
3772         tree src;
3773         tree src_type;
3774         tree dest_type;
3775
3776         src = TREE_OPERAND (value, 0);
3777         src_type = TREE_TYPE (src);
3778         dest_type = TREE_TYPE (value);
3779
3780         /* Allow conversions between pointer types, floating-point
3781            types, and offset types.  */
3782         if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
3783             || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
3784             || (TREE_CODE (dest_type) == OFFSET_TYPE
3785                 && TREE_CODE (src_type) == OFFSET_TYPE))
3786           return initializer_constant_valid_p (src, endtype);
3787
3788         /* Allow length-preserving conversions between integer types.  */
3789         if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
3790             && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
3791           return initializer_constant_valid_p (src, endtype);
3792
3793         /* Allow conversions between other integer types only if
3794            explicit value.  */
3795         if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
3796           {
3797             tree inner = initializer_constant_valid_p (src, endtype);
3798             if (inner == null_pointer_node)
3799               return null_pointer_node;
3800             break;
3801           }
3802
3803         /* Allow (int) &foo provided int is as wide as a pointer.  */
3804         if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
3805             && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
3806           return initializer_constant_valid_p (src, endtype);
3807
3808         /* Likewise conversions from int to pointers, but also allow
3809            conversions from 0.  */
3810         if ((POINTER_TYPE_P (dest_type)
3811              || TREE_CODE (dest_type) == OFFSET_TYPE)
3812             && INTEGRAL_TYPE_P (src_type))
3813           {
3814             if (TREE_CODE (src) == INTEGER_CST
3815                 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
3816               return null_pointer_node;
3817             if (integer_zerop (src))
3818               return null_pointer_node;
3819             else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
3820               return initializer_constant_valid_p (src, endtype);
3821           }
3822
3823         /* Allow conversions to struct or union types if the value
3824            inside is okay.  */
3825         if (TREE_CODE (dest_type) == RECORD_TYPE
3826             || TREE_CODE (dest_type) == UNION_TYPE)
3827           return initializer_constant_valid_p (src, endtype);
3828       }
3829       break;
3830
3831     case PLUS_EXPR:
3832       if (! INTEGRAL_TYPE_P (endtype)
3833           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3834         {
3835           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3836                                                       endtype);
3837           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3838                                                       endtype);
3839           /* If either term is absolute, use the other terms relocation.  */
3840           if (valid0 == null_pointer_node)
3841             return valid1;
3842           if (valid1 == null_pointer_node)
3843             return valid0;
3844         }
3845       break;
3846
3847     case MINUS_EXPR:
3848       if (! INTEGRAL_TYPE_P (endtype)
3849           || TYPE_PRECISION (endtype) >= POINTER_SIZE)
3850         {
3851           tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
3852                                                       endtype);
3853           tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
3854                                                       endtype);
3855           /* Win if second argument is absolute.  */
3856           if (valid1 == null_pointer_node)
3857             return valid0;
3858           /* Win if both arguments have the same relocation.
3859              Then the value is absolute.  */
3860           if (valid0 == valid1 && valid0 != 0)
3861             return null_pointer_node;
3862
3863           /* Since GCC guarantees that string constants are unique in the
3864              generated code, a subtraction between two copies of the same
3865              constant string is absolute.  */
3866           if (valid0 && TREE_CODE (valid0) == STRING_CST
3867               && valid1 && TREE_CODE (valid1) == STRING_CST
3868               && operand_equal_p (valid0, valid1, 1))
3869             return null_pointer_node;
3870         }
3871
3872       /* Support narrowing differences.  */
3873       if (INTEGRAL_TYPE_P (endtype))
3874         {
3875           tree op0, op1;
3876
3877           op0 = TREE_OPERAND (value, 0);
3878           op1 = TREE_OPERAND (value, 1);
3879
3880           /* Like STRIP_NOPS except allow the operand mode to widen.
3881              This works around a feature of fold that simplifies
3882              (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3883              that the narrower operation is cheaper.  */
3884
3885           while (TREE_CODE (op0) == NOP_EXPR
3886                  || TREE_CODE (op0) == CONVERT_EXPR
3887                  || TREE_CODE (op0) == NON_LVALUE_EXPR)
3888             {
3889               tree inner = TREE_OPERAND (op0, 0);
3890               if (inner == error_mark_node
3891                   || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3892                   || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
3893                       > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3894                 break;
3895               op0 = inner;
3896             }
3897
3898           while (TREE_CODE (op1) == NOP_EXPR
3899                  || TREE_CODE (op1) == CONVERT_EXPR
3900                  || TREE_CODE (op1) == NON_LVALUE_EXPR)
3901             {
3902               tree inner = TREE_OPERAND (op1, 0);
3903               if (inner == error_mark_node
3904                   || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
3905                   || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
3906                       > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
3907                 break;
3908               op1 = inner;
3909             }
3910
3911           op0 = initializer_constant_valid_p (op0, endtype);
3912           op1 = initializer_constant_valid_p (op1, endtype);
3913
3914           /* Both initializers must be known.  */
3915           if (op0 && op1)
3916             {
3917               if (op0 == op1)
3918                 return null_pointer_node;
3919
3920               /* Support differences between labels.  */
3921               if (TREE_CODE (op0) == LABEL_DECL
3922                   && TREE_CODE (op1) == LABEL_DECL)
3923                 return null_pointer_node;
3924
3925               if (TREE_CODE (op0) == STRING_CST
3926                   && TREE_CODE (op1) == STRING_CST
3927                   && operand_equal_p (op0, op1, 1))
3928                 return null_pointer_node;
3929             }
3930         }
3931       break;
3932
3933     default:
3934       break;
3935     }
3936
3937   return 0;
3938 }
3939 \f
3940 /* Output assembler code for constant EXP to FILE, with no label.
3941    This includes the pseudo-op such as ".int" or ".byte", and a newline.
3942    Assumes output_addressed_constants has been done on EXP already.
3943
3944    Generate exactly SIZE bytes of assembler data, padding at the end
3945    with zeros if necessary.  SIZE must always be specified.
3946
3947    SIZE is important for structure constructors,
3948    since trailing members may have been omitted from the constructor.
3949    It is also important for initialization of arrays from string constants
3950    since the full length of the string constant might not be wanted.
3951    It is also needed for initialization of unions, where the initializer's
3952    type is just one member, and that may not be as long as the union.
3953
3954    There a case in which we would fail to output exactly SIZE bytes:
3955    for a structure constructor that wants to produce more than SIZE bytes.
3956    But such constructors will never be generated for any possible input.
3957
3958    ALIGN is the alignment of the data in bits.  */
3959
3960 void
3961 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
3962 {
3963   enum tree_code code;
3964   unsigned HOST_WIDE_INT thissize;
3965
3966   /* Some front-ends use constants other than the standard language-independent
3967      varieties, but which may still be output directly.  Give the front-end a
3968      chance to convert EXP to a language-independent representation.  */
3969   exp = lang_hooks.expand_constant (exp);
3970
3971   if (size == 0 || flag_syntax_only)
3972     return;
3973
3974   /* See if we're trying to initialize a pointer in a non-default mode
3975      to the address of some declaration somewhere.  If the target says
3976      the mode is valid for pointers, assume the target has a way of
3977      resolving it.  */
3978   if (TREE_CODE (exp) == NOP_EXPR
3979       && POINTER_TYPE_P (TREE_TYPE (exp))
3980       && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3981     {
3982       tree saved_type = TREE_TYPE (exp);
3983
3984       /* Peel off any intermediate conversions-to-pointer for valid
3985          pointer modes.  */
3986       while (TREE_CODE (exp) == NOP_EXPR
3987              && POINTER_TYPE_P (TREE_TYPE (exp))
3988              && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
3989         exp = TREE_OPERAND (exp, 0);
3990
3991       /* If what we're left with is the address of something, we can
3992          convert the address to the final type and output it that
3993          way.  */
3994       if (TREE_CODE (exp) == ADDR_EXPR)
3995         exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
3996       /* Likewise for constant ints.  */
3997       else if (TREE_CODE (exp) == INTEGER_CST)
3998         exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
3999                                   TREE_INT_CST_HIGH (exp));
4000       
4001     }
4002
4003   /* Eliminate any conversions since we'll be outputting the underlying
4004      constant.  */
4005   while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4006          || TREE_CODE (exp) == NON_LVALUE_EXPR
4007          || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4008     {
4009       HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp));
4010       HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)));
4011
4012       /* Make sure eliminating the conversion is really a no-op, except with
4013          VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4014          union types to allow for Ada unchecked unions.  */
4015       if (type_size > op_size
4016           && TREE_CODE (exp) != VIEW_CONVERT_EXPR
4017           && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE)
4018         internal_error ("no-op convert from %wd to %wd bytes in initializer",
4019                         op_size, type_size);
4020
4021       exp = TREE_OPERAND (exp, 0);
4022     }
4023
4024   code = TREE_CODE (TREE_TYPE (exp));
4025   thissize = int_size_in_bytes (TREE_TYPE (exp));
4026
4027   /* Allow a constructor with no elements for any data type.
4028      This means to fill the space with zeros.  */
4029   if (TREE_CODE (exp) == CONSTRUCTOR
4030       && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
4031     {
4032       assemble_zeros (size);
4033       return;
4034     }
4035
4036   if (TREE_CODE (exp) == FDESC_EXPR)
4037     {
4038 #ifdef ASM_OUTPUT_FDESC
4039       HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4040       tree decl = TREE_OPERAND (exp, 0);
4041       ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4042 #else
4043       gcc_unreachable ();
4044 #endif
4045       return;
4046     }
4047
4048   /* Now output the underlying data.  If we've handling the padding, return.
4049      Otherwise, break and ensure SIZE is the size written.  */
4050   switch (code)
4051     {
4052     case BOOLEAN_TYPE:
4053     case INTEGER_TYPE:
4054     case ENUMERAL_TYPE:
4055     case POINTER_TYPE:
4056     case REFERENCE_TYPE:
4057     case OFFSET_TYPE:
4058       if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4059                                            EXPAND_INITIALIZER),
4060                               MIN (size, thissize), align, 0))
4061         error ("initializer for integer value is too complicated");
4062       break;
4063
4064     case REAL_TYPE:
4065       if (TREE_CODE (exp) != REAL_CST)
4066         error ("initializer for floating value is not a floating constant");
4067
4068       assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
4069       break;
4070
4071     case COMPLEX_TYPE:
4072       output_constant (TREE_REALPART (exp), thissize / 2, align);
4073       output_constant (TREE_IMAGPART (exp), thissize / 2,
4074                        min_align (align, BITS_PER_UNIT * (thissize / 2)));
4075       break;
4076
4077     case ARRAY_TYPE:
4078     case VECTOR_TYPE:
4079       switch (TREE_CODE (exp))
4080         {
4081         case CONSTRUCTOR:
4082           output_constructor (exp, size, align);
4083           return;
4084         case STRING_CST:
4085           thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
4086                           size);
4087           assemble_string (TREE_STRING_POINTER (exp), thissize);
4088           break;
4089
4090         case VECTOR_CST:
4091           {
4092             int elt_size;
4093             tree link;
4094             unsigned int nalign;
4095             enum machine_mode inner;
4096
4097             inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
4098             nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
4099
4100             elt_size = GET_MODE_SIZE (inner);
4101
4102             link = TREE_VECTOR_CST_ELTS (exp);
4103             output_constant (TREE_VALUE (link), elt_size, align);
4104             while ((link = TREE_CHAIN (link)) != NULL)
4105               output_constant (TREE_VALUE (link), elt_size, nalign);
4106             break;
4107           }
4108         default:
4109           gcc_unreachable ();
4110         }
4111       break;
4112
4113     case RECORD_TYPE:
4114     case UNION_TYPE:
4115       gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
4116       output_constructor (exp, size, align);
4117       return;
4118
4119     case ERROR_MARK:
4120       return;
4121
4122     default:
4123       gcc_unreachable ();
4124     }
4125
4126   if (size > thissize)
4127     assemble_zeros (size - thissize);
4128 }
4129
4130 \f
4131 /* Subroutine of output_constructor, used for computing the size of
4132    arrays of unspecified length.  VAL must be a CONSTRUCTOR of an array
4133    type with an unspecified upper bound.  */
4134
4135 static unsigned HOST_WIDE_INT
4136 array_size_for_constructor (tree val)
4137 {
4138   tree max_index, i;
4139   unsigned HOST_WIDE_INT cnt;
4140   tree index, value, tmp;
4141
4142   /* This code used to attempt to handle string constants that are not
4143      arrays of single-bytes, but nothing else does, so there's no point in
4144      doing it here.  */
4145   if (TREE_CODE (val) == STRING_CST)
4146     return TREE_STRING_LENGTH (val);
4147
4148   max_index = NULL_TREE;
4149   FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
4150     {
4151       if (TREE_CODE (index) == RANGE_EXPR)
4152         index = TREE_OPERAND (index, 1);
4153       if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4154         max_index = index;
4155     }
4156
4157   if (max_index == NULL_TREE)
4158     return 0;
4159
4160   /* Compute the total number of array elements.  */
4161   tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)));
4162   i = size_binop (MINUS_EXPR, fold_convert (sizetype, max_index),
4163                   fold_convert (sizetype, tmp));
4164   i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
4165
4166   /* Multiply by the array element unit size to find number of bytes.  */
4167   i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4168
4169   return tree_low_cst (i, 1);
4170 }
4171
4172 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4173    Generate at least SIZE bytes, padding if necessary.  */
4174
4175 static void
4176 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4177                     unsigned int align)
4178 {
4179   tree type = TREE_TYPE (exp);
4180   tree field = 0;
4181   tree min_index = 0;
4182   /* Number of bytes output or skipped so far.
4183      In other words, current position within the constructor.  */
4184   HOST_WIDE_INT total_bytes = 0;
4185   /* Nonzero means BYTE contains part of a byte, to be output.  */
4186   int byte_buffer_in_use = 0;
4187   int byte = 0;
4188   unsigned HOST_WIDE_INT cnt;
4189   constructor_elt *ce;
4190
4191   gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4192
4193   if (TREE_CODE (type) == RECORD_TYPE)
4194     field = TYPE_FIELDS (type);
4195
4196   if (TREE_CODE (type) == ARRAY_TYPE
4197       && TYPE_DOMAIN (type) != 0)
4198     min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4199
4200   /* As LINK goes through the elements of the constant,
4201      FIELD goes through the structure fields, if the constant is a structure.
4202      if the constant is a union, then we override this,
4203      by getting the field from the TREE_LIST element.
4204      But the constant could also be an array.  Then FIELD is zero.
4205
4206      There is always a maximum of one element in the chain LINK for unions
4207      (even if the initializer in a source program incorrectly contains
4208      more one).  */
4209   for (cnt = 0;
4210        VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4211        cnt++, field = field ? TREE_CHAIN (field) : 0)
4212     {
4213       tree val = ce->value;
4214       tree index = 0;
4215
4216       /* The element in a union constructor specifies the proper field
4217          or index.  */
4218       if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4219            || TREE_CODE (type) == QUAL_UNION_TYPE)
4220           && ce->index != 0)
4221         field = ce->index;
4222
4223       else if (TREE_CODE (type) == ARRAY_TYPE)
4224         index = ce->index;
4225
4226 #ifdef ASM_COMMENT_START
4227       if (field && flag_verbose_asm)
4228         fprintf (asm_out_file, "%s %s:\n",
4229                  ASM_COMMENT_START,
4230                  DECL_NAME (field)
4231                  ? IDENTIFIER_POINTER (DECL_NAME (field))
4232                  : "<anonymous>");
4233 #endif
4234
4235       /* Eliminate the marker that makes a cast not be an lvalue.  */
4236       if (val != 0)
4237         STRIP_NOPS (val);
4238
4239       if (index && TREE_CODE (index) == RANGE_EXPR)
4240         {
4241           unsigned HOST_WIDE_INT fieldsize
4242             = int_size_in_bytes (TREE_TYPE (type));
4243           HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4244           HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4245           HOST_WIDE_INT index;
4246           unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4247
4248           for (index = lo_index; index <= hi_index; index++)
4249             {
4250               /* Output the element's initial value.  */
4251               if (val == 0)
4252                 assemble_zeros (fieldsize);
4253               else
4254                 output_constant (val, fieldsize, align2);
4255
4256               /* Count its size.  */
4257               total_bytes += fieldsize;
4258             }
4259         }
4260       else if (field == 0 || !DECL_BIT_FIELD (field))
4261         {
4262           /* An element that is not a bit-field.  */
4263
4264           unsigned HOST_WIDE_INT fieldsize;
4265           /* Since this structure is static,
4266              we know the positions are constant.  */
4267           HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4268           unsigned int align2;
4269
4270           if (index != 0)
4271             pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4272                    * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4273
4274           /* Output any buffered-up bit-fields preceding this element.  */
4275           if (byte_buffer_in_use)
4276             {
4277               assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4278               total_bytes++;
4279               byte_buffer_in_use = 0;
4280             }
4281
4282           /* Advance to offset of this element.
4283              Note no alignment needed in an array, since that is guaranteed
4284              if each element has the proper size.  */
4285           if ((field != 0 || index != 0) && pos != total_bytes)
4286             {
4287               gcc_assert (pos >= total_bytes);
4288               assemble_zeros (pos - total_bytes);
4289               total_bytes = pos;
4290             }
4291
4292           /* Find the alignment of this element.  */
4293           align2 = min_align (align, BITS_PER_UNIT * pos);
4294
4295           /* Determine size this element should occupy.  */
4296           if (field)
4297             {
4298               fieldsize = 0;
4299
4300               /* If this is an array with an unspecified upper bound,
4301                  the initializer determines the size.  */
4302               /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4303                  but we cannot do this until the deprecated support for
4304                  initializing zero-length array members is removed.  */
4305               if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4306                   && TYPE_DOMAIN (TREE_TYPE (field))
4307                   && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4308                 {
4309                   fieldsize = array_size_for_constructor (val);
4310                   /* Given a non-empty initialization, this field had
4311                      better be last.  */
4312                   gcc_assert (!fieldsize || !TREE_CHAIN (field));
4313                 }
4314               else if (DECL_SIZE_UNIT (field))
4315                 {
4316                   /* ??? This can't be right.  If the decl size overflows
4317                      a host integer we will silently emit no data.  */
4318                   if (host_integerp (DECL_SIZE_UNIT (field), 1))
4319                     fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4320                 }
4321             }
4322           else
4323             fieldsize = int_size_in_bytes (TREE_TYPE (type));
4324
4325           /* Output the element's initial value.  */
4326           if (val == 0)
4327             assemble_zeros (fieldsize);
4328           else
4329             output_constant (val, fieldsize, align2);
4330
4331           /* Count its size.  */
4332           total_bytes += fieldsize;
4333         }
4334       else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4335         error ("invalid initial value for member %qs",
4336                IDENTIFIER_POINTER (DECL_NAME (field)));
4337       else
4338         {
4339           /* Element that is a bit-field.  */
4340
4341           HOST_WIDE_INT next_offset = int_bit_position (field);
4342           HOST_WIDE_INT end_offset
4343             = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4344
4345           if (val == 0)
4346             val = integer_zero_node;
4347
4348           /* If this field does not start in this (or, next) byte,
4349              skip some bytes.  */
4350           if (next_offset / BITS_PER_UNIT != total_bytes)
4351             {
4352               /* Output remnant of any bit field in previous bytes.  */
4353               if (byte_buffer_in_use)
4354                 {
4355                   assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4356                   total_bytes++;
4357                   byte_buffer_in_use = 0;
4358                 }
4359
4360               /* If still not at proper byte, advance to there.  */
4361               if (next_offset / BITS_PER_UNIT != total_bytes)
4362                 {
4363                   gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4364                   assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4365                   total_bytes = next_offset / BITS_PER_UNIT;
4366                 }