OSDN Git Service

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