OSDN Git Service

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