OSDN Git Service

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