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