OSDN Git Service

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