OSDN Git Service

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