OSDN Git Service

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