]> git.ipfire.org Git - thirdparty/gcc.git/blob - gcc/varasm.c
varasm.c (initializer_constant_valid_p): Forbid view-conversions from aggregate to...
[thirdparty/gcc.git] / gcc / varasm.c
1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007
4 Free Software Foundation, Inc.
5
6 This file is part of GCC.
7
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 3, or (at your option) any later
11 version.
12
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
16 for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING3. If not see
20 <http://www.gnu.org/licenses/>. */
21
22
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
26
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
29
30 #include "config.h"
31 #include "system.h"
32 #include "coretypes.h"
33 #include "tm.h"
34 #include "rtl.h"
35 #include "tree.h"
36 #include "flags.h"
37 #include "function.h"
38 #include "expr.h"
39 #include "hard-reg-set.h"
40 #include "regs.h"
41 #include "real.h"
42 #include "output.h"
43 #include "toplev.h"
44 #include "hashtab.h"
45 #include "c-pragma.h"
46 #include "ggc.h"
47 #include "langhooks.h"
48 #include "tm_p.h"
49 #include "debug.h"
50 #include "target.h"
51 #include "targhooks.h"
52 #include "tree-mudflap.h"
53 #include "cgraph.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
56 #include "tree-iterator.h"
57
58 #ifdef XCOFF_DEBUGGING_INFO
59 #include "xcoffout.h" /* Needed for external data
60 declarations for e.g. AIX 4.x. */
61 #endif
62
63 /* The (assembler) name of the first globally-visible object output. */
64 extern GTY(()) const char *first_global_object_name;
65 extern GTY(()) const char *weak_global_object_name;
66
67 const char *first_global_object_name;
68 const char *weak_global_object_name;
69
70 struct addr_const;
71 struct constant_descriptor_rtx;
72 struct rtx_constant_pool;
73
74 #define n_deferred_constants (crtl->varasm.deferred_constants)
75
76 /* Number for making the label on the next
77 constant that is stored in memory. */
78
79 static GTY(()) int const_labelno;
80
81 /* Carry information from ASM_DECLARE_OBJECT_NAME
82 to ASM_FINISH_DECLARE_OBJECT. */
83
84 int size_directive_output;
85
86 /* The last decl for which assemble_variable was called,
87 if it did ASM_DECLARE_OBJECT_NAME.
88 If the last call to assemble_variable didn't do that,
89 this holds 0. */
90
91 tree last_assemble_variable_decl;
92
93 /* The following global variable indicates if the first basic block
94 in a function belongs to the cold partition or not. */
95
96 bool first_function_block_is_cold;
97
98 /* We give all constants their own alias set. Perhaps redundant with
99 MEM_READONLY_P, but pre-dates it. */
100
101 static alias_set_type const_alias_set;
102
103 static const char *strip_reg_name (const char *);
104 static int contains_pointers_p (tree);
105 #ifdef ASM_OUTPUT_EXTERNAL
106 static bool incorporeal_function_p (tree);
107 #endif
108 static void decode_addr_const (tree, struct addr_const *);
109 static hashval_t const_desc_hash (const void *);
110 static int const_desc_eq (const void *, const void *);
111 static hashval_t const_hash_1 (const tree);
112 static int compare_constant (const tree, const tree);
113 static tree copy_constant (tree);
114 static void output_constant_def_contents (rtx);
115 static void output_addressed_constants (tree);
116 static unsigned HOST_WIDE_INT array_size_for_constructor (tree);
117 static unsigned min_align (unsigned, unsigned);
118 static void output_constructor (tree, unsigned HOST_WIDE_INT, unsigned int);
119 static void globalize_decl (tree);
120 #ifdef BSS_SECTION_ASM_OP
121 #ifdef ASM_OUTPUT_BSS
122 static void asm_output_bss (FILE *, tree, const char *,
123 unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT);
124 #endif
125 #ifdef ASM_OUTPUT_ALIGNED_BSS
126 static void asm_output_aligned_bss (FILE *, tree, const char *,
127 unsigned HOST_WIDE_INT, int)
128 ATTRIBUTE_UNUSED;
129 #endif
130 #endif /* BSS_SECTION_ASM_OP */
131 static void mark_weak (tree);
132 static void output_constant_pool (const char *, tree);
133 \f
134 /* Well-known sections, each one associated with some sort of *_ASM_OP. */
135 section *text_section;
136 section *data_section;
137 section *readonly_data_section;
138 section *sdata_section;
139 section *ctors_section;
140 section *dtors_section;
141 section *bss_section;
142 section *sbss_section;
143
144 /* Various forms of common section. All are guaranteed to be nonnull. */
145 section *tls_comm_section;
146 section *comm_section;
147 section *lcomm_section;
148
149 /* A SECTION_NOSWITCH section used for declaring global BSS variables.
150 May be null. */
151 section *bss_noswitch_section;
152
153 /* The section that holds the main exception table, when known. The section
154 is set either by the target's init_sections hook or by the first call to
155 switch_to_exception_section. */
156 section *exception_section;
157
158 /* The section that holds the DWARF2 frame unwind information, when known.
159 The section is set either by the target's init_sections hook or by the
160 first call to switch_to_eh_frame_section. */
161 section *eh_frame_section;
162
163 /* asm_out_file's current section. This is NULL if no section has yet
164 been selected or if we lose track of what the current section is. */
165 section *in_section;
166
167 /* True if code for the current function is currently being directed
168 at the cold section. */
169 bool in_cold_section_p;
170
171 /* A linked list of all the unnamed sections. */
172 static GTY(()) section *unnamed_sections;
173
174 /* Return a nonzero value if DECL has a section attribute. */
175 #ifndef IN_NAMED_SECTION
176 #define IN_NAMED_SECTION(DECL) \
177 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
178 && DECL_SECTION_NAME (DECL) != NULL_TREE)
179 #endif
180
181 /* Hash table of named sections. */
182 static GTY((param_is (section))) htab_t section_htab;
183
184 /* A table of object_blocks, indexed by section. */
185 static GTY((param_is (struct object_block))) htab_t object_block_htab;
186
187 /* The next number to use for internal anchor labels. */
188 static GTY(()) int anchor_labelno;
189
190 /* A pool of constants that can be shared between functions. */
191 static GTY(()) struct rtx_constant_pool *shared_constant_pool;
192
193 /* TLS emulation. */
194
195 static GTY ((if_marked ("tree_map_marked_p"), param_is (struct tree_map)))
196 htab_t emutls_htab;
197 static GTY (()) tree emutls_object_type;
198 /* Emulated TLS objects have the TLS model TLS_MODEL_EMULATED. This
199 macro can be used on them to distinguish the control variable from
200 the initialization template. */
201 #define DECL_EMUTLS_VAR_P(D) (TREE_TYPE (D) == emutls_object_type)
202
203 #if !defined (NO_DOT_IN_LABEL)
204 # define EMUTLS_SEPARATOR "."
205 #elif !defined (NO_DOLLAR_IN_LABEL)
206 # define EMUTLS_SEPARATOR "$"
207 #else
208 # define EMUTLS_SEPARATOR "_"
209 #endif
210
211 /* Create an IDENTIFIER_NODE by prefixing PREFIX to the
212 IDENTIFIER_NODE NAME's name. */
213
214 static tree
215 prefix_name (const char *prefix, tree name)
216 {
217 unsigned plen = strlen (prefix);
218 unsigned nlen = strlen (IDENTIFIER_POINTER (name));
219 char *toname = (char *) alloca (plen + nlen + 1);
220
221 memcpy (toname, prefix, plen);
222 memcpy (toname + plen, IDENTIFIER_POINTER (name), nlen + 1);
223
224 return get_identifier (toname);
225 }
226
227 /* Create an identifier for the struct __emutls_object, given an identifier
228 of the DECL_ASSEMBLY_NAME of the original object. */
229
230 static tree
231 get_emutls_object_name (tree name)
232 {
233 const char *prefix = (targetm.emutls.var_prefix
234 ? targetm.emutls.var_prefix
235 : "__emutls_v" EMUTLS_SEPARATOR);
236 return prefix_name (prefix, name);
237 }
238
239 tree
240 default_emutls_var_fields (tree type, tree *name ATTRIBUTE_UNUSED)
241 {
242 tree word_type_node, field, next_field;
243
244 field = build_decl (FIELD_DECL, get_identifier ("__templ"), ptr_type_node);
245 DECL_CONTEXT (field) = type;
246 next_field = field;
247
248 field = build_decl (FIELD_DECL, get_identifier ("__offset"),
249 ptr_type_node);
250 DECL_CONTEXT (field) = type;
251 TREE_CHAIN (field) = next_field;
252 next_field = field;
253
254 word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
255 field = build_decl (FIELD_DECL, get_identifier ("__align"),
256 word_type_node);
257 DECL_CONTEXT (field) = type;
258 TREE_CHAIN (field) = next_field;
259 next_field = field;
260
261 field = build_decl (FIELD_DECL, get_identifier ("__size"), word_type_node);
262 DECL_CONTEXT (field) = type;
263 TREE_CHAIN (field) = next_field;
264
265 return field;
266 }
267
268 /* Create the structure for struct __emutls_object. This should match the
269 structure at the top of emutls.c, modulo the union there. */
270
271 static tree
272 get_emutls_object_type (void)
273 {
274 tree type, type_name, field;
275
276 type = emutls_object_type;
277 if (type)
278 return type;
279
280 emutls_object_type = type = lang_hooks.types.make_type (RECORD_TYPE);
281 type_name = NULL;
282 field = targetm.emutls.var_fields (type, &type_name);
283 if (!type_name)
284 type_name = get_identifier ("__emutls_object");
285 type_name = build_decl (TYPE_DECL, type_name, type);
286 TYPE_NAME (type) = type_name;
287 TYPE_FIELDS (type) = field;
288 layout_type (type);
289
290 return type;
291 }
292
293 /* Create a read-only variable like DECL, with the same DECL_INITIAL.
294 This will be used for initializing the emulated tls data area. */
295
296 static tree
297 get_emutls_init_templ_addr (tree decl)
298 {
299 tree name, to;
300
301 if (targetm.emutls.register_common && !DECL_INITIAL (decl)
302 && !DECL_SECTION_NAME (decl))
303 return null_pointer_node;
304
305 name = DECL_ASSEMBLER_NAME (decl);
306 if (!targetm.emutls.tmpl_prefix || targetm.emutls.tmpl_prefix[0])
307 {
308 const char *prefix = (targetm.emutls.tmpl_prefix
309 ? targetm.emutls.tmpl_prefix
310 : "__emutls_t" EMUTLS_SEPARATOR);
311 name = prefix_name (prefix, name);
312 }
313
314 to = build_decl (VAR_DECL, name, TREE_TYPE (decl));
315 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
316 DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
317 DECL_ARTIFICIAL (to) = 1;
318 TREE_USED (to) = TREE_USED (decl);
319 TREE_READONLY (to) = 1;
320 DECL_IGNORED_P (to) = 1;
321 DECL_CONTEXT (to) = DECL_CONTEXT (decl);
322 DECL_SECTION_NAME (to) = DECL_SECTION_NAME (decl);
323
324 DECL_WEAK (to) = DECL_WEAK (decl);
325 if (DECL_ONE_ONLY (decl))
326 {
327 make_decl_one_only (to);
328 TREE_STATIC (to) = TREE_STATIC (decl);
329 TREE_PUBLIC (to) = TREE_PUBLIC (decl);
330 DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
331 }
332 else
333 TREE_STATIC (to) = 1;
334
335 DECL_INITIAL (to) = DECL_INITIAL (decl);
336 DECL_INITIAL (decl) = NULL;
337
338 varpool_finalize_decl (to);
339 return build_fold_addr_expr (to);
340 }
341
342 /* When emulating tls, we use a control structure for use by the runtime.
343 Create and return this structure. */
344
345 tree
346 emutls_decl (tree decl)
347 {
348 tree name, to;
349 struct tree_map *h, in;
350 void **loc;
351
352 if (targetm.have_tls || decl == NULL || decl == error_mark_node
353 || TREE_CODE (decl) != VAR_DECL || ! DECL_THREAD_LOCAL_P (decl))
354 return decl;
355
356 /* Look up the object in the hash; return the control structure if
357 it has already been created. */
358 if (! emutls_htab)
359 emutls_htab = htab_create_ggc (512, tree_map_hash, tree_map_eq, 0);
360
361 name = DECL_ASSEMBLER_NAME (decl);
362
363 /* Note that we use the hash of the decl's name, rather than a hash
364 of the decl's pointer. In emutls_finish we iterate through the
365 hash table, and we want this traversal to be predictable. */
366 in.hash = htab_hash_string (IDENTIFIER_POINTER (name));
367 in.base.from = decl;
368 loc = htab_find_slot_with_hash (emutls_htab, &in, in.hash, INSERT);
369 h = (struct tree_map *) *loc;
370 if (h != NULL)
371 to = h->to;
372 else
373 {
374 to = build_decl (VAR_DECL, get_emutls_object_name (name),
375 get_emutls_object_type ());
376
377 h = GGC_NEW (struct tree_map);
378 h->hash = in.hash;
379 h->base.from = decl;
380 h->to = to;
381 *(struct tree_map **) loc = h;
382
383 DECL_TLS_MODEL (to) = TLS_MODEL_EMULATED;
384 DECL_ARTIFICIAL (to) = 1;
385 DECL_IGNORED_P (to) = 1;
386 TREE_READONLY (to) = 0;
387 SET_DECL_ASSEMBLER_NAME (to, DECL_NAME (to));
388 if (DECL_ONE_ONLY (decl))
389 make_decl_one_only (to);
390 DECL_CONTEXT (to) = DECL_CONTEXT (decl);
391 if (targetm.emutls.var_align_fixed)
392 /* If we're not allowed to change the proxy object's
393 alignment, pretend it's been set by the user. */
394 DECL_USER_ALIGN (to) = 1;
395 }
396
397 /* Note that these fields may need to be updated from time to time from
398 the original decl. Consider:
399 extern __thread int i;
400 int foo() { return i; }
401 __thread int i = 1;
402 in which I goes from external to locally defined and initialized. */
403
404 TREE_STATIC (to) = TREE_STATIC (decl);
405 TREE_USED (to) = TREE_USED (decl);
406 TREE_PUBLIC (to) = TREE_PUBLIC (decl);
407 DECL_EXTERNAL (to) = DECL_EXTERNAL (decl);
408 DECL_COMMON (to) = DECL_COMMON (decl);
409 DECL_WEAK (to) = DECL_WEAK (decl);
410 DECL_VISIBILITY (to) = DECL_VISIBILITY (decl);
411
412 return to;
413 }
414
415 static int
416 emutls_common_1 (void **loc, void *xstmts)
417 {
418 struct tree_map *h = *(struct tree_map **) loc;
419 tree args, x, *pstmts = (tree *) xstmts;
420 tree word_type_node;
421
422 if (! DECL_COMMON (h->base.from)
423 || (DECL_INITIAL (h->base.from)
424 && DECL_INITIAL (h->base.from) != error_mark_node))
425 return 1;
426
427 word_type_node = lang_hooks.types.type_for_mode (word_mode, 1);
428
429 /* The idea was to call get_emutls_init_templ_addr here, but if we
430 do this and there is an initializer, -fanchor_section loses,
431 because it would be too late to ensure the template is
432 output. */
433 x = null_pointer_node;
434 args = tree_cons (NULL, x, NULL);
435 x = build_int_cst (word_type_node, DECL_ALIGN_UNIT (h->base.from));
436 args = tree_cons (NULL, x, args);
437 x = fold_convert (word_type_node, DECL_SIZE_UNIT (h->base.from));
438 args = tree_cons (NULL, x, args);
439 x = build_fold_addr_expr (h->to);
440 args = tree_cons (NULL, x, args);
441
442 x = built_in_decls[BUILT_IN_EMUTLS_REGISTER_COMMON];
443 x = build_function_call_expr (x, args);
444
445 append_to_statement_list (x, pstmts);
446 return 1;
447 }
448
449 void
450 emutls_finish (void)
451 {
452 if (!targetm.emutls.register_common)
453 {
454 tree body = NULL_TREE;
455
456 if (emutls_htab == NULL)
457 return;
458
459 htab_traverse_noresize (emutls_htab, emutls_common_1, &body);
460 if (body == NULL_TREE)
461 return;
462
463 cgraph_build_static_cdtor ('I', body, DEFAULT_INIT_PRIORITY);
464 }
465 }
466
467 /* Helper routines for maintaining section_htab. */
468
469 static int
470 section_entry_eq (const void *p1, const void *p2)
471 {
472 const section *old = (const section *) p1;
473 const char *new_name = (const char *) p2;
474
475 return strcmp (old->named.name, new_name) == 0;
476 }
477
478 static hashval_t
479 section_entry_hash (const void *p)
480 {
481 const section *old = (const section *) p;
482 return htab_hash_string (old->named.name);
483 }
484
485 /* Return a hash value for section SECT. */
486
487 static hashval_t
488 hash_section (section *sect)
489 {
490 if (sect->common.flags & SECTION_NAMED)
491 return htab_hash_string (sect->named.name);
492 return sect->common.flags;
493 }
494
495 /* Helper routines for maintaining object_block_htab. */
496
497 static int
498 object_block_entry_eq (const void *p1, const void *p2)
499 {
500 const struct object_block *old = (const struct object_block *) p1;
501 const section *new_section = (const section *) p2;
502
503 return old->sect == new_section;
504 }
505
506 static hashval_t
507 object_block_entry_hash (const void *p)
508 {
509 const struct object_block *old = (const struct object_block *) p;
510 return hash_section (old->sect);
511 }
512
513 /* Return a new unnamed section with the given fields. */
514
515 section *
516 get_unnamed_section (unsigned int flags, void (*callback) (const void *),
517 const void *data)
518 {
519 section *sect;
520
521 sect = GGC_NEW (section);
522 sect->unnamed.common.flags = flags | SECTION_UNNAMED;
523 sect->unnamed.callback = callback;
524 sect->unnamed.data = data;
525 sect->unnamed.next = unnamed_sections;
526
527 unnamed_sections = sect;
528 return sect;
529 }
530
531 /* Return a SECTION_NOSWITCH section with the given fields. */
532
533 static section *
534 get_noswitch_section (unsigned int flags, noswitch_section_callback callback)
535 {
536 section *sect;
537
538 sect = GGC_NEW (section);
539 sect->noswitch.common.flags = flags | SECTION_NOSWITCH;
540 sect->noswitch.callback = callback;
541
542 return sect;
543 }
544
545 /* Return the named section structure associated with NAME. Create
546 a new section with the given fields if no such structure exists. */
547
548 section *
549 get_section (const char *name, unsigned int flags, tree decl)
550 {
551 section *sect, **slot;
552
553 slot = (section **)
554 htab_find_slot_with_hash (section_htab, name,
555 htab_hash_string (name), INSERT);
556 flags |= SECTION_NAMED;
557 if (*slot == NULL)
558 {
559 sect = GGC_NEW (section);
560 sect->named.common.flags = flags;
561 sect->named.name = ggc_strdup (name);
562 sect->named.decl = decl;
563 *slot = sect;
564 }
565 else
566 {
567 sect = *slot;
568 if ((sect->common.flags & ~SECTION_DECLARED) != flags
569 && ((sect->common.flags | flags) & SECTION_OVERRIDE) == 0)
570 {
571 /* Sanity check user variables for flag changes. */
572 if (decl == 0)
573 decl = sect->named.decl;
574 gcc_assert (decl);
575 error ("%+D causes a section type conflict", decl);
576 }
577 }
578 return sect;
579 }
580
581 /* Return true if the current compilation mode benefits from having
582 objects grouped into blocks. */
583
584 static bool
585 use_object_blocks_p (void)
586 {
587 return flag_section_anchors;
588 }
589
590 /* Return the object_block structure for section SECT. Create a new
591 structure if we haven't created one already. Return null if SECT
592 itself is null. */
593
594 static struct object_block *
595 get_block_for_section (section *sect)
596 {
597 struct object_block *block;
598 void **slot;
599
600 if (sect == NULL)
601 return NULL;
602
603 slot = htab_find_slot_with_hash (object_block_htab, sect,
604 hash_section (sect), INSERT);
605 block = (struct object_block *) *slot;
606 if (block == NULL)
607 {
608 block = (struct object_block *)
609 ggc_alloc_cleared (sizeof (struct object_block));
610 block->sect = sect;
611 *slot = block;
612 }
613 return block;
614 }
615
616 /* Create a symbol with label LABEL and place it at byte offset
617 OFFSET in BLOCK. OFFSET can be negative if the symbol's offset
618 is not yet known. LABEL must be a garbage-collected string. */
619
620 static rtx
621 create_block_symbol (const char *label, struct object_block *block,
622 HOST_WIDE_INT offset)
623 {
624 rtx symbol;
625 unsigned int size;
626
627 /* Create the extended SYMBOL_REF. */
628 size = RTX_HDR_SIZE + sizeof (struct block_symbol);
629 symbol = (rtx) ggc_alloc_zone (size, &rtl_zone);
630
631 /* Initialize the normal SYMBOL_REF fields. */
632 memset (symbol, 0, size);
633 PUT_CODE (symbol, SYMBOL_REF);
634 PUT_MODE (symbol, Pmode);
635 XSTR (symbol, 0) = label;
636 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_HAS_BLOCK_INFO;
637
638 /* Initialize the block_symbol stuff. */
639 SYMBOL_REF_BLOCK (symbol) = block;
640 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
641
642 return symbol;
643 }
644
645 static void
646 initialize_cold_section_name (void)
647 {
648 const char *stripped_name;
649 char *name, *buffer;
650 tree dsn;
651
652 gcc_assert (cfun && current_function_decl);
653 if (crtl->subsections.unlikely_text_section_name)
654 return;
655
656 dsn = DECL_SECTION_NAME (current_function_decl);
657 if (flag_function_sections && dsn)
658 {
659 name = (char *) alloca (TREE_STRING_LENGTH (dsn) + 1);
660 memcpy (name, TREE_STRING_POINTER (dsn), TREE_STRING_LENGTH (dsn) + 1);
661
662 stripped_name = targetm.strip_name_encoding (name);
663
664 buffer = ACONCAT ((stripped_name, "_unlikely", NULL));
665 crtl->subsections.unlikely_text_section_name = ggc_strdup (buffer);
666 }
667 else
668 crtl->subsections.unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
669 }
670
671 /* Tell assembler to switch to unlikely-to-be-executed text section. */
672
673 section *
674 unlikely_text_section (void)
675 {
676 if (cfun)
677 {
678 if (!crtl->subsections.unlikely_text_section_name)
679 initialize_cold_section_name ();
680
681 return get_named_section (NULL, crtl->subsections.unlikely_text_section_name, 0);
682 }
683 else
684 return get_named_section (NULL, UNLIKELY_EXECUTED_TEXT_SECTION_NAME, 0);
685 }
686
687 /* When called within a function context, return true if the function
688 has been assigned a cold text section and if SECT is that section.
689 When called outside a function context, return true if SECT is the
690 default cold section. */
691
692 bool
693 unlikely_text_section_p (section *sect)
694 {
695 const char *name;
696
697 if (cfun)
698 name = crtl->subsections.unlikely_text_section_name;
699 else
700 name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
701
702 return (name
703 && sect
704 && SECTION_STYLE (sect) == SECTION_NAMED
705 && strcmp (name, sect->named.name) == 0);
706 }
707
708 /* Return a section with a particular name and with whatever SECTION_*
709 flags section_type_flags deems appropriate. The name of the section
710 is taken from NAME if nonnull, otherwise it is taken from DECL's
711 DECL_SECTION_NAME. DECL is the decl associated with the section
712 (see the section comment for details) and RELOC is as for
713 section_type_flags. */
714
715 section *
716 get_named_section (tree decl, const char *name, int reloc)
717 {
718 unsigned int flags;
719
720 gcc_assert (!decl || DECL_P (decl));
721 if (name == NULL)
722 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
723
724 flags = targetm.section_type_flags (decl, name, reloc);
725
726 return get_section (name, flags, decl);
727 }
728
729 /* If required, set DECL_SECTION_NAME to a unique name. */
730
731 void
732 resolve_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED,
733 int flag_function_or_data_sections)
734 {
735 if (DECL_SECTION_NAME (decl) == NULL_TREE
736 && targetm.have_named_sections
737 && (flag_function_or_data_sections
738 || DECL_ONE_ONLY (decl)))
739 targetm.asm_out.unique_section (decl, reloc);
740 }
741
742 #ifdef BSS_SECTION_ASM_OP
743
744 #ifdef ASM_OUTPUT_BSS
745
746 /* Utility function for ASM_OUTPUT_BSS for targets to use if
747 they don't support alignments in .bss.
748 ??? It is believed that this function will work in most cases so such
749 support is localized here. */
750
751 static void
752 asm_output_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
753 const char *name,
754 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
755 unsigned HOST_WIDE_INT rounded)
756 {
757 gcc_assert (strcmp (XSTR (XEXP (DECL_RTL (decl), 0), 0), name) == 0);
758 targetm.asm_out.globalize_decl_name (file, decl);
759 switch_to_section (bss_section);
760 #ifdef ASM_DECLARE_OBJECT_NAME
761 last_assemble_variable_decl = decl;
762 ASM_DECLARE_OBJECT_NAME (file, name, decl);
763 #else
764 /* Standard thing is just output label for the object. */
765 ASM_OUTPUT_LABEL (file, name);
766 #endif /* ASM_DECLARE_OBJECT_NAME */
767 ASM_OUTPUT_SKIP (file, rounded ? rounded : 1);
768 }
769
770 #endif
771
772 #ifdef ASM_OUTPUT_ALIGNED_BSS
773
774 /* Utility function for targets to use in implementing
775 ASM_OUTPUT_ALIGNED_BSS.
776 ??? It is believed that this function will work in most cases so such
777 support is localized here. */
778
779 static void
780 asm_output_aligned_bss (FILE *file, tree decl ATTRIBUTE_UNUSED,
781 const char *name, unsigned HOST_WIDE_INT size,
782 int align)
783 {
784 switch_to_section (bss_section);
785 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
786 #ifdef ASM_DECLARE_OBJECT_NAME
787 last_assemble_variable_decl = decl;
788 ASM_DECLARE_OBJECT_NAME (file, name, decl);
789 #else
790 /* Standard thing is just output label for the object. */
791 ASM_OUTPUT_LABEL (file, name);
792 #endif /* ASM_DECLARE_OBJECT_NAME */
793 ASM_OUTPUT_SKIP (file, size ? size : 1);
794 }
795
796 #endif
797
798 #endif /* BSS_SECTION_ASM_OP */
799
800 #ifndef USE_SELECT_SECTION_FOR_FUNCTIONS
801 /* Return the hot section for function DECL. Return text_section for
802 null DECLs. */
803
804 static section *
805 hot_function_section (tree decl)
806 {
807 if (decl != NULL_TREE
808 && DECL_SECTION_NAME (decl) != NULL_TREE
809 && targetm.have_named_sections)
810 return get_named_section (decl, NULL, 0);
811 else
812 return text_section;
813 }
814 #endif
815
816 /* Return the section for function DECL.
817
818 If DECL is NULL_TREE, return the text section. We can be passed
819 NULL_TREE under some circumstances by dbxout.c at least. */
820
821 section *
822 function_section (tree decl)
823 {
824 int reloc = 0;
825
826 if (first_function_block_is_cold)
827 reloc = 1;
828
829 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
830 if (decl != NULL_TREE
831 && DECL_SECTION_NAME (decl) != NULL_TREE)
832 return reloc ? unlikely_text_section ()
833 : get_named_section (decl, NULL, 0);
834 else
835 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
836 #else
837 return reloc ? unlikely_text_section () : hot_function_section (decl);
838 #endif
839 }
840
841 section *
842 current_function_section (void)
843 {
844 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
845 if (current_function_decl != NULL_TREE
846 && DECL_SECTION_NAME (current_function_decl) != NULL_TREE)
847 return in_cold_section_p ? unlikely_text_section ()
848 : get_named_section (current_function_decl,
849 NULL, 0);
850 else
851 return targetm.asm_out.select_section (current_function_decl,
852 in_cold_section_p,
853 DECL_ALIGN (current_function_decl));
854 #else
855 return (in_cold_section_p
856 ? unlikely_text_section ()
857 : hot_function_section (current_function_decl));
858 #endif
859 }
860
861 /* Return the read-only data section associated with function DECL. */
862
863 section *
864 default_function_rodata_section (tree decl)
865 {
866 if (decl != NULL_TREE && DECL_SECTION_NAME (decl))
867 {
868 const char *name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
869
870 if (DECL_ONE_ONLY (decl) && HAVE_COMDAT_GROUP)
871 {
872 size_t len = strlen (name) + 3;
873 char* rname = (char *) alloca (len);
874
875 strcpy (rname, ".rodata");
876 strcat (rname, name + 5);
877 return get_section (rname, SECTION_LINKONCE, decl);
878 }
879 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
880 else if (DECL_ONE_ONLY (decl)
881 && strncmp (name, ".gnu.linkonce.t.", 16) == 0)
882 {
883 size_t len = strlen (name) + 1;
884 char *rname = (char *) alloca (len);
885
886 memcpy (rname, name, len);
887 rname[14] = 'r';
888 return get_section (rname, SECTION_LINKONCE, decl);
889 }
890 /* For .text.foo we want to use .rodata.foo. */
891 else if (flag_function_sections && flag_data_sections
892 && strncmp (name, ".text.", 6) == 0)
893 {
894 size_t len = strlen (name) + 1;
895 char *rname = (char *) alloca (len + 2);
896
897 memcpy (rname, ".rodata", 7);
898 memcpy (rname + 7, name + 5, len - 5);
899 return get_section (rname, 0, decl);
900 }
901 }
902
903 return readonly_data_section;
904 }
905
906 /* Return the read-only data section associated with function DECL
907 for targets where that section should be always the single
908 readonly data section. */
909
910 section *
911 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED)
912 {
913 return readonly_data_section;
914 }
915
916 /* Return the section to use for string merging. */
917
918 static section *
919 mergeable_string_section (tree decl ATTRIBUTE_UNUSED,
920 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
921 unsigned int flags ATTRIBUTE_UNUSED)
922 {
923 HOST_WIDE_INT len;
924
925 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
926 && TREE_CODE (decl) == STRING_CST
927 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
928 && align <= 256
929 && (len = int_size_in_bytes (TREE_TYPE (decl))) > 0
930 && TREE_STRING_LENGTH (decl) >= len)
931 {
932 enum machine_mode mode;
933 unsigned int modesize;
934 const char *str;
935 HOST_WIDE_INT i;
936 int j, unit;
937 char name[30];
938
939 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
940 modesize = GET_MODE_BITSIZE (mode);
941 if (modesize >= 8 && modesize <= 256
942 && (modesize & (modesize - 1)) == 0)
943 {
944 if (align < modesize)
945 align = modesize;
946
947 str = TREE_STRING_POINTER (decl);
948 unit = GET_MODE_SIZE (mode);
949
950 /* Check for embedded NUL characters. */
951 for (i = 0; i < len; i += unit)
952 {
953 for (j = 0; j < unit; j++)
954 if (str[i + j] != '\0')
955 break;
956 if (j == unit)
957 break;
958 }
959 if (i == len - unit)
960 {
961 sprintf (name, ".rodata.str%d.%d", modesize / 8,
962 (int) (align / 8));
963 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
964 return get_section (name, flags, NULL);
965 }
966 }
967 }
968
969 return readonly_data_section;
970 }
971
972 /* Return the section to use for constant merging. */
973
974 section *
975 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED,
976 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED,
977 unsigned int flags ATTRIBUTE_UNUSED)
978 {
979 unsigned int modesize = GET_MODE_BITSIZE (mode);
980
981 if (HAVE_GAS_SHF_MERGE && flag_merge_constants
982 && mode != VOIDmode
983 && mode != BLKmode
984 && modesize <= align
985 && align >= 8
986 && align <= 256
987 && (align & (align - 1)) == 0)
988 {
989 char name[24];
990
991 sprintf (name, ".rodata.cst%d", (int) (align / 8));
992 flags |= (align / 8) | SECTION_MERGE;
993 return get_section (name, flags, NULL);
994 }
995 return readonly_data_section;
996 }
997 \f
998 /* Given NAME, a putative register name, discard any customary prefixes. */
999
1000 static const char *
1001 strip_reg_name (const char *name)
1002 {
1003 #ifdef REGISTER_PREFIX
1004 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
1005 name += strlen (REGISTER_PREFIX);
1006 #endif
1007 if (name[0] == '%' || name[0] == '#')
1008 name++;
1009 return name;
1010 }
1011 \f
1012 /* The user has asked for a DECL to have a particular name. Set (or
1013 change) it in such a way that we don't prefix an underscore to
1014 it. */
1015 void
1016 set_user_assembler_name (tree decl, const char *name)
1017 {
1018 char *starred = (char *) alloca (strlen (name) + 2);
1019 starred[0] = '*';
1020 strcpy (starred + 1, name);
1021 change_decl_assembler_name (decl, get_identifier (starred));
1022 SET_DECL_RTL (decl, NULL_RTX);
1023 }
1024 \f
1025 /* Decode an `asm' spec for a declaration as a register name.
1026 Return the register number, or -1 if nothing specified,
1027 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
1028 or -3 if ASMSPEC is `cc' and is not recognized,
1029 or -4 if ASMSPEC is `memory' and is not recognized.
1030 Accept an exact spelling or a decimal number.
1031 Prefixes such as % are optional. */
1032
1033 int
1034 decode_reg_name (const char *asmspec)
1035 {
1036 if (asmspec != 0)
1037 {
1038 int i;
1039
1040 /* Get rid of confusing prefixes. */
1041 asmspec = strip_reg_name (asmspec);
1042
1043 /* Allow a decimal number as a "register name". */
1044 for (i = strlen (asmspec) - 1; i >= 0; i--)
1045 if (! ISDIGIT (asmspec[i]))
1046 break;
1047 if (asmspec[0] != 0 && i < 0)
1048 {
1049 i = atoi (asmspec);
1050 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
1051 return i;
1052 else
1053 return -2;
1054 }
1055
1056 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1057 if (reg_names[i][0]
1058 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
1059 return i;
1060
1061 #ifdef ADDITIONAL_REGISTER_NAMES
1062 {
1063 static const struct { const char *const name; const int number; } table[]
1064 = ADDITIONAL_REGISTER_NAMES;
1065
1066 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
1067 if (table[i].name[0]
1068 && ! strcmp (asmspec, table[i].name))
1069 return table[i].number;
1070 }
1071 #endif /* ADDITIONAL_REGISTER_NAMES */
1072
1073 if (!strcmp (asmspec, "memory"))
1074 return -4;
1075
1076 if (!strcmp (asmspec, "cc"))
1077 return -3;
1078
1079 return -2;
1080 }
1081
1082 return -1;
1083 }
1084 \f
1085 /* Return true if DECL's initializer is suitable for a BSS section. */
1086
1087 static bool
1088 bss_initializer_p (const_tree decl)
1089 {
1090 return (DECL_INITIAL (decl) == NULL
1091 || DECL_INITIAL (decl) == error_mark_node
1092 || (flag_zero_initialized_in_bss
1093 /* Leave constant zeroes in .rodata so they
1094 can be shared. */
1095 && !TREE_READONLY (decl)
1096 && initializer_zerop (DECL_INITIAL (decl))));
1097 }
1098
1099 /* Compute the alignment of variable specified by DECL.
1100 DONT_OUTPUT_DATA is from assemble_variable. */
1101
1102 void
1103 align_variable (tree decl, bool dont_output_data)
1104 {
1105 unsigned int align = DECL_ALIGN (decl);
1106
1107 /* In the case for initialing an array whose length isn't specified,
1108 where we have not yet been able to do the layout,
1109 figure out the proper alignment now. */
1110 if (dont_output_data && DECL_SIZE (decl) == 0
1111 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1112 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1113
1114 /* Some object file formats have a maximum alignment which they support.
1115 In particular, a.out format supports a maximum alignment of 4. */
1116 if (align > MAX_OFILE_ALIGNMENT)
1117 {
1118 warning (0, "alignment of %q+D is greater than maximum object "
1119 "file alignment. Using %d", decl,
1120 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1121 align = MAX_OFILE_ALIGNMENT;
1122 }
1123
1124 /* On some machines, it is good to increase alignment sometimes. */
1125 if (! DECL_USER_ALIGN (decl))
1126 {
1127 #ifdef DATA_ALIGNMENT
1128 unsigned int data_align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1129 /* Don't increase alignment too much for TLS variables - TLS space
1130 is too precious. */
1131 if (! DECL_THREAD_LOCAL_P (decl) || data_align <= BITS_PER_WORD)
1132 align = data_align;
1133 #endif
1134 #ifdef CONSTANT_ALIGNMENT
1135 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1136 {
1137 unsigned int const_align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl),
1138 align);
1139 /* Don't increase alignment too much for TLS variables - TLS space
1140 is too precious. */
1141 if (! DECL_THREAD_LOCAL_P (decl) || const_align <= BITS_PER_WORD)
1142 align = const_align;
1143 }
1144 #endif
1145 }
1146
1147 /* Reset the alignment in case we have made it tighter, so we can benefit
1148 from it in get_pointer_alignment. */
1149 DECL_ALIGN (decl) = align;
1150 }
1151
1152 /* Return the section into which the given VAR_DECL or CONST_DECL
1153 should be placed. PREFER_NOSWITCH_P is true if a noswitch
1154 section should be used wherever possible. */
1155
1156 static section *
1157 get_variable_section (tree decl, bool prefer_noswitch_p)
1158 {
1159 int reloc;
1160
1161 /* If the decl has been given an explicit section name, then it
1162 isn't common, and shouldn't be handled as such. */
1163 if (DECL_COMMON (decl) && DECL_SECTION_NAME (decl) == NULL)
1164 {
1165 if (DECL_THREAD_LOCAL_P (decl))
1166 return tls_comm_section;
1167 /* This cannot be common bss for an emulated TLS object without
1168 a register_common hook. */
1169 else if (DECL_TLS_MODEL (decl) == TLS_MODEL_EMULATED
1170 && !targetm.emutls.register_common)
1171 ;
1172 else if (TREE_PUBLIC (decl) && bss_initializer_p (decl))
1173 return comm_section;
1174 }
1175
1176 if (DECL_INITIAL (decl) == error_mark_node)
1177 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1178 else if (DECL_INITIAL (decl))
1179 reloc = compute_reloc_for_constant (DECL_INITIAL (decl));
1180 else
1181 reloc = 0;
1182
1183 resolve_unique_section (decl, reloc, flag_data_sections);
1184 if (IN_NAMED_SECTION (decl))
1185 return get_named_section (decl, NULL, reloc);
1186
1187 if (!DECL_THREAD_LOCAL_P (decl)
1188 && !(prefer_noswitch_p && targetm.have_switchable_bss_sections)
1189 && bss_initializer_p (decl))
1190 {
1191 if (!TREE_PUBLIC (decl))
1192 return lcomm_section;
1193 if (bss_noswitch_section)
1194 return bss_noswitch_section;
1195 }
1196
1197 return targetm.asm_out.select_section (decl, reloc, DECL_ALIGN (decl));
1198 }
1199
1200 /* Return the block into which object_block DECL should be placed. */
1201
1202 static struct object_block *
1203 get_block_for_decl (tree decl)
1204 {
1205 section *sect;
1206
1207 if (TREE_CODE (decl) == VAR_DECL)
1208 {
1209 /* The object must be defined in this translation unit. */
1210 if (DECL_EXTERNAL (decl))
1211 return NULL;
1212
1213 /* There's no point using object blocks for something that is
1214 isolated by definition. */
1215 if (DECL_ONE_ONLY (decl))
1216 return NULL;
1217 }
1218
1219 /* We can only calculate block offsets if the decl has a known
1220 constant size. */
1221 if (DECL_SIZE_UNIT (decl) == NULL)
1222 return NULL;
1223 if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
1224 return NULL;
1225
1226 /* Find out which section should contain DECL. We cannot put it into
1227 an object block if it requires a standalone definition. */
1228 if (TREE_CODE (decl) == VAR_DECL)
1229 align_variable (decl, 0);
1230 sect = get_variable_section (decl, true);
1231 if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
1232 return NULL;
1233
1234 return get_block_for_section (sect);
1235 }
1236
1237 /* Make sure block symbol SYMBOL is in block BLOCK. */
1238
1239 static void
1240 change_symbol_block (rtx symbol, struct object_block *block)
1241 {
1242 if (block != SYMBOL_REF_BLOCK (symbol))
1243 {
1244 gcc_assert (SYMBOL_REF_BLOCK_OFFSET (symbol) < 0);
1245 SYMBOL_REF_BLOCK (symbol) = block;
1246 }
1247 }
1248
1249 /* Return true if it is possible to put DECL in an object_block. */
1250
1251 static bool
1252 use_blocks_for_decl_p (tree decl)
1253 {
1254 /* Only data DECLs can be placed into object blocks. */
1255 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != CONST_DECL)
1256 return false;
1257
1258 /* Detect decls created by dw2_force_const_mem. Such decls are
1259 special because DECL_INITIAL doesn't specify the decl's true value.
1260 dw2_output_indirect_constants will instead call assemble_variable
1261 with dont_output_data set to 1 and then print the contents itself. */
1262 if (DECL_INITIAL (decl) == decl)
1263 return false;
1264
1265 /* If this decl is an alias, then we don't want to emit a definition. */
1266 if (lookup_attribute ("alias", DECL_ATTRIBUTES (decl)))
1267 return false;
1268
1269 return true;
1270 }
1271
1272 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
1273 have static storage duration. In other words, it should not be an
1274 automatic variable, including PARM_DECLs.
1275
1276 There is, however, one exception: this function handles variables
1277 explicitly placed in a particular register by the user.
1278
1279 This is never called for PARM_DECL nodes. */
1280
1281 void
1282 make_decl_rtl (tree decl)
1283 {
1284 const char *name = 0;
1285 int reg_number;
1286 rtx x;
1287
1288 /* Check that we are not being given an automatic variable. */
1289 gcc_assert (TREE_CODE (decl) != PARM_DECL
1290 && TREE_CODE (decl) != RESULT_DECL);
1291
1292 /* A weak alias has TREE_PUBLIC set but not the other bits. */
1293 gcc_assert (TREE_CODE (decl) != VAR_DECL
1294 || TREE_STATIC (decl)
1295 || TREE_PUBLIC (decl)
1296 || DECL_EXTERNAL (decl)
1297 || DECL_REGISTER (decl));
1298
1299 /* And that we were not given a type or a label. */
1300 gcc_assert (TREE_CODE (decl) != TYPE_DECL
1301 && TREE_CODE (decl) != LABEL_DECL);
1302
1303 /* For a duplicate declaration, we can be called twice on the
1304 same DECL node. Don't discard the RTL already made. */
1305 if (DECL_RTL_SET_P (decl))
1306 {
1307 /* If the old RTL had the wrong mode, fix the mode. */
1308 x = DECL_RTL (decl);
1309 if (GET_MODE (x) != DECL_MODE (decl))
1310 SET_DECL_RTL (decl, adjust_address_nv (x, DECL_MODE (decl), 0));
1311
1312 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1313 return;
1314
1315 /* ??? Another way to do this would be to maintain a hashed
1316 table of such critters. Instead of adding stuff to a DECL
1317 to give certain attributes to it, we could use an external
1318 hash map from DECL to set of attributes. */
1319
1320 /* Let the target reassign the RTL if it wants.
1321 This is necessary, for example, when one machine specific
1322 decl attribute overrides another. */
1323 targetm.encode_section_info (decl, DECL_RTL (decl), false);
1324
1325 /* If the symbol has a SYMBOL_REF_BLOCK field, update it based
1326 on the new decl information. */
1327 if (MEM_P (x)
1328 && GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1329 && SYMBOL_REF_HAS_BLOCK_INFO_P (XEXP (x, 0)))
1330 change_symbol_block (XEXP (x, 0), get_block_for_decl (decl));
1331
1332 /* Make this function static known to the mudflap runtime. */
1333 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1334 mudflap_enqueue_decl (decl);
1335
1336 return;
1337 }
1338
1339 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
1340
1341 if (name[0] != '*' && TREE_CODE (decl) != FUNCTION_DECL
1342 && DECL_REGISTER (decl))
1343 {
1344 error ("register name not specified for %q+D", decl);
1345 }
1346 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
1347 {
1348 const char *asmspec = name+1;
1349 reg_number = decode_reg_name (asmspec);
1350 /* First detect errors in declaring global registers. */
1351 if (reg_number == -1)
1352 error ("register name not specified for %q+D", decl);
1353 else if (reg_number < 0)
1354 error ("invalid register name for %q+D", decl);
1355 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
1356 error ("data type of %q+D isn%'t suitable for a register",
1357 decl);
1358 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
1359 error ("register specified for %q+D isn%'t suitable for data type",
1360 decl);
1361 /* Now handle properly declared static register variables. */
1362 else
1363 {
1364 int nregs;
1365
1366 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
1367 {
1368 DECL_INITIAL (decl) = 0;
1369 error ("global register variable has initial value");
1370 }
1371 if (TREE_THIS_VOLATILE (decl))
1372 warning (OPT_Wvolatile_register_var,
1373 "optimization may eliminate reads and/or "
1374 "writes to register variables");
1375
1376 /* If the user specified one of the eliminables registers here,
1377 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
1378 confused with that register and be eliminated. This usage is
1379 somewhat suspect... */
1380
1381 SET_DECL_RTL (decl, gen_rtx_raw_REG (DECL_MODE (decl), reg_number));
1382 ORIGINAL_REGNO (DECL_RTL (decl)) = reg_number;
1383 REG_USERVAR_P (DECL_RTL (decl)) = 1;
1384
1385 if (TREE_STATIC (decl))
1386 {
1387 /* Make this register global, so not usable for anything
1388 else. */
1389 #ifdef ASM_DECLARE_REGISTER_GLOBAL
1390 name = IDENTIFIER_POINTER (DECL_NAME (decl));
1391 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
1392 #endif
1393 nregs = hard_regno_nregs[reg_number][DECL_MODE (decl)];
1394 while (nregs > 0)
1395 globalize_reg (reg_number + --nregs);
1396 }
1397
1398 /* As a register variable, it has no section. */
1399 return;
1400 }
1401 }
1402 /* Now handle ordinary static variables and functions (in memory).
1403 Also handle vars declared register invalidly. */
1404 else if (name[0] == '*')
1405 {
1406 #ifdef REGISTER_PREFIX
1407 if (strlen (REGISTER_PREFIX) != 0)
1408 {
1409 reg_number = decode_reg_name (name);
1410 if (reg_number >= 0 || reg_number == -3)
1411 error ("register name given for non-register variable %q+D", decl);
1412 }
1413 #endif
1414 }
1415
1416 /* Specifying a section attribute on a variable forces it into a
1417 non-.bss section, and thus it cannot be common. */
1418 if (TREE_CODE (decl) == VAR_DECL
1419 && DECL_SECTION_NAME (decl) != NULL_TREE
1420 && DECL_INITIAL (decl) == NULL_TREE
1421 && DECL_COMMON (decl))
1422 DECL_COMMON (decl) = 0;
1423
1424 /* Variables can't be both common and weak. */
1425 if (TREE_CODE (decl) == VAR_DECL && DECL_WEAK (decl))
1426 DECL_COMMON (decl) = 0;
1427
1428 if (use_object_blocks_p () && use_blocks_for_decl_p (decl))
1429 x = create_block_symbol (name, get_block_for_decl (decl), -1);
1430 else
1431 x = gen_rtx_SYMBOL_REF (Pmode, name);
1432 SYMBOL_REF_WEAK (x) = DECL_WEAK (decl);
1433 SET_SYMBOL_REF_DECL (x, decl);
1434
1435 x = gen_rtx_MEM (DECL_MODE (decl), x);
1436 if (TREE_CODE (decl) != FUNCTION_DECL)
1437 set_mem_attributes (x, decl, 1);
1438 SET_DECL_RTL (decl, x);
1439
1440 /* Optionally set flags or add text to the name to record information
1441 such as that it is a function name.
1442 If the name is changed, the macro ASM_OUTPUT_LABELREF
1443 will have to know how to strip this information. */
1444 targetm.encode_section_info (decl, DECL_RTL (decl), true);
1445
1446 /* Make this function static known to the mudflap runtime. */
1447 if (flag_mudflap && TREE_CODE (decl) == VAR_DECL)
1448 mudflap_enqueue_decl (decl);
1449 }
1450 \f
1451 /* Output a string of literal assembler code
1452 for an `asm' keyword used between functions. */
1453
1454 void
1455 assemble_asm (tree string)
1456 {
1457 app_enable ();
1458
1459 if (TREE_CODE (string) == ADDR_EXPR)
1460 string = TREE_OPERAND (string, 0);
1461
1462 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1463 }
1464
1465 /* Record an element in the table of global destructors. SYMBOL is
1466 a SYMBOL_REF of the function to be called; PRIORITY is a number
1467 between 0 and MAX_INIT_PRIORITY. */
1468
1469 void
1470 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED,
1471 int priority ATTRIBUTE_UNUSED)
1472 {
1473 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1474 /* Tell GNU LD that this is part of the static destructor set.
1475 This will work for any system that uses stabs, most usefully
1476 aout systems. */
1477 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1478 dbxout_stab_value_label (XSTR (symbol, 0));
1479 #else
1480 sorry ("global destructors not supported on this target");
1481 #endif
1482 }
1483
1484 /* Write the address of the entity given by SYMBOL to SEC. */
1485 void
1486 assemble_addr_to_section (rtx symbol, section *sec)
1487 {
1488 switch_to_section (sec);
1489 assemble_align (POINTER_SIZE);
1490 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1491 }
1492
1493 /* Return the numbered .ctors.N (if CONSTRUCTOR_P) or .dtors.N (if
1494 not) section for PRIORITY. */
1495 section *
1496 get_cdtor_priority_section (int priority, bool constructor_p)
1497 {
1498 char buf[16];
1499
1500 /* ??? This only works reliably with the GNU linker. */
1501 sprintf (buf, "%s.%.5u",
1502 constructor_p ? ".ctors" : ".dtors",
1503 /* Invert the numbering so the linker puts us in the proper
1504 order; constructors are run from right to left, and the
1505 linker sorts in increasing order. */
1506 MAX_INIT_PRIORITY - priority);
1507 return get_section (buf, SECTION_WRITE, NULL);
1508 }
1509
1510 void
1511 default_named_section_asm_out_destructor (rtx symbol, int priority)
1512 {
1513 section *sec;
1514
1515 if (priority != DEFAULT_INIT_PRIORITY)
1516 sec = get_cdtor_priority_section (priority,
1517 /*constructor_p=*/false);
1518 else
1519 sec = get_section (".dtors", SECTION_WRITE, NULL);
1520
1521 assemble_addr_to_section (symbol, sec);
1522 }
1523
1524 #ifdef DTORS_SECTION_ASM_OP
1525 void
1526 default_dtor_section_asm_out_destructor (rtx symbol,
1527 int priority ATTRIBUTE_UNUSED)
1528 {
1529 assemble_addr_to_section (symbol, dtors_section);
1530 }
1531 #endif
1532
1533 /* Likewise for global constructors. */
1534
1535 void
1536 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED,
1537 int priority ATTRIBUTE_UNUSED)
1538 {
1539 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1540 /* Tell GNU LD that this is part of the static destructor set.
1541 This will work for any system that uses stabs, most usefully
1542 aout systems. */
1543 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1544 dbxout_stab_value_label (XSTR (symbol, 0));
1545 #else
1546 sorry ("global constructors not supported on this target");
1547 #endif
1548 }
1549
1550 void
1551 default_named_section_asm_out_constructor (rtx symbol, int priority)
1552 {
1553 section *sec;
1554
1555 if (priority != DEFAULT_INIT_PRIORITY)
1556 sec = get_cdtor_priority_section (priority,
1557 /*constructor_p=*/true);
1558 else
1559 sec = get_section (".ctors", SECTION_WRITE, NULL);
1560
1561 assemble_addr_to_section (symbol, sec);
1562 }
1563
1564 #ifdef CTORS_SECTION_ASM_OP
1565 void
1566 default_ctor_section_asm_out_constructor (rtx symbol,
1567 int priority ATTRIBUTE_UNUSED)
1568 {
1569 assemble_addr_to_section (symbol, ctors_section);
1570 }
1571 #endif
1572 \f
1573 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1574 a nonzero value if the constant pool should be output before the
1575 start of the function, or a zero value if the pool should output
1576 after the end of the function. The default is to put it before the
1577 start. */
1578
1579 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1580 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1581 #endif
1582
1583 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1584 to be output to assembler.
1585 Set first_global_object_name and weak_global_object_name as appropriate. */
1586
1587 void
1588 notice_global_symbol (tree decl)
1589 {
1590 const char **type = &first_global_object_name;
1591
1592 if (first_global_object_name
1593 || !TREE_PUBLIC (decl)
1594 || DECL_EXTERNAL (decl)
1595 || !DECL_NAME (decl)
1596 || (TREE_CODE (decl) != FUNCTION_DECL
1597 && (TREE_CODE (decl) != VAR_DECL
1598 || (DECL_COMMON (decl)
1599 && (DECL_INITIAL (decl) == 0
1600 || DECL_INITIAL (decl) == error_mark_node))))
1601 || !MEM_P (DECL_RTL (decl)))
1602 return;
1603
1604 /* We win when global object is found, but it is useful to know about weak
1605 symbol as well so we can produce nicer unique names. */
1606 if (DECL_WEAK (decl) || DECL_ONE_ONLY (decl) || flag_shlib)
1607 type = &weak_global_object_name;
1608
1609 if (!*type)
1610 {
1611 const char *p;
1612 const char *name;
1613 rtx decl_rtl = DECL_RTL (decl);
1614
1615 p = targetm.strip_name_encoding (XSTR (XEXP (decl_rtl, 0), 0));
1616 name = ggc_strdup (p);
1617
1618 *type = name;
1619 }
1620 }
1621
1622 /* Output assembler code for the constant pool of a function and associated
1623 with defining the name of the function. DECL describes the function.
1624 NAME is the function's name. For the constant pool, we use the current
1625 constant pool data. */
1626
1627 void
1628 assemble_start_function (tree decl, const char *fnname)
1629 {
1630 int align;
1631 char tmp_label[100];
1632 bool hot_label_written = false;
1633
1634 crtl->subsections.unlikely_text_section_name = NULL;
1635
1636 first_function_block_is_cold = false;
1637 if (flag_reorder_blocks_and_partition)
1638 {
1639 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTB", const_labelno);
1640 crtl->subsections.hot_section_label = ggc_strdup (tmp_label);
1641 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDB", const_labelno);
1642 crtl->subsections.cold_section_label = ggc_strdup (tmp_label);
1643 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LHOTE", const_labelno);
1644 crtl->subsections.hot_section_end_label = ggc_strdup (tmp_label);
1645 ASM_GENERATE_INTERNAL_LABEL (tmp_label, "LCOLDE", const_labelno);
1646 crtl->subsections.cold_section_end_label = ggc_strdup (tmp_label);
1647 const_labelno++;
1648 }
1649 else
1650 {
1651 crtl->subsections.hot_section_label = NULL;
1652 crtl->subsections.cold_section_label = NULL;
1653 crtl->subsections.hot_section_end_label = NULL;
1654 crtl->subsections.cold_section_end_label = NULL;
1655 }
1656
1657 /* The following code does not need preprocessing in the assembler. */
1658
1659 app_disable ();
1660
1661 if (CONSTANT_POOL_BEFORE_FUNCTION)
1662 output_constant_pool (fnname, decl);
1663
1664 resolve_unique_section (decl, 0, flag_function_sections);
1665
1666 /* Make sure the not and cold text (code) sections are properly
1667 aligned. This is necessary here in the case where the function
1668 has both hot and cold sections, because we don't want to re-set
1669 the alignment when the section switch happens mid-function. */
1670
1671 if (flag_reorder_blocks_and_partition)
1672 {
1673 switch_to_section (unlikely_text_section ());
1674 assemble_align (DECL_ALIGN (decl));
1675 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_label);
1676
1677 /* When the function starts with a cold section, we need to explicitly
1678 align the hot section and write out the hot section label.
1679 But if the current function is a thunk, we do not have a CFG. */
1680 if (!crtl->is_thunk
1681 && BB_PARTITION (ENTRY_BLOCK_PTR->next_bb) == BB_COLD_PARTITION)
1682 {
1683 switch_to_section (text_section);
1684 assemble_align (DECL_ALIGN (decl));
1685 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1686 hot_label_written = true;
1687 first_function_block_is_cold = true;
1688 }
1689 }
1690 else if (DECL_SECTION_NAME (decl))
1691 {
1692 /* Calls to function_section rely on first_function_block_is_cold
1693 being accurate. The first block may be cold even if we aren't
1694 doing partitioning, if the entire function was decided by
1695 choose_function_section (predict.c) to be cold. */
1696
1697 initialize_cold_section_name ();
1698
1699 if (crtl->subsections.unlikely_text_section_name
1700 && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
1701 crtl->subsections.unlikely_text_section_name) == 0)
1702 first_function_block_is_cold = true;
1703 }
1704
1705 in_cold_section_p = first_function_block_is_cold;
1706
1707 /* Switch to the correct text section for the start of the function. */
1708
1709 switch_to_section (function_section (decl));
1710 if (flag_reorder_blocks_and_partition
1711 && !hot_label_written)
1712 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_label);
1713
1714 /* Tell assembler to move to target machine's alignment for functions. */
1715 align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT);
1716 if (align > 0)
1717 {
1718 ASM_OUTPUT_ALIGN (asm_out_file, align);
1719 }
1720
1721 /* Handle a user-specified function alignment.
1722 Note that we still need to align to DECL_ALIGN, as above,
1723 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1724 if (! DECL_USER_ALIGN (decl)
1725 && align_functions_log > align
1726 && optimize_function_for_speed_p (cfun))
1727 {
1728 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1729 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1730 align_functions_log, align_functions - 1);
1731 #else
1732 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1733 #endif
1734 }
1735
1736 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1737 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1738 #endif
1739
1740 (*debug_hooks->begin_function) (decl);
1741
1742 /* Make function name accessible from other files, if appropriate. */
1743
1744 if (TREE_PUBLIC (decl))
1745 {
1746 notice_global_symbol (decl);
1747
1748 globalize_decl (decl);
1749
1750 maybe_assemble_visibility (decl);
1751 }
1752
1753 if (DECL_PRESERVE_P (decl))
1754 targetm.asm_out.mark_decl_preserved (fnname);
1755
1756 /* Do any machine/system dependent processing of the function name. */
1757 #ifdef ASM_DECLARE_FUNCTION_NAME
1758 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1759 #else
1760 /* Standard thing is just output label for the function. */
1761 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1762 #endif /* ASM_DECLARE_FUNCTION_NAME */
1763 }
1764
1765 /* Output assembler code associated with defining the size of the
1766 function. DECL describes the function. NAME is the function's name. */
1767
1768 void
1769 assemble_end_function (tree decl, const char *fnname ATTRIBUTE_UNUSED)
1770 {
1771 #ifdef ASM_DECLARE_FUNCTION_SIZE
1772 /* We could have switched section in the middle of the function. */
1773 if (flag_reorder_blocks_and_partition)
1774 switch_to_section (function_section (decl));
1775 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1776 #endif
1777 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1778 {
1779 output_constant_pool (fnname, decl);
1780 switch_to_section (function_section (decl)); /* need to switch back */
1781 }
1782 /* Output labels for end of hot/cold text sections (to be used by
1783 debug info.) */
1784 if (flag_reorder_blocks_and_partition)
1785 {
1786 section *save_text_section;
1787
1788 save_text_section = in_section;
1789 switch_to_section (unlikely_text_section ());
1790 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.cold_section_end_label);
1791 if (first_function_block_is_cold)
1792 switch_to_section (text_section);
1793 else
1794 switch_to_section (function_section (decl));
1795 ASM_OUTPUT_LABEL (asm_out_file, crtl->subsections.hot_section_end_label);
1796 switch_to_section (save_text_section);
1797 }
1798 }
1799 \f
1800 /* Assemble code to leave SIZE bytes of zeros. */
1801
1802 void
1803 assemble_zeros (unsigned HOST_WIDE_INT size)
1804 {
1805 /* Do no output if -fsyntax-only. */
1806 if (flag_syntax_only)
1807 return;
1808
1809 #ifdef ASM_NO_SKIP_IN_TEXT
1810 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1811 so we must output 0s explicitly in the text section. */
1812 if (ASM_NO_SKIP_IN_TEXT && (in_section->common.flags & SECTION_CODE) != 0)
1813 {
1814 unsigned HOST_WIDE_INT i;
1815 for (i = 0; i < size; i++)
1816 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1817 }
1818 else
1819 #endif
1820 if (size > 0)
1821 ASM_OUTPUT_SKIP (asm_out_file, size);
1822 }
1823
1824 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1825
1826 void
1827 assemble_align (int align)
1828 {
1829 if (align > BITS_PER_UNIT)
1830 {
1831 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1832 }
1833 }
1834
1835 /* Assemble a string constant with the specified C string as contents. */
1836
1837 void
1838 assemble_string (const char *p, int size)
1839 {
1840 int pos = 0;
1841 int maximum = 2000;
1842
1843 /* If the string is very long, split it up. */
1844
1845 while (pos < size)
1846 {
1847 int thissize = size - pos;
1848 if (thissize > maximum)
1849 thissize = maximum;
1850
1851 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1852
1853 pos += thissize;
1854 p += thissize;
1855 }
1856 }
1857
1858 \f
1859 /* A noswitch_section_callback for lcomm_section. */
1860
1861 static bool
1862 emit_local (tree decl ATTRIBUTE_UNUSED,
1863 const char *name ATTRIBUTE_UNUSED,
1864 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1865 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1866 {
1867 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1868 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name,
1869 size, DECL_ALIGN (decl));
1870 return true;
1871 #elif defined ASM_OUTPUT_ALIGNED_LOCAL
1872 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl));
1873 return true;
1874 #else
1875 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1876 return false;
1877 #endif
1878 }
1879
1880 /* A noswitch_section_callback for bss_noswitch_section. */
1881
1882 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
1883 static bool
1884 emit_bss (tree decl ATTRIBUTE_UNUSED,
1885 const char *name ATTRIBUTE_UNUSED,
1886 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1887 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1888 {
1889 #if defined ASM_OUTPUT_ALIGNED_BSS
1890 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl));
1891 return true;
1892 #else
1893 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1894 return false;
1895 #endif
1896 }
1897 #endif
1898
1899 /* A noswitch_section_callback for comm_section. */
1900
1901 static bool
1902 emit_common (tree decl ATTRIBUTE_UNUSED,
1903 const char *name ATTRIBUTE_UNUSED,
1904 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1905 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1906 {
1907 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1908 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name,
1909 size, DECL_ALIGN (decl));
1910 return true;
1911 #elif defined ASM_OUTPUT_ALIGNED_COMMON
1912 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl));
1913 return true;
1914 #else
1915 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1916 return false;
1917 #endif
1918 }
1919
1920 /* A noswitch_section_callback for tls_comm_section. */
1921
1922 static bool
1923 emit_tls_common (tree decl ATTRIBUTE_UNUSED,
1924 const char *name ATTRIBUTE_UNUSED,
1925 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED,
1926 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED)
1927 {
1928 #ifdef ASM_OUTPUT_TLS_COMMON
1929 ASM_OUTPUT_TLS_COMMON (asm_out_file, decl, name, size);
1930 return true;
1931 #else
1932 sorry ("thread-local COMMON data not implemented");
1933 return true;
1934 #endif
1935 }
1936
1937 /* Assemble DECL given that it belongs in SECTION_NOSWITCH section SECT.
1938 NAME is the name of DECL's SYMBOL_REF. */
1939
1940 static void
1941 assemble_noswitch_variable (tree decl, const char *name, section *sect)
1942 {
1943 unsigned HOST_WIDE_INT size, rounded;
1944
1945 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1946 rounded = size;
1947
1948 /* Don't allocate zero bytes of common,
1949 since that means "undefined external" in the linker. */
1950 if (size == 0)
1951 rounded = 1;
1952
1953 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1954 so that each uninitialized object starts on such a boundary. */
1955 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1956 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1957 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1958
1959 if (!sect->noswitch.callback (decl, name, size, rounded)
1960 && (unsigned HOST_WIDE_INT) DECL_ALIGN_UNIT (decl) > rounded)
1961 warning (0, "requested alignment for %q+D is greater than "
1962 "implemented alignment of %wu", decl, rounded);
1963 }
1964
1965 /* A subroutine of assemble_variable. Output the label and contents of
1966 DECL, whose address is a SYMBOL_REF with name NAME. DONT_OUTPUT_DATA
1967 is as for assemble_variable. */
1968
1969 static void
1970 assemble_variable_contents (tree decl, const char *name,
1971 bool dont_output_data)
1972 {
1973 /* Do any machine/system dependent processing of the object. */
1974 #ifdef ASM_DECLARE_OBJECT_NAME
1975 last_assemble_variable_decl = decl;
1976 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1977 #else
1978 /* Standard thing is just output label for the object. */
1979 ASM_OUTPUT_LABEL (asm_out_file, name);
1980 #endif /* ASM_DECLARE_OBJECT_NAME */
1981
1982 if (!dont_output_data)
1983 {
1984 if (DECL_INITIAL (decl)
1985 && DECL_INITIAL (decl) != error_mark_node
1986 && !initializer_zerop (DECL_INITIAL (decl)))
1987 /* Output the actual data. */
1988 output_constant (DECL_INITIAL (decl),
1989 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1990 DECL_ALIGN (decl));
1991 else
1992 /* Leave space for it. */
1993 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1994 }
1995 }
1996
1997 /* Initialize emulated tls object TO, which refers to TLS variable
1998 DECL and is initialized by PROXY. */
1999
2000 tree
2001 default_emutls_var_init (tree to, tree decl, tree proxy)
2002 {
2003 VEC(constructor_elt,gc) *v = VEC_alloc (constructor_elt, gc, 4);
2004 constructor_elt *elt;
2005 tree type = TREE_TYPE (to);
2006 tree field = TYPE_FIELDS (type);
2007
2008 elt = VEC_quick_push (constructor_elt, v, NULL);
2009 elt->index = field;
2010 elt->value = fold_convert (TREE_TYPE (field), DECL_SIZE_UNIT (decl));
2011
2012 elt = VEC_quick_push (constructor_elt, v, NULL);
2013 field = TREE_CHAIN (field);
2014 elt->index = field;
2015 elt->value = build_int_cst (TREE_TYPE (field),
2016 DECL_ALIGN_UNIT (decl));
2017
2018 elt = VEC_quick_push (constructor_elt, v, NULL);
2019 field = TREE_CHAIN (field);
2020 elt->index = field;
2021 elt->value = null_pointer_node;
2022
2023 elt = VEC_quick_push (constructor_elt, v, NULL);
2024 field = TREE_CHAIN (field);
2025 elt->index = field;
2026 elt->value = proxy;
2027
2028 return build_constructor (type, v);
2029 }
2030
2031 /* Assemble everything that is needed for a variable or function declaration.
2032 Not used for automatic variables, and not used for function definitions.
2033 Should not be called for variables of incomplete structure type.
2034
2035 TOP_LEVEL is nonzero if this variable has file scope.
2036 AT_END is nonzero if this is the special handling, at end of compilation,
2037 to define things that have had only tentative definitions.
2038 DONT_OUTPUT_DATA if nonzero means don't actually output the
2039 initial value (that will be done by the caller). */
2040
2041 void
2042 assemble_variable (tree decl, int top_level ATTRIBUTE_UNUSED,
2043 int at_end ATTRIBUTE_UNUSED, int dont_output_data)
2044 {
2045 const char *name;
2046 rtx decl_rtl, symbol;
2047 section *sect;
2048
2049 if (! targetm.have_tls
2050 && TREE_CODE (decl) == VAR_DECL
2051 && DECL_THREAD_LOCAL_P (decl))
2052 {
2053 tree to = emutls_decl (decl);
2054
2055 /* If this variable is defined locally, then we need to initialize the
2056 control structure with size and alignment information. We do this
2057 at the last moment because tentative definitions can take a locally
2058 defined but uninitialized variable and initialize it later, which
2059 would result in incorrect contents. */
2060 if (! DECL_EXTERNAL (to)
2061 && (! DECL_COMMON (to)
2062 || (DECL_INITIAL (decl)
2063 && DECL_INITIAL (decl) != error_mark_node)))
2064 {
2065 DECL_INITIAL (to) = targetm.emutls.var_init
2066 (to, decl, get_emutls_init_templ_addr (decl));
2067
2068 /* Make sure the template is marked as needed early enough.
2069 Without this, if the variable is placed in a
2070 section-anchored block, the template will only be marked
2071 when it's too late. */
2072 record_references_in_initializer (to);
2073 }
2074
2075 decl = to;
2076 }
2077
2078 last_assemble_variable_decl = 0;
2079
2080 /* Normally no need to say anything here for external references,
2081 since assemble_external is called by the language-specific code
2082 when a declaration is first seen. */
2083
2084 if (DECL_EXTERNAL (decl))
2085 return;
2086
2087 /* Output no assembler code for a function declaration.
2088 Only definitions of functions output anything. */
2089
2090 if (TREE_CODE (decl) == FUNCTION_DECL)
2091 return;
2092
2093 /* Do nothing for global register variables. */
2094 if (DECL_RTL_SET_P (decl) && REG_P (DECL_RTL (decl)))
2095 {
2096 TREE_ASM_WRITTEN (decl) = 1;
2097 return;
2098 }
2099
2100 /* If type was incomplete when the variable was declared,
2101 see if it is complete now. */
2102
2103 if (DECL_SIZE (decl) == 0)
2104 layout_decl (decl, 0);
2105
2106 /* Still incomplete => don't allocate it; treat the tentative defn
2107 (which is what it must have been) as an `extern' reference. */
2108
2109 if (!dont_output_data && DECL_SIZE (decl) == 0)
2110 {
2111 error ("storage size of %q+D isn%'t known", decl);
2112 TREE_ASM_WRITTEN (decl) = 1;
2113 return;
2114 }
2115
2116 /* The first declaration of a variable that comes through this function
2117 decides whether it is global (in C, has external linkage)
2118 or local (in C, has internal linkage). So do nothing more
2119 if this function has already run. */
2120
2121 if (TREE_ASM_WRITTEN (decl))
2122 return;
2123
2124 /* Make sure targetm.encode_section_info is invoked before we set
2125 ASM_WRITTEN. */
2126 decl_rtl = DECL_RTL (decl);
2127
2128 TREE_ASM_WRITTEN (decl) = 1;
2129
2130 /* Do no output if -fsyntax-only. */
2131 if (flag_syntax_only)
2132 return;
2133
2134 app_disable ();
2135
2136 if (! dont_output_data
2137 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
2138 {
2139 error ("size of variable %q+D is too large", decl);
2140 return;
2141 }
2142
2143 gcc_assert (MEM_P (decl_rtl));
2144 gcc_assert (GET_CODE (XEXP (decl_rtl, 0)) == SYMBOL_REF);
2145 symbol = XEXP (decl_rtl, 0);
2146 name = XSTR (symbol, 0);
2147 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
2148 notice_global_symbol (decl);
2149
2150 /* Compute the alignment of this data. */
2151
2152 align_variable (decl, dont_output_data);
2153 set_mem_align (decl_rtl, DECL_ALIGN (decl));
2154
2155 if (TREE_PUBLIC (decl))
2156 maybe_assemble_visibility (decl);
2157
2158 if (DECL_PRESERVE_P (decl))
2159 targetm.asm_out.mark_decl_preserved (name);
2160
2161 /* First make the assembler name(s) global if appropriate. */
2162 sect = get_variable_section (decl, false);
2163 if (TREE_PUBLIC (decl)
2164 && DECL_NAME (decl)
2165 && (sect->common.flags & SECTION_COMMON) == 0)
2166 globalize_decl (decl);
2167
2168 /* Output any data that we will need to use the address of. */
2169 if (DECL_INITIAL (decl) && DECL_INITIAL (decl) != error_mark_node)
2170 output_addressed_constants (DECL_INITIAL (decl));
2171
2172 /* dbxout.c needs to know this. */
2173 if (sect && (sect->common.flags & SECTION_CODE) != 0)
2174 DECL_IN_TEXT_SECTION (decl) = 1;
2175
2176 /* If the decl is part of an object_block, make sure that the decl
2177 has been positioned within its block, but do not write out its
2178 definition yet. output_object_blocks will do that later. */
2179 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
2180 {
2181 gcc_assert (!dont_output_data);
2182 place_block_symbol (symbol);
2183 }
2184 else if (SECTION_STYLE (sect) == SECTION_NOSWITCH)
2185 assemble_noswitch_variable (decl, name, sect);
2186 else
2187 {
2188 switch_to_section (sect);
2189 if (DECL_ALIGN (decl) > BITS_PER_UNIT)
2190 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (DECL_ALIGN_UNIT (decl)));
2191 assemble_variable_contents (decl, name, dont_output_data);
2192 }
2193 }
2194
2195 /* Return 1 if type TYPE contains any pointers. */
2196
2197 static int
2198 contains_pointers_p (tree type)
2199 {
2200 switch (TREE_CODE (type))
2201 {
2202 case POINTER_TYPE:
2203 case REFERENCE_TYPE:
2204 /* I'm not sure whether OFFSET_TYPE needs this treatment,
2205 so I'll play safe and return 1. */
2206 case OFFSET_TYPE:
2207 return 1;
2208
2209 case RECORD_TYPE:
2210 case UNION_TYPE:
2211 case QUAL_UNION_TYPE:
2212 {
2213 tree fields;
2214 /* For a type that has fields, see if the fields have pointers. */
2215 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
2216 if (TREE_CODE (fields) == FIELD_DECL
2217 && contains_pointers_p (TREE_TYPE (fields)))
2218 return 1;
2219 return 0;
2220 }
2221
2222 case ARRAY_TYPE:
2223 /* An array type contains pointers if its element type does. */
2224 return contains_pointers_p (TREE_TYPE (type));
2225
2226 default:
2227 return 0;
2228 }
2229 }
2230
2231 /* We delay assemble_external processing until
2232 the compilation unit is finalized. This is the best we can do for
2233 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
2234 it all the way to final. See PR 17982 for further discussion. */
2235 static GTY(()) tree pending_assemble_externals;
2236
2237 #ifdef ASM_OUTPUT_EXTERNAL
2238 /* True if DECL is a function decl for which no out-of-line copy exists.
2239 It is assumed that DECL's assembler name has been set. */
2240
2241 static bool
2242 incorporeal_function_p (tree decl)
2243 {
2244 if (TREE_CODE (decl) == FUNCTION_DECL && DECL_BUILT_IN (decl))
2245 {
2246 const char *name;
2247
2248 if (DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
2249 && DECL_FUNCTION_CODE (decl) == BUILT_IN_ALLOCA)
2250 return true;
2251
2252 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
2253 if (strncmp (name, "__builtin_", strlen ("__builtin_")) == 0)
2254 return true;
2255 }
2256 return false;
2257 }
2258
2259 /* Actually do the tests to determine if this is necessary, and invoke
2260 ASM_OUTPUT_EXTERNAL. */
2261 static void
2262 assemble_external_real (tree decl)
2263 {
2264 rtx rtl = DECL_RTL (decl);
2265
2266 if (MEM_P (rtl) && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
2267 && !SYMBOL_REF_USED (XEXP (rtl, 0))
2268 && !incorporeal_function_p (decl))
2269 {
2270 /* Some systems do require some output. */
2271 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
2272 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
2273 }
2274 }
2275 #endif
2276
2277 void
2278 process_pending_assemble_externals (void)
2279 {
2280 #ifdef ASM_OUTPUT_EXTERNAL
2281 tree list;
2282 for (list = pending_assemble_externals; list; list = TREE_CHAIN (list))
2283 assemble_external_real (TREE_VALUE (list));
2284
2285 pending_assemble_externals = 0;
2286 #endif
2287 }
2288
2289 /* This TREE_LIST contains any weak symbol declarations waiting
2290 to be emitted. */
2291 static GTY(()) tree weak_decls;
2292
2293 /* Output something to declare an external symbol to the assembler.
2294 (Most assemblers don't need this, so we normally output nothing.)
2295 Do nothing if DECL is not external. */
2296
2297 void
2298 assemble_external (tree decl ATTRIBUTE_UNUSED)
2299 {
2300 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
2301 main body of this code is only rarely exercised. To provide some
2302 testing, on all platforms, we make sure that the ASM_OUT_FILE is
2303 open. If it's not, we should not be calling this function. */
2304 gcc_assert (asm_out_file);
2305
2306 #ifdef ASM_OUTPUT_EXTERNAL
2307 if (!DECL_P (decl) || !DECL_EXTERNAL (decl) || !TREE_PUBLIC (decl))
2308 return;
2309
2310 if (SUPPORTS_WEAK && DECL_WEAK (decl))
2311 weak_decls = tree_cons (NULL, decl, weak_decls);
2312
2313 /* We want to output external symbols at very last to check if they
2314 are references or not. */
2315 pending_assemble_externals = tree_cons (0, decl,
2316 pending_assemble_externals);
2317 #endif
2318 }
2319
2320 /* Similar, for calling a library function FUN. */
2321
2322 void
2323 assemble_external_libcall (rtx fun)
2324 {
2325 /* Declare library function name external when first used, if nec. */
2326 if (! SYMBOL_REF_USED (fun))
2327 {
2328 SYMBOL_REF_USED (fun) = 1;
2329 targetm.asm_out.external_libcall (fun);
2330 }
2331 }
2332
2333 /* Assemble a label named NAME. */
2334
2335 void
2336 assemble_label (const char *name)
2337 {
2338 ASM_OUTPUT_LABEL (asm_out_file, name);
2339 }
2340
2341 /* Set the symbol_referenced flag for ID. */
2342 void
2343 mark_referenced (tree id)
2344 {
2345 TREE_SYMBOL_REFERENCED (id) = 1;
2346 }
2347
2348 /* Set the symbol_referenced flag for DECL and notify callgraph. */
2349 void
2350 mark_decl_referenced (tree decl)
2351 {
2352 if (TREE_CODE (decl) == FUNCTION_DECL)
2353 {
2354 /* Extern inline functions don't become needed when referenced.
2355 If we know a method will be emitted in other TU and no new
2356 functions can be marked reachable, just use the external
2357 definition. */
2358 struct cgraph_node *node = cgraph_node (decl);
2359 if (!DECL_EXTERNAL (decl)
2360 && (!node->local.vtable_method || !cgraph_global_info_ready
2361 || !node->local.finalized))
2362 cgraph_mark_needed_node (node);
2363 }
2364 else if (TREE_CODE (decl) == VAR_DECL)
2365 {
2366 struct varpool_node *node = varpool_node (decl);
2367 varpool_mark_needed_node (node);
2368 /* C++ frontend use mark_decl_references to force COMDAT variables
2369 to be output that might appear dead otherwise. */
2370 node->force_output = true;
2371 }
2372 /* else do nothing - we can get various sorts of CST nodes here,
2373 which do not need to be marked. */
2374 }
2375
2376
2377 /* Follow the IDENTIFIER_TRANSPARENT_ALIAS chain starting at *ALIAS
2378 until we find an identifier that is not itself a transparent alias.
2379 Modify the alias passed to it by reference (and all aliases on the
2380 way to the ultimate target), such that they do not have to be
2381 followed again, and return the ultimate target of the alias
2382 chain. */
2383
2384 static inline tree
2385 ultimate_transparent_alias_target (tree *alias)
2386 {
2387 tree target = *alias;
2388
2389 if (IDENTIFIER_TRANSPARENT_ALIAS (target))
2390 {
2391 gcc_assert (TREE_CHAIN (target));
2392 target = ultimate_transparent_alias_target (&TREE_CHAIN (target));
2393 gcc_assert (! IDENTIFIER_TRANSPARENT_ALIAS (target)
2394 && ! TREE_CHAIN (target));
2395 *alias = target;
2396 }
2397
2398 return target;
2399 }
2400
2401 /* Output to FILE (an assembly file) a reference to NAME. If NAME
2402 starts with a *, the rest of NAME is output verbatim. Otherwise
2403 NAME is transformed in a target-specific way (usually by the
2404 addition of an underscore). */
2405
2406 void
2407 assemble_name_raw (FILE *file, const char *name)
2408 {
2409 if (name[0] == '*')
2410 fputs (&name[1], file);
2411 else
2412 ASM_OUTPUT_LABELREF (file, name);
2413 }
2414
2415 /* Like assemble_name_raw, but should be used when NAME might refer to
2416 an entity that is also represented as a tree (like a function or
2417 variable). If NAME does refer to such an entity, that entity will
2418 be marked as referenced. */
2419
2420 void
2421 assemble_name (FILE *file, const char *name)
2422 {
2423 const char *real_name;
2424 tree id;
2425
2426 real_name = targetm.strip_name_encoding (name);
2427
2428 id = maybe_get_identifier (real_name);
2429 if (id)
2430 {
2431 tree id_orig = id;
2432
2433 mark_referenced (id);
2434 ultimate_transparent_alias_target (&id);
2435 if (id != id_orig)
2436 name = IDENTIFIER_POINTER (id);
2437 gcc_assert (! TREE_CHAIN (id));
2438 }
2439
2440 assemble_name_raw (file, name);
2441 }
2442
2443 /* Allocate SIZE bytes writable static space with a gensym name
2444 and return an RTX to refer to its address. */
2445
2446 rtx
2447 assemble_static_space (unsigned HOST_WIDE_INT size)
2448 {
2449 char name[12];
2450 const char *namestring;
2451 rtx x;
2452
2453 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
2454 ++const_labelno;
2455 namestring = ggc_strdup (name);
2456
2457 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
2458 SYMBOL_REF_FLAGS (x) = SYMBOL_FLAG_LOCAL;
2459
2460 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2461 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
2462 BIGGEST_ALIGNMENT);
2463 #else
2464 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2465 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
2466 #else
2467 {
2468 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2469 so that each uninitialized object starts on such a boundary. */
2470 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2471 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2472 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
2473 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2474 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
2475 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
2476 }
2477 #endif
2478 #endif
2479 return x;
2480 }
2481
2482 /* Assemble the static constant template for function entry trampolines.
2483 This is done at most once per compilation.
2484 Returns an RTX for the address of the template. */
2485
2486 static GTY(()) rtx initial_trampoline;
2487
2488 #ifdef TRAMPOLINE_TEMPLATE
2489 rtx
2490 assemble_trampoline_template (void)
2491 {
2492 char label[256];
2493 const char *name;
2494 int align;
2495 rtx symbol;
2496
2497 if (initial_trampoline)
2498 return initial_trampoline;
2499
2500 /* By default, put trampoline templates in read-only data section. */
2501
2502 #ifdef TRAMPOLINE_SECTION
2503 switch_to_section (TRAMPOLINE_SECTION);
2504 #else
2505 switch_to_section (readonly_data_section);
2506 #endif
2507
2508 /* Write the assembler code to define one. */
2509 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
2510 if (align > 0)
2511 {
2512 ASM_OUTPUT_ALIGN (asm_out_file, align);
2513 }
2514
2515 targetm.asm_out.internal_label (asm_out_file, "LTRAMP", 0);
2516 TRAMPOLINE_TEMPLATE (asm_out_file);
2517
2518 /* Record the rtl to refer to it. */
2519 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
2520 name = ggc_strdup (label);
2521 symbol = gen_rtx_SYMBOL_REF (Pmode, name);
2522 SYMBOL_REF_FLAGS (symbol) = SYMBOL_FLAG_LOCAL;
2523
2524 initial_trampoline = gen_rtx_MEM (BLKmode, symbol);
2525 set_mem_align (initial_trampoline, TRAMPOLINE_ALIGNMENT);
2526
2527 return initial_trampoline;
2528 }
2529 #endif
2530 \f
2531 /* A and B are either alignments or offsets. Return the minimum alignment
2532 that may be assumed after adding the two together. */
2533
2534 static inline unsigned
2535 min_align (unsigned int a, unsigned int b)
2536 {
2537 return (a | b) & -(a | b);
2538 }
2539
2540 /* Return the assembler directive for creating a given kind of integer
2541 object. SIZE is the number of bytes in the object and ALIGNED_P
2542 indicates whether it is known to be aligned. Return NULL if the
2543 assembly dialect has no such directive.
2544
2545 The returned string should be printed at the start of a new line and
2546 be followed immediately by the object's initial value. */
2547
2548 const char *
2549 integer_asm_op (int size, int aligned_p)
2550 {
2551 struct asm_int_op *ops;
2552
2553 if (aligned_p)
2554 ops = &targetm.asm_out.aligned_op;
2555 else
2556 ops = &targetm.asm_out.unaligned_op;
2557
2558 switch (size)
2559 {
2560 case 1:
2561 return targetm.asm_out.byte_op;
2562 case 2:
2563 return ops->hi;
2564 case 4:
2565 return ops->si;
2566 case 8:
2567 return ops->di;
2568 case 16:
2569 return ops->ti;
2570 default:
2571 return NULL;
2572 }
2573 }
2574
2575 /* Use directive OP to assemble an integer object X. Print OP at the
2576 start of the line, followed immediately by the value of X. */
2577
2578 void
2579 assemble_integer_with_op (const char *op, rtx x)
2580 {
2581 fputs (op, asm_out_file);
2582 output_addr_const (asm_out_file, x);
2583 fputc ('\n', asm_out_file);
2584 }
2585
2586 /* The default implementation of the asm_out.integer target hook. */
2587
2588 bool
2589 default_assemble_integer (rtx x ATTRIBUTE_UNUSED,
2590 unsigned int size ATTRIBUTE_UNUSED,
2591 int aligned_p ATTRIBUTE_UNUSED)
2592 {
2593 const char *op = integer_asm_op (size, aligned_p);
2594 /* Avoid GAS bugs for large values. Specifically negative values whose
2595 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2596 if (size > UNITS_PER_WORD && size > POINTER_SIZE / BITS_PER_UNIT)
2597 return false;
2598 return op && (assemble_integer_with_op (op, x), true);
2599 }
2600
2601 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2602 the alignment of the integer in bits. Return 1 if we were able to output
2603 the constant, otherwise 0. We must be able to output the constant,
2604 if FORCE is nonzero. */
2605
2606 bool
2607 assemble_integer (rtx x, unsigned int size, unsigned int align, int force)
2608 {
2609 int aligned_p;
2610
2611 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2612
2613 /* See if the target hook can handle this kind of object. */
2614 if (targetm.asm_out.integer (x, size, aligned_p))
2615 return true;
2616
2617 /* If the object is a multi-byte one, try splitting it up. Split
2618 it into words it if is multi-word, otherwise split it into bytes. */
2619 if (size > 1)
2620 {
2621 enum machine_mode omode, imode;
2622 unsigned int subalign;
2623 unsigned int subsize, i;
2624 unsigned char mclass;
2625
2626 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2627 subalign = MIN (align, subsize * BITS_PER_UNIT);
2628 if (GET_CODE (x) == CONST_FIXED)
2629 mclass = GET_MODE_CLASS (GET_MODE (x));
2630 else
2631 mclass = MODE_INT;
2632
2633 omode = mode_for_size (subsize * BITS_PER_UNIT, mclass, 0);
2634 imode = mode_for_size (size * BITS_PER_UNIT, mclass, 0);
2635
2636 for (i = 0; i < size; i += subsize)
2637 {
2638 rtx partial = simplify_subreg (omode, x, imode, i);
2639 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2640 break;
2641 }
2642 if (i == size)
2643 return true;
2644
2645 /* If we've printed some of it, but not all of it, there's no going
2646 back now. */
2647 gcc_assert (!i);
2648 }
2649
2650 gcc_assert (!force);
2651
2652 return false;
2653 }
2654 \f
2655 void
2656 assemble_real (REAL_VALUE_TYPE d, enum machine_mode mode, unsigned int align)
2657 {
2658 long data[4] = {0, 0, 0, 0};
2659 int i;
2660 int bitsize, nelts, nunits, units_per;
2661
2662 /* This is hairy. We have a quantity of known size. real_to_target
2663 will put it into an array of *host* longs, 32 bits per element
2664 (even if long is more than 32 bits). We need to determine the
2665 number of array elements that are occupied (nelts) and the number
2666 of *target* min-addressable units that will be occupied in the
2667 object file (nunits). We cannot assume that 32 divides the
2668 mode's bitsize (size * BITS_PER_UNIT) evenly.
2669
2670 size * BITS_PER_UNIT is used here to make sure that padding bits
2671 (which might appear at either end of the value; real_to_target
2672 will include the padding bits in its output array) are included. */
2673
2674 nunits = GET_MODE_SIZE (mode);
2675 bitsize = nunits * BITS_PER_UNIT;
2676 nelts = CEIL (bitsize, 32);
2677 units_per = 32 / BITS_PER_UNIT;
2678
2679 real_to_target (data, &d, mode);
2680
2681 /* Put out the first word with the specified alignment. */
2682 assemble_integer (GEN_INT (data[0]), MIN (nunits, units_per), align, 1);
2683 nunits -= units_per;
2684
2685 /* Subsequent words need only 32-bit alignment. */
2686 align = min_align (align, 32);
2687
2688 for (i = 1; i < nelts; i++)
2689 {
2690 assemble_integer (GEN_INT (data[i]), MIN (nunits, units_per), align, 1);
2691 nunits -= units_per;
2692 }
2693 }
2694 \f
2695 /* Given an expression EXP with a constant value,
2696 reduce it to the sum of an assembler symbol and an integer.
2697 Store them both in the structure *VALUE.
2698 EXP must be reducible. */
2699
2700 struct addr_const GTY(())
2701 {
2702 rtx base;
2703 HOST_WIDE_INT offset;
2704 };
2705
2706 static void
2707 decode_addr_const (tree exp, struct addr_const *value)
2708 {
2709 tree target = TREE_OPERAND (exp, 0);
2710 int offset = 0;
2711 rtx x;
2712
2713 while (1)
2714 {
2715 if (TREE_CODE (target) == COMPONENT_REF
2716 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2717
2718 {
2719 offset += int_byte_position (TREE_OPERAND (target, 1));
2720 target = TREE_OPERAND (target, 0);
2721 }
2722 else if (TREE_CODE (target) == ARRAY_REF
2723 || TREE_CODE (target) == ARRAY_RANGE_REF)
2724 {
2725 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2726 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2727 target = TREE_OPERAND (target, 0);
2728 }
2729 else
2730 break;
2731 }
2732
2733 switch (TREE_CODE (target))
2734 {
2735 case VAR_DECL:
2736 case FUNCTION_DECL:
2737 x = DECL_RTL (target);
2738 break;
2739
2740 case LABEL_DECL:
2741 x = gen_rtx_MEM (FUNCTION_MODE,
2742 gen_rtx_LABEL_REF (Pmode, force_label_rtx (target)));
2743 break;
2744
2745 case REAL_CST:
2746 case FIXED_CST:
2747 case STRING_CST:
2748 case COMPLEX_CST:
2749 case CONSTRUCTOR:
2750 case INTEGER_CST:
2751 x = output_constant_def (target, 1);
2752 break;
2753
2754 default:
2755 gcc_unreachable ();
2756 }
2757
2758 gcc_assert (MEM_P (x));
2759 x = XEXP (x, 0);
2760
2761 value->base = x;
2762 value->offset = offset;
2763 }
2764 \f
2765 /* Uniquize all constants that appear in memory.
2766 Each constant in memory thus far output is recorded
2767 in `const_desc_table'. */
2768
2769 struct constant_descriptor_tree GTY(())
2770 {
2771 /* A MEM for the constant. */
2772 rtx rtl;
2773
2774 /* The value of the constant. */
2775 tree value;
2776
2777 /* Hash of value. Computing the hash from value each time
2778 hashfn is called can't work properly, as that means recursive
2779 use of the hash table during hash table expansion. */
2780 hashval_t hash;
2781 };
2782
2783 static GTY((param_is (struct constant_descriptor_tree)))
2784 htab_t const_desc_htab;
2785
2786 static struct constant_descriptor_tree * build_constant_desc (tree);
2787 static void maybe_output_constant_def_contents (struct constant_descriptor_tree *, int);
2788
2789 /* Compute a hash code for a constant expression. */
2790
2791 static hashval_t
2792 const_desc_hash (const void *ptr)
2793 {
2794 return ((const struct constant_descriptor_tree *)ptr)->hash;
2795 }
2796
2797 static hashval_t
2798 const_hash_1 (const tree exp)
2799 {
2800 const char *p;
2801 hashval_t hi;
2802 int len, i;
2803 enum tree_code code = TREE_CODE (exp);
2804
2805 /* Either set P and LEN to the address and len of something to hash and
2806 exit the switch or return a value. */
2807
2808 switch (code)
2809 {
2810 case INTEGER_CST:
2811 p = (char *) &TREE_INT_CST (exp);
2812 len = sizeof TREE_INT_CST (exp);
2813 break;
2814
2815 case REAL_CST:
2816 return real_hash (TREE_REAL_CST_PTR (exp));
2817
2818 case FIXED_CST:
2819 return fixed_hash (TREE_FIXED_CST_PTR (exp));
2820
2821 case STRING_CST:
2822 p = TREE_STRING_POINTER (exp);
2823 len = TREE_STRING_LENGTH (exp);
2824 break;
2825
2826 case COMPLEX_CST:
2827 return (const_hash_1 (TREE_REALPART (exp)) * 5
2828 + const_hash_1 (TREE_IMAGPART (exp)));
2829
2830 case CONSTRUCTOR:
2831 {
2832 unsigned HOST_WIDE_INT idx;
2833 tree value;
2834
2835 hi = 5 + int_size_in_bytes (TREE_TYPE (exp));
2836
2837 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, value)
2838 if (value)
2839 hi = hi * 603 + const_hash_1 (value);
2840
2841 return hi;
2842 }
2843
2844 case ADDR_EXPR:
2845 case FDESC_EXPR:
2846 {
2847 struct addr_const value;
2848
2849 decode_addr_const (exp, &value);
2850 switch (GET_CODE (value.base))
2851 {
2852 case SYMBOL_REF:
2853 /* Don't hash the address of the SYMBOL_REF;
2854 only use the offset and the symbol name. */
2855 hi = value.offset;
2856 p = XSTR (value.base, 0);
2857 for (i = 0; p[i] != 0; i++)
2858 hi = ((hi * 613) + (unsigned) (p[i]));
2859 break;
2860
2861 case LABEL_REF:
2862 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2863 break;
2864
2865 default:
2866 gcc_unreachable ();
2867 }
2868 }
2869 return hi;
2870
2871 case PLUS_EXPR:
2872 case POINTER_PLUS_EXPR:
2873 case MINUS_EXPR:
2874 return (const_hash_1 (TREE_OPERAND (exp, 0)) * 9
2875 + const_hash_1 (TREE_OPERAND (exp, 1)));
2876
2877 CASE_CONVERT:
2878 return const_hash_1 (TREE_OPERAND (exp, 0)) * 7 + 2;
2879
2880 default:
2881 /* A language specific constant. Just hash the code. */
2882 return code;
2883 }
2884
2885 /* Compute hashing function. */
2886 hi = len;
2887 for (i = 0; i < len; i++)
2888 hi = ((hi * 613) + (unsigned) (p[i]));
2889
2890 return hi;
2891 }
2892
2893 /* Wrapper of compare_constant, for the htab interface. */
2894 static int
2895 const_desc_eq (const void *p1, const void *p2)
2896 {
2897 const struct constant_descriptor_tree *const c1
2898 = (const struct constant_descriptor_tree *) p1;
2899 const struct constant_descriptor_tree *const c2
2900 = (const struct constant_descriptor_tree *) p2;
2901 if (c1->hash != c2->hash)
2902 return 0;
2903 return compare_constant (c1->value, c2->value);
2904 }
2905
2906 /* Compare t1 and t2, and return 1 only if they are known to result in
2907 the same bit pattern on output. */
2908
2909 static int
2910 compare_constant (const tree t1, const tree t2)
2911 {
2912 enum tree_code typecode;
2913
2914 if (t1 == NULL_TREE)
2915 return t2 == NULL_TREE;
2916 if (t2 == NULL_TREE)
2917 return 0;
2918
2919 if (TREE_CODE (t1) != TREE_CODE (t2))
2920 return 0;
2921
2922 switch (TREE_CODE (t1))
2923 {
2924 case INTEGER_CST:
2925 /* Integer constants are the same only if the same width of type. */
2926 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2927 return 0;
2928 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2929 return 0;
2930 return tree_int_cst_equal (t1, t2);
2931
2932 case REAL_CST:
2933 /* Real constants are the same only if the same width of type. */
2934 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2935 return 0;
2936
2937 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1), TREE_REAL_CST (t2));
2938
2939 case FIXED_CST:
2940 /* Fixed constants are the same only if the same width of type. */
2941 if (TYPE_PRECISION (TREE_TYPE (t1)) != TYPE_PRECISION (TREE_TYPE (t2)))
2942 return 0;
2943
2944 return FIXED_VALUES_IDENTICAL (TREE_FIXED_CST (t1), TREE_FIXED_CST (t2));
2945
2946 case STRING_CST:
2947 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2)))
2948 return 0;
2949
2950 return (TREE_STRING_LENGTH (t1) == TREE_STRING_LENGTH (t2)
2951 && ! memcmp (TREE_STRING_POINTER (t1), TREE_STRING_POINTER (t2),
2952 TREE_STRING_LENGTH (t1)));
2953
2954 case COMPLEX_CST:
2955 return (compare_constant (TREE_REALPART (t1), TREE_REALPART (t2))
2956 && compare_constant (TREE_IMAGPART (t1), TREE_IMAGPART (t2)));
2957
2958 case CONSTRUCTOR:
2959 {
2960 VEC(constructor_elt, gc) *v1, *v2;
2961 unsigned HOST_WIDE_INT idx;
2962
2963 typecode = TREE_CODE (TREE_TYPE (t1));
2964 if (typecode != TREE_CODE (TREE_TYPE (t2)))
2965 return 0;
2966
2967 if (typecode == ARRAY_TYPE)
2968 {
2969 HOST_WIDE_INT size_1 = int_size_in_bytes (TREE_TYPE (t1));
2970 /* For arrays, check that the sizes all match. */
2971 if (TYPE_MODE (TREE_TYPE (t1)) != TYPE_MODE (TREE_TYPE (t2))
2972 || size_1 == -1
2973 || size_1 != int_size_in_bytes (TREE_TYPE (t2)))
2974 return 0;
2975 }
2976 else
2977 {
2978 /* For record and union constructors, require exact type
2979 equality. */
2980 if (TREE_TYPE (t1) != TREE_TYPE (t2))
2981 return 0;
2982 }
2983
2984 v1 = CONSTRUCTOR_ELTS (t1);
2985 v2 = CONSTRUCTOR_ELTS (t2);
2986 if (VEC_length (constructor_elt, v1)
2987 != VEC_length (constructor_elt, v2))
2988 return 0;
2989
2990 for (idx = 0; idx < VEC_length (constructor_elt, v1); ++idx)
2991 {
2992 constructor_elt *c1 = VEC_index (constructor_elt, v1, idx);
2993 constructor_elt *c2 = VEC_index (constructor_elt, v2, idx);
2994
2995 /* Check that each value is the same... */
2996 if (!compare_constant (c1->value, c2->value))
2997 return 0;
2998 /* ... and that they apply to the same fields! */
2999 if (typecode == ARRAY_TYPE)
3000 {
3001 if (!compare_constant (c1->index, c2->index))
3002 return 0;
3003 }
3004 else
3005 {
3006 if (c1->index != c2->index)
3007 return 0;
3008 }
3009 }
3010
3011 return 1;
3012 }
3013
3014 case ADDR_EXPR:
3015 case FDESC_EXPR:
3016 {
3017 struct addr_const value1, value2;
3018
3019 decode_addr_const (t1, &value1);
3020 decode_addr_const (t2, &value2);
3021 return (value1.offset == value2.offset
3022 && strcmp (XSTR (value1.base, 0), XSTR (value2.base, 0)) == 0);
3023 }
3024
3025 case PLUS_EXPR:
3026 case POINTER_PLUS_EXPR:
3027 case MINUS_EXPR:
3028 case RANGE_EXPR:
3029 return (compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0))
3030 && compare_constant(TREE_OPERAND (t1, 1), TREE_OPERAND (t2, 1)));
3031
3032 CASE_CONVERT:
3033 case VIEW_CONVERT_EXPR:
3034 return compare_constant (TREE_OPERAND (t1, 0), TREE_OPERAND (t2, 0));
3035
3036 default:
3037 return 0;
3038 }
3039
3040 gcc_unreachable ();
3041 }
3042 \f
3043 /* Make a copy of the whole tree structure for a constant. This
3044 handles the same types of nodes that compare_constant handles. */
3045
3046 static tree
3047 copy_constant (tree exp)
3048 {
3049 switch (TREE_CODE (exp))
3050 {
3051 case ADDR_EXPR:
3052 /* For ADDR_EXPR, we do not want to copy the decl whose address
3053 is requested. We do want to copy constants though. */
3054 if (CONSTANT_CLASS_P (TREE_OPERAND (exp, 0)))
3055 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3056 copy_constant (TREE_OPERAND (exp, 0)));
3057 else
3058 return copy_node (exp);
3059
3060 case INTEGER_CST:
3061 case REAL_CST:
3062 case FIXED_CST:
3063 case STRING_CST:
3064 return copy_node (exp);
3065
3066 case COMPLEX_CST:
3067 return build_complex (TREE_TYPE (exp),
3068 copy_constant (TREE_REALPART (exp)),
3069 copy_constant (TREE_IMAGPART (exp)));
3070
3071 case PLUS_EXPR:
3072 case POINTER_PLUS_EXPR:
3073 case MINUS_EXPR:
3074 return build2 (TREE_CODE (exp), TREE_TYPE (exp),
3075 copy_constant (TREE_OPERAND (exp, 0)),
3076 copy_constant (TREE_OPERAND (exp, 1)));
3077
3078 CASE_CONVERT:
3079 case VIEW_CONVERT_EXPR:
3080 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3081 copy_constant (TREE_OPERAND (exp, 0)));
3082
3083 case CONSTRUCTOR:
3084 {
3085 tree copy = copy_node (exp);
3086 VEC(constructor_elt, gc) *v;
3087 unsigned HOST_WIDE_INT idx;
3088 tree purpose, value;
3089
3090 v = VEC_alloc(constructor_elt, gc, VEC_length(constructor_elt,
3091 CONSTRUCTOR_ELTS (exp)));
3092 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (exp), idx, purpose, value)
3093 {
3094 constructor_elt *ce = VEC_quick_push (constructor_elt, v, NULL);
3095 ce->index = purpose;
3096 ce->value = copy_constant (value);
3097 }
3098 CONSTRUCTOR_ELTS (copy) = v;
3099 return copy;
3100 }
3101
3102 default:
3103 gcc_unreachable ();
3104 }
3105 }
3106 \f
3107 /* Return the alignment of constant EXP in bits. */
3108
3109 static unsigned int
3110 get_constant_alignment (tree exp)
3111 {
3112 unsigned int align;
3113
3114 align = TYPE_ALIGN (TREE_TYPE (exp));
3115 #ifdef CONSTANT_ALIGNMENT
3116 align = CONSTANT_ALIGNMENT (exp, align);
3117 #endif
3118 return align;
3119 }
3120
3121 /* Return the section into which constant EXP should be placed. */
3122
3123 static section *
3124 get_constant_section (tree exp)
3125 {
3126 if (IN_NAMED_SECTION (exp))
3127 return get_named_section (exp, NULL, compute_reloc_for_constant (exp));
3128 else
3129 return targetm.asm_out.select_section (exp,
3130 compute_reloc_for_constant (exp),
3131 get_constant_alignment (exp));
3132 }
3133
3134 /* Return the size of constant EXP in bytes. */
3135
3136 static HOST_WIDE_INT
3137 get_constant_size (tree exp)
3138 {
3139 HOST_WIDE_INT size;
3140
3141 size = int_size_in_bytes (TREE_TYPE (exp));
3142 if (TREE_CODE (exp) == STRING_CST)
3143 size = MAX (TREE_STRING_LENGTH (exp), size);
3144 return size;
3145 }
3146
3147 /* Subroutine of output_constant_def:
3148 No constant equal to EXP is known to have been output.
3149 Make a constant descriptor to enter EXP in the hash table.
3150 Assign the label number and construct RTL to refer to the
3151 constant's location in memory.
3152 Caller is responsible for updating the hash table. */
3153
3154 static struct constant_descriptor_tree *
3155 build_constant_desc (tree exp)
3156 {
3157 rtx symbol;
3158 rtx rtl;
3159 char label[256];
3160 int labelno;
3161 struct constant_descriptor_tree *desc;
3162
3163 desc = GGC_NEW (struct constant_descriptor_tree);
3164 desc->value = copy_constant (exp);
3165
3166 /* Propagate marked-ness to copied constant. */
3167 if (flag_mudflap && mf_marked_p (exp))
3168 mf_mark (desc->value);
3169
3170 /* Create a string containing the label name, in LABEL. */
3171 labelno = const_labelno++;
3172 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3173
3174 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3175 if (use_object_blocks_p ())
3176 {
3177 section *sect = get_constant_section (exp);
3178 symbol = create_block_symbol (ggc_strdup (label),
3179 get_block_for_section (sect), -1);
3180 }
3181 else
3182 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3183 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3184 SET_SYMBOL_REF_DECL (symbol, desc->value);
3185 TREE_CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3186
3187 rtl = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), symbol);
3188 set_mem_attributes (rtl, exp, 1);
3189 set_mem_alias_set (rtl, 0);
3190 set_mem_alias_set (rtl, const_alias_set);
3191
3192 /* Set flags or add text to the name to record information, such as
3193 that it is a local symbol. If the name is changed, the macro
3194 ASM_OUTPUT_LABELREF will have to know how to strip this
3195 information. This call might invalidate our local variable
3196 SYMBOL; we can't use it afterward. */
3197
3198 targetm.encode_section_info (exp, rtl, true);
3199
3200 desc->rtl = rtl;
3201
3202 return desc;
3203 }
3204
3205 /* Return an rtx representing a reference to constant data in memory
3206 for the constant expression EXP.
3207
3208 If assembler code for such a constant has already been output,
3209 return an rtx to refer to it.
3210 Otherwise, output such a constant in memory
3211 and generate an rtx for it.
3212
3213 If DEFER is nonzero, this constant can be deferred and output only
3214 if referenced in the function after all optimizations.
3215
3216 `const_desc_table' records which constants already have label strings. */
3217
3218 rtx
3219 output_constant_def (tree exp, int defer)
3220 {
3221 struct constant_descriptor_tree *desc;
3222 struct constant_descriptor_tree key;
3223 void **loc;
3224
3225 /* Look up EXP in the table of constant descriptors. If we didn't find
3226 it, create a new one. */
3227 key.value = exp;
3228 key.hash = const_hash_1 (exp);
3229 loc = htab_find_slot_with_hash (const_desc_htab, &key, key.hash, INSERT);
3230
3231 desc = (struct constant_descriptor_tree *) *loc;
3232 if (desc == 0)
3233 {
3234 desc = build_constant_desc (exp);
3235 desc->hash = key.hash;
3236 *loc = desc;
3237 }
3238
3239 maybe_output_constant_def_contents (desc, defer);
3240 return desc->rtl;
3241 }
3242
3243 /* Subroutine of output_constant_def: Decide whether or not we need to
3244 output the constant DESC now, and if so, do it. */
3245 static void
3246 maybe_output_constant_def_contents (struct constant_descriptor_tree *desc,
3247 int defer)
3248 {
3249 rtx symbol = XEXP (desc->rtl, 0);
3250 tree exp = desc->value;
3251
3252 if (flag_syntax_only)
3253 return;
3254
3255 if (TREE_ASM_WRITTEN (exp))
3256 /* Already output; don't do it again. */
3257 return;
3258
3259 /* We can always defer constants as long as the context allows
3260 doing so. */
3261 if (defer)
3262 {
3263 /* Increment n_deferred_constants if it exists. It needs to be at
3264 least as large as the number of constants actually referred to
3265 by the function. If it's too small we'll stop looking too early
3266 and fail to emit constants; if it's too large we'll only look
3267 through the entire function when we could have stopped earlier. */
3268 if (cfun)
3269 n_deferred_constants++;
3270 return;
3271 }
3272
3273 output_constant_def_contents (symbol);
3274 }
3275
3276 /* Subroutine of output_constant_def_contents. Output the definition
3277 of constant EXP, which is pointed to by label LABEL. ALIGN is the
3278 constant's alignment in bits. */
3279
3280 static void
3281 assemble_constant_contents (tree exp, const char *label, unsigned int align)
3282 {
3283 HOST_WIDE_INT size;
3284
3285 size = get_constant_size (exp);
3286
3287 /* Do any machine/system dependent processing of the constant. */
3288 #ifdef ASM_DECLARE_CONSTANT_NAME
3289 ASM_DECLARE_CONSTANT_NAME (asm_out_file, label, exp, size);
3290 #else
3291 /* Standard thing is just output label for the constant. */
3292 ASM_OUTPUT_LABEL (asm_out_file, label);
3293 #endif /* ASM_DECLARE_CONSTANT_NAME */
3294
3295 /* Output the value of EXP. */
3296 output_constant (exp, size, align);
3297 }
3298
3299 /* We must output the constant data referred to by SYMBOL; do so. */
3300
3301 static void
3302 output_constant_def_contents (rtx symbol)
3303 {
3304 tree exp = SYMBOL_REF_DECL (symbol);
3305 unsigned int align;
3306
3307 /* Make sure any other constants whose addresses appear in EXP
3308 are assigned label numbers. */
3309 output_addressed_constants (exp);
3310
3311 /* We are no longer deferring this constant. */
3312 TREE_ASM_WRITTEN (exp) = 1;
3313
3314 /* If the constant is part of an object block, make sure that the
3315 decl has been positioned within its block, but do not write out
3316 its definition yet. output_object_blocks will do that later. */
3317 if (SYMBOL_REF_HAS_BLOCK_INFO_P (symbol) && SYMBOL_REF_BLOCK (symbol))
3318 place_block_symbol (symbol);
3319 else
3320 {
3321 switch_to_section (get_constant_section (exp));
3322 align = get_constant_alignment (exp);
3323 if (align > BITS_PER_UNIT)
3324 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3325 assemble_constant_contents (exp, XSTR (symbol, 0), align);
3326 }
3327 if (flag_mudflap)
3328 mudflap_enqueue_constant (exp);
3329 }
3330
3331 /* Look up EXP in the table of constant descriptors. Return the rtl
3332 if it has been emitted, else null. */
3333
3334 rtx
3335 lookup_constant_def (tree exp)
3336 {
3337 struct constant_descriptor_tree *desc;
3338 struct constant_descriptor_tree key;
3339
3340 key.value = exp;
3341 key.hash = const_hash_1 (exp);
3342 desc = (struct constant_descriptor_tree *)
3343 htab_find_with_hash (const_desc_htab, &key, key.hash);
3344
3345 return (desc ? desc->rtl : NULL_RTX);
3346 }
3347 \f
3348 /* Used in the hash tables to avoid outputting the same constant
3349 twice. Unlike 'struct constant_descriptor_tree', RTX constants
3350 are output once per function, not once per file. */
3351 /* ??? Only a few targets need per-function constant pools. Most
3352 can use one per-file pool. Should add a targetm bit to tell the
3353 difference. */
3354
3355 struct rtx_constant_pool GTY(())
3356 {
3357 /* Pointers to first and last constant in pool, as ordered by offset. */
3358 struct constant_descriptor_rtx *first;
3359 struct constant_descriptor_rtx *last;
3360
3361 /* Hash facility for making memory-constants from constant rtl-expressions.
3362 It is used on RISC machines where immediate integer arguments and
3363 constant addresses are restricted so that such constants must be stored
3364 in memory. */
3365 htab_t GTY((param_is (struct constant_descriptor_rtx))) const_rtx_htab;
3366
3367 /* Current offset in constant pool (does not include any
3368 machine-specific header). */
3369 HOST_WIDE_INT offset;
3370 };
3371
3372 struct constant_descriptor_rtx GTY((chain_next ("%h.next")))
3373 {
3374 struct constant_descriptor_rtx *next;
3375 rtx mem;
3376 rtx sym;
3377 rtx constant;
3378 HOST_WIDE_INT offset;
3379 hashval_t hash;
3380 enum machine_mode mode;
3381 unsigned int align;
3382 int labelno;
3383 int mark;
3384 };
3385
3386 /* Hash and compare functions for const_rtx_htab. */
3387
3388 static hashval_t
3389 const_desc_rtx_hash (const void *ptr)
3390 {
3391 const struct constant_descriptor_rtx *const desc
3392 = (const struct constant_descriptor_rtx *) ptr;
3393 return desc->hash;
3394 }
3395
3396 static int
3397 const_desc_rtx_eq (const void *a, const void *b)
3398 {
3399 const struct constant_descriptor_rtx *const x
3400 = (const struct constant_descriptor_rtx *) a;
3401 const struct constant_descriptor_rtx *const y
3402 = (const struct constant_descriptor_rtx *) b;
3403
3404 if (x->mode != y->mode)
3405 return 0;
3406 return rtx_equal_p (x->constant, y->constant);
3407 }
3408
3409 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
3410
3411 static int
3412 const_rtx_hash_1 (rtx *xp, void *data)
3413 {
3414 unsigned HOST_WIDE_INT hwi;
3415 enum machine_mode mode;
3416 enum rtx_code code;
3417 hashval_t h, *hp;
3418 rtx x;
3419
3420 x = *xp;
3421 code = GET_CODE (x);
3422 mode = GET_MODE (x);
3423 h = (hashval_t) code * 1048573 + mode;
3424
3425 switch (code)
3426 {
3427 case CONST_INT:
3428 hwi = INTVAL (x);
3429 fold_hwi:
3430 {
3431 const int shift = sizeof (hashval_t) * CHAR_BIT;
3432 const int n = sizeof (HOST_WIDE_INT) / sizeof (hashval_t);
3433 int i;
3434
3435 h ^= (hashval_t) hwi;
3436 for (i = 1; i < n; ++i)
3437 {
3438 hwi >>= shift;
3439 h ^= (hashval_t) hwi;
3440 }
3441 }
3442 break;
3443
3444 case CONST_DOUBLE:
3445 if (mode == VOIDmode)
3446 {
3447 hwi = CONST_DOUBLE_LOW (x) ^ CONST_DOUBLE_HIGH (x);
3448 goto fold_hwi;
3449 }
3450 else
3451 h ^= real_hash (CONST_DOUBLE_REAL_VALUE (x));
3452 break;
3453
3454 case CONST_FIXED:
3455 h ^= fixed_hash (CONST_FIXED_VALUE (x));
3456 break;
3457
3458 case CONST_VECTOR:
3459 {
3460 int i;
3461 for (i = XVECLEN (x, 0); i-- > 0; )
3462 h = h * 251 + const_rtx_hash_1 (&XVECEXP (x, 0, i), data);
3463 }
3464 break;
3465
3466 case SYMBOL_REF:
3467 h ^= htab_hash_string (XSTR (x, 0));
3468 break;
3469
3470 case LABEL_REF:
3471 h = h * 251 + CODE_LABEL_NUMBER (XEXP (x, 0));
3472 break;
3473
3474 case UNSPEC:
3475 case UNSPEC_VOLATILE:
3476 h = h * 251 + XINT (x, 1);
3477 break;
3478
3479 default:
3480 break;
3481 }
3482
3483 hp = (hashval_t *) data;
3484 *hp = *hp * 509 + h;
3485 return 0;
3486 }
3487
3488 /* Compute a hash value for X, which should be a constant. */
3489
3490 static hashval_t
3491 const_rtx_hash (rtx x)
3492 {
3493 hashval_t h = 0;
3494 for_each_rtx (&x, const_rtx_hash_1, &h);
3495 return h;
3496 }
3497
3498 \f
3499 /* Create and return a new rtx constant pool. */
3500
3501 static struct rtx_constant_pool *
3502 create_constant_pool (void)
3503 {
3504 struct rtx_constant_pool *pool;
3505
3506 pool = GGC_NEW (struct rtx_constant_pool);
3507 pool->const_rtx_htab = htab_create_ggc (31, const_desc_rtx_hash,
3508 const_desc_rtx_eq, NULL);
3509 pool->first = NULL;
3510 pool->last = NULL;
3511 pool->offset = 0;
3512 return pool;
3513 }
3514
3515 /* Initialize constant pool hashing for a new function. */
3516
3517 void
3518 init_varasm_status (void)
3519 {
3520 crtl->varasm.pool = create_constant_pool ();
3521 crtl->varasm.deferred_constants = 0;
3522 }
3523 \f
3524 /* Given a MINUS expression, simplify it if both sides
3525 include the same symbol. */
3526
3527 rtx
3528 simplify_subtraction (rtx x)
3529 {
3530 rtx r = simplify_rtx (x);
3531 return r ? r : x;
3532 }
3533 \f
3534 /* Given a constant rtx X, make (or find) a memory constant for its value
3535 and return a MEM rtx to refer to it in memory. */
3536
3537 rtx
3538 force_const_mem (enum machine_mode mode, rtx x)
3539 {
3540 struct constant_descriptor_rtx *desc, tmp;
3541 struct rtx_constant_pool *pool;
3542 char label[256];
3543 rtx def, symbol;
3544 hashval_t hash;
3545 unsigned int align;
3546 void **slot;
3547
3548 /* If we're not allowed to drop X into the constant pool, don't. */
3549 if (targetm.cannot_force_const_mem (x))
3550 return NULL_RTX;
3551
3552 /* Record that this function has used a constant pool entry. */
3553 crtl->uses_const_pool = 1;
3554
3555 /* Decide which pool to use. */
3556 pool = (targetm.use_blocks_for_constant_p (mode, x)
3557 ? shared_constant_pool
3558 : crtl->varasm.pool);
3559
3560 /* Lookup the value in the hashtable. */
3561 tmp.constant = x;
3562 tmp.mode = mode;
3563 hash = const_rtx_hash (x);
3564 slot = htab_find_slot_with_hash (pool->const_rtx_htab, &tmp, hash, INSERT);
3565 desc = (struct constant_descriptor_rtx *) *slot;
3566
3567 /* If the constant was already present, return its memory. */
3568 if (desc)
3569 return copy_rtx (desc->mem);
3570
3571 /* Otherwise, create a new descriptor. */
3572 desc = GGC_NEW (struct constant_descriptor_rtx);
3573 *slot = desc;
3574
3575 /* Align the location counter as required by EXP's data type. */
3576 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3577 #ifdef CONSTANT_ALIGNMENT
3578 {
3579 tree type = lang_hooks.types.type_for_mode (mode, 0);
3580 if (type != NULL_TREE)
3581 align = CONSTANT_ALIGNMENT (make_tree (type, x), align);
3582 }
3583 #endif
3584
3585 pool->offset += (align / BITS_PER_UNIT) - 1;
3586 pool->offset &= ~ ((align / BITS_PER_UNIT) - 1);
3587
3588 desc->next = NULL;
3589 desc->constant = tmp.constant;
3590 desc->offset = pool->offset;
3591 desc->hash = hash;
3592 desc->mode = mode;
3593 desc->align = align;
3594 desc->labelno = const_labelno;
3595 desc->mark = 0;
3596
3597 pool->offset += GET_MODE_SIZE (mode);
3598 if (pool->last)
3599 pool->last->next = desc;
3600 else
3601 pool->first = pool->last = desc;
3602 pool->last = desc;
3603
3604 /* Create a string containing the label name, in LABEL. */
3605 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3606 ++const_labelno;
3607
3608 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3609 the constants pool. */
3610 if (use_object_blocks_p () && targetm.use_blocks_for_constant_p (mode, x))
3611 {
3612 section *sect = targetm.asm_out.select_rtx_section (mode, x, align);
3613 symbol = create_block_symbol (ggc_strdup (label),
3614 get_block_for_section (sect), -1);
3615 }
3616 else
3617 symbol = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label));
3618 desc->sym = symbol;
3619 SYMBOL_REF_FLAGS (symbol) |= SYMBOL_FLAG_LOCAL;
3620 CONSTANT_POOL_ADDRESS_P (symbol) = 1;
3621 SET_SYMBOL_REF_CONSTANT (symbol, desc);
3622
3623 /* Construct the MEM. */
3624 desc->mem = def = gen_const_mem (mode, symbol);
3625 set_mem_attributes (def, lang_hooks.types.type_for_mode (mode, 0), 1);
3626 set_mem_align (def, align);
3627
3628 /* If we're dropping a label to the constant pool, make sure we
3629 don't delete it. */
3630 if (GET_CODE (x) == LABEL_REF)
3631 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3632
3633 return copy_rtx (def);
3634 }
3635 \f
3636 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3637
3638 rtx
3639 get_pool_constant (rtx addr)
3640 {
3641 return SYMBOL_REF_CONSTANT (addr)->constant;
3642 }
3643
3644 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3645 and whether it has been output or not. */
3646
3647 rtx
3648 get_pool_constant_mark (rtx addr, bool *pmarked)
3649 {
3650 struct constant_descriptor_rtx *desc;
3651
3652 desc = SYMBOL_REF_CONSTANT (addr);
3653 *pmarked = (desc->mark != 0);
3654 return desc->constant;
3655 }
3656
3657 /* Similar, return the mode. */
3658
3659 enum machine_mode
3660 get_pool_mode (const_rtx addr)
3661 {
3662 return SYMBOL_REF_CONSTANT (addr)->mode;
3663 }
3664
3665 /* Return the size of the constant pool. */
3666
3667 int
3668 get_pool_size (void)
3669 {
3670 return crtl->varasm.pool->offset;
3671 }
3672 \f
3673 /* Worker function for output_constant_pool_1. Emit assembly for X
3674 in MODE with known alignment ALIGN. */
3675
3676 static void
3677 output_constant_pool_2 (enum machine_mode mode, rtx x, unsigned int align)
3678 {
3679 switch (GET_MODE_CLASS (mode))
3680 {
3681 case MODE_FLOAT:
3682 case MODE_DECIMAL_FLOAT:
3683 {
3684 REAL_VALUE_TYPE r;
3685
3686 gcc_assert (GET_CODE (x) == CONST_DOUBLE);
3687 REAL_VALUE_FROM_CONST_DOUBLE (r, x);
3688 assemble_real (r, mode, align);
3689 break;
3690 }
3691
3692 case MODE_INT:
3693 case MODE_PARTIAL_INT:
3694 case MODE_FRACT:
3695 case MODE_UFRACT:
3696 case MODE_ACCUM:
3697 case MODE_UACCUM:
3698 assemble_integer (x, GET_MODE_SIZE (mode), align, 1);
3699 break;
3700
3701 case MODE_VECTOR_FLOAT:
3702 case MODE_VECTOR_INT:
3703 case MODE_VECTOR_FRACT:
3704 case MODE_VECTOR_UFRACT:
3705 case MODE_VECTOR_ACCUM:
3706 case MODE_VECTOR_UACCUM:
3707 {
3708 int i, units;
3709 enum machine_mode submode = GET_MODE_INNER (mode);
3710 unsigned int subalign = MIN (align, GET_MODE_BITSIZE (submode));
3711
3712 gcc_assert (GET_CODE (x) == CONST_VECTOR);
3713 units = CONST_VECTOR_NUNITS (x);
3714
3715 for (i = 0; i < units; i++)
3716 {
3717 rtx elt = CONST_VECTOR_ELT (x, i);
3718 output_constant_pool_2 (submode, elt, i ? subalign : align);
3719 }
3720 }
3721 break;
3722
3723 default:
3724 gcc_unreachable ();
3725 }
3726 }
3727
3728 /* Worker function for output_constant_pool. Emit constant DESC,
3729 giving it ALIGN bits of alignment. */
3730
3731 static void
3732 output_constant_pool_1 (struct constant_descriptor_rtx *desc,
3733 unsigned int align)
3734 {
3735 rtx x, tmp;
3736
3737 x = desc->constant;
3738
3739 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3740 whose CODE_LABEL has been deleted. This can occur if a jump table
3741 is eliminated by optimization. If so, write a constant of zero
3742 instead. Note that this can also happen by turning the
3743 CODE_LABEL into a NOTE. */
3744 /* ??? This seems completely and utterly wrong. Certainly it's
3745 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3746 functioning even with INSN_DELETED_P and friends. */
3747
3748 tmp = x;
3749 switch (GET_CODE (tmp))
3750 {
3751 case CONST:
3752 if (GET_CODE (XEXP (tmp, 0)) != PLUS
3753 || GET_CODE (XEXP (XEXP (tmp, 0), 0)) != LABEL_REF)
3754 break;
3755 tmp = XEXP (XEXP (tmp, 0), 0);
3756 /* FALLTHRU */
3757
3758 case LABEL_REF:
3759 tmp = XEXP (tmp, 0);
3760 gcc_assert (!INSN_DELETED_P (tmp));
3761 gcc_assert (!NOTE_P (tmp)
3762 || NOTE_KIND (tmp) != NOTE_INSN_DELETED);
3763 break;
3764
3765 default:
3766 break;
3767 }
3768
3769 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3770 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, desc->mode,
3771 align, desc->labelno, done);
3772 #endif
3773
3774 assemble_align (align);
3775
3776 /* Output the label. */
3777 targetm.asm_out.internal_label (asm_out_file, "LC", desc->labelno);
3778
3779 /* Output the data. */
3780 output_constant_pool_2 (desc->mode, x, align);
3781
3782 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3783 sections have proper size. */
3784 if (align > GET_MODE_BITSIZE (desc->mode)
3785 && in_section
3786 && (in_section->common.flags & SECTION_MERGE))
3787 assemble_align (align);
3788
3789 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3790 done:
3791 #endif
3792 return;
3793 }
3794
3795 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3796 to as used. Emit referenced deferred strings. This function can
3797 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3798
3799 static int
3800 mark_constant (rtx *current_rtx, void *data ATTRIBUTE_UNUSED)
3801 {
3802 rtx x = *current_rtx;
3803
3804 if (x == NULL_RTX || GET_CODE (x) != SYMBOL_REF)
3805 return 0;
3806
3807 if (CONSTANT_POOL_ADDRESS_P (x))
3808 {
3809 struct constant_descriptor_rtx *desc = SYMBOL_REF_CONSTANT (x);
3810 if (desc->mark == 0)
3811 {
3812 desc->mark = 1;
3813 for_each_rtx (&desc->constant, mark_constant, NULL);
3814 }
3815 }
3816 else if (TREE_CONSTANT_POOL_ADDRESS_P (x))
3817 {
3818 tree exp = SYMBOL_REF_DECL (x);
3819 if (!TREE_ASM_WRITTEN (exp))
3820 {
3821 n_deferred_constants--;
3822 output_constant_def_contents (x);
3823 }
3824 }
3825
3826 return -1;
3827 }
3828
3829 /* Look through appropriate parts of INSN, marking all entries in the
3830 constant pool which are actually being used. Entries that are only
3831 referenced by other constants are also marked as used. Emit
3832 deferred strings that are used. */
3833
3834 static void
3835 mark_constants (rtx insn)
3836 {
3837 if (!INSN_P (insn))
3838 return;
3839
3840 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3841 insns, not any notes that may be attached. We don't want to mark
3842 a constant just because it happens to appear in a REG_EQUIV note. */
3843 if (GET_CODE (PATTERN (insn)) == SEQUENCE)
3844 {
3845 rtx seq = PATTERN (insn);
3846 int i, n = XVECLEN (seq, 0);
3847 for (i = 0; i < n; ++i)
3848 {
3849 rtx subinsn = XVECEXP (seq, 0, i);
3850 if (INSN_P (subinsn))
3851 for_each_rtx (&PATTERN (subinsn), mark_constant, NULL);
3852 }
3853 }
3854 else
3855 for_each_rtx (&PATTERN (insn), mark_constant, NULL);
3856 }
3857
3858 /* Look through the instructions for this function, and mark all the
3859 entries in POOL which are actually being used. Emit deferred constants
3860 which have indeed been used. */
3861
3862 static void
3863 mark_constant_pool (void)
3864 {
3865 rtx insn, link;
3866
3867 if (!crtl->uses_const_pool && n_deferred_constants == 0)
3868 return;
3869
3870 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3871 mark_constants (insn);
3872
3873 for (link = crtl->epilogue_delay_list;
3874 link;
3875 link = XEXP (link, 1))
3876 mark_constants (XEXP (link, 0));
3877 }
3878
3879 /* Write all the constants in POOL. */
3880
3881 static void
3882 output_constant_pool_contents (struct rtx_constant_pool *pool)
3883 {
3884 struct constant_descriptor_rtx *desc;
3885
3886 for (desc = pool->first; desc ; desc = desc->next)
3887 if (desc->mark)
3888 {
3889 /* If the constant is part of an object_block, make sure that
3890 the constant has been positioned within its block, but do not
3891 write out its definition yet. output_object_blocks will do
3892 that later. */
3893 if (SYMBOL_REF_HAS_BLOCK_INFO_P (desc->sym)
3894 && SYMBOL_REF_BLOCK (desc->sym))
3895 place_block_symbol (desc->sym);
3896 else
3897 {
3898 switch_to_section (targetm.asm_out.select_rtx_section
3899 (desc->mode, desc->constant, desc->align));
3900 output_constant_pool_1 (desc, desc->align);
3901 }
3902 }
3903 }
3904
3905 /* Mark all constants that are used in the current function, then write
3906 out the function's private constant pool. */
3907
3908 static void
3909 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED,
3910 tree fndecl ATTRIBUTE_UNUSED)
3911 {
3912 struct rtx_constant_pool *pool = crtl->varasm.pool;
3913
3914 /* It is possible for gcc to call force_const_mem and then to later
3915 discard the instructions which refer to the constant. In such a
3916 case we do not need to output the constant. */
3917 mark_constant_pool ();
3918
3919 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3920 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool->offset);
3921 #endif
3922
3923 output_constant_pool_contents (pool);
3924
3925 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3926 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool->offset);
3927 #endif
3928 }
3929 \f
3930 /* Write the contents of the shared constant pool. */
3931
3932 void
3933 output_shared_constant_pool (void)
3934 {
3935 output_constant_pool_contents (shared_constant_pool);
3936 }
3937 \f
3938 /* Determine what kind of relocations EXP may need. */
3939
3940 int
3941 compute_reloc_for_constant (tree exp)
3942 {
3943 int reloc = 0, reloc2;
3944 tree tem;
3945
3946 switch (TREE_CODE (exp))
3947 {
3948 case ADDR_EXPR:
3949 case FDESC_EXPR:
3950 /* Go inside any operations that get_inner_reference can handle and see
3951 if what's inside is a constant: no need to do anything here for
3952 addresses of variables or functions. */
3953 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
3954 tem = TREE_OPERAND (tem, 0))
3955 ;
3956
3957 if (TREE_PUBLIC (tem))
3958 reloc |= 2;
3959 else
3960 reloc |= 1;
3961 break;
3962
3963 case PLUS_EXPR:
3964 case POINTER_PLUS_EXPR:
3965 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3966 reloc |= compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3967 break;
3968
3969 case MINUS_EXPR:
3970 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3971 reloc2 = compute_reloc_for_constant (TREE_OPERAND (exp, 1));
3972 /* The difference of two local labels is computable at link time. */
3973 if (reloc == 1 && reloc2 == 1)
3974 reloc = 0;
3975 else
3976 reloc |= reloc2;
3977 break;
3978
3979 CASE_CONVERT:
3980 case VIEW_CONVERT_EXPR:
3981 reloc = compute_reloc_for_constant (TREE_OPERAND (exp, 0));
3982 break;
3983
3984 case CONSTRUCTOR:
3985 {
3986 unsigned HOST_WIDE_INT idx;
3987 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
3988 if (tem != 0)
3989 reloc |= compute_reloc_for_constant (tem);
3990 }
3991 break;
3992
3993 default:
3994 break;
3995 }
3996 return reloc;
3997 }
3998
3999 /* Find all the constants whose addresses are referenced inside of EXP,
4000 and make sure assembler code with a label has been output for each one.
4001 Indicate whether an ADDR_EXPR has been encountered. */
4002
4003 static void
4004 output_addressed_constants (tree exp)
4005 {
4006 tree tem;
4007
4008 switch (TREE_CODE (exp))
4009 {
4010 case ADDR_EXPR:
4011 case FDESC_EXPR:
4012 /* Go inside any operations that get_inner_reference can handle and see
4013 if what's inside is a constant: no need to do anything here for
4014 addresses of variables or functions. */
4015 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
4016 tem = TREE_OPERAND (tem, 0))
4017 ;
4018
4019 /* If we have an initialized CONST_DECL, retrieve the initializer. */
4020 if (TREE_CODE (tem) == CONST_DECL && DECL_INITIAL (tem))
4021 tem = DECL_INITIAL (tem);
4022
4023 if (CONSTANT_CLASS_P (tem) || TREE_CODE (tem) == CONSTRUCTOR)
4024 output_constant_def (tem, 0);
4025 break;
4026
4027 case PLUS_EXPR:
4028 case POINTER_PLUS_EXPR:
4029 case MINUS_EXPR:
4030 output_addressed_constants (TREE_OPERAND (exp, 1));
4031 /* Fall through. */
4032
4033 CASE_CONVERT:
4034 case VIEW_CONVERT_EXPR:
4035 output_addressed_constants (TREE_OPERAND (exp, 0));
4036 break;
4037
4038 case CONSTRUCTOR:
4039 {
4040 unsigned HOST_WIDE_INT idx;
4041 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), idx, tem)
4042 if (tem != 0)
4043 output_addressed_constants (tem);
4044 }
4045 break;
4046
4047 default:
4048 break;
4049 }
4050 }
4051 \f
4052 /* Whether a constructor CTOR is a valid static constant initializer if all
4053 its elements are. This used to be internal to initializer_constant_valid_p
4054 and has been exposed to let other functions like categorize_ctor_elements
4055 evaluate the property while walking a constructor for other purposes. */
4056
4057 bool
4058 constructor_static_from_elts_p (const_tree ctor)
4059 {
4060 return (TREE_CONSTANT (ctor)
4061 && (TREE_CODE (TREE_TYPE (ctor)) == UNION_TYPE
4062 || TREE_CODE (TREE_TYPE (ctor)) == RECORD_TYPE)
4063 && !VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (ctor)));
4064 }
4065
4066 /* A subroutine of initializer_constant_valid_p. VALUE is either a
4067 MINUS_EXPR or a POINTER_PLUS_EXPR, and ENDTYPE is a narrowing
4068 conversion to something smaller than a pointer. This returns
4069 null_pointer_node if the resulting value is an absolute constant
4070 which can be used to initialize a static variable. Otherwise it
4071 returns NULL. */
4072
4073 static tree
4074 narrowing_initializer_constant_valid_p (tree value, tree endtype)
4075 {
4076 tree op0, op1;
4077
4078 op0 = TREE_OPERAND (value, 0);
4079 op1 = TREE_OPERAND (value, 1);
4080
4081 /* Like STRIP_NOPS except allow the operand mode to widen. This
4082 works around a feature of fold that simplifies (int)(p1 - p2) to
4083 ((int)p1 - (int)p2) under the theory that the narrower operation
4084 is cheaper. */
4085
4086 while (CONVERT_EXPR_P (op0)
4087 || TREE_CODE (op0) == NON_LVALUE_EXPR)
4088 {
4089 tree inner = TREE_OPERAND (op0, 0);
4090 if (inner == error_mark_node
4091 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
4092 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0)))
4093 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
4094 break;
4095 op0 = inner;
4096 }
4097
4098 while (CONVERT_EXPR_P (op1)
4099 || TREE_CODE (op1) == NON_LVALUE_EXPR)
4100 {
4101 tree inner = TREE_OPERAND (op1, 0);
4102 if (inner == error_mark_node
4103 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner)))
4104 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1)))
4105 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner)))))
4106 break;
4107 op1 = inner;
4108 }
4109
4110 op0 = initializer_constant_valid_p (op0, endtype);
4111 op1 = initializer_constant_valid_p (op1, endtype);
4112
4113 /* Both initializers must be known. */
4114 if (op0 && op1)
4115 {
4116 if (op0 == op1)
4117 return null_pointer_node;
4118
4119 /* Support differences between labels. */
4120 if (TREE_CODE (op0) == LABEL_DECL
4121 && TREE_CODE (op1) == LABEL_DECL)
4122 return null_pointer_node;
4123
4124 if (TREE_CODE (op0) == STRING_CST
4125 && TREE_CODE (op1) == STRING_CST
4126 && operand_equal_p (op0, op1, 1))
4127 return null_pointer_node;
4128 }
4129
4130 return NULL_TREE;
4131 }
4132
4133 /* Return nonzero if VALUE is a valid constant-valued expression
4134 for use in initializing a static variable; one that can be an
4135 element of a "constant" initializer.
4136
4137 Return null_pointer_node if the value is absolute;
4138 if it is relocatable, return the variable that determines the relocation.
4139 We assume that VALUE has been folded as much as possible;
4140 therefore, we do not need to check for such things as
4141 arithmetic-combinations of integers. */
4142
4143 tree
4144 initializer_constant_valid_p (tree value, tree endtype)
4145 {
4146 tree ret;
4147
4148 switch (TREE_CODE (value))
4149 {
4150 case CONSTRUCTOR:
4151 if (constructor_static_from_elts_p (value))
4152 {
4153 unsigned HOST_WIDE_INT idx;
4154 tree elt;
4155 bool absolute = true;
4156
4157 FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (value), idx, elt)
4158 {
4159 tree reloc;
4160 reloc = initializer_constant_valid_p (elt, TREE_TYPE (elt));
4161 if (!reloc)
4162 return NULL_TREE;
4163 if (reloc != null_pointer_node)
4164 absolute = false;
4165 }
4166 /* For a non-absolute relocation, there is no single
4167 variable that can be "the variable that determines the
4168 relocation." */
4169 return absolute ? null_pointer_node : error_mark_node;
4170 }
4171
4172 return TREE_STATIC (value) ? null_pointer_node : NULL_TREE;
4173
4174 case INTEGER_CST:
4175 case VECTOR_CST:
4176 case REAL_CST:
4177 case FIXED_CST:
4178 case STRING_CST:
4179 case COMPLEX_CST:
4180 return null_pointer_node;
4181
4182 case ADDR_EXPR:
4183 case FDESC_EXPR:
4184 {
4185 tree op0 = staticp (TREE_OPERAND (value, 0));
4186 if (op0)
4187 {
4188 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out
4189 to be a constant, this is old-skool offsetof-like nonsense. */
4190 if (TREE_CODE (op0) == INDIRECT_REF
4191 && TREE_CONSTANT (TREE_OPERAND (op0, 0)))
4192 return null_pointer_node;
4193 /* Taking the address of a nested function involves a trampoline,
4194 unless we don't need or want one. */
4195 if (TREE_CODE (op0) == FUNCTION_DECL
4196 && decl_function_context (op0)
4197 && !DECL_NO_STATIC_CHAIN (op0)
4198 && !TREE_NO_TRAMPOLINE (value))
4199 return NULL_TREE;
4200 /* "&{...}" requires a temporary to hold the constructed
4201 object. */
4202 if (TREE_CODE (op0) == CONSTRUCTOR)
4203 return NULL_TREE;
4204 }
4205 return op0;
4206 }
4207
4208 case NON_LVALUE_EXPR:
4209 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4210
4211 case VIEW_CONVERT_EXPR:
4212 {
4213 tree src = TREE_OPERAND (value, 0);
4214 tree src_type = TREE_TYPE (src);
4215 tree dest_type = TREE_TYPE (value);
4216
4217 /* Allow view-conversions from aggregate to non-aggregate type only
4218 if the bit pattern is fully preserved afterwards; otherwise, the
4219 RTL expander won't be able to apply a subsequent transformation
4220 to the underlying constructor. */
4221 if (AGGREGATE_TYPE_P (src_type) && !AGGREGATE_TYPE_P (dest_type))
4222 {
4223 if (TYPE_MODE (endtype) == TYPE_MODE (dest_type))
4224 return initializer_constant_valid_p (src, endtype);
4225 else
4226 return NULL_TREE;
4227 }
4228
4229 /* Allow all other kinds of view-conversion. */
4230 return initializer_constant_valid_p (src, endtype);
4231 }
4232
4233 CASE_CONVERT:
4234 {
4235 tree src = TREE_OPERAND (value, 0);
4236 tree src_type = TREE_TYPE (src);
4237 tree dest_type = TREE_TYPE (value);
4238
4239 /* Allow conversions between pointer types, floating-point
4240 types, and offset types. */
4241 if ((POINTER_TYPE_P (dest_type) && POINTER_TYPE_P (src_type))
4242 || (FLOAT_TYPE_P (dest_type) && FLOAT_TYPE_P (src_type))
4243 || (TREE_CODE (dest_type) == OFFSET_TYPE
4244 && TREE_CODE (src_type) == OFFSET_TYPE))
4245 return initializer_constant_valid_p (src, endtype);
4246
4247 /* Allow length-preserving conversions between integer types. */
4248 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type)
4249 && (TYPE_PRECISION (dest_type) == TYPE_PRECISION (src_type)))
4250 return initializer_constant_valid_p (src, endtype);
4251
4252 /* Allow conversions between other integer types only if
4253 explicit value. */
4254 if (INTEGRAL_TYPE_P (dest_type) && INTEGRAL_TYPE_P (src_type))
4255 {
4256 tree inner = initializer_constant_valid_p (src, endtype);
4257 if (inner == null_pointer_node)
4258 return null_pointer_node;
4259 break;
4260 }
4261
4262 /* Allow (int) &foo provided int is as wide as a pointer. */
4263 if (INTEGRAL_TYPE_P (dest_type) && POINTER_TYPE_P (src_type)
4264 && (TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type)))
4265 return initializer_constant_valid_p (src, endtype);
4266
4267 /* Likewise conversions from int to pointers, but also allow
4268 conversions from 0. */
4269 if ((POINTER_TYPE_P (dest_type)
4270 || TREE_CODE (dest_type) == OFFSET_TYPE)
4271 && INTEGRAL_TYPE_P (src_type))
4272 {
4273 if (TREE_CODE (src) == INTEGER_CST
4274 && TYPE_PRECISION (dest_type) >= TYPE_PRECISION (src_type))
4275 return null_pointer_node;
4276 if (integer_zerop (src))
4277 return null_pointer_node;
4278 else if (TYPE_PRECISION (dest_type) <= TYPE_PRECISION (src_type))
4279 return initializer_constant_valid_p (src, endtype);
4280 }
4281
4282 /* Allow conversions to struct or union types if the value
4283 inside is okay. */
4284 if (TREE_CODE (dest_type) == RECORD_TYPE
4285 || TREE_CODE (dest_type) == UNION_TYPE)
4286 return initializer_constant_valid_p (src, endtype);
4287 }
4288 break;
4289
4290 case POINTER_PLUS_EXPR:
4291 case PLUS_EXPR:
4292 if (! INTEGRAL_TYPE_P (endtype)
4293 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4294 {
4295 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4296 endtype);
4297 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4298 endtype);
4299 /* If either term is absolute, use the other term's relocation. */
4300 if (valid0 == null_pointer_node)
4301 return valid1;
4302 if (valid1 == null_pointer_node)
4303 return valid0;
4304 }
4305
4306 /* Support narrowing pointer differences. */
4307 if (TREE_CODE (value) == POINTER_PLUS_EXPR)
4308 {
4309 ret = narrowing_initializer_constant_valid_p (value, endtype);
4310 if (ret != NULL_TREE)
4311 return ret;
4312 }
4313 break;
4314
4315 case MINUS_EXPR:
4316 if (! INTEGRAL_TYPE_P (endtype)
4317 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4318 {
4319 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4320 endtype);
4321 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4322 endtype);
4323 /* Win if second argument is absolute. */
4324 if (valid1 == null_pointer_node)
4325 return valid0;
4326 /* Win if both arguments have the same relocation.
4327 Then the value is absolute. */
4328 if (valid0 == valid1 && valid0 != 0)
4329 return null_pointer_node;
4330
4331 /* Since GCC guarantees that string constants are unique in the
4332 generated code, a subtraction between two copies of the same
4333 constant string is absolute. */
4334 if (valid0 && TREE_CODE (valid0) == STRING_CST
4335 && valid1 && TREE_CODE (valid1) == STRING_CST
4336 && operand_equal_p (valid0, valid1, 1))
4337 return null_pointer_node;
4338 }
4339
4340 /* Support narrowing differences. */
4341 ret = narrowing_initializer_constant_valid_p (value, endtype);
4342 if (ret != NULL_TREE)
4343 return ret;
4344
4345 break;
4346
4347 default:
4348 break;
4349 }
4350
4351 return 0;
4352 }
4353 \f
4354 /* Output assembler code for constant EXP to FILE, with no label.
4355 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4356 Assumes output_addressed_constants has been done on EXP already.
4357
4358 Generate exactly SIZE bytes of assembler data, padding at the end
4359 with zeros if necessary. SIZE must always be specified.
4360
4361 SIZE is important for structure constructors,
4362 since trailing members may have been omitted from the constructor.
4363 It is also important for initialization of arrays from string constants
4364 since the full length of the string constant might not be wanted.
4365 It is also needed for initialization of unions, where the initializer's
4366 type is just one member, and that may not be as long as the union.
4367
4368 There a case in which we would fail to output exactly SIZE bytes:
4369 for a structure constructor that wants to produce more than SIZE bytes.
4370 But such constructors will never be generated for any possible input.
4371
4372 ALIGN is the alignment of the data in bits. */
4373
4374 void
4375 output_constant (tree exp, unsigned HOST_WIDE_INT size, unsigned int align)
4376 {
4377 enum tree_code code;
4378 unsigned HOST_WIDE_INT thissize;
4379
4380 if (size == 0 || flag_syntax_only)
4381 return;
4382
4383 /* See if we're trying to initialize a pointer in a non-default mode
4384 to the address of some declaration somewhere. If the target says
4385 the mode is valid for pointers, assume the target has a way of
4386 resolving it. */
4387 if (TREE_CODE (exp) == NOP_EXPR
4388 && POINTER_TYPE_P (TREE_TYPE (exp))
4389 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
4390 {
4391 tree saved_type = TREE_TYPE (exp);
4392
4393 /* Peel off any intermediate conversions-to-pointer for valid
4394 pointer modes. */
4395 while (TREE_CODE (exp) == NOP_EXPR
4396 && POINTER_TYPE_P (TREE_TYPE (exp))
4397 && targetm.valid_pointer_mode (TYPE_MODE (TREE_TYPE (exp))))
4398 exp = TREE_OPERAND (exp, 0);
4399
4400 /* If what we're left with is the address of something, we can
4401 convert the address to the final type and output it that
4402 way. */
4403 if (TREE_CODE (exp) == ADDR_EXPR)
4404 exp = build1 (ADDR_EXPR, saved_type, TREE_OPERAND (exp, 0));
4405 /* Likewise for constant ints. */
4406 else if (TREE_CODE (exp) == INTEGER_CST)
4407 exp = build_int_cst_wide (saved_type, TREE_INT_CST_LOW (exp),
4408 TREE_INT_CST_HIGH (exp));
4409
4410 }
4411
4412 /* Eliminate any conversions since we'll be outputting the underlying
4413 constant. */
4414 while (CONVERT_EXPR_P (exp)
4415 || TREE_CODE (exp) == NON_LVALUE_EXPR
4416 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4417 {
4418 HOST_WIDE_INT type_size = int_size_in_bytes (TREE_TYPE (exp));
4419 HOST_WIDE_INT op_size = int_size_in_bytes (TREE_TYPE (TREE_OPERAND (exp, 0)));
4420
4421 /* Make sure eliminating the conversion is really a no-op, except with
4422 VIEW_CONVERT_EXPRs to allow for wild Ada unchecked conversions and
4423 union types to allow for Ada unchecked unions. */
4424 if (type_size > op_size
4425 && TREE_CODE (exp) != VIEW_CONVERT_EXPR
4426 && TREE_CODE (TREE_TYPE (exp)) != UNION_TYPE)
4427 /* Keep the conversion. */
4428 break;
4429 else
4430 exp = TREE_OPERAND (exp, 0);
4431 }
4432
4433 code = TREE_CODE (TREE_TYPE (exp));
4434 thissize = int_size_in_bytes (TREE_TYPE (exp));
4435
4436 /* Allow a constructor with no elements for any data type.
4437 This means to fill the space with zeros. */
4438 if (TREE_CODE (exp) == CONSTRUCTOR
4439 && VEC_empty (constructor_elt, CONSTRUCTOR_ELTS (exp)))
4440 {
4441 assemble_zeros (size);
4442 return;
4443 }
4444
4445 if (TREE_CODE (exp) == FDESC_EXPR)
4446 {
4447 #ifdef ASM_OUTPUT_FDESC
4448 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4449 tree decl = TREE_OPERAND (exp, 0);
4450 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4451 #else
4452 gcc_unreachable ();
4453 #endif
4454 return;
4455 }
4456
4457 /* Now output the underlying data. If we've handling the padding, return.
4458 Otherwise, break and ensure SIZE is the size written. */
4459 switch (code)
4460 {
4461 case BOOLEAN_TYPE:
4462 case INTEGER_TYPE:
4463 case ENUMERAL_TYPE:
4464 case POINTER_TYPE:
4465 case REFERENCE_TYPE:
4466 case OFFSET_TYPE:
4467 case FIXED_POINT_TYPE:
4468 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4469 EXPAND_INITIALIZER),
4470 MIN (size, thissize), align, 0))
4471 error ("initializer for integer/fixed-point value is too complicated");
4472 break;
4473
4474 case REAL_TYPE:
4475 if (TREE_CODE (exp) != REAL_CST)
4476 error ("initializer for floating value is not a floating constant");
4477
4478 assemble_real (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)), align);
4479 break;
4480
4481 case COMPLEX_TYPE:
4482 output_constant (TREE_REALPART (exp), thissize / 2, align);
4483 output_constant (TREE_IMAGPART (exp), thissize / 2,
4484 min_align (align, BITS_PER_UNIT * (thissize / 2)));
4485 break;
4486
4487 case ARRAY_TYPE:
4488 case VECTOR_TYPE:
4489 switch (TREE_CODE (exp))
4490 {
4491 case CONSTRUCTOR:
4492 output_constructor (exp, size, align);
4493 return;
4494 case STRING_CST:
4495 thissize = MIN ((unsigned HOST_WIDE_INT)TREE_STRING_LENGTH (exp),
4496 size);
4497 assemble_string (TREE_STRING_POINTER (exp), thissize);
4498 break;
4499
4500 case VECTOR_CST:
4501 {
4502 int elt_size;
4503 tree link;
4504 unsigned int nalign;
4505 enum machine_mode inner;
4506
4507 inner = TYPE_MODE (TREE_TYPE (TREE_TYPE (exp)));
4508 nalign = MIN (align, GET_MODE_ALIGNMENT (inner));
4509
4510 elt_size = GET_MODE_SIZE (inner);
4511
4512 link = TREE_VECTOR_CST_ELTS (exp);
4513 output_constant (TREE_VALUE (link), elt_size, align);
4514 thissize = elt_size;
4515 while ((link = TREE_CHAIN (link)) != NULL)
4516 {
4517 output_constant (TREE_VALUE (link), elt_size, nalign);
4518 thissize += elt_size;
4519 }
4520 break;
4521 }
4522 default:
4523 gcc_unreachable ();
4524 }
4525 break;
4526
4527 case RECORD_TYPE:
4528 case UNION_TYPE:
4529 gcc_assert (TREE_CODE (exp) == CONSTRUCTOR);
4530 output_constructor (exp, size, align);
4531 return;
4532
4533 case ERROR_MARK:
4534 return;
4535
4536 default:
4537 gcc_unreachable ();
4538 }
4539
4540 if (size > thissize)
4541 assemble_zeros (size - thissize);
4542 }
4543
4544 \f
4545 /* Subroutine of output_constructor, used for computing the size of
4546 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4547 type with an unspecified upper bound. */
4548
4549 static unsigned HOST_WIDE_INT
4550 array_size_for_constructor (tree val)
4551 {
4552 tree max_index, i;
4553 unsigned HOST_WIDE_INT cnt;
4554 tree index, value, tmp;
4555
4556 /* This code used to attempt to handle string constants that are not
4557 arrays of single-bytes, but nothing else does, so there's no point in
4558 doing it here. */
4559 if (TREE_CODE (val) == STRING_CST)
4560 return TREE_STRING_LENGTH (val);
4561
4562 max_index = NULL_TREE;
4563 FOR_EACH_CONSTRUCTOR_ELT (CONSTRUCTOR_ELTS (val), cnt, index, value)
4564 {
4565 if (TREE_CODE (index) == RANGE_EXPR)
4566 index = TREE_OPERAND (index, 1);
4567 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4568 max_index = index;
4569 }
4570
4571 if (max_index == NULL_TREE)
4572 return 0;
4573
4574 /* Compute the total number of array elements. */
4575 tmp = TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)));
4576 i = size_binop (MINUS_EXPR, fold_convert (sizetype, max_index),
4577 fold_convert (sizetype, tmp));
4578 i = size_binop (PLUS_EXPR, i, build_int_cst (sizetype, 1));
4579
4580 /* Multiply by the array element unit size to find number of bytes. */
4581 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4582
4583 return tree_low_cst (i, 1);
4584 }
4585
4586 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4587 Generate at least SIZE bytes, padding if necessary. */
4588
4589 static void
4590 output_constructor (tree exp, unsigned HOST_WIDE_INT size,
4591 unsigned int align)
4592 {
4593 tree type = TREE_TYPE (exp);
4594 tree field = 0;
4595 tree min_index = 0;
4596 /* Number of bytes output or skipped so far.
4597 In other words, current position within the constructor. */
4598 HOST_WIDE_INT total_bytes = 0;
4599 /* Nonzero means BYTE contains part of a byte, to be output. */
4600 int byte_buffer_in_use = 0;
4601 int byte = 0;
4602 unsigned HOST_WIDE_INT cnt;
4603 constructor_elt *ce;
4604
4605 gcc_assert (HOST_BITS_PER_WIDE_INT >= BITS_PER_UNIT);
4606
4607 if (TREE_CODE (type) == RECORD_TYPE)
4608 field = TYPE_FIELDS (type);
4609
4610 if (TREE_CODE (type) == ARRAY_TYPE
4611 && TYPE_DOMAIN (type) != 0)
4612 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4613
4614 /* As LINK goes through the elements of the constant,
4615 FIELD goes through the structure fields, if the constant is a structure.
4616 if the constant is a union, then we override this,
4617 by getting the field from the TREE_LIST element.
4618 But the constant could also be an array. Then FIELD is zero.
4619
4620 There is always a maximum of one element in the chain LINK for unions
4621 (even if the initializer in a source program incorrectly contains
4622 more one). */
4623 for (cnt = 0;
4624 VEC_iterate (constructor_elt, CONSTRUCTOR_ELTS (exp), cnt, ce);
4625 cnt++, field = field ? TREE_CHAIN (field) : 0)
4626 {
4627 tree val = ce->value;
4628 tree index = 0;
4629
4630 /* The element in a union constructor specifies the proper field
4631 or index. */
4632 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4633 || TREE_CODE (type) == QUAL_UNION_TYPE)
4634 && ce->index != 0)
4635 field = ce->index;
4636
4637 else if (TREE_CODE (type) == ARRAY_TYPE)
4638 index = ce->index;
4639
4640 #ifdef ASM_COMMENT_START
4641 if (field && flag_verbose_asm)
4642 fprintf (asm_out_file, "%s %s:\n",
4643 ASM_COMMENT_START,
4644 DECL_NAME (field)
4645 ? IDENTIFIER_POINTER (DECL_NAME (field))
4646 : "<anonymous>");
4647 #endif
4648
4649 /* Eliminate the marker that makes a cast not be an lvalue. */
4650 if (val != 0)
4651 STRIP_NOPS (val);
4652
4653 if (index && TREE_CODE (index) == RANGE_EXPR)
4654 {
4655 unsigned HOST_WIDE_INT fieldsize
4656 = int_size_in_bytes (TREE_TYPE (type));
4657 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4658 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4659 HOST_WIDE_INT index;
4660 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4661
4662 for (index = lo_index; index <= hi_index; index++)
4663 {
4664 /* Output the element's initial value. */
4665 if (val == 0)
4666 assemble_zeros (fieldsize);
4667 else
4668 output_constant (val, fieldsize, align2);
4669
4670 /* Count its size. */
4671 total_bytes += fieldsize;
4672 }
4673 }
4674 else if (field == 0 || !DECL_BIT_FIELD (field))
4675 {
4676 /* An element that is not a bit-field. */
4677
4678 unsigned HOST_WIDE_INT fieldsize;
4679 /* Since this structure is static,
4680 we know the positions are constant. */
4681 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4682 unsigned int align2;
4683
4684 if (index != 0)
4685 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4686 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4687
4688 /* Output any buffered-up bit-fields preceding this element. */
4689 if (byte_buffer_in_use)
4690 {
4691 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4692 total_bytes++;
4693 byte_buffer_in_use = 0;
4694 }
4695
4696 /* Advance to offset of this element.
4697 Note no alignment needed in an array, since that is guaranteed
4698 if each element has the proper size. */
4699 if ((field != 0 || index != 0) && pos != total_bytes)
4700 {
4701 gcc_assert (pos >= total_bytes);
4702 assemble_zeros (pos - total_bytes);
4703 total_bytes = pos;
4704 }
4705
4706 /* Find the alignment of this element. */
4707 align2 = min_align (align, BITS_PER_UNIT * pos);
4708
4709 /* Determine size this element should occupy. */
4710 if (field)
4711 {
4712 fieldsize = 0;
4713
4714 /* If this is an array with an unspecified upper bound,
4715 the initializer determines the size. */
4716 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4717 but we cannot do this until the deprecated support for
4718 initializing zero-length array members is removed. */
4719 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4720 && TYPE_DOMAIN (TREE_TYPE (field))
4721 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4722 {
4723 fieldsize = array_size_for_constructor (val);
4724 /* Given a non-empty initialization, this field had
4725 better be last. */
4726 gcc_assert (!fieldsize || !TREE_CHAIN (field));
4727 }
4728 else if (DECL_SIZE_UNIT (field))
4729 {
4730 /* ??? This can't be right. If the decl size overflows
4731 a host integer we will silently emit no data. */
4732 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4733 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4734 }
4735 }
4736 else
4737 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4738
4739 /* Output the element's initial value. */
4740 if (val == 0)
4741 assemble_zeros (fieldsize);
4742 else
4743 output_constant (val, fieldsize, align2);
4744
4745 /* Count its size. */
4746 total_bytes += fieldsize;
4747 }
4748 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4749 error ("invalid initial value for member %qs",
4750 IDENTIFIER_POINTER (DECL_NAME (field)));
4751 else
4752 {
4753 /* Element that is a bit-field. */
4754
4755 HOST_WIDE_INT next_offset = int_bit_position (field);
4756 HOST_WIDE_INT end_offset
4757 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4758
4759 if (val == 0)
4760 val = integer_zero_node;
4761
4762 /* If this field does not start in this (or, next) byte,
4763 skip some bytes. */
4764 if (next_offset / BITS_PER_UNIT != total_bytes)
4765 {
4766 /* Output remnant of any bit field in previous bytes. */
4767 if (byte_buffer_in_use)
4768 {
4769 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4770 total_bytes++;
4771 byte_buffer_in_use = 0;
4772 }
4773
4774 /* If still not at proper byte, advance to there. */
4775 if (next_offset / BITS_PER_UNIT != total_bytes)
4776 {
4777 gcc_assert (next_offset / BITS_PER_UNIT >= total_bytes);
4778 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4779 total_bytes = next_offset / BITS_PER_UNIT;
4780 }
4781 }
4782
4783 if (! byte_buffer_in_use)
4784 byte = 0;
4785
4786 /* We must split the element into pieces that fall within
4787 separate bytes, and combine each byte with previous or
4788 following bit-fields. */
4789
4790 /* next_offset is the offset n fbits from the beginning of
4791 the structure to the next bit of this element to be processed.
4792 end_offset is the offset of the first bit past the end of
4793 this element. */
4794 while (next_offset < end_offset)
4795 {
4796 int this_time;
4797 int shift;
4798 HOST_WIDE_INT value;
4799 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4800 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4801
4802 /* Advance from byte to byte
4803 within this element when necessary. */
4804 while (next_byte != total_bytes)
4805 {
4806 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4807 total_bytes++;
4808 byte = 0;
4809 }
4810
4811 /* Number of bits we can process at once
4812 (all part of the same byte). */
4813 this_time = MIN (end_offset - next_offset,
4814 BITS_PER_UNIT - next_bit);
4815 if (BYTES_BIG_ENDIAN)
4816 {
4817 /* On big-endian machine, take the most significant bits
4818 first (of the bits that are significant)
4819 and put them into bytes from the most significant end. */
4820 shift = end_offset - next_offset - this_time;
4821
4822 /* Don't try to take a bunch of bits that cross
4823 the word boundary in the INTEGER_CST. We can
4824 only select bits from the LOW or HIGH part
4825 not from both. */
4826 if (shift < HOST_BITS_PER_WIDE_INT
4827 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4828 {
4829 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4830 shift = HOST_BITS_PER_WIDE_INT;
4831 }
4832
4833 /* Now get the bits from the appropriate constant word. */
4834 if (shift < HOST_BITS_PER_WIDE_INT)
4835 value = TREE_INT_CST_LOW (val);
4836 else
4837 {
4838 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4839 value = TREE_INT_CST_HIGH (val);
4840 shift -= HOST_BITS_PER_WIDE_INT;
4841 }
4842
4843 /* Get the result. This works only when:
4844 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4845 byte |= (((value >> shift)
4846 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4847 << (BITS_PER_UNIT - this_time - next_bit));
4848 }
4849 else
4850 {
4851 /* On little-endian machines,
4852 take first the least significant bits of the value
4853 and pack them starting at the least significant
4854 bits of the bytes. */
4855 shift = next_offset - int_bit_position (field);
4856
4857 /* Don't try to take a bunch of bits that cross
4858 the word boundary in the INTEGER_CST. We can
4859 only select bits from the LOW or HIGH part
4860 not from both. */
4861 if (shift < HOST_BITS_PER_WIDE_INT
4862 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4863 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4864
4865 /* Now get the bits from the appropriate constant word. */
4866 if (shift < HOST_BITS_PER_WIDE_INT)
4867 value = TREE_INT_CST_LOW (val);
4868 else
4869 {
4870 gcc_assert (shift < 2 * HOST_BITS_PER_WIDE_INT);
4871 value = TREE_INT_CST_HIGH (val);
4872 shift -= HOST_BITS_PER_WIDE_INT;
4873 }
4874
4875 /* Get the result. This works only when:
4876 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4877 byte |= (((value >> shift)
4878 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4879 << next_bit);
4880 }
4881
4882 next_offset += this_time;
4883 byte_buffer_in_use = 1;
4884 }
4885 }
4886 }
4887
4888 if (byte_buffer_in_use)
4889 {
4890 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4891 total_bytes++;
4892 }
4893
4894 if ((unsigned HOST_WIDE_INT)total_bytes < size)
4895 assemble_zeros (size - total_bytes);
4896 }
4897
4898 /* Mark DECL as weak. */
4899
4900 static void
4901 mark_weak (tree decl)
4902 {
4903 DECL_WEAK (decl) = 1;
4904
4905 if (DECL_RTL_SET_P (decl)
4906 && MEM_P (DECL_RTL (decl))
4907 && XEXP (DECL_RTL (decl), 0)
4908 && GET_CODE (XEXP (DECL_RTL (decl), 0)) == SYMBOL_REF)
4909 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = 1;
4910 }
4911
4912 /* Merge weak status between NEWDECL and OLDDECL. */
4913
4914 void
4915 merge_weak (tree newdecl, tree olddecl)
4916 {
4917 if (DECL_WEAK (newdecl) == DECL_WEAK (olddecl))
4918 {
4919 if (DECL_WEAK (newdecl) && SUPPORTS_WEAK)
4920 {
4921 tree *pwd;
4922 /* We put the NEWDECL on the weak_decls list at some point
4923 and OLDDECL as well. Keep just OLDDECL on the list. */
4924 for (pwd = &weak_decls; *pwd; pwd = &TREE_CHAIN (*pwd))
4925 if (TREE_VALUE (*pwd) == newdecl)
4926 {
4927 *pwd = TREE_CHAIN (*pwd);
4928 break;
4929 }
4930 }
4931 return;
4932 }
4933
4934 if (DECL_WEAK (newdecl))
4935 {
4936 tree wd;
4937
4938 /* NEWDECL is weak, but OLDDECL is not. */
4939
4940 /* If we already output the OLDDECL, we're in trouble; we can't
4941 go back and make it weak. This error cannot be caught in
4942 declare_weak because the NEWDECL and OLDDECL was not yet
4943 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4944 if (TREE_ASM_WRITTEN (olddecl))
4945 error ("weak declaration of %q+D must precede definition",
4946 newdecl);
4947
4948 /* If we've already generated rtl referencing OLDDECL, we may
4949 have done so in a way that will not function properly with
4950 a weak symbol. */
4951 else if (TREE_USED (olddecl)
4952 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl)))
4953 warning (0, "weak declaration of %q+D after first use results "
4954 "in unspecified behavior", newdecl);
4955
4956 if (SUPPORTS_WEAK)
4957 {
4958 /* We put the NEWDECL on the weak_decls list at some point.
4959 Replace it with the OLDDECL. */
4960 for (wd = weak_decls; wd; wd = TREE_CHAIN (wd))
4961 if (TREE_VALUE (wd) == newdecl)
4962 {
4963 TREE_VALUE (wd) = olddecl;
4964 break;
4965 }
4966 /* We may not find the entry on the list. If NEWDECL is a
4967 weak alias, then we will have already called
4968 globalize_decl to remove the entry; in that case, we do
4969 not need to do anything. */
4970 }
4971
4972 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4973 mark_weak (olddecl);
4974 }
4975 else
4976 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4977 weak. Just update NEWDECL to indicate that it's weak too. */
4978 mark_weak (newdecl);
4979 }
4980
4981 /* Declare DECL to be a weak symbol. */
4982
4983 void
4984 declare_weak (tree decl)
4985 {
4986 if (! TREE_PUBLIC (decl))
4987 error ("weak declaration of %q+D must be public", decl);
4988 else if (TREE_CODE (decl) == FUNCTION_DECL && TREE_ASM_WRITTEN (decl))
4989 error ("weak declaration of %q+D must precede definition", decl);
4990 else if (!SUPPORTS_WEAK)
4991 warning (0, "weak declaration of %q+D not supported", decl);
4992
4993 mark_weak (decl);
4994 }
4995
4996 static void
4997 weak_finish_1 (tree decl)
4998 {
4999 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
5000 const char *const name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5001 #endif
5002
5003 if (! TREE_USED (decl))
5004 return;
5005
5006 #ifdef ASM_WEAKEN_DECL
5007 ASM_WEAKEN_DECL (asm_out_file, decl, name, NULL);
5008 #else
5009 #ifdef ASM_WEAKEN_LABEL
5010 ASM_WEAKEN_LABEL (asm_out_file, name);
5011 #else
5012 #ifdef ASM_OUTPUT_WEAK_ALIAS
5013 {
5014 static bool warn_once = 0;
5015 if (! warn_once)
5016 {
5017 warning (0, "only weak aliases are supported in this configuration");
5018 warn_once = 1;
5019 }
5020 return;
5021 }
5022 #endif
5023 #endif
5024 #endif
5025 }
5026
5027 /* This TREE_LIST contains weakref targets. */
5028
5029 static GTY(()) tree weakref_targets;
5030
5031 /* Forward declaration. */
5032 static tree find_decl_and_mark_needed (tree decl, tree target);
5033
5034 /* Emit any pending weak declarations. */
5035
5036 void
5037 weak_finish (void)
5038 {
5039 tree t;
5040
5041 for (t = weakref_targets; t; t = TREE_CHAIN (t))
5042 {
5043 tree alias_decl = TREE_PURPOSE (t);
5044 tree target = ultimate_transparent_alias_target (&TREE_VALUE (t));
5045
5046 if (! TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (alias_decl)))
5047 /* Remove alias_decl from the weak list, but leave entries for
5048 the target alone. */
5049 target = NULL_TREE;
5050 #ifndef ASM_OUTPUT_WEAKREF
5051 else if (! TREE_SYMBOL_REFERENCED (target))
5052 {
5053 /* Use ASM_WEAKEN_LABEL only if ASM_WEAKEN_DECL is not
5054 defined, otherwise we and weak_finish_1 would use
5055 different macros. */
5056 # if defined ASM_WEAKEN_LABEL && ! defined ASM_WEAKEN_DECL
5057 ASM_WEAKEN_LABEL (asm_out_file, IDENTIFIER_POINTER (target));
5058 # else
5059 tree decl = find_decl_and_mark_needed (alias_decl, target);
5060
5061 if (! decl)
5062 {
5063 decl = build_decl (TREE_CODE (alias_decl), target,
5064 TREE_TYPE (alias_decl));
5065
5066 DECL_EXTERNAL (decl) = 1;
5067 TREE_PUBLIC (decl) = 1;
5068 DECL_ARTIFICIAL (decl) = 1;
5069 TREE_NOTHROW (decl) = TREE_NOTHROW (alias_decl);
5070 TREE_USED (decl) = 1;
5071 }
5072
5073 weak_finish_1 (decl);
5074 # endif
5075 }
5076 #endif
5077
5078 {
5079 tree *p;
5080 tree t2;
5081
5082 /* Remove the alias and the target from the pending weak list
5083 so that we do not emit any .weak directives for the former,
5084 nor multiple .weak directives for the latter. */
5085 for (p = &weak_decls; (t2 = *p) ; )
5086 {
5087 if (TREE_VALUE (t2) == alias_decl
5088 || target == DECL_ASSEMBLER_NAME (TREE_VALUE (t2)))
5089 *p = TREE_CHAIN (t2);
5090 else
5091 p = &TREE_CHAIN (t2);
5092 }
5093
5094 /* Remove other weakrefs to the same target, to speed things up. */
5095 for (p = &TREE_CHAIN (t); (t2 = *p) ; )
5096 {
5097 if (target == ultimate_transparent_alias_target (&TREE_VALUE (t2)))
5098 *p = TREE_CHAIN (t2);
5099 else
5100 p = &TREE_CHAIN (t2);
5101 }
5102 }
5103 }
5104
5105 for (t = weak_decls; t; t = TREE_CHAIN (t))
5106 {
5107 tree decl = TREE_VALUE (t);
5108
5109 weak_finish_1 (decl);
5110 }
5111 }
5112
5113 /* Emit the assembly bits to indicate that DECL is globally visible. */
5114
5115 static void
5116 globalize_decl (tree decl)
5117 {
5118
5119 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5120 if (DECL_WEAK (decl))
5121 {
5122 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
5123 tree *p, t;
5124
5125 #ifdef ASM_WEAKEN_DECL
5126 ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
5127 #else
5128 ASM_WEAKEN_LABEL (asm_out_file, name);
5129 #endif
5130
5131 /* Remove this function from the pending weak list so that
5132 we do not emit multiple .weak directives for it. */
5133 for (p = &weak_decls; (t = *p) ; )
5134 {
5135 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
5136 *p = TREE_CHAIN (t);
5137 else
5138 p = &TREE_CHAIN (t);
5139 }
5140
5141 /* Remove weakrefs to the same target from the pending weakref
5142 list, for the same reason. */
5143 for (p = &weakref_targets; (t = *p) ; )
5144 {
5145 if (DECL_ASSEMBLER_NAME (decl)
5146 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
5147 *p = TREE_CHAIN (t);
5148 else
5149 p = &TREE_CHAIN (t);
5150 }
5151
5152 return;
5153 }
5154 #endif
5155
5156 targetm.asm_out.globalize_decl_name (asm_out_file, decl);
5157 }
5158
5159 /* We have to be able to tell cgraph about the needed-ness of the target
5160 of an alias. This requires that the decl have been defined. Aliases
5161 that precede their definition have to be queued for later processing. */
5162
5163 typedef struct alias_pair GTY(())
5164 {
5165 tree decl;
5166 tree target;
5167 } alias_pair;
5168
5169 /* Define gc'd vector type. */
5170 DEF_VEC_O(alias_pair);
5171 DEF_VEC_ALLOC_O(alias_pair,gc);
5172
5173 static GTY(()) VEC(alias_pair,gc) *alias_pairs;
5174
5175 /* Given an assembly name, find the decl it is associated with. At the
5176 same time, mark it needed for cgraph. */
5177
5178 static tree
5179 find_decl_and_mark_needed (tree decl, tree target)
5180 {
5181 struct cgraph_node *fnode = NULL;
5182 struct varpool_node *vnode = NULL;
5183
5184 if (TREE_CODE (decl) == FUNCTION_DECL)
5185 {
5186 fnode = cgraph_node_for_asm (target);
5187 if (fnode == NULL)
5188 vnode = varpool_node_for_asm (target);
5189 }
5190 else
5191 {
5192 vnode = varpool_node_for_asm (target);
5193 if (vnode == NULL)
5194 fnode = cgraph_node_for_asm (target);
5195 }
5196
5197 if (fnode)
5198 {
5199 /* We can't mark function nodes as used after cgraph global info
5200 is finished. This wouldn't generally be necessary, but C++
5201 virtual table thunks are introduced late in the game and
5202 might seem like they need marking, although in fact they
5203 don't. */
5204 if (! cgraph_global_info_ready)
5205 cgraph_mark_needed_node (fnode);
5206 return fnode->decl;
5207 }
5208 else if (vnode)
5209 {
5210 varpool_mark_needed_node (vnode);
5211 return vnode->decl;
5212 }
5213 else
5214 return NULL_TREE;
5215 }
5216
5217 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
5218 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
5219 tree node is DECL to have the value of the tree node TARGET. */
5220
5221 static void
5222 do_assemble_alias (tree decl, tree target)
5223 {
5224 if (TREE_ASM_WRITTEN (decl))
5225 return;
5226
5227 TREE_ASM_WRITTEN (decl) = 1;
5228 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl)) = 1;
5229
5230 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5231 {
5232 ultimate_transparent_alias_target (&target);
5233
5234 if (!targetm.have_tls
5235 && TREE_CODE (decl) == VAR_DECL
5236 && DECL_THREAD_LOCAL_P (decl))
5237 {
5238 decl = emutls_decl (decl);
5239 target = get_emutls_object_name (target);
5240 }
5241
5242 if (!TREE_SYMBOL_REFERENCED (target))
5243 weakref_targets = tree_cons (decl, target, weakref_targets);
5244
5245 #ifdef ASM_OUTPUT_WEAKREF
5246 ASM_OUTPUT_WEAKREF (asm_out_file, decl,
5247 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
5248 IDENTIFIER_POINTER (target));
5249 #else
5250 if (!SUPPORTS_WEAK)
5251 {
5252 error ("%Jweakref is not supported in this configuration", decl);
5253 return;
5254 }
5255 #endif
5256 return;
5257 }
5258
5259 if (!targetm.have_tls
5260 && TREE_CODE (decl) == VAR_DECL
5261 && DECL_THREAD_LOCAL_P (decl))
5262 {
5263 decl = emutls_decl (decl);
5264 target = get_emutls_object_name (target);
5265 }
5266
5267 #ifdef ASM_OUTPUT_DEF
5268 /* Make name accessible from other files, if appropriate. */
5269
5270 if (TREE_PUBLIC (decl))
5271 {
5272 globalize_decl (decl);
5273 maybe_assemble_visibility (decl);
5274 }
5275
5276 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
5277 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
5278 # else
5279 ASM_OUTPUT_DEF (asm_out_file,
5280 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)),
5281 IDENTIFIER_POINTER (target));
5282 # endif
5283 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5284 {
5285 const char *name;
5286 tree *p, t;
5287
5288 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5289 # ifdef ASM_WEAKEN_DECL
5290 ASM_WEAKEN_DECL (asm_out_file, decl, name, IDENTIFIER_POINTER (target));
5291 # else
5292 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
5293 # endif
5294 /* Remove this function from the pending weak list so that
5295 we do not emit multiple .weak directives for it. */
5296 for (p = &weak_decls; (t = *p) ; )
5297 if (DECL_ASSEMBLER_NAME (decl) == DECL_ASSEMBLER_NAME (TREE_VALUE (t)))
5298 *p = TREE_CHAIN (t);
5299 else
5300 p = &TREE_CHAIN (t);
5301
5302 /* Remove weakrefs to the same target from the pending weakref
5303 list, for the same reason. */
5304 for (p = &weakref_targets; (t = *p) ; )
5305 {
5306 if (DECL_ASSEMBLER_NAME (decl)
5307 == ultimate_transparent_alias_target (&TREE_VALUE (t)))
5308 *p = TREE_CHAIN (t);
5309 else
5310 p = &TREE_CHAIN (t);
5311 }
5312 }
5313 #endif
5314 }
5315
5316 /* First pass of completing pending aliases. Make sure that cgraph knows
5317 which symbols will be required. */
5318
5319 void
5320 finish_aliases_1 (void)
5321 {
5322 unsigned i;
5323 alias_pair *p;
5324
5325 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
5326 {
5327 tree target_decl;
5328
5329 target_decl = find_decl_and_mark_needed (p->decl, p->target);
5330 if (target_decl == NULL)
5331 {
5332 if (! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
5333 error ("%q+D aliased to undefined symbol %qs",
5334 p->decl, IDENTIFIER_POINTER (p->target));
5335 }
5336 else if (DECL_EXTERNAL (target_decl)
5337 && ! lookup_attribute ("weakref", DECL_ATTRIBUTES (p->decl)))
5338 error ("%q+D aliased to external symbol %qs",
5339 p->decl, IDENTIFIER_POINTER (p->target));
5340 }
5341 }
5342
5343 /* Second pass of completing pending aliases. Emit the actual assembly.
5344 This happens at the end of compilation and thus it is assured that the
5345 target symbol has been emitted. */
5346
5347 void
5348 finish_aliases_2 (void)
5349 {
5350 unsigned i;
5351 alias_pair *p;
5352
5353 for (i = 0; VEC_iterate (alias_pair, alias_pairs, i, p); i++)
5354 do_assemble_alias (p->decl, p->target);
5355
5356 VEC_truncate (alias_pair, alias_pairs, 0);
5357 }
5358
5359 /* Emit an assembler directive to make the symbol for DECL an alias to
5360 the symbol for TARGET. */
5361
5362 void
5363 assemble_alias (tree decl, tree target)
5364 {
5365 tree target_decl;
5366 bool is_weakref = false;
5367
5368 if (lookup_attribute ("weakref", DECL_ATTRIBUTES (decl)))
5369 {
5370 tree alias = DECL_ASSEMBLER_NAME (decl);
5371
5372 is_weakref = true;
5373
5374 ultimate_transparent_alias_target (&target);
5375
5376 if (alias == target)
5377 error ("weakref %q+D ultimately targets itself", decl);
5378 else
5379 {
5380 #ifndef ASM_OUTPUT_WEAKREF
5381 IDENTIFIER_TRANSPARENT_ALIAS (alias) = 1;
5382 TREE_CHAIN (alias) = target;
5383 #endif
5384 }
5385 if (TREE_PUBLIC (decl))
5386 error ("weakref %q+D must have static linkage", decl);
5387 }
5388 else
5389 {
5390 #if !defined (ASM_OUTPUT_DEF)
5391 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
5392 error ("%Jalias definitions not supported in this configuration", decl);
5393 return;
5394 # else
5395 if (!DECL_WEAK (decl))
5396 {
5397 error ("%Jonly weak aliases are supported in this configuration", decl);
5398 return;
5399 }
5400 # endif
5401 #endif
5402 }
5403
5404 /* We must force creation of DECL_RTL for debug info generation, even though
5405 we don't use it here. */
5406 make_decl_rtl (decl);
5407 TREE_USED (decl) = 1;
5408
5409 /* A quirk of the initial implementation of aliases required that the user
5410 add "extern" to all of them. Which is silly, but now historical. Do
5411 note that the symbol is in fact locally defined. */
5412 if (! is_weakref)
5413 DECL_EXTERNAL (decl) = 0;
5414
5415 /* Allow aliases to aliases. */
5416 if (TREE_CODE (decl) == FUNCTION_DECL)
5417 cgraph_node (decl)->alias = true;
5418 else
5419 varpool_node (decl)->alias = true;
5420
5421 /* If the target has already been emitted, we don't have to queue the
5422 alias. This saves a tad of memory. */
5423 if (cgraph_global_info_ready)
5424 target_decl = find_decl_and_mark_needed (decl, target);
5425 else
5426 target_decl= NULL;
5427 if (target_decl && TREE_ASM_WRITTEN (target_decl))
5428 do_assemble_alias (decl, target);
5429 else
5430 {
5431 alias_pair *p = VEC_safe_push (alias_pair, gc, alias_pairs, NULL);
5432 p->decl = decl;
5433 p->target = target;
5434 }
5435 }
5436
5437 /* Emit an assembler directive to set symbol for DECL visibility to
5438 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
5439
5440 void
5441 default_assemble_visibility (tree decl, int vis)
5442 {
5443 static const char * const visibility_types[] = {
5444 NULL, "protected", "hidden", "internal"
5445 };
5446
5447 const char *name, *type;
5448
5449 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
5450 type = visibility_types[vis];
5451
5452 #ifdef HAVE_GAS_HIDDEN
5453 fprintf (asm_out_file, "\t.%s\t", type);
5454 assemble_name (asm_out_file, name);
5455 fprintf (asm_out_file, "\n");
5456 #else
5457 warning (OPT_Wattributes, "visibility attribute not supported "
5458 "in this configuration; ignored");
5459 #endif
5460 }
5461
5462 /* A helper function to call assemble_visibility when needed for a decl. */
5463
5464 int
5465 maybe_assemble_visibility (tree decl)
5466 {
5467 enum symbol_visibility vis = DECL_VISIBILITY (decl);
5468
5469 if (vis != VISIBILITY_DEFAULT)
5470 {
5471 targetm.asm_out.visibility (decl, vis);
5472 return 1;
5473 }
5474 else
5475 return 0;
5476 }
5477
5478 /* Returns 1 if the target configuration supports defining public symbols
5479 so that one of them will be chosen at link time instead of generating a
5480 multiply-defined symbol error, whether through the use of weak symbols or
5481 a target-specific mechanism for having duplicates discarded. */
5482
5483 int
5484 supports_one_only (void)
5485 {
5486 if (SUPPORTS_ONE_ONLY)
5487 return 1;
5488 return SUPPORTS_WEAK;
5489 }
5490
5491 /* Set up DECL as a public symbol that can be defined in multiple
5492 translation units without generating a linker error. */
5493
5494 void
5495 make_decl_one_only (tree decl)
5496 {
5497 gcc_assert (TREE_CODE (decl) == VAR_DECL
5498 || TREE_CODE (decl) == FUNCTION_DECL);
5499
5500 TREE_PUBLIC (decl) = 1;
5501
5502 if (SUPPORTS_ONE_ONLY)
5503 {
5504 #ifdef MAKE_DECL_ONE_ONLY
5505 MAKE_DECL_ONE_ONLY (decl);
5506 #endif
5507 DECL_ONE_ONLY (decl) = 1;
5508 }
5509 else if (TREE_CODE (decl) == VAR_DECL
5510 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5511 DECL_COMMON (decl) = 1;
5512 else
5513 {
5514 gcc_assert (SUPPORTS_WEAK);
5515 DECL_WEAK (decl) = 1;
5516 }
5517 }
5518
5519 void
5520 init_varasm_once (void)
5521 {
5522 section_htab = htab_create_ggc (31, section_entry_hash,
5523 section_entry_eq, NULL);
5524 object_block_htab = htab_create_ggc (31, object_block_entry_hash,
5525 object_block_entry_eq, NULL);
5526 const_desc_htab = htab_create_ggc (1009, const_desc_hash,
5527 const_desc_eq, NULL);
5528
5529 const_alias_set = new_alias_set ();
5530 shared_constant_pool = create_constant_pool ();
5531
5532 #ifdef TEXT_SECTION_ASM_OP
5533 text_section = get_unnamed_section (SECTION_CODE, output_section_asm_op,
5534 TEXT_SECTION_ASM_OP);
5535 #endif
5536
5537 #ifdef DATA_SECTION_ASM_OP
5538 data_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5539 DATA_SECTION_ASM_OP);
5540 #endif
5541
5542 #ifdef SDATA_SECTION_ASM_OP
5543 sdata_section = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
5544 SDATA_SECTION_ASM_OP);
5545 #endif
5546
5547 #ifdef READONLY_DATA_SECTION_ASM_OP
5548 readonly_data_section = get_unnamed_section (0, output_section_asm_op,
5549 READONLY_DATA_SECTION_ASM_OP);
5550 #endif
5551
5552 #ifdef CTORS_SECTION_ASM_OP
5553 ctors_section = get_unnamed_section (0, output_section_asm_op,
5554 CTORS_SECTION_ASM_OP);
5555 #endif
5556
5557 #ifdef DTORS_SECTION_ASM_OP
5558 dtors_section = get_unnamed_section (0, output_section_asm_op,
5559 DTORS_SECTION_ASM_OP);
5560 #endif
5561
5562 #ifdef BSS_SECTION_ASM_OP
5563 bss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5564 output_section_asm_op,
5565 BSS_SECTION_ASM_OP);
5566 #endif
5567
5568 #ifdef SBSS_SECTION_ASM_OP
5569 sbss_section = get_unnamed_section (SECTION_WRITE | SECTION_BSS,
5570 output_section_asm_op,
5571 SBSS_SECTION_ASM_OP);
5572 #endif
5573
5574 tls_comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5575 | SECTION_COMMON, emit_tls_common);
5576 lcomm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5577 | SECTION_COMMON, emit_local);
5578 comm_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS
5579 | SECTION_COMMON, emit_common);
5580
5581 #if defined ASM_OUTPUT_ALIGNED_BSS || defined ASM_OUTPUT_BSS
5582 bss_noswitch_section = get_noswitch_section (SECTION_WRITE | SECTION_BSS,
5583 emit_bss);
5584 #endif
5585
5586 targetm.asm_out.init_sections ();
5587
5588 if (readonly_data_section == NULL)
5589 readonly_data_section = text_section;
5590 }
5591
5592 enum tls_model
5593 decl_default_tls_model (const_tree decl)
5594 {
5595 enum tls_model kind;
5596 bool is_local;
5597
5598 is_local = targetm.binds_local_p (decl);
5599 if (!flag_shlib)
5600 {
5601 if (is_local)
5602 kind = TLS_MODEL_LOCAL_EXEC;
5603 else
5604 kind = TLS_MODEL_INITIAL_EXEC;
5605 }
5606
5607 /* Local dynamic is inefficient when we're not combining the
5608 parts of the address. */
5609 else if (optimize && is_local)
5610 kind = TLS_MODEL_LOCAL_DYNAMIC;
5611 else
5612 kind = TLS_MODEL_GLOBAL_DYNAMIC;
5613 if (kind < flag_tls_default)
5614 kind = flag_tls_default;
5615
5616 return kind;
5617 }
5618
5619 /* Select a set of attributes for section NAME based on the properties
5620 of DECL and whether or not RELOC indicates that DECL's initializer
5621 might contain runtime relocations.
5622
5623 We make the section read-only and executable for a function decl,
5624 read-only for a const data decl, and writable for a non-const data decl. */
5625
5626 unsigned int
5627 default_section_type_flags (tree decl, const char *name, int reloc)
5628 {
5629 unsigned int flags;
5630
5631 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5632 flags = SECTION_CODE;
5633 else if (decl && decl_readonly_section (decl, reloc))
5634 flags = 0;
5635 else if (current_function_decl
5636 && cfun
5637 && crtl->subsections.unlikely_text_section_name
5638 && strcmp (name, crtl->subsections.unlikely_text_section_name) == 0)
5639 flags = SECTION_CODE;
5640 else if (!decl
5641 && (!current_function_decl || !cfun)
5642 && strcmp (name, UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
5643 flags = SECTION_CODE;
5644 else
5645 flags = SECTION_WRITE;
5646
5647 if (decl && DECL_ONE_ONLY (decl))
5648 flags |= SECTION_LINKONCE;
5649
5650 if (decl && TREE_CODE (decl) == VAR_DECL && DECL_THREAD_LOCAL_P (decl))
5651 flags |= SECTION_TLS | SECTION_WRITE;
5652
5653 if (strcmp (name, ".bss") == 0
5654 || strncmp (name, ".bss.", 5) == 0
5655 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5656 || strcmp (name, ".sbss") == 0
5657 || strncmp (name, ".sbss.", 6) == 0
5658 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5659 flags |= SECTION_BSS;
5660
5661 if (strcmp (name, ".tdata") == 0
5662 || strncmp (name, ".tdata.", 7) == 0
5663 || strncmp (name, ".gnu.linkonce.td.", 17) == 0)
5664 flags |= SECTION_TLS;
5665
5666 if (strcmp (name, ".tbss") == 0
5667 || strncmp (name, ".tbss.", 6) == 0
5668 || strncmp (name, ".gnu.linkonce.tb.", 17) == 0)
5669 flags |= SECTION_TLS | SECTION_BSS;
5670
5671 /* These three sections have special ELF types. They are neither
5672 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
5673 want to print a section type (@progbits or @nobits). If someone
5674 is silly enough to emit code or TLS variables to one of these
5675 sections, then don't handle them specially. */
5676 if (!(flags & (SECTION_CODE | SECTION_BSS | SECTION_TLS))
5677 && (strcmp (name, ".init_array") == 0
5678 || strcmp (name, ".fini_array") == 0
5679 || strcmp (name, ".preinit_array") == 0))
5680 flags |= SECTION_NOTYPE;
5681
5682 return flags;
5683 }
5684
5685 /* Return true if the target supports some form of global BSS,
5686 either through bss_noswitch_section, or by selecting a BSS
5687 section in TARGET_ASM_SELECT_SECTION. */
5688
5689 bool
5690 have_global_bss_p (void)
5691 {
5692 return bss_noswitch_section || targetm.have_switchable_bss_sections;
5693 }
5694
5695 /* Output assembly to switch to section NAME with attribute FLAGS.
5696 Four variants for common object file formats. */
5697
5698 void
5699 default_no_named_section (const char *name ATTRIBUTE_UNUSED,
5700 unsigned int flags ATTRIBUTE_UNUSED,
5701 tree decl ATTRIBUTE_UNUSED)
5702 {
5703 /* Some object formats don't support named sections at all. The
5704 front-end should already have flagged this as an error. */
5705 gcc_unreachable ();
5706 }
5707
5708 void
5709 default_elf_asm_named_section (const char *name, unsigned int flags,
5710 tree decl ATTRIBUTE_UNUSED)
5711 {
5712 char flagchars[10], *f = flagchars;
5713
5714 /* If we have already declared this section, we can use an
5715 abbreviated form to switch back to it -- unless this section is
5716 part of a COMDAT groups, in which case GAS requires the full
5717 declaration every time. */
5718 if (!(HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5719 && (flags & SECTION_DECLARED))
5720 {
5721 fprintf (asm_out_file, "\t.section\t%s\n", name);
5722 return;
5723 }
5724
5725 if (!(flags & SECTION_DEBUG))
5726 *f++ = 'a';
5727 if (flags & SECTION_WRITE)
5728 *f++ = 'w';
5729 if (flags & SECTION_CODE)
5730 *f++ = 'x';
5731 if (flags & SECTION_SMALL)
5732 *f++ = 's';
5733 if (flags & SECTION_MERGE)
5734 *f++ = 'M';
5735 if (flags & SECTION_STRINGS)
5736 *f++ = 'S';
5737 if (flags & SECTION_TLS)
5738 *f++ = 'T';
5739 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5740 *f++ = 'G';
5741 *f = '\0';
5742
5743 fprintf (asm_out_file, "\t.section\t%s,\"%s\"", name, flagchars);
5744
5745 if (!(flags & SECTION_NOTYPE))
5746 {
5747 const char *type;
5748 const char *format;
5749
5750 if (flags & SECTION_BSS)
5751 type = "nobits";
5752 else
5753 type = "progbits";
5754
5755 format = ",@%s";
5756 #ifdef ASM_COMMENT_START
5757 /* On platforms that use "@" as the assembly comment character,
5758 use "%" instead. */
5759 if (strcmp (ASM_COMMENT_START, "@") == 0)
5760 format = ",%%%s";
5761 #endif
5762 fprintf (asm_out_file, format, type);
5763
5764 if (flags & SECTION_ENTSIZE)
5765 fprintf (asm_out_file, ",%d", flags & SECTION_ENTSIZE);
5766 if (HAVE_COMDAT_GROUP && (flags & SECTION_LINKONCE))
5767 fprintf (asm_out_file, ",%s,comdat",
5768 lang_hooks.decls.comdat_group (decl));
5769 }
5770
5771 putc ('\n', asm_out_file);
5772 }
5773
5774 void
5775 default_coff_asm_named_section (const char *name, unsigned int flags,
5776 tree decl ATTRIBUTE_UNUSED)
5777 {
5778 char flagchars[8], *f = flagchars;
5779
5780 if (flags & SECTION_WRITE)
5781 *f++ = 'w';
5782 if (flags & SECTION_CODE)
5783 *f++ = 'x';
5784 *f = '\0';
5785
5786 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5787 }
5788
5789 void
5790 default_pe_asm_named_section (const char *name, unsigned int flags,
5791 tree decl)
5792 {
5793 default_coff_asm_named_section (name, flags, decl);
5794
5795 if (flags & SECTION_LINKONCE)
5796 {
5797 /* Functions may have been compiled at various levels of
5798 optimization so we can't use `same_size' here.
5799 Instead, have the linker pick one. */
5800 fprintf (asm_out_file, "\t.linkonce %s\n",
5801 (flags & SECTION_CODE ? "discard" : "same_size"));
5802 }
5803 }
5804 \f
5805 /* The lame default section selector. */
5806
5807 section *
5808 default_select_section (tree decl, int reloc,
5809 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
5810 {
5811 if (DECL_P (decl))
5812 {
5813 if (decl_readonly_section (decl, reloc))
5814 return readonly_data_section;
5815 }
5816 else if (TREE_CODE (decl) == CONSTRUCTOR)
5817 {
5818 if (! ((flag_pic && reloc)
5819 || !TREE_READONLY (decl)
5820 || TREE_SIDE_EFFECTS (decl)
5821 || !TREE_CONSTANT (decl)))
5822 return readonly_data_section;
5823 }
5824 else if (TREE_CODE (decl) == STRING_CST)
5825 return readonly_data_section;
5826 else if (! (flag_pic && reloc))
5827 return readonly_data_section;
5828
5829 return data_section;
5830 }
5831
5832 enum section_category
5833 categorize_decl_for_section (const_tree decl, int reloc)
5834 {
5835 enum section_category ret;
5836
5837 if (TREE_CODE (decl) == FUNCTION_DECL)
5838 return SECCAT_TEXT;
5839 else if (TREE_CODE (decl) == STRING_CST)
5840 {
5841 if (flag_mudflap) /* or !flag_merge_constants */
5842 return SECCAT_RODATA;
5843 else
5844 return SECCAT_RODATA_MERGE_STR;
5845 }
5846 else if (TREE_CODE (decl) == VAR_DECL)
5847 {
5848 if (bss_initializer_p (decl))
5849 ret = SECCAT_BSS;
5850 else if (! TREE_READONLY (decl)
5851 || TREE_SIDE_EFFECTS (decl)
5852 || ! TREE_CONSTANT (DECL_INITIAL (decl)))
5853 {
5854 /* Here the reloc_rw_mask is not testing whether the section should
5855 be read-only or not, but whether the dynamic link will have to
5856 do something. If so, we wish to segregate the data in order to
5857 minimize cache misses inside the dynamic linker. */
5858 if (reloc & targetm.asm_out.reloc_rw_mask ())
5859 ret = reloc == 1 ? SECCAT_DATA_REL_LOCAL : SECCAT_DATA_REL;
5860 else
5861 ret = SECCAT_DATA;
5862 }
5863 else if (reloc & targetm.asm_out.reloc_rw_mask ())
5864 ret = reloc == 1 ? SECCAT_DATA_REL_RO_LOCAL : SECCAT_DATA_REL_RO;
5865 else if (reloc || flag_merge_constants < 2)
5866 /* C and C++ don't allow different variables to share the same
5867 location. -fmerge-all-constants allows even that (at the
5868 expense of not conforming). */
5869 ret = SECCAT_RODATA;
5870 else if (TREE_CODE (DECL_INITIAL (decl)) == STRING_CST)
5871 ret = SECCAT_RODATA_MERGE_STR_INIT;
5872 else
5873 ret = SECCAT_RODATA_MERGE_CONST;
5874 }
5875 else if (TREE_CODE (decl) == CONSTRUCTOR)
5876 {
5877 if ((reloc & targetm.asm_out.reloc_rw_mask ())
5878 || TREE_SIDE_EFFECTS (decl)
5879 || ! TREE_CONSTANT (decl))
5880 ret = SECCAT_DATA;
5881 else
5882 ret = SECCAT_RODATA;
5883 }
5884 else
5885 ret = SECCAT_RODATA;
5886
5887 /* There are no read-only thread-local sections. */
5888 if (TREE_CODE (decl) == VAR_DECL && DECL_TLS_MODEL (decl))
5889 {
5890 if (DECL_TLS_MODEL (decl) == TLS_MODEL_EMULATED)
5891 {
5892 if (DECL_EMUTLS_VAR_P (decl))
5893 {
5894 if (targetm.emutls.var_section)
5895 ret = SECCAT_EMUTLS_VAR;
5896 }
5897 else
5898 {
5899 if (targetm.emutls.tmpl_prefix)
5900 ret = SECCAT_EMUTLS_TMPL;
5901 }
5902 }
5903 /* Note that this would be *just* SECCAT_BSS, except that there's
5904 no concept of a read-only thread-local-data section. */
5905 else if (ret == SECCAT_BSS
5906 || (flag_zero_initialized_in_bss
5907 && initializer_zerop (DECL_INITIAL (decl))))
5908 ret = SECCAT_TBSS;
5909 else
5910 ret = SECCAT_TDATA;
5911 }
5912
5913 /* If the target uses small data sections, select it. */
5914 else if (targetm.in_small_data_p (decl))
5915 {
5916 if (ret == SECCAT_BSS)
5917 ret = SECCAT_SBSS;
5918 else if (targetm.have_srodata_section && ret == SECCAT_RODATA)
5919 ret = SECCAT_SRODATA;
5920 else
5921 ret = SECCAT_SDATA;
5922 }
5923
5924 return ret;
5925 }
5926
5927 bool
5928 decl_readonly_section (const_tree decl, int reloc)
5929 {
5930 switch (categorize_decl_for_section (decl, reloc))
5931 {
5932 case SECCAT_RODATA:
5933 case SECCAT_RODATA_MERGE_STR:
5934 case SECCAT_RODATA_MERGE_STR_INIT:
5935 case SECCAT_RODATA_MERGE_CONST:
5936 case SECCAT_SRODATA:
5937 return true;
5938 break;
5939 default:
5940 return false;
5941 break;
5942 }
5943 }
5944
5945 /* Select a section based on the above categorization. */
5946
5947 section *
5948 default_elf_select_section (tree decl, int reloc,
5949 unsigned HOST_WIDE_INT align)
5950 {
5951 const char *sname;
5952 switch (categorize_decl_for_section (decl, reloc))
5953 {
5954 case SECCAT_TEXT:
5955 /* We're not supposed to be called on FUNCTION_DECLs. */
5956 gcc_unreachable ();
5957 case SECCAT_RODATA:
5958 return readonly_data_section;
5959 case SECCAT_RODATA_MERGE_STR:
5960 return mergeable_string_section (decl, align, 0);
5961 case SECCAT_RODATA_MERGE_STR_INIT:
5962 return mergeable_string_section (DECL_INITIAL (decl), align, 0);
5963 case SECCAT_RODATA_MERGE_CONST:
5964 return mergeable_constant_section (DECL_MODE (decl), align, 0);
5965 case SECCAT_SRODATA:
5966 sname = ".sdata2";
5967 break;
5968 case SECCAT_DATA:
5969 return data_section;
5970 case SECCAT_DATA_REL:
5971 sname = ".data.rel";
5972 break;
5973 case SECCAT_DATA_REL_LOCAL:
5974 sname = ".data.rel.local";
5975 break;
5976 case SECCAT_DATA_REL_RO:
5977 sname = ".data.rel.ro";
5978 break;
5979 case SECCAT_DATA_REL_RO_LOCAL:
5980 sname = ".data.rel.ro.local";
5981 break;
5982 case SECCAT_SDATA:
5983 sname = ".sdata";
5984 break;
5985 case SECCAT_TDATA:
5986 sname = ".tdata";
5987 break;
5988 case SECCAT_BSS:
5989 if (bss_section)
5990 return bss_section;
5991 sname = ".bss";
5992 break;
5993 case SECCAT_SBSS:
5994 sname = ".sbss";
5995 break;
5996 case SECCAT_TBSS:
5997 sname = ".tbss";
5998 break;
5999 case SECCAT_EMUTLS_VAR:
6000 sname = targetm.emutls.var_section;
6001 break;
6002 case SECCAT_EMUTLS_TMPL:
6003 sname = targetm.emutls.tmpl_section;
6004 break;
6005 default:
6006 gcc_unreachable ();
6007 }
6008
6009 if (!DECL_P (decl))
6010 decl = NULL_TREE;
6011 return get_named_section (decl, sname, reloc);
6012 }
6013
6014 /* Construct a unique section name based on the decl name and the
6015 categorization performed above. */
6016
6017 void
6018 default_unique_section (tree decl, int reloc)
6019 {
6020 /* We only need to use .gnu.linkonce if we don't have COMDAT groups. */
6021 bool one_only = DECL_ONE_ONLY (decl) && !HAVE_COMDAT_GROUP;
6022 const char *prefix, *name, *linkonce;
6023 char *string;
6024
6025 switch (categorize_decl_for_section (decl, reloc))
6026 {
6027 case SECCAT_TEXT:
6028 prefix = one_only ? ".t" : ".text";
6029 break;
6030 case SECCAT_RODATA:
6031 case SECCAT_RODATA_MERGE_STR:
6032 case SECCAT_RODATA_MERGE_STR_INIT:
6033 case SECCAT_RODATA_MERGE_CONST:
6034 prefix = one_only ? ".r" : ".rodata";
6035 break;
6036 case SECCAT_SRODATA:
6037 prefix = one_only ? ".s2" : ".sdata2";
6038 break;
6039 case SECCAT_DATA:
6040 prefix = one_only ? ".d" : ".data";
6041 break;
6042 case SECCAT_DATA_REL:
6043 prefix = one_only ? ".d.rel" : ".data.rel";
6044 break;
6045 case SECCAT_DATA_REL_LOCAL:
6046 prefix = one_only ? ".d.rel.local" : ".data.rel.local";
6047 break;
6048 case SECCAT_DATA_REL_RO:
6049 prefix = one_only ? ".d.rel.ro" : ".data.rel.ro";
6050 break;
6051 case SECCAT_DATA_REL_RO_LOCAL:
6052 prefix = one_only ? ".d.rel.ro.local" : ".data.rel.ro.local";
6053 break;
6054 case SECCAT_SDATA:
6055 prefix = one_only ? ".s" : ".sdata";
6056 break;
6057 case SECCAT_BSS:
6058 prefix = one_only ? ".b" : ".bss";
6059 break;
6060 case SECCAT_SBSS:
6061 prefix = one_only ? ".sb" : ".sbss";
6062 break;
6063 case SECCAT_TDATA:
6064 prefix = one_only ? ".td" : ".tdata";
6065 break;
6066 case SECCAT_TBSS:
6067 prefix = one_only ? ".tb" : ".tbss";
6068 break;
6069 case SECCAT_EMUTLS_VAR:
6070 prefix = targetm.emutls.var_section;
6071 break;
6072 case SECCAT_EMUTLS_TMPL:
6073 prefix = targetm.emutls.tmpl_section;
6074 break;
6075 default:
6076 gcc_unreachable ();
6077 }
6078
6079 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
6080 name = targetm.strip_name_encoding (name);
6081
6082 /* If we're using one_only, then there needs to be a .gnu.linkonce
6083 prefix to the section name. */
6084 linkonce = one_only ? ".gnu.linkonce" : "";
6085
6086 string = ACONCAT ((linkonce, prefix, ".", name, NULL));
6087
6088 DECL_SECTION_NAME (decl) = build_string (strlen (string), string);
6089 }
6090
6091 /* Like compute_reloc_for_constant, except for an RTX. The return value
6092 is a mask for which bit 1 indicates a global relocation, and bit 0
6093 indicates a local relocation. */
6094
6095 static int
6096 compute_reloc_for_rtx_1 (rtx *xp, void *data)
6097 {
6098 int *preloc = (int *) data;
6099 rtx x = *xp;
6100
6101 switch (GET_CODE (x))
6102 {
6103 case SYMBOL_REF:
6104 *preloc |= SYMBOL_REF_LOCAL_P (x) ? 1 : 2;
6105 break;
6106 case LABEL_REF:
6107 *preloc |= 1;
6108 break;
6109 default:
6110 break;
6111 }
6112
6113 return 0;
6114 }
6115
6116 static int
6117 compute_reloc_for_rtx (rtx x)
6118 {
6119 int reloc;
6120
6121 switch (GET_CODE (x))
6122 {
6123 case CONST:
6124 case SYMBOL_REF:
6125 case LABEL_REF:
6126 reloc = 0;
6127 for_each_rtx (&x, compute_reloc_for_rtx_1, &reloc);
6128 return reloc;
6129
6130 default:
6131 return 0;
6132 }
6133 }
6134
6135 section *
6136 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED,
6137 rtx x,
6138 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
6139 {
6140 if (compute_reloc_for_rtx (x) & targetm.asm_out.reloc_rw_mask ())
6141 return data_section;
6142 else
6143 return readonly_data_section;
6144 }
6145
6146 section *
6147 default_elf_select_rtx_section (enum machine_mode mode, rtx x,
6148 unsigned HOST_WIDE_INT align)
6149 {
6150 int reloc = compute_reloc_for_rtx (x);
6151
6152 /* ??? Handle small data here somehow. */
6153
6154 if (reloc & targetm.asm_out.reloc_rw_mask ())
6155 {
6156 if (reloc == 1)
6157 return get_named_section (NULL, ".data.rel.ro.local", 1);
6158 else
6159 return get_named_section (NULL, ".data.rel.ro", 3);
6160 }
6161
6162 return mergeable_constant_section (mode, align, 0);
6163 }
6164
6165 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
6166
6167 void
6168 default_encode_section_info (tree decl, rtx rtl, int first ATTRIBUTE_UNUSED)
6169 {
6170 rtx symbol;
6171 int flags;
6172
6173 /* Careful not to prod global register variables. */
6174 if (!MEM_P (rtl))
6175 return;
6176 symbol = XEXP (rtl, 0);
6177 if (GET_CODE (symbol) != SYMBOL_REF)
6178 return;
6179
6180 flags = SYMBOL_REF_FLAGS (symbol) & SYMBOL_FLAG_HAS_BLOCK_INFO;
6181 if (TREE_CODE (decl) == FUNCTION_DECL)
6182 flags |= SYMBOL_FLAG_FUNCTION;
6183 if (targetm.binds_local_p (decl))
6184 flags |= SYMBOL_FLAG_LOCAL;
6185 if (targetm.have_tls && TREE_CODE (decl) == VAR_DECL
6186 && DECL_THREAD_LOCAL_P (decl))
6187 flags |= DECL_TLS_MODEL (decl) << SYMBOL_FLAG_TLS_SHIFT;
6188 else if (targetm.in_small_data_p (decl))
6189 flags |= SYMBOL_FLAG_SMALL;
6190 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
6191 being PUBLIC, the thing *must* be defined in this translation unit.
6192 Prevent this buglet from being propagated into rtl code as well. */
6193 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
6194 flags |= SYMBOL_FLAG_EXTERNAL;
6195
6196 SYMBOL_REF_FLAGS (symbol) = flags;
6197 }
6198
6199 /* By default, we do nothing for encode_section_info, so we need not
6200 do anything but discard the '*' marker. */
6201
6202 const char *
6203 default_strip_name_encoding (const char *str)
6204 {
6205 return str + (*str == '*');
6206 }
6207
6208 #ifdef ASM_OUTPUT_DEF
6209 /* The default implementation of TARGET_ASM_OUTPUT_ANCHOR. Define the
6210 anchor relative to ".", the current section position. */
6211
6212 void
6213 default_asm_output_anchor (rtx symbol)
6214 {
6215 char buffer[100];
6216
6217 sprintf (buffer, "*. + " HOST_WIDE_INT_PRINT_DEC,
6218 SYMBOL_REF_BLOCK_OFFSET (symbol));
6219 ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer);
6220 }
6221 #endif
6222
6223 /* The default implementation of TARGET_USE_ANCHORS_FOR_SYMBOL_P. */
6224
6225 bool
6226 default_use_anchors_for_symbol_p (const_rtx symbol)
6227 {
6228 section *sect;
6229 tree decl;
6230
6231 /* Don't use anchors for mergeable sections. The linker might move
6232 the objects around. */
6233 sect = SYMBOL_REF_BLOCK (symbol)->sect;
6234 if (sect->common.flags & SECTION_MERGE)
6235 return false;
6236
6237 /* Don't use anchors for small data sections. The small data register
6238 acts as an anchor for such sections. */
6239 if (sect->common.flags & SECTION_SMALL)
6240 return false;
6241
6242 decl = SYMBOL_REF_DECL (symbol);
6243 if (decl && DECL_P (decl))
6244 {
6245 /* Don't use section anchors for decls that might be defined by
6246 other modules. */
6247 if (!targetm.binds_local_p (decl))
6248 return false;
6249
6250 /* Don't use section anchors for decls that will be placed in a
6251 small data section. */
6252 /* ??? Ideally, this check would be redundant with the SECTION_SMALL
6253 one above. The problem is that we only use SECTION_SMALL for
6254 sections that should be marked as small in the section directive. */
6255 if (targetm.in_small_data_p (decl))
6256 return false;
6257 }
6258 return true;
6259 }
6260
6261 /* Assume ELF-ish defaults, since that's pretty much the most liberal
6262 wrt cross-module name binding. */
6263
6264 bool
6265 default_binds_local_p (const_tree exp)
6266 {
6267 return default_binds_local_p_1 (exp, flag_shlib);
6268 }
6269
6270 bool
6271 default_binds_local_p_1 (const_tree exp, int shlib)
6272 {
6273 bool local_p;
6274
6275 /* A non-decl is an entry in the constant pool. */
6276 if (!DECL_P (exp))
6277 local_p = true;
6278 /* Weakrefs may not bind locally, even though the weakref itself is
6279 always static and therefore local. */
6280 else if (lookup_attribute ("weakref", DECL_ATTRIBUTES (exp)))
6281 local_p = false;
6282 /* Static variables are always local. */
6283 else if (! TREE_PUBLIC (exp))
6284 local_p = true;
6285 /* A variable is local if the user has said explicitly that it will
6286 be. */
6287 else if (DECL_VISIBILITY_SPECIFIED (exp)
6288 && DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
6289 local_p = true;
6290 /* Variables defined outside this object might not be local. */
6291 else if (DECL_EXTERNAL (exp))
6292 local_p = false;
6293 /* If defined in this object and visibility is not default, must be
6294 local. */
6295 else if (DECL_VISIBILITY (exp) != VISIBILITY_DEFAULT)
6296 local_p = true;
6297 /* Default visibility weak data can be overridden by a strong symbol
6298 in another module and so are not local. */
6299 else if (DECL_WEAK (exp))
6300 local_p = false;
6301 /* If PIC, then assume that any global name can be overridden by
6302 symbols resolved from other modules, unless we are compiling with
6303 -fwhole-program, which assumes that names are local. */
6304 else if (shlib)
6305 local_p = flag_whole_program;
6306 /* Uninitialized COMMON variable may be unified with symbols
6307 resolved from other modules. */
6308 else if (DECL_COMMON (exp)
6309 && (DECL_INITIAL (exp) == NULL
6310 || DECL_INITIAL (exp) == error_mark_node))
6311 local_p = false;
6312 /* Otherwise we're left with initialized (or non-common) global data
6313 which is of necessity defined locally. */
6314 else
6315 local_p = true;
6316
6317 return local_p;
6318 }
6319
6320 /* Determine whether or not a pointer mode is valid. Assume defaults
6321 of ptr_mode or Pmode - can be overridden. */
6322 bool
6323 default_valid_pointer_mode (enum machine_mode mode)
6324 {
6325 return (mode == ptr_mode || mode == Pmode);
6326 }
6327
6328 /* Default function to output code that will globalize a label. A
6329 target must define GLOBAL_ASM_OP or provide its own function to
6330 globalize a label. */
6331 #ifdef GLOBAL_ASM_OP
6332 void
6333 default_globalize_label (FILE * stream, const char *name)
6334 {
6335 fputs (GLOBAL_ASM_OP, stream);
6336 assemble_name (stream, name);
6337 putc ('\n', stream);
6338 }
6339 #endif /* GLOBAL_ASM_OP */
6340
6341 /* Default function to output code that will globalize a declaration. */
6342 void
6343 default_globalize_decl_name (FILE * stream, tree decl)
6344 {
6345 const char *name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
6346 targetm.asm_out.globalize_label (stream, name);
6347 }
6348
6349 /* Default function to output a label for unwind information. The
6350 default is to do nothing. A target that needs nonlocal labels for
6351 unwind information must provide its own function to do this. */
6352 void
6353 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED,
6354 tree decl ATTRIBUTE_UNUSED,
6355 int for_eh ATTRIBUTE_UNUSED,
6356 int empty ATTRIBUTE_UNUSED)
6357 {
6358 }
6359
6360 /* Default function to output a label to divide up the exception table.
6361 The default is to do nothing. A target that needs/wants to divide
6362 up the table must provide it's own function to do this. */
6363 void
6364 default_emit_except_table_label (FILE * stream ATTRIBUTE_UNUSED)
6365 {
6366 }
6367
6368 /* This is how to output an internal numbered label where PREFIX is
6369 the class of label and LABELNO is the number within the class. */
6370
6371 void
6372 default_internal_label (FILE *stream, const char *prefix,
6373 unsigned long labelno)
6374 {
6375 char *const buf = (char *) alloca (40 + strlen (prefix));
6376 ASM_GENERATE_INTERNAL_LABEL (buf, prefix, labelno);
6377 ASM_OUTPUT_INTERNAL_LABEL (stream, buf);
6378 }
6379
6380 /* This is the default behavior at the beginning of a file. It's
6381 controlled by two other target-hook toggles. */
6382 void
6383 default_file_start (void)
6384 {
6385 if (targetm.file_start_app_off && !flag_verbose_asm)
6386 fputs (ASM_APP_OFF, asm_out_file);
6387
6388 if (targetm.file_start_file_directive)
6389 output_file_directive (asm_out_file, main_input_filename);
6390 }
6391
6392 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
6393 which emits a special section directive used to indicate whether or
6394 not this object file needs an executable stack. This is primarily
6395 a GNU extension to ELF but could be used on other targets. */
6396
6397 int trampolines_created;
6398
6399 void
6400 file_end_indicate_exec_stack (void)
6401 {
6402 unsigned int flags = SECTION_DEBUG;
6403 if (trampolines_created)
6404 flags |= SECTION_CODE;
6405
6406 switch_to_section (get_section (".note.GNU-stack", flags, NULL));
6407 }
6408
6409 /* Output DIRECTIVE (a C string) followed by a newline. This is used as
6410 a get_unnamed_section callback. */
6411
6412 void
6413 output_section_asm_op (const void *directive)
6414 {
6415 fprintf (asm_out_file, "%s\n", (const char *) directive);
6416 }
6417
6418 /* Emit assembly code to switch to section NEW_SECTION. Do nothing if
6419 the current section is NEW_SECTION. */
6420
6421 void
6422 switch_to_section (section *new_section)
6423 {
6424 if (in_section == new_section)
6425 return;
6426
6427 if (new_section->common.flags & SECTION_FORGET)
6428 in_section = NULL;
6429 else
6430 in_section = new_section;
6431
6432 switch (SECTION_STYLE (new_section))
6433 {
6434 case SECTION_NAMED:
6435 if (cfun
6436 && !crtl->subsections.unlikely_text_section_name
6437 && strcmp (new_section->named.name,
6438 UNLIKELY_EXECUTED_TEXT_SECTION_NAME) == 0)
6439 crtl->subsections.unlikely_text_section_name = UNLIKELY_EXECUTED_TEXT_SECTION_NAME;
6440
6441 targetm.asm_out.named_section (new_section->named.name,
6442 new_section->named.common.flags,
6443 new_section->named.decl);
6444 break;
6445
6446 case SECTION_UNNAMED:
6447 new_section->unnamed.callback (new_section->unnamed.data);
6448 break;
6449
6450 case SECTION_NOSWITCH:
6451 gcc_unreachable ();
6452 break;
6453 }
6454
6455 new_section->common.flags |= SECTION_DECLARED;
6456 }
6457
6458 /* If block symbol SYMBOL has not yet been assigned an offset, place
6459 it at the end of its block. */
6460
6461 void
6462 place_block_symbol (rtx symbol)
6463 {
6464 unsigned HOST_WIDE_INT size, mask, offset;
6465 struct constant_descriptor_rtx *desc;
6466 unsigned int alignment;
6467 struct object_block *block;
6468 tree decl;
6469
6470 gcc_assert (SYMBOL_REF_BLOCK (symbol));
6471 if (SYMBOL_REF_BLOCK_OFFSET (symbol) >= 0)
6472 return;
6473
6474 /* Work out the symbol's size and alignment. */
6475 if (CONSTANT_POOL_ADDRESS_P (symbol))
6476 {
6477 desc = SYMBOL_REF_CONSTANT (symbol);
6478 alignment = desc->align;
6479 size = GET_MODE_SIZE (desc->mode);
6480 }
6481 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6482 {
6483 decl = SYMBOL_REF_DECL (symbol);
6484 alignment = get_constant_alignment (decl);
6485 size = get_constant_size (decl);
6486 }
6487 else
6488 {
6489 decl = SYMBOL_REF_DECL (symbol);
6490 alignment = DECL_ALIGN (decl);
6491 size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6492 }
6493
6494 /* Calculate the object's offset from the start of the block. */
6495 block = SYMBOL_REF_BLOCK (symbol);
6496 mask = alignment / BITS_PER_UNIT - 1;
6497 offset = (block->size + mask) & ~mask;
6498 SYMBOL_REF_BLOCK_OFFSET (symbol) = offset;
6499
6500 /* Record the block's new alignment and size. */
6501 block->alignment = MAX (block->alignment, alignment);
6502 block->size = offset + size;
6503
6504 VEC_safe_push (rtx, gc, block->objects, symbol);
6505 }
6506
6507 /* Return the anchor that should be used to address byte offset OFFSET
6508 from the first object in BLOCK. MODEL is the TLS model used
6509 to access it. */
6510
6511 rtx
6512 get_section_anchor (struct object_block *block, HOST_WIDE_INT offset,
6513 enum tls_model model)
6514 {
6515 char label[100];
6516 unsigned int begin, middle, end;
6517 unsigned HOST_WIDE_INT min_offset, max_offset, range, bias, delta;
6518 rtx anchor;
6519
6520 /* Work out the anchor's offset. Use an offset of 0 for the first
6521 anchor so that we don't pessimize the case where we take the address
6522 of a variable at the beginning of the block. This is particularly
6523 useful when a block has only one variable assigned to it.
6524
6525 We try to place anchors RANGE bytes apart, so there can then be
6526 anchors at +/-RANGE, +/-2 * RANGE, and so on, up to the limits of
6527 a ptr_mode offset. With some target settings, the lowest such
6528 anchor might be out of range for the lowest ptr_mode offset;
6529 likewise the highest anchor for the highest offset. Use anchors
6530 at the extreme ends of the ptr_mode range in such cases.
6531
6532 All arithmetic uses unsigned integers in order to avoid
6533 signed overflow. */
6534 max_offset = (unsigned HOST_WIDE_INT) targetm.max_anchor_offset;
6535 min_offset = (unsigned HOST_WIDE_INT) targetm.min_anchor_offset;
6536 range = max_offset - min_offset + 1;
6537 if (range == 0)
6538 offset = 0;
6539 else
6540 {
6541 bias = 1 << (GET_MODE_BITSIZE (ptr_mode) - 1);
6542 if (offset < 0)
6543 {
6544 delta = -(unsigned HOST_WIDE_INT) offset + max_offset;
6545 delta -= delta % range;
6546 if (delta > bias)
6547 delta = bias;
6548 offset = (HOST_WIDE_INT) (-delta);
6549 }
6550 else
6551 {
6552 delta = (unsigned HOST_WIDE_INT) offset - min_offset;
6553 delta -= delta % range;
6554 if (delta > bias - 1)
6555 delta = bias - 1;
6556 offset = (HOST_WIDE_INT) delta;
6557 }
6558 }
6559
6560 /* Do a binary search to see if there's already an anchor we can use.
6561 Set BEGIN to the new anchor's index if not. */
6562 begin = 0;
6563 end = VEC_length (rtx, block->anchors);
6564 while (begin != end)
6565 {
6566 middle = (end + begin) / 2;
6567 anchor = VEC_index (rtx, block->anchors, middle);
6568 if (SYMBOL_REF_BLOCK_OFFSET (anchor) > offset)
6569 end = middle;
6570 else if (SYMBOL_REF_BLOCK_OFFSET (anchor) < offset)
6571 begin = middle + 1;
6572 else if (SYMBOL_REF_TLS_MODEL (anchor) > model)
6573 end = middle;
6574 else if (SYMBOL_REF_TLS_MODEL (anchor) < model)
6575 begin = middle + 1;
6576 else
6577 return anchor;
6578 }
6579
6580 /* Create a new anchor with a unique label. */
6581 ASM_GENERATE_INTERNAL_LABEL (label, "LANCHOR", anchor_labelno++);
6582 anchor = create_block_symbol (ggc_strdup (label), block, offset);
6583 SYMBOL_REF_FLAGS (anchor) |= SYMBOL_FLAG_LOCAL | SYMBOL_FLAG_ANCHOR;
6584 SYMBOL_REF_FLAGS (anchor) |= model << SYMBOL_FLAG_TLS_SHIFT;
6585
6586 /* Insert it at index BEGIN. */
6587 VEC_safe_insert (rtx, gc, block->anchors, begin, anchor);
6588 return anchor;
6589 }
6590
6591 /* Output the objects in BLOCK. */
6592
6593 static void
6594 output_object_block (struct object_block *block)
6595 {
6596 struct constant_descriptor_rtx *desc;
6597 unsigned int i;
6598 HOST_WIDE_INT offset;
6599 tree decl;
6600 rtx symbol;
6601
6602 if (block->objects == NULL)
6603 return;
6604
6605 /* Switch to the section and make sure that the first byte is
6606 suitably aligned. */
6607 switch_to_section (block->sect);
6608 assemble_align (block->alignment);
6609
6610 /* Define the values of all anchors relative to the current section
6611 position. */
6612 for (i = 0; VEC_iterate (rtx, block->anchors, i, symbol); i++)
6613 targetm.asm_out.output_anchor (symbol);
6614
6615 /* Output the objects themselves. */
6616 offset = 0;
6617 for (i = 0; VEC_iterate (rtx, block->objects, i, symbol); i++)
6618 {
6619 /* Move to the object's offset, padding with zeros if necessary. */
6620 assemble_zeros (SYMBOL_REF_BLOCK_OFFSET (symbol) - offset);
6621 offset = SYMBOL_REF_BLOCK_OFFSET (symbol);
6622 if (CONSTANT_POOL_ADDRESS_P (symbol))
6623 {
6624 desc = SYMBOL_REF_CONSTANT (symbol);
6625 output_constant_pool_1 (desc, 1);
6626 offset += GET_MODE_SIZE (desc->mode);
6627 }
6628 else if (TREE_CONSTANT_POOL_ADDRESS_P (symbol))
6629 {
6630 decl = SYMBOL_REF_DECL (symbol);
6631 assemble_constant_contents (decl, XSTR (symbol, 0),
6632 get_constant_alignment (decl));
6633 offset += get_constant_size (decl);
6634 }
6635 else
6636 {
6637 decl = SYMBOL_REF_DECL (symbol);
6638 assemble_variable_contents (decl, XSTR (symbol, 0), false);
6639 offset += tree_low_cst (DECL_SIZE_UNIT (decl), 1);
6640 }
6641 }
6642 }
6643
6644 /* A htab_traverse callback used to call output_object_block for
6645 each member of object_block_htab. */
6646
6647 static int
6648 output_object_block_htab (void **slot, void *data ATTRIBUTE_UNUSED)
6649 {
6650 output_object_block ((struct object_block *) (*slot));
6651 return 1;
6652 }
6653
6654 /* Output the definitions of all object_blocks. */
6655
6656 void
6657 output_object_blocks (void)
6658 {
6659 htab_traverse (object_block_htab, output_object_block_htab, NULL);
6660 }
6661
6662 /* This function provides a possible implementation of the
6663 TARGET_ASM_RECORD_GCC_SWITCHES target hook for ELF targets. When triggered
6664 by -frecord-gcc-switches it creates a new mergeable, string section in the
6665 assembler output file called TARGET_ASM_RECORD_GCC_SWITCHES_SECTION which
6666 contains the switches in ASCII format.
6667
6668 FIXME: This code does not correctly handle double quote characters
6669 that appear inside strings, (it strips them rather than preserving them).
6670 FIXME: ASM_OUTPUT_ASCII, as defined in config/elfos.h will not emit NUL
6671 characters - instead it treats them as sub-string separators. Since
6672 we want to emit NUL strings terminators into the object file we have to use
6673 ASM_OUTPUT_SKIP. */
6674
6675 int
6676 elf_record_gcc_switches (print_switch_type type, const char * name)
6677 {
6678 static char buffer[1024];
6679
6680 /* This variable is used as part of a simplistic heuristic to detect
6681 command line switches which take an argument:
6682
6683 "If a command line option does not start with a dash then
6684 it is an argument for the previous command line option."
6685
6686 This fails in the case of the command line option which is the name
6687 of the file to compile, but otherwise it is pretty reasonable. */
6688 static bool previous_name_held_back = FALSE;
6689
6690 switch (type)
6691 {
6692 case SWITCH_TYPE_PASSED:
6693 if (* name != '-')
6694 {
6695 if (previous_name_held_back)
6696 {
6697 unsigned int len = strlen (buffer);
6698
6699 snprintf (buffer + len, sizeof buffer - len, " %s", name);
6700 ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
6701 ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
6702 previous_name_held_back = FALSE;
6703 }
6704 else
6705 {
6706 strncpy (buffer, name, sizeof buffer);
6707 ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
6708 ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
6709 }
6710 }
6711 else
6712 {
6713 if (previous_name_held_back)
6714 {
6715 ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
6716 ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
6717 }
6718
6719 strncpy (buffer, name, sizeof buffer);
6720 previous_name_held_back = TRUE;
6721 }
6722 break;
6723
6724 case SWITCH_TYPE_DESCRIPTIVE:
6725 if (name == NULL)
6726 {
6727 /* Distinguish between invocations where name is NULL. */
6728 static bool started = false;
6729
6730 if (started)
6731 {
6732 if (previous_name_held_back)
6733 {
6734 ASM_OUTPUT_ASCII (asm_out_file, buffer, strlen (buffer));
6735 ASM_OUTPUT_SKIP (asm_out_file, (unsigned HOST_WIDE_INT) 1);
6736 }
6737 }
6738 else
6739 {
6740 section * sec;
6741
6742 sec = get_section (targetm.asm_out.record_gcc_switches_section,
6743 SECTION_DEBUG
6744 | SECTION_MERGE
6745 | SECTION_STRINGS
6746 | (SECTION_ENTSIZE & 1),
6747 NULL);
6748 switch_to_section (sec);
6749 started = true;
6750 }
6751 }
6752
6753 default:
6754 break;
6755 }
6756
6757 /* The return value is currently ignored by the caller, but must be 0.
6758 For -fverbose-asm the return value would be the number of characters
6759 emitted into the assembler file. */
6760 return 0;
6761 }
6762
6763 /* Emit text to declare externally defined symbols. It is needed to
6764 properly support non-default visibility. */
6765 void
6766 default_elf_asm_output_external (FILE *file ATTRIBUTE_UNUSED,
6767 tree decl,
6768 const char *name ATTRIBUTE_UNUSED)
6769 {
6770 /* We output the name if and only if TREE_SYMBOL_REFERENCED is
6771 set in order to avoid putting out names that are never really
6772 used. */
6773 if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl))
6774 && targetm.binds_local_p (decl))
6775 maybe_assemble_visibility (decl);
6776 }
6777
6778 #include "gt-varasm.h"