OSDN Git Service

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