OSDN Git Service

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