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
4 Free Software Foundation, Inc.
6 This file is part of GCC.
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 2, or (at your option) any later
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
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
24 /* This file handles generation of all the assembler code
25 *except* the instructions of a function.
26 This includes declarations of variables and their initial values.
28 We also output the assembler code for constants stored in memory
29 and are responsible for combining constants with the same value. */
33 #include "coretypes.h"
40 #include "hard-reg-set.h"
48 #include "langhooks.h"
52 #include "tree-mudflap.h"
54 #include "cfglayout.h"
55 #include "basic-block.h"
57 #ifdef XCOFF_DEBUGGING_INFO
58 #include "xcoffout.h" /* Needed for external data
59 declarations for e.g. AIX 4.x. */
62 /* The (assembler) name of the first globally-visible object output. */
63 const char *first_global_object_name
;
64 const char *weak_global_object_name
;
67 struct constant_descriptor_rtx
;
68 struct rtx_constant_pool
;
70 struct varasm_status
GTY(())
72 /* If we're using a per-function constant pool, this is it. */
73 struct rtx_constant_pool
*pool
;
75 /* Number of tree-constants deferred during the expansion of this
77 unsigned int deferred_constants
;
80 #define n_deferred_constants (cfun->varasm->deferred_constants)
82 /* Number for making the label on the next
83 constant that is stored in memory. */
85 static GTY(()) int const_labelno
;
87 /* Carry information from ASM_DECLARE_OBJECT_NAME
88 to ASM_FINISH_DECLARE_OBJECT. */
90 int size_directive_output
;
92 /* The last decl for which assemble_variable was called,
93 if it did ASM_DECLARE_OBJECT_NAME.
94 If the last call to assemble_variable didn't do that,
97 tree last_assemble_variable_decl
;
99 /* The following global variable indicates if the first basic block
100 in a function belongs to the cold partition or not. */
102 bool first_function_block_is_cold
;
104 /* We give all constants their own alias set. Perhaps redundant with
105 MEM_READONLY_P, but pre-dates it. */
107 static HOST_WIDE_INT const_alias_set
;
109 static const char *strip_reg_name (const char *);
110 static int contains_pointers_p (tree
);
111 #ifdef ASM_OUTPUT_EXTERNAL
112 static bool incorporeal_function_p (tree
);
114 static void decode_addr_const (tree
, struct addr_const
*);
115 static hashval_t
const_desc_hash (const void *);
116 static int const_desc_eq (const void *, const void *);
117 static hashval_t
const_hash_1 (const tree
);
118 static int compare_constant (const tree
, const tree
);
119 static tree
copy_constant (tree
);
120 static void output_constant_def_contents (rtx
);
121 static void output_addressed_constants (tree
);
122 static unsigned HOST_WIDE_INT
array_size_for_constructor (tree
);
123 static unsigned min_align (unsigned, unsigned);
124 static void output_constructor (tree
, unsigned HOST_WIDE_INT
, unsigned int);
125 static void globalize_decl (tree
);
126 static void maybe_assemble_visibility (tree
);
127 static int in_named_entry_eq (const void *, const void *);
128 static hashval_t
in_named_entry_hash (const void *);
129 static void initialize_cold_section_name (void);
130 #ifdef BSS_SECTION_ASM_OP
131 #ifdef ASM_OUTPUT_BSS
132 static void asm_output_bss (FILE *, tree
, const char *,
133 unsigned HOST_WIDE_INT
, unsigned HOST_WIDE_INT
);
135 #ifdef ASM_OUTPUT_ALIGNED_BSS
136 static void asm_output_aligned_bss (FILE *, tree
, const char *,
137 unsigned HOST_WIDE_INT
, int)
140 #endif /* BSS_SECTION_ASM_OP */
141 static bool asm_emit_uninitialised (tree
, const char*,
142 unsigned HOST_WIDE_INT
,
143 unsigned HOST_WIDE_INT
);
144 static void mark_weak (tree
);
146 static GTY(()) enum in_section in_section
= no_section
;
147 enum in_section last_text_section
;
149 /* Return a nonzero value if DECL has a section attribute. */
150 #ifndef IN_NAMED_SECTION
151 #define IN_NAMED_SECTION(DECL) \
152 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
153 && DECL_SECTION_NAME (DECL) != NULL_TREE)
156 /* Text of section name when in_section == in_named. */
157 static GTY(()) const char *in_named_name
;
158 const char *last_text_section_name
;
160 /* Hash table of flags that have been used for a particular named section. */
162 struct in_named_entry
GTY(())
169 static GTY((param_is (struct in_named_entry
))) htab_t in_named_htab
;
171 /* Define functions like text_section for any extra sections. */
172 #ifdef EXTRA_SECTION_FUNCTIONS
173 EXTRA_SECTION_FUNCTIONS
177 initialize_cold_section_name (void)
180 const char *stripped_name
;
185 && current_function_decl
)
187 if (!cfun
->unlikely_text_section_name
)
189 if (flag_function_sections
190 && DECL_SECTION_NAME (current_function_decl
))
192 name
= xstrdup (TREE_STRING_POINTER (DECL_SECTION_NAME
193 (current_function_decl
)));
194 stripped_name
= targetm
.strip_name_encoding (name
);
195 len
= strlen (stripped_name
);
196 buffer
= (char *) xmalloc (len
+ 10);
197 sprintf (buffer
, "%s%s", stripped_name
, "_unlikely");
198 cfun
->unlikely_text_section_name
= ggc_strdup (buffer
);
200 free ((char *) name
);
203 cfun
->unlikely_text_section_name
=
204 UNLIKELY_EXECUTED_TEXT_SECTION_NAME
;
209 ("initialize_cold_section_name called without valid current_function_decl.");
212 /* Tell assembler to switch to text section. */
217 if (in_section
!= in_text
)
219 in_section
= in_text
;
220 last_text_section
= in_text
;
221 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
225 /* Tell assembler to switch to unlikely-to-be-executed text section. */
228 unlikely_text_section (void)
232 if (!cfun
->unlikely_text_section_name
)
233 initialize_cold_section_name ();
235 if ((in_section
!= in_unlikely_executed_text
)
236 && (in_section
!= in_named
237 || strcmp (in_named_name
, cfun
->unlikely_text_section_name
) != 0))
239 named_section (NULL_TREE
, cfun
->unlikely_text_section_name
, 0);
240 in_section
= in_unlikely_executed_text
;
241 last_text_section
= in_unlikely_executed_text
;
246 named_section (NULL_TREE
, UNLIKELY_EXECUTED_TEXT_SECTION_NAME
, 0);
247 in_section
= in_unlikely_executed_text
;
248 last_text_section
= in_unlikely_executed_text
;
252 /* Tell assembler to switch to data section. */
257 if (in_section
!= in_data
)
259 in_section
= in_data
;
260 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
264 /* Tell assembler to switch to read-only data section. This is normally
268 readonly_data_section (void)
270 #ifdef READONLY_DATA_SECTION
271 READONLY_DATA_SECTION (); /* Note this can call data_section. */
273 #ifdef READONLY_DATA_SECTION_ASM_OP
274 if (in_section
!= in_readonly_data
)
276 in_section
= in_readonly_data
;
277 fputs (READONLY_DATA_SECTION_ASM_OP
, asm_out_file
);
278 fputc ('\n', asm_out_file
);
286 /* Determine if we're in the text section. */
289 in_text_section (void)
291 return in_section
== in_text
;
294 /* Determine if we're in the unlikely-to-be-executed text section. */
297 in_unlikely_text_section (void)
303 ret_val
= ((in_section
== in_unlikely_executed_text
)
304 || (in_section
== in_named
305 && cfun
->unlikely_text_section_name
306 && strcmp (in_named_name
,
307 cfun
->unlikely_text_section_name
) == 0));
311 ret_val
= ((in_section
== in_unlikely_executed_text
)
312 || (in_section
== in_named
313 && strcmp (in_named_name
,
314 UNLIKELY_EXECUTED_TEXT_SECTION_NAME
) == 0));
320 /* Determine if we're in the data section. */
323 in_data_section (void)
325 return in_section
== in_data
;
328 /* Helper routines for maintaining in_named_htab. */
331 in_named_entry_eq (const void *p1
, const void *p2
)
333 const struct in_named_entry
*old
= p1
;
334 const char *new = p2
;
336 return strcmp (old
->name
, new) == 0;
340 in_named_entry_hash (const void *p
)
342 const struct in_named_entry
*old
= p
;
343 return htab_hash_string (old
->name
);
346 /* If SECTION has been seen before as a named section, return the flags
347 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
348 set of flags for a section to have, so 0 does not mean that the section
349 has not been seen. */
352 get_named_section_flags (const char *section
)
354 struct in_named_entry
**slot
;
356 slot
= (struct in_named_entry
**)
357 htab_find_slot_with_hash (in_named_htab
, section
,
358 htab_hash_string (section
), NO_INSERT
);
360 return slot
? (*slot
)->flags
: 0;
363 /* Returns true if the section has been declared before. Sets internal
364 flag on this section in in_named_hash so subsequent calls on this
365 section will return false. */
368 named_section_first_declaration (const char *name
)
370 struct in_named_entry
**slot
;
372 slot
= (struct in_named_entry
**)
373 htab_find_slot_with_hash (in_named_htab
, name
,
374 htab_hash_string (name
), NO_INSERT
);
375 if (! (*slot
)->declared
)
377 (*slot
)->declared
= true;
387 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
388 different set of flags, return false. */
391 set_named_section_flags (const char *section
, unsigned int flags
)
393 struct in_named_entry
**slot
, *entry
;
395 slot
= (struct in_named_entry
**)
396 htab_find_slot_with_hash (in_named_htab
, section
,
397 htab_hash_string (section
), INSERT
);
402 entry
= ggc_alloc (sizeof (*entry
));
404 entry
->name
= ggc_strdup (section
);
405 entry
->flags
= flags
;
406 entry
->declared
= false;
408 else if (entry
->flags
!= flags
)
414 /* Tell assembler to change to section NAME with attributes FLAGS. If
415 DECL is non-NULL, it is the VAR_DECL or FUNCTION_DECL with which
416 this section is associated. */
419 named_section_real (const char *name
, unsigned int flags
, tree decl
)
421 if (in_section
!= in_named
|| strcmp (name
, in_named_name
) != 0)
423 bool unchanged
= set_named_section_flags (name
, flags
);
425 gcc_assert (unchanged
);
427 targetm
.asm_out
.named_section (name
, flags
, decl
);
429 if (flags
& SECTION_FORGET
)
430 in_section
= no_section
;
433 in_named_name
= ggc_strdup (name
);
434 in_section
= in_named
;
438 if (in_text_section () || in_unlikely_text_section ())
440 last_text_section
= in_section
;
441 last_text_section_name
= name
;
445 /* Tell assembler to change to section NAME for DECL.
446 If DECL is NULL, just switch to section NAME.
447 If NAME is NULL, get the name from DECL.
448 If RELOC is 1, the initializer for DECL contains relocs. */
451 named_section (tree decl
, const char *name
, int reloc
)
455 gcc_assert (!decl
|| DECL_P (decl
));
457 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
459 if (strcmp (name
, UNLIKELY_EXECUTED_TEXT_SECTION_NAME
) == 0
461 && ! cfun
->unlikely_text_section_name
)
462 cfun
->unlikely_text_section_name
= UNLIKELY_EXECUTED_TEXT_SECTION_NAME
;
464 flags
= targetm
.section_type_flags (decl
, name
, reloc
);
466 /* Sanity check user variables for flag changes. Non-user
467 section flag changes will die in named_section_flags.
468 However, don't complain if SECTION_OVERRIDE is set.
469 We trust that the setter knows that it is safe to ignore
470 the default flags for this decl. */
471 if (decl
&& ! set_named_section_flags (name
, flags
))
473 flags
= get_named_section_flags (name
);
474 if ((flags
& SECTION_OVERRIDE
) == 0)
475 error ("%J%D causes a section type conflict", decl
, decl
);
478 named_section_real (name
, flags
, decl
);
481 /* If required, set DECL_SECTION_NAME to a unique name. */
484 resolve_unique_section (tree decl
, int reloc ATTRIBUTE_UNUSED
,
485 int flag_function_or_data_sections
)
487 if (DECL_SECTION_NAME (decl
) == NULL_TREE
488 && targetm
.have_named_sections
489 && (flag_function_or_data_sections
490 || DECL_ONE_ONLY (decl
)))
491 targetm
.asm_out
.unique_section (decl
, reloc
);
494 #ifdef BSS_SECTION_ASM_OP
496 /* Tell the assembler to switch to the bss section. */
501 if (in_section
!= in_bss
)
503 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
508 #ifdef ASM_OUTPUT_BSS
510 /* Utility function for ASM_OUTPUT_BSS for targets to use if
511 they don't support alignments in .bss.
512 ??? It is believed that this function will work in most cases so such
513 support is localized here. */
516 asm_output_bss (FILE *file
, tree decl ATTRIBUTE_UNUSED
,
518 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
519 unsigned HOST_WIDE_INT rounded
)
521 targetm
.asm_out
.globalize_label (file
, name
);
523 #ifdef ASM_DECLARE_OBJECT_NAME
524 last_assemble_variable_decl
= decl
;
525 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
527 /* Standard thing is just output label for the object. */
528 ASM_OUTPUT_LABEL (file
, name
);
529 #endif /* ASM_DECLARE_OBJECT_NAME */
530 ASM_OUTPUT_SKIP (file
, rounded
? rounded
: 1);
535 #ifdef ASM_OUTPUT_ALIGNED_BSS
537 /* Utility function for targets to use in implementing
538 ASM_OUTPUT_ALIGNED_BSS.
539 ??? It is believed that this function will work in most cases so such
540 support is localized here. */
543 asm_output_aligned_bss (FILE *file
, tree decl ATTRIBUTE_UNUSED
,
544 const char *name
, unsigned HOST_WIDE_INT size
,
548 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
549 #ifdef ASM_DECLARE_OBJECT_NAME
550 last_assemble_variable_decl
= decl
;
551 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
553 /* Standard thing is just output label for the object. */
554 ASM_OUTPUT_LABEL (file
, name
);
555 #endif /* ASM_DECLARE_OBJECT_NAME */
556 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
561 #endif /* BSS_SECTION_ASM_OP */
563 /* Switch to the section for function DECL.
565 If DECL is NULL_TREE, switch to the text section. We can be passed
566 NULL_TREE under some circumstances by dbxout.c at least. */
569 function_section (tree decl
)
573 if (first_function_block_is_cold
)
576 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
577 targetm
.asm_out
.select_section (decl
, reloc
, DECL_ALIGN (decl
));
579 if (decl
!= NULL_TREE
580 && DECL_SECTION_NAME (decl
) != NULL_TREE
581 && targetm
.have_named_sections
)
582 named_section (decl
, (char *) 0, 0);
589 current_function_section (tree decl
)
591 #ifdef USE_SELECT_SECTION_FOR_FUNCTIONS
594 if (in_unlikely_text_section ()
595 || last_text_section
== in_unlikely_executed_text
)
598 targetm
.asm_out
.select_section (decl
, reloc
, DECL_ALIGN (decl
));
600 if (last_text_section
== in_unlikely_executed_text
)
601 unlikely_text_section ();
602 else if (last_text_section
== in_text
)
604 else if (last_text_section
== in_named
605 && targetm
.have_named_sections
)
606 named_section (NULL_TREE
, last_text_section_name
, 0);
608 function_section (decl
);
612 /* Switch to read-only data section associated with function DECL. */
615 default_function_rodata_section (tree decl
)
617 if (decl
!= NULL_TREE
&& DECL_SECTION_NAME (decl
))
619 const char *name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
621 /* For .gnu.linkonce.t.foo we want to use .gnu.linkonce.r.foo. */
622 if (DECL_ONE_ONLY (decl
) && strncmp (name
, ".gnu.linkonce.t.", 16) == 0)
624 size_t len
= strlen (name
) + 1;
625 char *rname
= alloca (len
);
627 memcpy (rname
, name
, len
);
629 named_section_real (rname
, SECTION_LINKONCE
, decl
);
632 /* For .text.foo we want to use .rodata.foo. */
633 else if (flag_function_sections
&& flag_data_sections
634 && strncmp (name
, ".text.", 6) == 0)
636 size_t len
= strlen (name
) + 1;
637 char *rname
= alloca (len
+ 2);
639 memcpy (rname
, ".rodata", 7);
640 memcpy (rname
+ 7, name
+ 5, len
- 5);
641 named_section_flags (rname
, 0);
646 readonly_data_section ();
649 /* Switch to read-only data section associated with function DECL
650 for targets where that section should be always the single
651 readonly data section. */
654 default_no_function_rodata_section (tree decl ATTRIBUTE_UNUSED
)
656 readonly_data_section ();
659 /* Switch to section for variable DECL. RELOC is the same as the
660 argument to SELECT_SECTION. */
663 variable_section (tree decl
, int reloc
)
665 if (IN_NAMED_SECTION (decl
))
666 named_section (decl
, NULL
, reloc
);
668 targetm
.asm_out
.select_section (decl
, reloc
, DECL_ALIGN (decl
));
671 /* Tell assembler to switch to the section for string merging. */
674 mergeable_string_section (tree decl ATTRIBUTE_UNUSED
,
675 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
676 unsigned int flags ATTRIBUTE_UNUSED
)
678 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
679 && TREE_CODE (decl
) == STRING_CST
680 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
682 && TREE_STRING_LENGTH (decl
) >= int_size_in_bytes (TREE_TYPE (decl
)))
684 enum machine_mode mode
;
685 unsigned int modesize
;
690 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
691 modesize
= GET_MODE_BITSIZE (mode
);
692 if (modesize
>= 8 && modesize
<= 256
693 && (modesize
& (modesize
- 1)) == 0)
695 if (align
< modesize
)
698 str
= TREE_STRING_POINTER (decl
);
699 len
= TREE_STRING_LENGTH (decl
);
700 unit
= GET_MODE_SIZE (mode
);
702 /* Check for embedded NUL characters. */
703 for (i
= 0; i
< len
; i
+= unit
)
705 for (j
= 0; j
< unit
; j
++)
706 if (str
[i
+ j
] != '\0')
713 sprintf (name
, ".rodata.str%d.%d", modesize
/ 8,
715 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
716 if (!i
&& modesize
< align
)
718 /* A "" string with requested alignment greater than
719 character size might cause a problem:
720 if some other string required even bigger
721 alignment than "", then linker might think the
722 "" is just part of padding after some other string
723 and not put it into the hash table initially.
724 But this means "" could have smaller alignment
726 #ifdef ASM_OUTPUT_SECTION_START
727 named_section_flags (name
, flags
);
728 ASM_OUTPUT_SECTION_START (asm_out_file
);
730 readonly_data_section ();
735 named_section_flags (name
, flags
);
741 readonly_data_section ();
744 /* Tell assembler to switch to the section for constant merging. */
747 mergeable_constant_section (enum machine_mode mode ATTRIBUTE_UNUSED
,
748 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
,
749 unsigned int flags ATTRIBUTE_UNUSED
)
751 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
753 if (HAVE_GAS_SHF_MERGE
&& flag_merge_constants
759 && (align
& (align
- 1)) == 0)
763 sprintf (name
, ".rodata.cst%d", (int) (align
/ 8));
764 flags
|= (align
/ 8) | SECTION_MERGE
;
765 named_section_flags (name
, flags
);
769 readonly_data_section ();
772 /* Given NAME, a putative register name, discard any customary prefixes. */
775 strip_reg_name (const char *name
)
777 #ifdef REGISTER_PREFIX
778 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
779 name
+= strlen (REGISTER_PREFIX
);
781 if (name
[0] == '%' || name
[0] == '#')
786 /* The user has asked for a DECL to have a particular name. Set (or
787 change) it in such a way that we don't prefix an underscore to
790 set_user_assembler_name (tree decl
, const char *name
)
792 char *starred
= alloca (strlen (name
) + 2);
794 strcpy (starred
+ 1, name
);
795 change_decl_assembler_name (decl
, get_identifier (starred
));
796 SET_DECL_RTL (decl
, NULL_RTX
);
799 /* Decode an `asm' spec for a declaration as a register name.
800 Return the register number, or -1 if nothing specified,
801 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
802 or -3 if ASMSPEC is `cc' and is not recognized,
803 or -4 if ASMSPEC is `memory' and is not recognized.
804 Accept an exact spelling or a decimal number.
805 Prefixes such as % are optional. */
808 decode_reg_name (const char *asmspec
)
814 /* Get rid of confusing prefixes. */
815 asmspec
= strip_reg_name (asmspec
);
817 /* Allow a decimal number as a "register name". */
818 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
819 if (! ISDIGIT (asmspec
[i
]))
821 if (asmspec
[0] != 0 && i
< 0)
824 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
830 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
832 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
835 #ifdef ADDITIONAL_REGISTER_NAMES
837 static const struct { const char *const name
; const int number
; } table
[]
838 = ADDITIONAL_REGISTER_NAMES
;
840 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
841 if (! strcmp (asmspec
, table
[i
].name
))
842 return table
[i
].number
;
844 #endif /* ADDITIONAL_REGISTER_NAMES */
846 if (!strcmp (asmspec
, "memory"))
849 if (!strcmp (asmspec
, "cc"))
858 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
859 have static storage duration. In other words, it should not be an
860 automatic variable, including PARM_DECLs.
862 There is, however, one exception: this function handles variables
863 explicitly placed in a particular register by the user.
865 This is never called for PARM_DECL nodes. */
868 make_decl_rtl (tree decl
)
870 const char *name
= 0;
874 /* Check that we are not being given an automatic variable. */
875 gcc_assert (TREE_CODE (decl
) != PARM_DECL
876 && TREE_CODE (decl
) != RESULT_DECL
);
878 /* A weak alias has TREE_PUBLIC set but not the other bits. */
879 gcc_assert (TREE_CODE (decl
) != VAR_DECL
880 || TREE_STATIC (decl
)
881 || TREE_PUBLIC (decl
)
882 || DECL_EXTERNAL (decl
)
883 || DECL_REGISTER (decl
));
885 /* And that we were not given a type or a label. */
886 gcc_assert (TREE_CODE (decl
) != TYPE_DECL
887 && TREE_CODE (decl
) != LABEL_DECL
);
889 /* For a duplicate declaration, we can be called twice on the
890 same DECL node. Don't discard the RTL already made. */
891 if (DECL_RTL_SET_P (decl
))
893 /* If the old RTL had the wrong mode, fix the mode. */
894 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
895 SET_DECL_RTL (decl
, adjust_address_nv (DECL_RTL (decl
),
896 DECL_MODE (decl
), 0));
898 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
901 /* ??? Another way to do this would be to maintain a hashed
902 table of such critters. Instead of adding stuff to a DECL
903 to give certain attributes to it, we could use an external
904 hash map from DECL to set of attributes. */
906 /* Let the target reassign the RTL if it wants.
907 This is necessary, for example, when one machine specific
908 decl attribute overrides another. */
909 targetm
.encode_section_info (decl
, DECL_RTL (decl
), false);
911 /* Make this function static known to the mudflap runtime. */
912 if (flag_mudflap
&& TREE_CODE (decl
) == VAR_DECL
)
913 mudflap_enqueue_decl (decl
);
918 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
920 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
922 reg_number
= decode_reg_name (name
);
923 /* First detect errors in declaring global registers. */
924 if (reg_number
== -1)
925 error ("%Jregister name not specified for %qD", decl
, decl
);
926 else if (reg_number
< 0)
927 error ("%Jinvalid register name for %qD", decl
, decl
);
928 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
929 error ("%Jdata type of %qD isn%'t suitable for a register",
931 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
932 error ("%Jregister specified for %qD isn%'t suitable for data type",
934 /* Now handle properly declared static register variables. */
939 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
941 DECL_INITIAL (decl
) = 0;
942 error ("global register variable has initial value");
944 if (TREE_THIS_VOLATILE (decl
))
945 warning (0, "volatile register variables don%'t "
946 "work as you might wish");
948 /* If the user specified one of the eliminables registers here,
949 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
950 confused with that register and be eliminated. This usage is
951 somewhat suspect... */
953 SET_DECL_RTL (decl
, gen_rtx_raw_REG (DECL_MODE (decl
), reg_number
));
954 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
955 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
957 if (TREE_STATIC (decl
))
959 /* Make this register global, so not usable for anything
961 #ifdef ASM_DECLARE_REGISTER_GLOBAL
962 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
963 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
965 nregs
= hard_regno_nregs
[reg_number
][DECL_MODE (decl
)];
967 globalize_reg (reg_number
+ --nregs
);
970 /* As a register variable, it has no section. */
974 /* Now handle ordinary static variables and functions (in memory).
975 Also handle vars declared register invalidly. */
976 else if (name
[0] == '*')
978 #ifdef REGISTER_PREFIX
979 if (strlen (REGISTER_PREFIX
) != 0)
981 reg_number
= decode_reg_name (name
);
982 if (reg_number
>= 0 || reg_number
== -3)
983 error ("%Jregister name given for non-register variable %qD", decl
, decl
);
988 /* Specifying a section attribute on a variable forces it into a
989 non-.bss section, and thus it cannot be common. */
990 if (TREE_CODE (decl
) == VAR_DECL
991 && DECL_SECTION_NAME (decl
) != NULL_TREE
992 && DECL_INITIAL (decl
) == NULL_TREE
993 && DECL_COMMON (decl
))
994 DECL_COMMON (decl
) = 0;
996 /* Variables can't be both common and weak. */
997 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_WEAK (decl
))
998 DECL_COMMON (decl
) = 0;
1000 x
= gen_rtx_SYMBOL_REF (Pmode
, name
);
1001 SYMBOL_REF_WEAK (x
) = DECL_WEAK (decl
);
1002 SYMBOL_REF_DECL (x
) = decl
;
1004 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
1005 if (TREE_CODE (decl
) != FUNCTION_DECL
)
1006 set_mem_attributes (x
, decl
, 1);
1007 SET_DECL_RTL (decl
, x
);
1009 /* Optionally set flags or add text to the name to record information
1010 such as that it is a function name.
1011 If the name is changed, the macro ASM_OUTPUT_LABELREF
1012 will have to know how to strip this information. */
1013 targetm
.encode_section_info (decl
, DECL_RTL (decl
), true);
1015 /* Make this function static known to the mudflap runtime. */
1016 if (flag_mudflap
&& TREE_CODE (decl
) == VAR_DECL
)
1017 mudflap_enqueue_decl (decl
);
1020 /* Make the rtl for variable VAR be volatile.
1021 Use this only for static variables. */
1024 make_var_volatile (tree var
)
1026 gcc_assert (MEM_P (DECL_RTL (var
)));
1028 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
1031 /* Output a string of literal assembler code
1032 for an `asm' keyword used between functions. */
1035 assemble_asm (tree string
)
1039 if (TREE_CODE (string
) == ADDR_EXPR
)
1040 string
= TREE_OPERAND (string
, 0);
1042 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
1045 /* Record an element in the table of global destructors. SYMBOL is
1046 a SYMBOL_REF of the function to be called; PRIORITY is a number
1047 between 0 and MAX_INIT_PRIORITY. */
1050 default_stabs_asm_out_destructor (rtx symbol ATTRIBUTE_UNUSED
,
1051 int priority ATTRIBUTE_UNUSED
)
1053 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1054 /* Tell GNU LD that this is part of the static destructor set.
1055 This will work for any system that uses stabs, most usefully
1057 dbxout_begin_simple_stabs ("___DTOR_LIST__", 22 /* N_SETT */);
1058 dbxout_stab_value_label (XSTR (symbol
, 0));
1060 sorry ("global destructors not supported on this target");
1065 default_named_section_asm_out_destructor (rtx symbol
, int priority
)
1067 const char *section
= ".dtors";
1070 /* ??? This only works reliably with the GNU linker. */
1071 if (priority
!= DEFAULT_INIT_PRIORITY
)
1073 sprintf (buf
, ".dtors.%.5u",
1074 /* Invert the numbering so the linker puts us in the proper
1075 order; constructors are run from right to left, and the
1076 linker sorts in increasing order. */
1077 MAX_INIT_PRIORITY
- priority
);
1081 named_section_flags (section
, SECTION_WRITE
);
1082 assemble_align (POINTER_SIZE
);
1083 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1086 #ifdef DTORS_SECTION_ASM_OP
1088 dtors_section (void)
1090 if (in_section
!= in_dtors
)
1092 in_section
= in_dtors
;
1093 fputs (DTORS_SECTION_ASM_OP
, asm_out_file
);
1094 fputc ('\n', asm_out_file
);
1099 default_dtor_section_asm_out_destructor (rtx symbol
,
1100 int priority ATTRIBUTE_UNUSED
)
1103 assemble_align (POINTER_SIZE
);
1104 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1108 /* Likewise for global constructors. */
1111 default_stabs_asm_out_constructor (rtx symbol ATTRIBUTE_UNUSED
,
1112 int priority ATTRIBUTE_UNUSED
)
1114 #if defined DBX_DEBUGGING_INFO || defined XCOFF_DEBUGGING_INFO
1115 /* Tell GNU LD that this is part of the static destructor set.
1116 This will work for any system that uses stabs, most usefully
1118 dbxout_begin_simple_stabs ("___CTOR_LIST__", 22 /* N_SETT */);
1119 dbxout_stab_value_label (XSTR (symbol
, 0));
1121 sorry ("global constructors not supported on this target");
1126 default_named_section_asm_out_constructor (rtx symbol
, int priority
)
1128 const char *section
= ".ctors";
1131 /* ??? This only works reliably with the GNU linker. */
1132 if (priority
!= DEFAULT_INIT_PRIORITY
)
1134 sprintf (buf
, ".ctors.%.5u",
1135 /* Invert the numbering so the linker puts us in the proper
1136 order; constructors are run from right to left, and the
1137 linker sorts in increasing order. */
1138 MAX_INIT_PRIORITY
- priority
);
1142 named_section_flags (section
, SECTION_WRITE
);
1143 assemble_align (POINTER_SIZE
);
1144 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1147 #ifdef CTORS_SECTION_ASM_OP
1149 ctors_section (void)
1151 if (in_section
!= in_ctors
)
1153 in_section
= in_ctors
;
1154 fputs (CTORS_SECTION_ASM_OP
, asm_out_file
);
1155 fputc ('\n', asm_out_file
);
1160 default_ctor_section_asm_out_constructor (rtx symbol
,
1161 int priority ATTRIBUTE_UNUSED
)
1164 assemble_align (POINTER_SIZE
);
1165 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1169 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1170 a nonzero value if the constant pool should be output before the
1171 start of the function, or a zero value if the pool should output
1172 after the end of the function. The default is to put it before the
1175 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1176 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1179 /* DECL is an object (either VAR_DECL or FUNCTION_DECL) which is going
1180 to be output to assembler.
1181 Set first_global_object_name and weak_global_object_name as appropriate. */
1184 notice_global_symbol (tree decl
)
1186 const char **type
= &first_global_object_name
;
1188 if (first_global_object_name
1189 || !TREE_PUBLIC (decl
) || DECL_EXTERNAL (decl
)
1190 || !DECL_NAME (decl
)
1191 || (TREE_CODE (decl
) != FUNCTION_DECL
1192 && (TREE_CODE (decl
) != VAR_DECL
1193 || (DECL_COMMON (decl
)
1194 && (DECL_INITIAL (decl
) == 0
1195 || DECL_INITIAL (decl
) == error_mark_node
))))
1196 || !MEM_P (DECL_RTL (decl
)))
1199 /* We win when global object is found, but it is useful to know about weak
1200 symbol as well so we can produce nicer unique names. */
1201 if (DECL_WEAK (decl
) || DECL_ONE_ONLY (decl
))
1202 type
= &weak_global_object_name
;
1208 rtx decl_rtl
= DECL_RTL (decl
);
1210 p
= targetm
.strip_name_encoding (XSTR (XEXP (decl_rtl
, 0), 0));
1217 /* Output assembler code for the constant pool of a function and associated
1218 with defining the name of the function. DECL describes the function.
1219 NAME is the function's name. For the constant pool, we use the current
1220 constant pool data. */
1223 assemble_start_function (tree decl
, const char *fnname
)
1226 char tmp_label
[100];
1227 bool hot_label_written
= false;
1229 cfun
->unlikely_text_section_name
= NULL
;
1231 first_function_block_is_cold
= false;
1232 if (flag_reorder_blocks_and_partition
)
1234 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "HOTB", const_labelno
);
1235 cfun
->hot_section_label
= ggc_strdup (tmp_label
);
1236 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "COLDB", const_labelno
);
1237 cfun
->cold_section_label
= ggc_strdup (tmp_label
);
1238 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "HOTE", const_labelno
);
1239 cfun
->hot_section_end_label
= ggc_strdup (tmp_label
);
1240 ASM_GENERATE_INTERNAL_LABEL (tmp_label
, "COLDE", const_labelno
);
1241 cfun
->cold_section_end_label
= ggc_strdup (tmp_label
);
1246 cfun
->hot_section_label
= NULL
;
1247 cfun
->cold_section_label
= NULL
;
1248 cfun
->hot_section_end_label
= NULL
;
1249 cfun
->cold_section_end_label
= NULL
;
1252 /* The following code does not need preprocessing in the assembler. */
1256 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1257 output_constant_pool (fnname
, decl
);
1259 /* Make sure the not and cold text (code) sections are properly
1260 aligned. This is necessary here in the case where the function
1261 has both hot and cold sections, because we don't want to re-set
1262 the alignment when the section switch happens mid-function. */
1264 if (flag_reorder_blocks_and_partition
)
1266 unlikely_text_section ();
1267 assemble_align (FUNCTION_BOUNDARY
);
1268 ASM_OUTPUT_LABEL (asm_out_file
, cfun
->cold_section_label
);
1269 if (BB_PARTITION (ENTRY_BLOCK_PTR
->next_bb
) == BB_COLD_PARTITION
)
1271 /* Since the function starts with a cold section, we need to
1272 explicitly align the hot section and write out the hot
1275 assemble_align (FUNCTION_BOUNDARY
);
1276 ASM_OUTPUT_LABEL (asm_out_file
, cfun
->hot_section_label
);
1277 hot_label_written
= true;
1278 first_function_block_is_cold
= true;
1281 else if (DECL_SECTION_NAME (decl
))
1283 /* Calls to function_section rely on first_function_block_is_cold
1284 being accurate. The first block may be cold even if we aren't
1285 doing partitioning, if the entire function was decided by
1286 choose_function_section (predict.c) to be cold. */
1292 initialize_cold_section_name ();
1294 /* The following is necessary, because 'strcmp
1295 (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)), blah)' always
1296 fails, presumably because TREE_STRING_POINTER is declared to
1297 be an array of size 1 of char. */
1299 len
= TREE_STRING_LENGTH (DECL_SECTION_NAME (decl
));
1300 s
= (char *) xmalloc (len
+ 1);
1302 for (i
= 0; i
< len
; i
++)
1303 s
[i
] = (TREE_STRING_POINTER (DECL_SECTION_NAME (decl
)))[i
];
1306 if (cfun
->unlikely_text_section_name
1307 && (strcmp (s
, cfun
->unlikely_text_section_name
) == 0))
1308 first_function_block_is_cold
= true;
1311 last_text_section
= no_section
;
1312 resolve_unique_section (decl
, 0, flag_function_sections
);
1314 /* Switch to the correct text section for the start of the function. */
1316 function_section (decl
);
1317 if (flag_reorder_blocks_and_partition
1318 && !hot_label_written
)
1319 ASM_OUTPUT_LABEL (asm_out_file
, cfun
->hot_section_label
);
1321 /* Tell assembler to move to target machine's alignment for functions. */
1322 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1323 if (align
< force_align_functions_log
)
1324 align
= force_align_functions_log
;
1327 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1330 /* Handle a user-specified function alignment.
1331 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1332 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1333 if (align_functions_log
> align
1334 && cfun
->function_frequency
!= FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
)
1336 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1337 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1338 align_functions_log
, align_functions
- 1);
1340 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1344 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1345 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1348 (*debug_hooks
->begin_function
) (decl
);
1350 /* Make function name accessible from other files, if appropriate. */
1352 if (TREE_PUBLIC (decl
))
1354 notice_global_symbol (decl
);
1356 globalize_decl (decl
);
1358 maybe_assemble_visibility (decl
);
1361 if (DECL_PRESERVE_P (decl
))
1362 targetm
.asm_out
.mark_decl_preserved (fnname
);
1364 /* Do any machine/system dependent processing of the function name. */
1365 #ifdef ASM_DECLARE_FUNCTION_NAME
1366 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1368 /* Standard thing is just output label for the function. */
1369 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1370 #endif /* ASM_DECLARE_FUNCTION_NAME */
1372 insert_section_boundary_note ();
1375 /* Output assembler code associated with defining the size of the
1376 function. DECL describes the function. NAME is the function's name. */
1379 assemble_end_function (tree decl
, const char *fnname
)
1381 #ifdef ASM_DECLARE_FUNCTION_SIZE
1382 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1384 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1386 output_constant_pool (fnname
, decl
);
1387 function_section (decl
); /* need to switch back */
1389 /* Output labels for end of hot/cold text sections (to be used by
1391 if (flag_reorder_blocks_and_partition
)
1393 enum in_section save_text_section
;
1395 save_text_section
= in_section
;
1396 unlikely_text_section ();
1397 ASM_OUTPUT_LABEL (asm_out_file
, cfun
->cold_section_end_label
);
1399 ASM_OUTPUT_LABEL (asm_out_file
, cfun
->hot_section_end_label
);
1400 if (save_text_section
== in_unlikely_executed_text
)
1401 unlikely_text_section ();
1405 /* Assemble code to leave SIZE bytes of zeros. */
1408 assemble_zeros (unsigned HOST_WIDE_INT size
)
1410 /* Do no output if -fsyntax-only. */
1411 if (flag_syntax_only
)
1414 #ifdef ASM_NO_SKIP_IN_TEXT
1415 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1416 so we must output 0s explicitly in the text section. */
1417 if ((ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1418 || (ASM_NO_SKIP_IN_TEXT
&& in_unlikely_text_section ()))
1420 unsigned HOST_WIDE_INT i
;
1421 for (i
= 0; i
< size
; i
++)
1422 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1427 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1430 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1433 assemble_align (int align
)
1435 if (align
> BITS_PER_UNIT
)
1437 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1441 /* Assemble a string constant with the specified C string as contents. */
1444 assemble_string (const char *p
, int size
)
1449 /* If the string is very long, split it up. */
1453 int thissize
= size
- pos
;
1454 if (thissize
> maximum
)
1457 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1465 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1466 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1467 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1469 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1470 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1471 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1473 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1474 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1478 #if defined ASM_OUTPUT_ALIGNED_BSS
1479 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1480 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1482 #if defined ASM_OUTPUT_BSS
1483 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1484 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1490 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1491 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1492 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1494 #if defined ASM_OUTPUT_ALIGNED_COMMON
1495 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1496 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1498 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1499 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1504 asm_emit_uninitialised (tree decl
, const char *name
,
1505 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
,
1506 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
)
1514 destination
= asm_dest_local
;
1516 /* ??? We should handle .bss via select_section mechanisms rather than
1517 via special target hooks. That would eliminate this special case. */
1518 if (TREE_PUBLIC (decl
))
1520 if (!DECL_COMMON (decl
))
1522 destination
= asm_dest_bss
;
1527 destination
= asm_dest_common
;
1530 if (destination
!= asm_dest_common
)
1532 resolve_unique_section (decl
, 0, flag_data_sections
);
1533 /* Custom sections don't belong here. */
1534 if (DECL_SECTION_NAME (decl
))
1538 if (destination
== asm_dest_bss
)
1539 globalize_decl (decl
);
1541 if (flag_shared_data
)
1543 switch (destination
)
1545 #ifdef ASM_OUTPUT_SHARED_BSS
1547 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1550 #ifdef ASM_OUTPUT_SHARED_COMMON
1551 case asm_dest_common
:
1552 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1555 #ifdef ASM_OUTPUT_SHARED_LOCAL
1556 case asm_dest_local
:
1557 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1565 switch (destination
)
1569 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1572 case asm_dest_common
:
1573 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1575 case asm_dest_local
:
1576 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1585 /* Assemble everything that is needed for a variable or function declaration.
1586 Not used for automatic variables, and not used for function definitions.
1587 Should not be called for variables of incomplete structure type.
1589 TOP_LEVEL is nonzero if this variable has file scope.
1590 AT_END is nonzero if this is the special handling, at end of compilation,
1591 to define things that have had only tentative definitions.
1592 DONT_OUTPUT_DATA if nonzero means don't actually output the
1593 initial value (that will be done by the caller). */
1596 assemble_variable (tree decl
, int top_level ATTRIBUTE_UNUSED
,
1597 int at_end ATTRIBUTE_UNUSED
, int dont_output_data
)
1604 if (lang_hooks
.decls
.prepare_assemble_variable
)
1605 lang_hooks
.decls
.prepare_assemble_variable (decl
);
1607 last_assemble_variable_decl
= 0;
1609 /* Normally no need to say anything here for external references,
1610 since assemble_external is called by the language-specific code
1611 when a declaration is first seen. */
1613 if (DECL_EXTERNAL (decl
))
1616 /* Output no assembler code for a function declaration.
1617 Only definitions of functions output anything. */
1619 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1622 /* Do nothing for global register variables. */
1623 if (DECL_RTL_SET_P (decl
) && REG_P (DECL_RTL (decl
)))
1625 TREE_ASM_WRITTEN (decl
) = 1;
1629 /* If type was incomplete when the variable was declared,
1630 see if it is complete now. */
1632 if (DECL_SIZE (decl
) == 0)
1633 layout_decl (decl
, 0);
1635 /* Still incomplete => don't allocate it; treat the tentative defn
1636 (which is what it must have been) as an `extern' reference. */
1638 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1640 error ("%Jstorage size of %qD isn%'t known", decl
, decl
);
1641 TREE_ASM_WRITTEN (decl
) = 1;
1645 /* The first declaration of a variable that comes through this function
1646 decides whether it is global (in C, has external linkage)
1647 or local (in C, has internal linkage). So do nothing more
1648 if this function has already run. */
1650 if (TREE_ASM_WRITTEN (decl
))
1653 /* Make sure targetm.encode_section_info is invoked before we set
1655 decl_rtl
= DECL_RTL (decl
);
1657 TREE_ASM_WRITTEN (decl
) = 1;
1659 /* Do no output if -fsyntax-only. */
1660 if (flag_syntax_only
)
1665 if (! dont_output_data
1666 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1668 error ("%Jsize of variable %qD is too large", decl
, decl
);
1672 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1673 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1674 notice_global_symbol (decl
);
1676 /* Compute the alignment of this data. */
1678 align
= DECL_ALIGN (decl
);
1680 /* In the case for initialing an array whose length isn't specified,
1681 where we have not yet been able to do the layout,
1682 figure out the proper alignment now. */
1683 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1684 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1685 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1687 /* Some object file formats have a maximum alignment which they support.
1688 In particular, a.out format supports a maximum alignment of 4. */
1689 if (align
> MAX_OFILE_ALIGNMENT
)
1691 warning (0, "%Jalignment of %qD is greater than maximum object "
1692 "file alignment. Using %d", decl
, decl
,
1693 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1694 align
= MAX_OFILE_ALIGNMENT
;
1697 /* On some machines, it is good to increase alignment sometimes. */
1698 if (! DECL_USER_ALIGN (decl
))
1700 #ifdef DATA_ALIGNMENT
1701 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1703 #ifdef CONSTANT_ALIGNMENT
1704 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1705 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1709 /* Reset the alignment in case we have made it tighter, so we can benefit
1710 from it in get_pointer_alignment. */
1711 DECL_ALIGN (decl
) = align
;
1712 set_mem_align (decl_rtl
, align
);
1714 if (TREE_PUBLIC (decl
))
1715 maybe_assemble_visibility (decl
);
1717 if (DECL_PRESERVE_P (decl
))
1718 targetm
.asm_out
.mark_decl_preserved (name
);
1720 /* Handle uninitialized definitions. */
1722 /* If the decl has been given an explicit section name, then it
1723 isn't common, and shouldn't be handled as such. */
1724 if (DECL_SECTION_NAME (decl
) || dont_output_data
)
1726 /* We don't implement common thread-local data at present. */
1727 else if (DECL_THREAD_LOCAL (decl
))
1729 if (DECL_COMMON (decl
))
1730 sorry ("thread-local COMMON data not implemented");
1732 else if (DECL_INITIAL (decl
) == 0
1733 || DECL_INITIAL (decl
) == error_mark_node
1734 || (flag_zero_initialized_in_bss
1735 /* Leave constant zeroes in .rodata so they can be shared. */
1736 && !TREE_READONLY (decl
)
1737 && initializer_zerop (DECL_INITIAL (decl
))))
1739 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1740 unsigned HOST_WIDE_INT rounded
= size
;
1742 /* Don't allocate zero bytes of common,
1743 since that means "undefined external" in the linker. */
1747 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1748 so that each uninitialized object starts on such a boundary. */
1749 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1750 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1751 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1753 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1754 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN_UNIT (decl
) > rounded
)
1755 warning (0, "%Jrequested alignment for %qD is greater than "
1756 "implemented alignment of %d", decl
, decl
, rounded
);
1759 /* If the target cannot output uninitialized but not common global data
1760 in .bss, then we have to use .data, so fall through. */
1761 if (asm_emit_uninitialised (decl
, name
, size
, rounded
))
1765 /* Handle initialized definitions.
1766 Also handle uninitialized global definitions if -fno-common and the
1767 target doesn't support ASM_OUTPUT_BSS. */
1769 /* First make the assembler name(s) global if appropriate. */
1770 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1771 globalize_decl (decl
);
1773 /* Output any data that we will need to use the address of. */
1774 if (DECL_INITIAL (decl
) == error_mark_node
)
1775 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1776 else if (DECL_INITIAL (decl
))
1778 reloc
= compute_reloc_for_constant (DECL_INITIAL (decl
));
1779 output_addressed_constants (DECL_INITIAL (decl
));
1782 /* Switch to the appropriate section. */
1783 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1784 variable_section (decl
, reloc
);
1786 /* dbxout.c needs to know this. */
1787 if (in_text_section () || in_unlikely_text_section ())
1788 DECL_IN_TEXT_SECTION (decl
) = 1;
1790 /* Output the alignment of this data. */
1791 if (align
> BITS_PER_UNIT
)
1792 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (DECL_ALIGN_UNIT (decl
)));
1794 /* Do any machine/system dependent processing of the object. */
1795 #ifdef ASM_DECLARE_OBJECT_NAME
1796 last_assemble_variable_decl
= decl
;
1797 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1799 /* Standard thing is just output label for the object. */
1800 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1801 #endif /* ASM_DECLARE_OBJECT_NAME */
1803 if (!dont_output_data
)
1805 if (DECL_INITIAL (decl
)
1806 && DECL_INITIAL (decl
) != error_mark_node
1807 && !initializer_zerop (DECL_INITIAL (decl
)))
1808 /* Output the actual data. */
1809 output_constant (DECL_INITIAL (decl
),
1810 tree_low_cst (DECL_SIZE_UNIT (decl
), 1),
1813 /* Leave space for it. */
1814 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1818 /* Return 1 if type TYPE contains any pointers. */
1821 contains_pointers_p (tree type
)
1823 switch (TREE_CODE (type
))
1826 case REFERENCE_TYPE
:
1827 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1828 so I'll play safe and return 1. */
1834 case QUAL_UNION_TYPE
:
1837 /* For a type that has fields, see if the fields have pointers. */
1838 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1839 if (TREE_CODE (fields
) == FIELD_DECL
1840 && contains_pointers_p (TREE_TYPE (fields
)))
1846 /* An array type contains pointers if its element type does. */
1847 return contains_pointers_p (TREE_TYPE (type
));
1854 /* In unit-at-a-time mode, we delay assemble_external processing until
1855 the compilation unit is finalized. This is the best we can do for
1856 right now (i.e. stage 3 of GCC 4.0) - the right thing is to delay
1857 it all the way to final. See PR 17982 for further discussion. */
1858 static GTY(()) tree pending_assemble_externals
;
1860 #ifdef ASM_OUTPUT_EXTERNAL
1861 /* True if DECL is a function decl for which no out-of-line copy exists.
1862 It is assumed that DECL's assembler name has been set. */
1865 incorporeal_function_p (tree decl
)
1867 if (TREE_CODE (decl
) == FUNCTION_DECL
&& DECL_BUILT_IN (decl
))
1871 if (DECL_BUILT_IN_CLASS (decl
) == BUILT_IN_NORMAL
1872 && DECL_FUNCTION_CODE (decl
) == BUILT_IN_ALLOCA
)
1875 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
1876 if (strncmp (name
, "__builtin_", strlen ("__builtin_")) == 0)
1882 /* Actually do the tests to determine if this is necessary, and invoke
1883 ASM_OUTPUT_EXTERNAL. */
1885 assemble_external_real (tree decl
)
1887 rtx rtl
= DECL_RTL (decl
);
1889 if (MEM_P (rtl
) && GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1890 && !SYMBOL_REF_USED (XEXP (rtl
, 0))
1891 && !incorporeal_function_p (decl
))
1893 /* Some systems do require some output. */
1894 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1895 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1901 process_pending_assemble_externals (void)
1903 #ifdef ASM_OUTPUT_EXTERNAL
1905 for (list
= pending_assemble_externals
; list
; list
= TREE_CHAIN (list
))
1906 assemble_external_real (TREE_VALUE (list
));
1908 pending_assemble_externals
= 0;
1912 /* Output something to declare an external symbol to the assembler.
1913 (Most assemblers don't need this, so we normally output nothing.)
1914 Do nothing if DECL is not external. */
1917 assemble_external (tree decl ATTRIBUTE_UNUSED
)
1919 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1920 main body of this code is only rarely exercised. To provide some
1921 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1922 open. If it's not, we should not be calling this function. */
1923 gcc_assert (asm_out_file
);
1925 #ifdef ASM_OUTPUT_EXTERNAL
1926 if (!DECL_P (decl
) || !DECL_EXTERNAL (decl
) || !TREE_PUBLIC (decl
))
1929 if (flag_unit_at_a_time
)
1930 pending_assemble_externals
= tree_cons (0, decl
,
1931 pending_assemble_externals
);
1933 assemble_external_real (decl
);
1937 /* Similar, for calling a library function FUN. */
1940 assemble_external_libcall (rtx fun
)
1942 /* Declare library function name external when first used, if nec. */
1943 if (! SYMBOL_REF_USED (fun
))
1945 SYMBOL_REF_USED (fun
) = 1;
1946 targetm
.asm_out
.external_libcall (fun
);
1950 /* Assemble a label named NAME. */
1953 assemble_label (const char *name
)
1955 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1958 /* Set the symbol_referenced flag for ID. */
1960 mark_referenced (tree id
)
1962 TREE_SYMBOL_REFERENCED (id
) = 1;
1965 /* Set the symbol_referenced flag for DECL and notify callgraph. */
1967 mark_decl_referenced (tree decl
)
1969 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1971 /* Extern inline functions don't become needed when referenced.
1972 If we know a method will be emitted in other TU and no new
1973 functions can be marked reachable, just use the external
1975 struct cgraph_node
*node
= cgraph_node (decl
);
1976 if (!DECL_EXTERNAL (decl
)
1977 && (!node
->local
.vtable_method
|| !cgraph_global_info_ready
1978 || !node
->local
.finalized
))
1979 cgraph_mark_needed_node (node
);
1981 else if (TREE_CODE (decl
) == VAR_DECL
)
1983 struct cgraph_varpool_node
*node
= cgraph_varpool_node (decl
);
1984 cgraph_varpool_mark_needed_node (node
);
1985 /* C++ frontend use mark_decl_references to force COMDAT variables
1986 to be output that might appear dead otherwise. */
1987 node
->force_output
= true;
1989 /* else do nothing - we can get various sorts of CST nodes here,
1990 which do not need to be marked. */
1993 /* Output to FILE (an assembly file) a reference to NAME. If NAME
1994 starts with a *, the rest of NAME is output verbatim. Otherwise
1995 NAME is transformed in a target-specific way (usually by the
1996 addition of an underscore). */
1999 assemble_name_raw (FILE *file
, const char *name
)
2002 fputs (&name
[1], file
);
2004 ASM_OUTPUT_LABELREF (file
, name
);
2007 /* Like assemble_name_raw, but should be used when NAME might refer to
2008 an entity that is also represented as a tree (like a function or
2009 variable). If NAME does refer to such an entity, that entity will
2010 be marked as referenced. */
2013 assemble_name (FILE *file
, const char *name
)
2015 const char *real_name
;
2018 real_name
= targetm
.strip_name_encoding (name
);
2020 id
= maybe_get_identifier (real_name
);
2022 mark_referenced (id
);
2024 assemble_name_raw (file
, name
);
2027 /* Allocate SIZE bytes writable static space with a gensym name
2028 and return an RTX to refer to its address. */
2031 assemble_static_space (unsigned HOST_WIDE_INT size
)
2034 const char *namestring
;
2038 if (flag_shared_data
)
2042 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
2044 namestring
= ggc_strdup (name
);
2046 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
2047 SYMBOL_REF_FLAGS (x
) = SYMBOL_FLAG_LOCAL
;
2049 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
2050 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
2053 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
2054 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
2057 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
2058 so that each uninitialized object starts on such a boundary. */
2059 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
2060 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
2061 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
2062 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
2063 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
2064 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
2071 /* Assemble the static constant template for function entry trampolines.
2072 This is done at most once per compilation.
2073 Returns an RTX for the address of the template. */
2075 static GTY(()) rtx initial_trampoline
;
2077 #ifdef TRAMPOLINE_TEMPLATE
2079 assemble_trampoline_template (void)
2086 if (initial_trampoline
)
2087 return initial_trampoline
;
2089 /* By default, put trampoline templates in read-only data section. */
2091 #ifdef TRAMPOLINE_SECTION
2092 TRAMPOLINE_SECTION ();
2094 readonly_data_section ();
2097 /* Write the assembler code to define one. */
2098 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
2101 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
2104 targetm
.asm_out
.internal_label (asm_out_file
, "LTRAMP", 0);
2105 TRAMPOLINE_TEMPLATE (asm_out_file
);
2107 /* Record the rtl to refer to it. */
2108 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
2109 name
= ggc_strdup (label
);
2110 symbol
= gen_rtx_SYMBOL_REF (Pmode
, name
);
2111 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2113 initial_trampoline
= gen_rtx_MEM (BLKmode
, symbol
);
2114 set_mem_align (initial_trampoline
, TRAMPOLINE_ALIGNMENT
);
2116 return initial_trampoline
;
2120 /* A and B are either alignments or offsets. Return the minimum alignment
2121 that may be assumed after adding the two together. */
2123 static inline unsigned
2124 min_align (unsigned int a
, unsigned int b
)
2126 return (a
| b
) & -(a
| b
);
2129 /* Return the assembler directive for creating a given kind of integer
2130 object. SIZE is the number of bytes in the object and ALIGNED_P
2131 indicates whether it is known to be aligned. Return NULL if the
2132 assembly dialect has no such directive.
2134 The returned string should be printed at the start of a new line and
2135 be followed immediately by the object's initial value. */
2138 integer_asm_op (int size
, int aligned_p
)
2140 struct asm_int_op
*ops
;
2143 ops
= &targetm
.asm_out
.aligned_op
;
2145 ops
= &targetm
.asm_out
.unaligned_op
;
2150 return targetm
.asm_out
.byte_op
;
2164 /* Use directive OP to assemble an integer object X. Print OP at the
2165 start of the line, followed immediately by the value of X. */
2168 assemble_integer_with_op (const char *op
, rtx x
)
2170 fputs (op
, asm_out_file
);
2171 output_addr_const (asm_out_file
, x
);
2172 fputc ('\n', asm_out_file
);
2175 /* The default implementation of the asm_out.integer target hook. */
2178 default_assemble_integer (rtx x ATTRIBUTE_UNUSED
,
2179 unsigned int size ATTRIBUTE_UNUSED
,
2180 int aligned_p ATTRIBUTE_UNUSED
)
2182 const char *op
= integer_asm_op (size
, aligned_p
);
2183 /* Avoid GAS bugs for large values. Specifically negative values whose
2184 absolute value fits in a bfd_vma, but not in a bfd_signed_vma. */
2185 if (size
> UNITS_PER_WORD
&& size
> POINTER_SIZE
/ BITS_PER_UNIT
)
2187 return op
&& (assemble_integer_with_op (op
, x
), true);
2190 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
2191 the alignment of the integer in bits. Return 1 if we were able to output
2192 the constant, otherwise 0. We must be able to output the constant,
2193 if FORCE is nonzero. */
2196 assemble_integer (rtx x
, unsigned int size
, unsigned int align
, int force
)
2200 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
2202 /* See if the target hook can handle this kind of object. */
2203 if (targetm
.asm_out
.integer (x
, size
, aligned_p
))
2206 /* If the object is a multi-byte one, try splitting it up. Split
2207 it into words it if is multi-word, otherwise split it into bytes. */
2210 enum machine_mode omode
, imode
;
2211 unsigned int subalign
;
2212 unsigned int subsize
, i
;
2214 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
2215 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
2216 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, MODE_INT
, 0);
2217 imode
= mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
2219 for (i
= 0; i
< size
; i
+= subsize
)
2221 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
2222 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
2228 /* If we've printed some of it, but not all of it, there's no going
2233 gcc_assert (!force
);
2239 assemble_real (REAL_VALUE_TYPE d
, enum machine_mode mode
, unsigned int align
)
2243 int bitsize
, nelts
, nunits
, units_per
;
2245 /* This is hairy. We have a quantity of known size. real_to_target
2246 will put it into an array of *host* longs, 32 bits per element
2247 (even if long is more than 32 bits). We need to determine the
2248 number of array elements that are occupied (nelts) and the number
2249 of *target* min-addressable units that will be occupied in the
2250 object file (nunits). We cannot assume that 32 divides the
2251 mode's bitsize (size * BITS_PER_UNIT) evenly.
2253 size * BITS_PER_UNIT is used here to make sure that padding bits
2254 (which might appear at either end of the value; real_to_target
2255 will include the padding bits in its output array) are included. */
2257 nunits
= GET_MODE_SIZE (mode
);
2258 bitsize
= nunits
* BITS_PER_UNIT
;
2259 nelts
= CEIL (bitsize
, 32);
2260 units_per
= 32 / BITS_PER_UNIT
;
2262 real_to_target (data
, &d
, mode
);
2264 /* Put out the first word with the specified alignment. */
2265 assemble_integer (GEN_INT (data
[0]), MIN (nunits
, units_per
), align
, 1);
2266 nunits
-= units_per
;
2268 /* Subsequent words need only 32-bit alignment. */
2269 align
= min_align (align
, 32);
2271 for (i
= 1; i
< nelts
; i
++)
2273 assemble_integer (GEN_INT (data
[i
]), MIN (nunits
, units_per
), align
, 1);
2274 nunits
-= units_per
;
2278 /* Given an expression EXP with a constant value,
2279 reduce it to the sum of an assembler symbol and an integer.
2280 Store them both in the structure *VALUE.
2281 EXP must be reducible. */
2283 struct addr_const
GTY(())
2286 HOST_WIDE_INT offset
;
2290 decode_addr_const (tree exp
, struct addr_const
*value
)
2292 tree target
= TREE_OPERAND (exp
, 0);
2298 if (TREE_CODE (target
) == COMPONENT_REF
2299 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2302 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2303 target
= TREE_OPERAND (target
, 0);
2305 else if (TREE_CODE (target
) == ARRAY_REF
2306 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2308 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2309 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2310 target
= TREE_OPERAND (target
, 0);
2316 switch (TREE_CODE (target
))
2320 x
= DECL_RTL (target
);
2324 x
= gen_rtx_MEM (FUNCTION_MODE
,
2325 gen_rtx_LABEL_REF (Pmode
, force_label_rtx (target
)));
2333 x
= output_constant_def (target
, 1);
2340 gcc_assert (MEM_P (x
));
2344 value
->offset
= offset
;
2347 /* Uniquize all constants that appear in memory.
2348 Each constant in memory thus far output is recorded
2349 in `const_desc_table'. */
2351 struct constant_descriptor_tree
GTY(())
2353 /* A MEM for the constant. */
2356 /* The value of the constant. */
2360 static GTY((param_is (struct constant_descriptor_tree
)))
2361 htab_t const_desc_htab
;
2363 static struct constant_descriptor_tree
* build_constant_desc (tree
);
2364 static void maybe_output_constant_def_contents (struct constant_descriptor_tree
*, int);
2366 /* Compute a hash code for a constant expression. */
2369 const_desc_hash (const void *ptr
)
2371 return const_hash_1 (((struct constant_descriptor_tree
*)ptr
)->value
);
2375 const_hash_1 (const tree exp
)
2380 enum tree_code code
= TREE_CODE (exp
);
2382 /* Either set P and LEN to the address and len of something to hash and
2383 exit the switch or return a value. */
2388 p
= (char *) &TREE_INT_CST (exp
);
2389 len
= sizeof TREE_INT_CST (exp
);
2393 return real_hash (TREE_REAL_CST_PTR (exp
));
2396 p
= TREE_STRING_POINTER (exp
);
2397 len
= TREE_STRING_LENGTH (exp
);
2401 return (const_hash_1 (TREE_REALPART (exp
)) * 5
2402 + const_hash_1 (TREE_IMAGPART (exp
)));
2408 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
2410 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2411 if (TREE_VALUE (link
))
2412 hi
= hi
* 603 + const_hash_1 (TREE_VALUE (link
));
2420 struct addr_const value
;
2422 decode_addr_const (exp
, &value
);
2423 switch (GET_CODE (value
.base
))
2426 /* Don't hash the address of the SYMBOL_REF;
2427 only use the offset and the symbol name. */
2429 p
= XSTR (value
.base
, 0);
2430 for (i
= 0; p
[i
] != 0; i
++)
2431 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2435 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2446 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
2447 + const_hash_1 (TREE_OPERAND (exp
, 1)));
2451 case NON_LVALUE_EXPR
:
2452 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
2455 /* A language specific constant. Just hash the code. */
2459 /* Compute hashing function. */
2461 for (i
= 0; i
< len
; i
++)
2462 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2467 /* Wrapper of compare_constant, for the htab interface. */
2469 const_desc_eq (const void *p1
, const void *p2
)
2471 return compare_constant (((struct constant_descriptor_tree
*)p1
)->value
,
2472 ((struct constant_descriptor_tree
*)p2
)->value
);
2475 /* Compare t1 and t2, and return 1 only if they are known to result in
2476 the same bit pattern on output. */
2479 compare_constant (const tree t1
, const tree t2
)
2481 enum tree_code typecode
;
2483 if (t1
== NULL_TREE
)
2484 return t2
== NULL_TREE
;
2485 if (t2
== NULL_TREE
)
2488 if (TREE_CODE (t1
) != TREE_CODE (t2
))
2491 switch (TREE_CODE (t1
))
2494 /* Integer constants are the same only if the same width of type. */
2495 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2497 return tree_int_cst_equal (t1
, t2
);
2500 /* Real constants are the same only if the same width of type. */
2501 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2504 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2507 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
2510 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2511 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2512 TREE_STRING_LENGTH (t1
)));
2515 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
2516 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
2522 typecode
= TREE_CODE (TREE_TYPE (t1
));
2523 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
2526 if (typecode
== ARRAY_TYPE
)
2528 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
2529 /* For arrays, check that the sizes all match. */
2530 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
2532 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
)))
2537 /* For record and union constructors, require exact type
2539 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
2543 for (l1
= CONSTRUCTOR_ELTS (t1
), l2
= CONSTRUCTOR_ELTS (t2
);
2545 l1
= TREE_CHAIN (l1
), l2
= TREE_CHAIN (l2
))
2547 /* Check that each value is the same... */
2548 if (! compare_constant (TREE_VALUE (l1
), TREE_VALUE (l2
)))
2550 /* ... and that they apply to the same fields! */
2551 if (typecode
== ARRAY_TYPE
)
2553 if (! compare_constant (TREE_PURPOSE (l1
),
2559 if (TREE_PURPOSE (l1
) != TREE_PURPOSE (l2
))
2564 return l1
== NULL_TREE
&& l2
== NULL_TREE
;
2570 struct addr_const value1
, value2
;
2572 decode_addr_const (t1
, &value1
);
2573 decode_addr_const (t2
, &value2
);
2574 return (value1
.offset
== value2
.offset
2575 && strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
2581 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
2582 && compare_constant(TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
2586 case NON_LVALUE_EXPR
:
2587 case VIEW_CONVERT_EXPR
:
2588 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2593 nt1
= lang_hooks
.expand_constant (t1
);
2594 nt2
= lang_hooks
.expand_constant (t2
);
2595 if (nt1
!= t1
|| nt2
!= t2
)
2596 return compare_constant (nt1
, nt2
);
2605 /* Make a copy of the whole tree structure for a constant. This
2606 handles the same types of nodes that compare_constant handles. */
2609 copy_constant (tree exp
)
2611 switch (TREE_CODE (exp
))
2614 /* For ADDR_EXPR, we do not want to copy the decl whose address
2615 is requested. We do want to copy constants though. */
2616 if (CONSTANT_CLASS_P (TREE_OPERAND (exp
, 0)))
2617 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2618 copy_constant (TREE_OPERAND (exp
, 0)));
2620 return copy_node (exp
);
2625 return copy_node (exp
);
2628 return build_complex (TREE_TYPE (exp
),
2629 copy_constant (TREE_REALPART (exp
)),
2630 copy_constant (TREE_IMAGPART (exp
)));
2634 return build2 (TREE_CODE (exp
), TREE_TYPE (exp
),
2635 copy_constant (TREE_OPERAND (exp
, 0)),
2636 copy_constant (TREE_OPERAND (exp
, 1)));
2640 case NON_LVALUE_EXPR
:
2641 case VIEW_CONVERT_EXPR
:
2642 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2643 copy_constant (TREE_OPERAND (exp
, 0)));
2647 tree copy
= copy_node (exp
);
2648 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
2651 CONSTRUCTOR_ELTS (copy
) = list
;
2652 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2653 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
2660 tree t
= lang_hooks
.expand_constant (exp
);
2662 gcc_assert (t
== exp
);
2663 return copy_constant (t
);
2668 /* Subroutine of output_constant_def:
2669 No constant equal to EXP is known to have been output.
2670 Make a constant descriptor to enter EXP in the hash table.
2671 Assign the label number and construct RTL to refer to the
2672 constant's location in memory.
2673 Caller is responsible for updating the hash table. */
2675 static struct constant_descriptor_tree
*
2676 build_constant_desc (tree exp
)
2682 struct constant_descriptor_tree
*desc
;
2684 desc
= ggc_alloc (sizeof (*desc
));
2685 desc
->value
= copy_constant (exp
);
2687 /* Propagate marked-ness to copied constant. */
2688 if (flag_mudflap
&& mf_marked_p (exp
))
2689 mf_mark (desc
->value
);
2691 /* Create a string containing the label name, in LABEL. */
2692 labelno
= const_labelno
++;
2693 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
2695 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2696 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
2697 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2698 SYMBOL_REF_DECL (symbol
) = desc
->value
;
2699 TREE_CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
2701 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)), symbol
);
2702 set_mem_attributes (rtl
, exp
, 1);
2703 set_mem_alias_set (rtl
, 0);
2704 set_mem_alias_set (rtl
, const_alias_set
);
2706 /* Set flags or add text to the name to record information, such as
2707 that it is a local symbol. If the name is changed, the macro
2708 ASM_OUTPUT_LABELREF will have to know how to strip this
2709 information. This call might invalidate our local variable
2710 SYMBOL; we can't use it afterward. */
2712 targetm
.encode_section_info (exp
, rtl
, true);
2719 /* Return an rtx representing a reference to constant data in memory
2720 for the constant expression EXP.
2722 If assembler code for such a constant has already been output,
2723 return an rtx to refer to it.
2724 Otherwise, output such a constant in memory
2725 and generate an rtx for it.
2727 If DEFER is nonzero, this constant can be deferred and output only
2728 if referenced in the function after all optimizations.
2730 `const_desc_table' records which constants already have label strings. */
2733 output_constant_def (tree exp
, int defer
)
2735 struct constant_descriptor_tree
*desc
;
2736 struct constant_descriptor_tree key
;
2739 /* Look up EXP in the table of constant descriptors. If we didn't find
2740 it, create a new one. */
2742 loc
= htab_find_slot (const_desc_htab
, &key
, INSERT
);
2747 desc
= build_constant_desc (exp
);
2751 maybe_output_constant_def_contents (desc
, defer
);
2755 /* Subroutine of output_constant_def: Decide whether or not we need to
2756 output the constant DESC now, and if so, do it. */
2758 maybe_output_constant_def_contents (struct constant_descriptor_tree
*desc
,
2761 rtx symbol
= XEXP (desc
->rtl
, 0);
2762 tree exp
= desc
->value
;
2764 if (flag_syntax_only
)
2767 if (TREE_ASM_WRITTEN (exp
))
2768 /* Already output; don't do it again. */
2771 /* We can always defer constants as long as the context allows
2775 /* Increment n_deferred_constants if it exists. It needs to be at
2776 least as large as the number of constants actually referred to
2777 by the function. If it's too small we'll stop looking too early
2778 and fail to emit constants; if it's too large we'll only look
2779 through the entire function when we could have stopped earlier. */
2781 n_deferred_constants
++;
2785 output_constant_def_contents (symbol
);
2788 /* We must output the constant data referred to by SYMBOL; do so. */
2791 output_constant_def_contents (rtx symbol
)
2793 tree exp
= SYMBOL_REF_DECL (symbol
);
2794 const char *label
= XSTR (symbol
, 0);
2797 /* Make sure any other constants whose addresses appear in EXP
2798 are assigned label numbers. */
2799 int reloc
= compute_reloc_for_constant (exp
);
2801 /* Align the location counter as required by EXP's data type. */
2802 unsigned int align
= TYPE_ALIGN (TREE_TYPE (exp
));
2803 #ifdef CONSTANT_ALIGNMENT
2804 align
= CONSTANT_ALIGNMENT (exp
, align
);
2807 output_addressed_constants (exp
);
2809 /* We are no longer deferring this constant. */
2810 TREE_ASM_WRITTEN (exp
) = 1;
2812 if (IN_NAMED_SECTION (exp
))
2813 named_section (exp
, NULL
, reloc
);
2815 targetm
.asm_out
.select_section (exp
, reloc
, align
);
2817 if (align
> BITS_PER_UNIT
)
2819 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2822 size
= int_size_in_bytes (TREE_TYPE (exp
));
2823 if (TREE_CODE (exp
) == STRING_CST
)
2824 size
= MAX (TREE_STRING_LENGTH (exp
), size
);
2826 /* Do any machine/system dependent processing of the constant. */
2827 #ifdef ASM_DECLARE_CONSTANT_NAME
2828 ASM_DECLARE_CONSTANT_NAME (asm_out_file
, label
, exp
, size
);
2830 /* Standard thing is just output label for the constant. */
2831 ASM_OUTPUT_LABEL (asm_out_file
, label
);
2832 #endif /* ASM_DECLARE_CONSTANT_NAME */
2834 /* Output the value of EXP. */
2835 output_constant (exp
, size
, align
);
2837 mudflap_enqueue_constant (exp
);
2840 /* Look up EXP in the table of constant descriptors. Return the rtl
2841 if it has been emitted, else null. */
2844 lookup_constant_def (tree exp
)
2846 struct constant_descriptor_tree
*desc
;
2847 struct constant_descriptor_tree key
;
2850 desc
= htab_find (const_desc_htab
, &key
);
2852 return (desc
? desc
->rtl
: NULL_RTX
);
2855 /* Used in the hash tables to avoid outputting the same constant
2856 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2857 are output once per function, not once per file. */
2858 /* ??? Only a few targets need per-function constant pools. Most
2859 can use one per-file pool. Should add a targetm bit to tell the
2862 struct rtx_constant_pool
GTY(())
2864 /* Pointers to first and last constant in pool, as ordered by offset. */
2865 struct constant_descriptor_rtx
*first
;
2866 struct constant_descriptor_rtx
*last
;
2868 /* Hash facility for making memory-constants from constant rtl-expressions.
2869 It is used on RISC machines where immediate integer arguments and
2870 constant addresses are restricted so that such constants must be stored
2872 htab_t
GTY((param_is (struct constant_descriptor_rtx
))) const_rtx_htab
;
2873 htab_t
GTY((param_is (struct constant_descriptor_rtx
))) const_rtx_sym_htab
;
2875 /* Current offset in constant pool (does not include any
2876 machine-specific header). */
2877 HOST_WIDE_INT offset
;
2880 struct constant_descriptor_rtx
GTY((chain_next ("%h.next")))
2882 struct constant_descriptor_rtx
*next
;
2886 HOST_WIDE_INT offset
;
2888 enum machine_mode mode
;
2894 /* Hash and compare functions for const_rtx_htab. */
2897 const_desc_rtx_hash (const void *ptr
)
2899 const struct constant_descriptor_rtx
*desc
= ptr
;
2904 const_desc_rtx_eq (const void *a
, const void *b
)
2906 const struct constant_descriptor_rtx
*x
= a
;
2907 const struct constant_descriptor_rtx
*y
= b
;
2909 if (x
->mode
!= y
->mode
)
2911 return rtx_equal_p (x
->constant
, y
->constant
);
2914 /* Hash and compare functions for const_rtx_sym_htab. */
2917 const_desc_rtx_sym_hash (const void *ptr
)
2919 const struct constant_descriptor_rtx
*desc
= ptr
;
2920 return htab_hash_string (XSTR (desc
->sym
, 0));
2924 const_desc_rtx_sym_eq (const void *a
, const void *b
)
2926 const struct constant_descriptor_rtx
*x
= a
;
2927 const struct constant_descriptor_rtx
*y
= b
;
2928 return XSTR (x
->sym
, 0) == XSTR (y
->sym
, 0);
2931 /* This is the worker function for const_rtx_hash, called via for_each_rtx. */
2934 const_rtx_hash_1 (rtx
*xp
, void *data
)
2936 unsigned HOST_WIDE_INT hwi
;
2937 enum machine_mode mode
;
2943 code
= GET_CODE (x
);
2944 mode
= GET_MODE (x
);
2945 h
= (hashval_t
) code
* 1048573 + mode
;
2953 const int shift
= sizeof (hashval_t
) * CHAR_BIT
;
2954 const int n
= sizeof (HOST_WIDE_INT
) / sizeof (hashval_t
);
2957 h
^= (hashval_t
) hwi
;
2958 for (i
= 1; i
< n
; ++i
)
2961 h
^= (hashval_t
) hwi
;
2967 if (mode
== VOIDmode
)
2969 hwi
= CONST_DOUBLE_LOW (x
) ^ CONST_DOUBLE_HIGH (x
);
2973 h
^= real_hash (CONST_DOUBLE_REAL_VALUE (x
));
2979 for (i
= XVECLEN (x
, 0); i
-- > 0; )
2980 h
= h
* 251 + const_rtx_hash_1 (&XVECEXP (x
, 0, i
), data
);
2985 h
^= htab_hash_string (XSTR (x
, 0));
2989 h
= h
* 251 + CODE_LABEL_NUMBER (XEXP (x
, 0));
2993 case UNSPEC_VOLATILE
:
2994 h
= h
* 251 + XINT (x
, 1);
3002 *hp
= *hp
* 509 + h
;
3006 /* Compute a hash value for X, which should be a constant. */
3009 const_rtx_hash (rtx x
)
3012 for_each_rtx (&x
, const_rtx_hash_1
, &h
);
3017 /* Initialize constant pool hashing for a new function. */
3020 init_varasm_status (struct function
*f
)
3022 struct varasm_status
*p
;
3023 struct rtx_constant_pool
*pool
;
3025 p
= ggc_alloc (sizeof (struct varasm_status
));
3028 pool
= ggc_alloc (sizeof (struct rtx_constant_pool
));
3030 p
->deferred_constants
= 0;
3032 pool
->const_rtx_htab
= htab_create_ggc (31, const_desc_rtx_hash
,
3033 const_desc_rtx_eq
, NULL
);
3034 pool
->const_rtx_sym_htab
= htab_create_ggc (31, const_desc_rtx_sym_hash
,
3035 const_desc_rtx_sym_eq
, NULL
);
3036 pool
->first
= pool
->last
= NULL
;
3040 /* Given a MINUS expression, simplify it if both sides
3041 include the same symbol. */
3044 simplify_subtraction (rtx x
)
3046 rtx r
= simplify_rtx (x
);
3050 /* Given a constant rtx X, make (or find) a memory constant for its value
3051 and return a MEM rtx to refer to it in memory. */
3054 force_const_mem (enum machine_mode mode
, rtx x
)
3056 struct constant_descriptor_rtx
*desc
, tmp
;
3057 struct rtx_constant_pool
*pool
= cfun
->varasm
->pool
;
3064 /* If we're not allowed to drop X into the constant pool, don't. */
3065 if (targetm
.cannot_force_const_mem (x
))
3068 /* Lookup the value in the hashtable. */
3071 hash
= const_rtx_hash (x
);
3072 slot
= htab_find_slot_with_hash (pool
->const_rtx_htab
, &tmp
, hash
, INSERT
);
3075 /* If the constant was already present, return its memory. */
3077 return copy_rtx (desc
->mem
);
3079 /* Otherwise, create a new descriptor. */
3080 desc
= ggc_alloc (sizeof (*desc
));
3083 /* Align the location counter as required by EXP's data type. */
3084 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3085 #ifdef CONSTANT_ALIGNMENT
3087 tree type
= lang_hooks
.types
.type_for_mode (mode
, 0);
3088 if (type
!= NULL_TREE
)
3089 align
= CONSTANT_ALIGNMENT (make_tree (type
, x
), align
);
3093 pool
->offset
+= (align
/ BITS_PER_UNIT
) - 1;
3094 pool
->offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3097 desc
->constant
= tmp
.constant
;
3098 desc
->offset
= pool
->offset
;
3101 desc
->align
= align
;
3102 desc
->labelno
= const_labelno
;
3105 pool
->offset
+= GET_MODE_SIZE (mode
);
3107 pool
->last
->next
= desc
;
3109 pool
->first
= pool
->last
= desc
;
3112 /* Create a string containing the label name, in LABEL. */
3113 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3116 /* Construct the SYMBOL_REF. Make sure to mark it as belonging to
3117 the constants pool. */
3118 desc
->sym
= symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3119 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
3120 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3121 current_function_uses_const_pool
= 1;
3123 /* Insert the descriptor into the symbol cross-reference table too. */
3124 slot
= htab_find_slot (pool
->const_rtx_sym_htab
, desc
, INSERT
);
3125 gcc_assert (!*slot
);
3128 /* Construct the MEM. */
3129 desc
->mem
= def
= gen_const_mem (mode
, symbol
);
3130 set_mem_attributes (def
, lang_hooks
.types
.type_for_mode (mode
, 0), 1);
3131 set_mem_align (def
, align
);
3133 /* If we're dropping a label to the constant pool, make sure we
3135 if (GET_CODE (x
) == LABEL_REF
)
3136 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3138 return copy_rtx (def
);
3141 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3142 the corresponding constant_descriptor_rtx structure. */
3144 static struct constant_descriptor_rtx
*
3145 find_pool_constant (struct rtx_constant_pool
*pool
, rtx sym
)
3147 struct constant_descriptor_rtx tmp
;
3149 return htab_find (pool
->const_rtx_sym_htab
, &tmp
);
3152 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3155 get_pool_constant (rtx addr
)
3157 return find_pool_constant (cfun
->varasm
->pool
, addr
)->constant
;
3160 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3161 and whether it has been output or not. */
3164 get_pool_constant_mark (rtx addr
, bool *pmarked
)
3166 struct constant_descriptor_rtx
*desc
;
3168 desc
= find_pool_constant (cfun
->varasm
->pool
, addr
);
3169 *pmarked
= (desc
->mark
!= 0);
3170 return desc
->constant
;
3173 /* Likewise, but for the constant pool of a specific function. */
3176 get_pool_constant_for_function (struct function
*f
, rtx addr
)
3178 return find_pool_constant (f
->varasm
->pool
, addr
)->constant
;
3181 /* Similar, return the mode. */
3184 get_pool_mode (rtx addr
)
3186 return find_pool_constant (cfun
->varasm
->pool
, addr
)->mode
;
3189 /* Return the size of the constant pool. */
3192 get_pool_size (void)
3194 return cfun
->varasm
->pool
->offset
;
3197 /* Worker function for output_constant_pool_1. Emit assembly for X
3198 in MODE with known alignment ALIGN. */
3201 output_constant_pool_2 (enum machine_mode mode
, rtx x
, unsigned int align
)
3203 switch (GET_MODE_CLASS (mode
))
3209 gcc_assert (GET_CODE (x
) == CONST_DOUBLE
);
3210 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
3211 assemble_real (r
, mode
, align
);
3216 case MODE_PARTIAL_INT
:
3217 assemble_integer (x
, GET_MODE_SIZE (mode
), align
, 1);
3220 case MODE_VECTOR_FLOAT
:
3221 case MODE_VECTOR_INT
:
3224 enum machine_mode submode
= GET_MODE_INNER (mode
);
3225 unsigned int subalign
= MIN (align
, GET_MODE_BITSIZE (submode
));
3227 gcc_assert (GET_CODE (x
) == CONST_VECTOR
);
3228 units
= CONST_VECTOR_NUNITS (x
);
3230 for (i
= 0; i
< units
; i
++)
3232 rtx elt
= CONST_VECTOR_ELT (x
, i
);
3233 output_constant_pool_2 (submode
, elt
, i
? subalign
: align
);
3243 /* Worker function for output_constant_pool. Emit POOL. */
3246 output_constant_pool_1 (struct constant_descriptor_rtx
*desc
)
3254 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3255 whose CODE_LABEL has been deleted. This can occur if a jump table
3256 is eliminated by optimization. If so, write a constant of zero
3257 instead. Note that this can also happen by turning the
3258 CODE_LABEL into a NOTE. */
3259 /* ??? This seems completely and utterly wrong. Certainly it's
3260 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3261 functioning even with INSN_DELETED_P and friends. */
3264 switch (GET_CODE (x
))
3267 if (GET_CODE (XEXP (x
, 0)) != PLUS
3268 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3270 tmp
= XEXP (XEXP (x
, 0), 0);
3275 gcc_assert (!INSN_DELETED_P (tmp
));
3276 gcc_assert (!NOTE_P (tmp
)
3277 || NOTE_LINE_NUMBER (tmp
) != NOTE_INSN_DELETED
);
3284 /* First switch to correct section. */
3285 targetm
.asm_out
.select_rtx_section (desc
->mode
, x
, desc
->align
);
3287 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3288 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, desc
->mode
,
3289 desc
->align
, desc
->labelno
, done
);
3292 assemble_align (desc
->align
);
3294 /* Output the label. */
3295 targetm
.asm_out
.internal_label (asm_out_file
, "LC", desc
->labelno
);
3297 /* Output the data. */
3298 output_constant_pool_2 (desc
->mode
, x
, desc
->align
);
3300 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3301 sections have proper size. */
3302 if (desc
->align
> GET_MODE_BITSIZE (desc
->mode
)
3303 && in_section
== in_named
3304 && get_named_section_flags (in_named_name
) & SECTION_MERGE
)
3305 assemble_align (desc
->align
);
3307 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3313 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3314 to as used. Emit referenced deferred strings. This function can
3315 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3318 mark_constant (rtx
*current_rtx
, void *data
)
3320 struct rtx_constant_pool
*pool
= data
;
3321 rtx x
= *current_rtx
;
3323 if (x
== NULL_RTX
|| GET_CODE (x
) != SYMBOL_REF
)
3326 if (CONSTANT_POOL_ADDRESS_P (x
))
3328 struct constant_descriptor_rtx
*desc
= find_pool_constant (pool
, x
);
3329 if (desc
->mark
== 0)
3332 for_each_rtx (&desc
->constant
, mark_constant
, pool
);
3335 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
3337 tree exp
= SYMBOL_REF_DECL (x
);
3338 if (!TREE_ASM_WRITTEN (exp
))
3340 n_deferred_constants
--;
3341 output_constant_def_contents (x
);
3348 /* Look through appropriate parts of INSN, marking all entries in the
3349 constant pool which are actually being used. Entries that are only
3350 referenced by other constants are also marked as used. Emit
3351 deferred strings that are used. */
3354 mark_constants (struct rtx_constant_pool
*pool
, rtx insn
)
3359 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3360 insns, not any notes that may be attached. We don't want to mark
3361 a constant just because it happens to appear in a REG_EQUIV note. */
3362 if (GET_CODE (PATTERN (insn
)) == SEQUENCE
)
3364 rtx seq
= PATTERN (insn
);
3365 int i
, n
= XVECLEN (seq
, 0);
3366 for (i
= 0; i
< n
; ++i
)
3368 rtx subinsn
= XVECEXP (seq
, 0, i
);
3369 if (INSN_P (subinsn
))
3370 for_each_rtx (&PATTERN (subinsn
), mark_constant
, pool
);
3374 for_each_rtx (&PATTERN (insn
), mark_constant
, pool
);
3377 /* Look through the instructions for this function, and mark all the
3378 entries in POOL which are actually being used. Emit deferred constants
3379 which have indeed been used. */
3382 mark_constant_pool (struct rtx_constant_pool
*pool
)
3386 if (pool
->first
== 0 && n_deferred_constants
== 0)
3389 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3390 mark_constants (pool
, insn
);
3392 for (link
= current_function_epilogue_delay_list
;
3394 link
= XEXP (link
, 1))
3395 mark_constants (pool
, XEXP (link
, 0));
3398 /* Write all the constants in the constant pool. */
3401 output_constant_pool (const char *fnname ATTRIBUTE_UNUSED
,
3402 tree fndecl ATTRIBUTE_UNUSED
)
3404 struct rtx_constant_pool
*pool
= cfun
->varasm
->pool
;
3405 struct constant_descriptor_rtx
*desc
;
3407 /* It is possible for gcc to call force_const_mem and then to later
3408 discard the instructions which refer to the constant. In such a
3409 case we do not need to output the constant. */
3410 mark_constant_pool (pool
);
3412 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3413 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
3416 for (desc
= pool
->first
; desc
; desc
= desc
->next
)
3417 output_constant_pool_1 (desc
);
3419 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3420 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool
->offset
);
3424 /* Determine what kind of relocations EXP may need. */
3427 compute_reloc_for_constant (tree exp
)
3429 int reloc
= 0, reloc2
;
3432 /* Give the front-end a chance to convert VALUE to something that
3433 looks more like a constant to the back-end. */
3434 exp
= lang_hooks
.expand_constant (exp
);
3436 switch (TREE_CODE (exp
))
3440 /* Go inside any operations that get_inner_reference can handle and see
3441 if what's inside is a constant: no need to do anything here for
3442 addresses of variables or functions. */
3443 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
3444 tem
= TREE_OPERAND (tem
, 0))
3447 if (TREE_PUBLIC (tem
))
3454 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
3455 reloc
|= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
3459 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
3460 reloc2
= compute_reloc_for_constant (TREE_OPERAND (exp
, 1));
3461 /* The difference of two local labels is computable at link time. */
3462 if (reloc
== 1 && reloc2
== 1)
3470 case NON_LVALUE_EXPR
:
3471 reloc
= compute_reloc_for_constant (TREE_OPERAND (exp
, 0));
3475 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
3476 if (TREE_VALUE (tem
) != 0)
3477 reloc
|= compute_reloc_for_constant (TREE_VALUE (tem
));
3487 /* Find all the constants whose addresses are referenced inside of EXP,
3488 and make sure assembler code with a label has been output for each one.
3489 Indicate whether an ADDR_EXPR has been encountered. */
3492 output_addressed_constants (tree exp
)
3496 /* Give the front-end a chance to convert VALUE to something that
3497 looks more like a constant to the back-end. */
3498 exp
= lang_hooks
.expand_constant (exp
);
3500 switch (TREE_CODE (exp
))
3504 /* Go inside any operations that get_inner_reference can handle and see
3505 if what's inside is a constant: no need to do anything here for
3506 addresses of variables or functions. */
3507 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
3508 tem
= TREE_OPERAND (tem
, 0))
3511 /* If we have an initialized CONST_DECL, retrieve the initializer. */
3512 if (TREE_CODE (tem
) == CONST_DECL
&& DECL_INITIAL (tem
))
3513 tem
= DECL_INITIAL (tem
);
3515 if (CONSTANT_CLASS_P (tem
) || TREE_CODE (tem
) == CONSTRUCTOR
)
3516 output_constant_def (tem
, 0);
3521 output_addressed_constants (TREE_OPERAND (exp
, 1));
3526 case NON_LVALUE_EXPR
:
3527 output_addressed_constants (TREE_OPERAND (exp
, 0));
3531 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
3532 if (TREE_VALUE (tem
) != 0)
3533 output_addressed_constants (TREE_VALUE (tem
));
3542 /* Return nonzero if VALUE is a valid constant-valued expression
3543 for use in initializing a static variable; one that can be an
3544 element of a "constant" initializer.
3546 Return null_pointer_node if the value is absolute;
3547 if it is relocatable, return the variable that determines the relocation.
3548 We assume that VALUE has been folded as much as possible;
3549 therefore, we do not need to check for such things as
3550 arithmetic-combinations of integers. */
3553 initializer_constant_valid_p (tree value
, tree endtype
)
3555 /* Give the front-end a chance to convert VALUE to something that
3556 looks more like a constant to the back-end. */
3557 value
= lang_hooks
.expand_constant (value
);
3559 switch (TREE_CODE (value
))
3562 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
3563 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
3564 && TREE_CONSTANT (value
)
3565 && CONSTRUCTOR_ELTS (value
))
3568 bool absolute
= true;
3570 for (elt
= CONSTRUCTOR_ELTS (value
); elt
; elt
= TREE_CHAIN (elt
))
3573 value
= TREE_VALUE (elt
);
3574 reloc
= initializer_constant_valid_p (value
, TREE_TYPE (value
));
3577 if (reloc
!= null_pointer_node
)
3580 /* For a non-absolute relocation, there is no single
3581 variable that can be "the variable that determines the
3583 return absolute
? null_pointer_node
: error_mark_node
;
3586 return TREE_STATIC (value
) ? null_pointer_node
: NULL_TREE
;
3593 return null_pointer_node
;
3597 value
= staticp (TREE_OPERAND (value
, 0));
3598 /* "&(*a).f" is like unto pointer arithmetic. If "a" turns out to
3599 be a constant, this is old-skool offsetof-like nonsense. */
3601 && TREE_CODE (value
) == INDIRECT_REF
3602 && TREE_CONSTANT (TREE_OPERAND (value
, 0)))
3603 return null_pointer_node
;
3604 /* Taking the address of a nested function involves a trampoline. */
3606 && TREE_CODE (value
) == FUNCTION_DECL
3607 && ((decl_function_context (value
) && !DECL_NO_STATIC_CHAIN (value
))
3608 || DECL_NON_ADDR_CONST_P (value
)))
3612 case VIEW_CONVERT_EXPR
:
3613 case NON_LVALUE_EXPR
:
3614 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3623 src
= TREE_OPERAND (value
, 0);
3624 src_type
= TREE_TYPE (src
);
3625 dest_type
= TREE_TYPE (value
);
3627 /* Allow conversions between pointer types, floating-point
3628 types, and offset types. */
3629 if ((POINTER_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
))
3630 || (FLOAT_TYPE_P (dest_type
) && FLOAT_TYPE_P (src_type
))
3631 || (TREE_CODE (dest_type
) == OFFSET_TYPE
3632 && TREE_CODE (src_type
) == OFFSET_TYPE
))
3633 return initializer_constant_valid_p (src
, endtype
);
3635 /* Allow length-preserving conversions between integer types. */
3636 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
)
3637 && (TYPE_PRECISION (dest_type
) == TYPE_PRECISION (src_type
)))
3638 return initializer_constant_valid_p (src
, endtype
);
3640 /* Allow conversions between other integer types only if
3642 if (INTEGRAL_TYPE_P (dest_type
) && INTEGRAL_TYPE_P (src_type
))
3644 tree inner
= initializer_constant_valid_p (src
, endtype
);
3645 if (inner
== null_pointer_node
)
3646 return null_pointer_node
;
3650 /* Allow (int) &foo provided int is as wide as a pointer. */
3651 if (INTEGRAL_TYPE_P (dest_type
) && POINTER_TYPE_P (src_type
)
3652 && (TYPE_PRECISION (dest_type
) >= TYPE_PRECISION (src_type
)))
3653 return initializer_constant_valid_p (src
, endtype
);
3655 /* Likewise conversions from int to pointers, but also allow
3656 conversions from 0. */
3657 if ((POINTER_TYPE_P (dest_type
)
3658 || TREE_CODE (dest_type
) == OFFSET_TYPE
)
3659 && INTEGRAL_TYPE_P (src_type
))
3661 if (integer_zerop (src
))
3662 return null_pointer_node
;
3663 else if (TYPE_PRECISION (dest_type
) <= TYPE_PRECISION (src_type
))
3664 return initializer_constant_valid_p (src
, endtype
);
3667 /* Allow conversions to struct or union types if the value
3669 if (TREE_CODE (dest_type
) == RECORD_TYPE
3670 || TREE_CODE (dest_type
) == UNION_TYPE
)
3671 return initializer_constant_valid_p (src
, endtype
);
3676 if (! INTEGRAL_TYPE_P (endtype
)
3677 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3679 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3681 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3683 /* If either term is absolute, use the other terms relocation. */
3684 if (valid0
== null_pointer_node
)
3686 if (valid1
== null_pointer_node
)
3692 if (! INTEGRAL_TYPE_P (endtype
)
3693 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3695 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3697 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3699 /* Win if second argument is absolute. */
3700 if (valid1
== null_pointer_node
)
3702 /* Win if both arguments have the same relocation.
3703 Then the value is absolute. */
3704 if (valid0
== valid1
&& valid0
!= 0)
3705 return null_pointer_node
;
3707 /* Since GCC guarantees that string constants are unique in the
3708 generated code, a subtraction between two copies of the same
3709 constant string is absolute. */
3710 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
3711 && valid1
&& TREE_CODE (valid1
) == STRING_CST
3712 && operand_equal_p (valid0
, valid1
, 1))
3713 return null_pointer_node
;
3716 /* Support narrowing differences. */
3717 if (INTEGRAL_TYPE_P (endtype
))
3721 op0
= TREE_OPERAND (value
, 0);
3722 op1
= TREE_OPERAND (value
, 1);
3724 /* Like STRIP_NOPS except allow the operand mode to widen.
3725 This works around a feature of fold that simplifies
3726 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3727 that the narrower operation is cheaper. */
3729 while (TREE_CODE (op0
) == NOP_EXPR
3730 || TREE_CODE (op0
) == CONVERT_EXPR
3731 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3733 tree inner
= TREE_OPERAND (op0
, 0);
3734 if (inner
== error_mark_node
3735 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3736 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
3737 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3742 while (TREE_CODE (op1
) == NOP_EXPR
3743 || TREE_CODE (op1
) == CONVERT_EXPR
3744 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
3746 tree inner
= TREE_OPERAND (op1
, 0);
3747 if (inner
== error_mark_node
3748 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3749 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
3750 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3755 op0
= initializer_constant_valid_p (op0
, endtype
);
3756 op1
= initializer_constant_valid_p (op1
, endtype
);
3758 /* Both initializers must be known. */
3762 return null_pointer_node
;
3764 /* Support differences between labels. */
3765 if (TREE_CODE (op0
) == LABEL_DECL
3766 && TREE_CODE (op1
) == LABEL_DECL
)
3767 return null_pointer_node
;
3769 if (TREE_CODE (op0
) == STRING_CST
3770 && TREE_CODE (op1
) == STRING_CST
3771 && operand_equal_p (op0
, op1
, 1))
3772 return null_pointer_node
;
3784 /* Output assembler code for constant EXP to FILE, with no label.
3785 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3786 Assumes output_addressed_constants has been done on EXP already.
3788 Generate exactly SIZE bytes of assembler data, padding at the end
3789 with zeros if necessary. SIZE must always be specified.
3791 SIZE is important for structure constructors,
3792 since trailing members may have been omitted from the constructor.
3793 It is also important for initialization of arrays from string constants
3794 since the full length of the string constant might not be wanted.
3795 It is also needed for initialization of unions, where the initializer's
3796 type is just one member, and that may not be as long as the union.
3798 There a case in which we would fail to output exactly SIZE bytes:
3799 for a structure constructor that wants to produce more than SIZE bytes.
3800 But such constructors will never be generated for any possible input.
3802 ALIGN is the alignment of the data in bits. */
3805 output_constant (tree exp
, unsigned HOST_WIDE_INT size
, unsigned int align
)
3807 enum tree_code code
;
3808 unsigned HOST_WIDE_INT thissize
;
3810 /* Some front-ends use constants other than the standard language-independent
3811 varieties, but which may still be output directly. Give the front-end a
3812 chance to convert EXP to a language-independent representation. */
3813 exp
= lang_hooks
.expand_constant (exp
);
3815 if (size
== 0 || flag_syntax_only
)
3818 /* Eliminate any conversions since we'll be outputting the underlying
3820 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
3821 || TREE_CODE (exp
) == NON_LVALUE_EXPR
3822 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
3823 exp
= TREE_OPERAND (exp
, 0);
3825 code
= TREE_CODE (TREE_TYPE (exp
));
3826 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
3828 /* Allow a constructor with no elements for any data type.
3829 This means to fill the space with zeros. */
3830 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
3832 assemble_zeros (size
);
3836 if (TREE_CODE (exp
) == FDESC_EXPR
)
3838 #ifdef ASM_OUTPUT_FDESC
3839 HOST_WIDE_INT part
= tree_low_cst (TREE_OPERAND (exp
, 1), 0);
3840 tree decl
= TREE_OPERAND (exp
, 0);
3841 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
3848 /* Now output the underlying data. If we've handling the padding, return.
3849 Otherwise, break and ensure SIZE is the size written. */
3857 case REFERENCE_TYPE
:
3859 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
3860 EXPAND_INITIALIZER
),
3861 MIN (size
, thissize
), align
, 0))
3862 error ("initializer for integer value is too complicated");
3866 if (TREE_CODE (exp
) != REAL_CST
)
3867 error ("initializer for floating value is not a floating constant");
3869 assemble_real (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)), align
);
3873 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
3874 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
3875 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
3880 switch (TREE_CODE (exp
))
3883 output_constructor (exp
, size
, align
);
3886 thissize
= MIN ((unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
),
3888 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
3895 unsigned int nalign
;
3896 enum machine_mode inner
;
3898 inner
= TYPE_MODE (TREE_TYPE (TREE_TYPE (exp
)));
3899 nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
3901 elt_size
= GET_MODE_SIZE (inner
);
3903 link
= TREE_VECTOR_CST_ELTS (exp
);
3904 output_constant (TREE_VALUE (link
), elt_size
, align
);
3905 while ((link
= TREE_CHAIN (link
)) != NULL
)
3906 output_constant (TREE_VALUE (link
), elt_size
, nalign
);
3916 gcc_assert (TREE_CODE (exp
) == CONSTRUCTOR
);
3917 output_constructor (exp
, size
, align
);
3927 if (size
> thissize
)
3928 assemble_zeros (size
- thissize
);
3932 /* Subroutine of output_constructor, used for computing the size of
3933 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3934 type with an unspecified upper bound. */
3936 static unsigned HOST_WIDE_INT
3937 array_size_for_constructor (tree val
)
3941 /* This code used to attempt to handle string constants that are not
3942 arrays of single-bytes, but nothing else does, so there's no point in
3944 if (TREE_CODE (val
) == STRING_CST
)
3945 return TREE_STRING_LENGTH (val
);
3947 max_index
= NULL_TREE
;
3948 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
3950 tree index
= TREE_PURPOSE (i
);
3952 if (TREE_CODE (index
) == RANGE_EXPR
)
3953 index
= TREE_OPERAND (index
, 1);
3954 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
3958 if (max_index
== NULL_TREE
)
3961 /* Compute the total number of array elements. */
3962 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
3964 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
3965 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
3967 /* Multiply by the array element unit size to find number of bytes. */
3968 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
3970 return tree_low_cst (i
, 1);
3973 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3974 Generate at least SIZE bytes, padding if necessary. */
3977 output_constructor (tree exp
, unsigned HOST_WIDE_INT size
,
3980 tree type
= TREE_TYPE (exp
);
3981 tree link
, field
= 0;
3983 /* Number of bytes output or skipped so far.
3984 In other words, current position within the constructor. */
3985 HOST_WIDE_INT total_bytes
= 0;
3986 /* Nonzero means BYTE contains part of a byte, to be output. */
3987 int byte_buffer_in_use
= 0;
3990 gcc_assert (HOST_BITS_PER_WIDE_INT
>= BITS_PER_UNIT
);
3992 if (TREE_CODE (type
) == RECORD_TYPE
)
3993 field
= TYPE_FIELDS (type
);
3995 if (TREE_CODE (type
) == ARRAY_TYPE
3996 && TYPE_DOMAIN (type
) != 0)
3997 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
3999 /* As LINK goes through the elements of the constant,
4000 FIELD goes through the structure fields, if the constant is a structure.
4001 if the constant is a union, then we override this,
4002 by getting the field from the TREE_LIST element.
4003 But the constant could also be an array. Then FIELD is zero.
4005 There is always a maximum of one element in the chain LINK for unions
4006 (even if the initializer in a source program incorrectly contains
4008 for (link
= CONSTRUCTOR_ELTS (exp
);
4010 link
= TREE_CHAIN (link
),
4011 field
= field
? TREE_CHAIN (field
) : 0)
4013 tree val
= TREE_VALUE (link
);
4016 /* The element in a union constructor specifies the proper field
4018 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4019 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4020 && TREE_PURPOSE (link
) != 0)
4021 field
= TREE_PURPOSE (link
);
4023 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4024 index
= TREE_PURPOSE (link
);
4026 #ifdef ASM_COMMENT_START
4027 if (field
&& flag_verbose_asm
)
4028 fprintf (asm_out_file
, "%s %s:\n",
4031 ? IDENTIFIER_POINTER (DECL_NAME (field
))
4035 /* Eliminate the marker that makes a cast not be an lvalue. */
4039 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4041 unsigned HOST_WIDE_INT fieldsize
4042 = int_size_in_bytes (TREE_TYPE (type
));
4043 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4044 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4045 HOST_WIDE_INT index
;
4046 unsigned int align2
= min_align (align
, fieldsize
* BITS_PER_UNIT
);
4048 for (index
= lo_index
; index
<= hi_index
; index
++)
4050 /* Output the element's initial value. */
4052 assemble_zeros (fieldsize
);
4054 output_constant (val
, fieldsize
, align2
);
4056 /* Count its size. */
4057 total_bytes
+= fieldsize
;
4060 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4062 /* An element that is not a bit-field. */
4064 unsigned HOST_WIDE_INT fieldsize
;
4065 /* Since this structure is static,
4066 we know the positions are constant. */
4067 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4068 unsigned int align2
;
4071 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4072 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4074 /* Output any buffered-up bit-fields preceding this element. */
4075 if (byte_buffer_in_use
)
4077 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4079 byte_buffer_in_use
= 0;
4082 /* Advance to offset of this element.
4083 Note no alignment needed in an array, since that is guaranteed
4084 if each element has the proper size. */
4085 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4087 assemble_zeros (pos
- total_bytes
);
4091 /* Find the alignment of this element. */
4092 align2
= min_align (align
, BITS_PER_UNIT
* pos
);
4094 /* Determine size this element should occupy. */
4099 /* If this is an array with an unspecified upper bound,
4100 the initializer determines the size. */
4101 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4102 but we cannot do this until the deprecated support for
4103 initializing zero-length array members is removed. */
4104 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4105 && TYPE_DOMAIN (TREE_TYPE (field
))
4106 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4108 fieldsize
= array_size_for_constructor (val
);
4109 /* Given a non-empty initialization, this field had
4111 gcc_assert (!fieldsize
|| !TREE_CHAIN (field
));
4113 else if (DECL_SIZE_UNIT (field
))
4115 /* ??? This can't be right. If the decl size overflows
4116 a host integer we will silently emit no data. */
4117 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4118 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4122 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4124 /* Output the element's initial value. */
4126 assemble_zeros (fieldsize
);
4128 output_constant (val
, fieldsize
, align2
);
4130 /* Count its size. */
4131 total_bytes
+= fieldsize
;
4133 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4134 error ("invalid initial value for member %qs",
4135 IDENTIFIER_POINTER (DECL_NAME (field
)));
4138 /* Element that is a bit-field. */
4140 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4141 HOST_WIDE_INT end_offset
4142 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4145 val
= integer_zero_node
;
4147 /* If this field does not start in this (or, next) byte,
4149 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4151 /* Output remnant of any bit field in previous bytes. */
4152 if (byte_buffer_in_use
)
4154 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4156 byte_buffer_in_use
= 0;
4159 /* If still not at proper byte, advance to there. */
4160 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4162 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4163 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4167 if (! byte_buffer_in_use
)
4170 /* We must split the element into pieces that fall within
4171 separate bytes, and combine each byte with previous or
4172 following bit-fields. */
4174 /* next_offset is the offset n fbits from the beginning of
4175 the structure to the next bit of this element to be processed.
4176 end_offset is the offset of the first bit past the end of
4178 while (next_offset
< end_offset
)
4182 HOST_WIDE_INT value
;
4183 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4184 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4186 /* Advance from byte to byte
4187 within this element when necessary. */
4188 while (next_byte
!= total_bytes
)
4190 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4195 /* Number of bits we can process at once
4196 (all part of the same byte). */
4197 this_time
= MIN (end_offset
- next_offset
,
4198 BITS_PER_UNIT
- next_bit
);
4199 if (BYTES_BIG_ENDIAN
)
4201 /* On big-endian machine, take the most significant bits
4202 first (of the bits that are significant)
4203 and put them into bytes from the most significant end. */
4204 shift
= end_offset
- next_offset
- this_time
;
4206 /* Don't try to take a bunch of bits that cross
4207 the word boundary in the INTEGER_CST. We can
4208 only select bits from the LOW or HIGH part
4210 if (shift
< HOST_BITS_PER_WIDE_INT
4211 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4213 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4214 shift
= HOST_BITS_PER_WIDE_INT
;
4217 /* Now get the bits from the appropriate constant word. */
4218 if (shift
< HOST_BITS_PER_WIDE_INT
)
4219 value
= TREE_INT_CST_LOW (val
);
4222 gcc_assert (shift
< 2 * HOST_BITS_PER_WIDE_INT
);
4223 value
= TREE_INT_CST_HIGH (val
);
4224 shift
-= HOST_BITS_PER_WIDE_INT
;
4227 /* Get the result. This works only when:
4228 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4229 byte
|= (((value
>> shift
)
4230 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4231 << (BITS_PER_UNIT
- this_time
- next_bit
));
4235 /* On little-endian machines,
4236 take first the least significant bits of the value
4237 and pack them starting at the least significant
4238 bits of the bytes. */
4239 shift
= next_offset
- int_bit_position (field
);
4241 /* Don't try to take a bunch of bits that cross
4242 the word boundary in the INTEGER_CST. We can
4243 only select bits from the LOW or HIGH part
4245 if (shift
< HOST_BITS_PER_WIDE_INT
4246 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4247 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4249 /* Now get the bits from the appropriate constant word. */
4250 if (shift
< HOST_BITS_PER_WIDE_INT
)
4251 value
= TREE_INT_CST_LOW (val
);
4254 gcc_assert (shift
< 2 * HOST_BITS_PER_WIDE_INT
);
4255 value
= TREE_INT_CST_HIGH (val
);
4256 shift
-= HOST_BITS_PER_WIDE_INT
;
4259 /* Get the result. This works only when:
4260 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4261 byte
|= (((value
>> shift
)
4262 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4266 next_offset
+= this_time
;
4267 byte_buffer_in_use
= 1;
4272 if (byte_buffer_in_use
)
4274 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4278 if ((unsigned HOST_WIDE_INT
)total_bytes
< size
)
4279 assemble_zeros (size
- total_bytes
);
4282 /* This TREE_LIST contains any weak symbol declarations waiting
4284 static GTY(()) tree weak_decls
;
4286 /* Mark DECL as weak. */
4289 mark_weak (tree decl
)
4291 DECL_WEAK (decl
) = 1;
4293 if (DECL_RTL_SET_P (decl
)
4294 && MEM_P (DECL_RTL (decl
))
4295 && XEXP (DECL_RTL (decl
), 0)
4296 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
4297 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
4300 /* Merge weak status between NEWDECL and OLDDECL. */
4303 merge_weak (tree newdecl
, tree olddecl
)
4305 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
4308 if (DECL_WEAK (newdecl
))
4312 /* NEWDECL is weak, but OLDDECL is not. */
4314 /* If we already output the OLDDECL, we're in trouble; we can't
4315 go back and make it weak. This error cannot caught in
4316 declare_weak because the NEWDECL and OLDDECL was not yet
4317 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4318 if (TREE_ASM_WRITTEN (olddecl
))
4319 error ("%Jweak declaration of %qD must precede definition",
4322 /* If we've already generated rtl referencing OLDDECL, we may
4323 have done so in a way that will not function properly with
4325 else if (TREE_USED (olddecl
)
4326 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)))
4327 warning (0, "%Jweak declaration of %qD after first use results "
4328 "in unspecified behavior", newdecl
, newdecl
);
4332 /* We put the NEWDECL on the weak_decls list at some point.
4333 Replace it with the OLDDECL. */
4334 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
4335 if (TREE_VALUE (wd
) == newdecl
)
4337 TREE_VALUE (wd
) = olddecl
;
4340 /* We may not find the entry on the list. If NEWDECL is a
4341 weak alias, then we will have already called
4342 globalize_decl to remove the entry; in that case, we do
4343 not need to do anything. */
4346 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4347 mark_weak (olddecl
);
4350 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4351 weak. Just update NEWDECL to indicate that it's weak too. */
4352 mark_weak (newdecl
);
4355 /* Declare DECL to be a weak symbol. */
4358 declare_weak (tree decl
)
4360 if (! TREE_PUBLIC (decl
))
4361 error ("%Jweak declaration of %qD must be public", decl
, decl
);
4362 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
4363 error ("%Jweak declaration of %qD must precede definition", decl
, decl
);
4364 else if (SUPPORTS_WEAK
)
4366 if (! DECL_WEAK (decl
))
4367 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
4370 warning (0, "%Jweak declaration of %qD not supported", decl
, decl
);
4375 /* Emit any pending weak declarations. */
4382 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
4384 tree decl
= TREE_VALUE (t
);
4385 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4386 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4389 if (! TREE_USED (decl
))
4392 #ifdef ASM_WEAKEN_DECL
4393 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
4395 #ifdef ASM_WEAKEN_LABEL
4396 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4398 #ifdef ASM_OUTPUT_WEAK_ALIAS
4399 warning (0, "only weak aliases are supported in this configuration");
4407 /* Emit the assembly bits to indicate that DECL is globally visible. */
4410 globalize_decl (tree decl
)
4412 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
4414 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4415 if (DECL_WEAK (decl
))
4419 #ifdef ASM_WEAKEN_DECL
4420 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
4422 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4425 /* Remove this function from the pending weak list so that
4426 we do not emit multiple .weak directives for it. */
4427 for (p
= &weak_decls
; (t
= *p
) ; )
4429 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
4430 *p
= TREE_CHAIN (t
);
4432 p
= &TREE_CHAIN (t
);
4436 #elif defined(ASM_MAKE_LABEL_LINKONCE)
4437 if (DECL_ONE_ONLY (decl
))
4438 ASM_MAKE_LABEL_LINKONCE (asm_out_file
, name
);
4441 targetm
.asm_out
.globalize_label (asm_out_file
, name
);
4444 /* We have to be able to tell cgraph about the needed-ness of the target
4445 of an alias. This requires that the decl have been defined. Aliases
4446 that precede their definition have to be queued for later processing. */
4448 typedef struct alias_pair
GTY(())
4454 /* Define gc'd vector type. */
4455 DEF_VEC_O(alias_pair
);
4456 DEF_VEC_ALLOC_O(alias_pair
,gc
);
4458 static GTY(()) VEC(alias_pair
,gc
) *alias_pairs
;
4460 /* Given an assembly name, find the decl it is associated with. At the
4461 same time, mark it needed for cgraph. */
4464 find_decl_and_mark_needed (tree decl
, tree target
)
4466 struct cgraph_node
*fnode
= NULL
;
4467 struct cgraph_varpool_node
*vnode
= NULL
;
4469 /* C++ thunk emitting code produces aliases late in the game.
4470 Avoid confusing cgraph code in that case. */
4471 if (!cgraph_global_info_ready
)
4473 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4475 fnode
= cgraph_node_for_asm (target
);
4477 vnode
= cgraph_varpool_node_for_asm (target
);
4481 vnode
= cgraph_varpool_node_for_asm (target
);
4483 fnode
= cgraph_node_for_asm (target
);
4489 cgraph_mark_needed_node (fnode
);
4494 cgraph_varpool_mark_needed_node (vnode
);
4501 /* Output the assembler code for a define (equate) using ASM_OUTPUT_DEF
4502 or ASM_OUTPUT_DEF_FROM_DECLS. The function defines the symbol whose
4503 tree node is DECL to have the value of the tree node TARGET. */
4506 do_assemble_alias (tree decl
, tree target ATTRIBUTE_UNUSED
)
4508 if (TREE_ASM_WRITTEN (decl
))
4511 TREE_ASM_WRITTEN (decl
) = 1;
4512 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
4514 #ifdef ASM_OUTPUT_DEF
4515 /* Make name accessible from other files, if appropriate. */
4517 if (TREE_PUBLIC (decl
))
4519 globalize_decl (decl
);
4520 maybe_assemble_visibility (decl
);
4523 # ifdef ASM_OUTPUT_DEF_FROM_DECLS
4524 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4526 ASM_OUTPUT_DEF (asm_out_file
,
4527 IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)),
4528 IDENTIFIER_POINTER (target
));
4530 #elif defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4535 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4536 # ifdef ASM_WEAKEN_DECL
4537 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
4539 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4541 /* Remove this function from the pending weak list so that
4542 we do not emit multiple .weak directives for it. */
4543 for (p
= &weak_decls
; (t
= *p
) ; )
4544 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
4545 *p
= TREE_CHAIN (t
);
4547 p
= &TREE_CHAIN (t
);
4552 /* First pass of completing pending aliases. Make sure that cgraph knows
4553 which symbols will be required. */
4556 finish_aliases_1 (void)
4561 for (i
= 0; VEC_iterate (alias_pair
, alias_pairs
, i
, p
); i
++)
4565 target_decl
= find_decl_and_mark_needed (p
->decl
, p
->target
);
4566 if (target_decl
== NULL
)
4567 error ("%J%qD aliased to undefined symbol %qE",
4568 p
->decl
, p
->decl
, p
->target
);
4569 else if (DECL_EXTERNAL (target_decl
))
4570 error ("%J%qD aliased to external symbol %qE",
4571 p
->decl
, p
->decl
, p
->target
);
4575 /* Second pass of completing pending aliases. Emit the actual assembly.
4576 This happens at the end of compilation and thus it is assured that the
4577 target symbol has been emitted. */
4580 finish_aliases_2 (void)
4585 for (i
= 0; VEC_iterate (alias_pair
, alias_pairs
, i
, p
); i
++)
4586 do_assemble_alias (p
->decl
, p
->target
);
4588 VEC_truncate (alias_pair
, alias_pairs
, 0);
4591 /* Emit an assembler directive to make the symbol for DECL an alias to
4592 the symbol for TARGET. */
4595 assemble_alias (tree decl
, tree target
)
4599 #if !defined (ASM_OUTPUT_DEF)
4600 # if !defined(ASM_OUTPUT_WEAK_ALIAS) && !defined (ASM_WEAKEN_DECL)
4601 error ("%Jalias definitions not supported in this configuration", decl
);
4604 if (!DECL_WEAK (decl
))
4606 error ("%Jonly weak aliases are supported in this configuration", decl
);
4612 /* We must force creation of DECL_RTL for debug info generation, even though
4613 we don't use it here. */
4614 make_decl_rtl (decl
);
4615 TREE_USED (decl
) = 1;
4617 /* A quirk of the initial implementation of aliases required that the user
4618 add "extern" to all of them. Which is silly, but now historical. Do
4619 note that the symbol is in fact locally defined. */
4620 DECL_EXTERNAL (decl
) = 0;
4622 /* Allow aliases to aliases. */
4623 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4624 cgraph_node (decl
)->alias
= true;
4626 cgraph_varpool_node (decl
)->alias
= true;
4628 /* If the target has already been emitted, we don't have to queue the
4629 alias. This saves a tad o memory. */
4630 target_decl
= find_decl_and_mark_needed (decl
, target
);
4631 if (target_decl
&& TREE_ASM_WRITTEN (target_decl
))
4632 do_assemble_alias (decl
, target
);
4635 alias_pair
*p
= VEC_safe_push (alias_pair
, gc
, alias_pairs
, NULL
);
4641 /* Emit an assembler directive to set symbol for DECL visibility to
4642 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4645 default_assemble_visibility (tree decl
, int vis
)
4647 static const char * const visibility_types
[] = {
4648 NULL
, "internal", "hidden", "protected"
4651 const char *name
, *type
;
4653 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4654 type
= visibility_types
[vis
];
4656 #ifdef HAVE_GAS_HIDDEN
4657 fprintf (asm_out_file
, "\t.%s\t", type
);
4658 assemble_name (asm_out_file
, name
);
4659 fprintf (asm_out_file
, "\n");
4661 warning (0, "visibility attribute not supported in this configuration; ignored");
4665 /* A helper function to call assemble_visibility when needed for a decl. */
4668 maybe_assemble_visibility (tree decl
)
4670 enum symbol_visibility vis
= DECL_VISIBILITY (decl
);
4672 if (vis
!= VISIBILITY_DEFAULT
)
4673 targetm
.asm_out
.visibility (decl
, vis
);
4676 /* Returns 1 if the target configuration supports defining public symbols
4677 so that one of them will be chosen at link time instead of generating a
4678 multiply-defined symbol error, whether through the use of weak symbols or
4679 a target-specific mechanism for having duplicates discarded. */
4682 supports_one_only (void)
4684 if (SUPPORTS_ONE_ONLY
)
4686 return SUPPORTS_WEAK
;
4689 /* Set up DECL as a public symbol that can be defined in multiple
4690 translation units without generating a linker error. */
4693 make_decl_one_only (tree decl
)
4695 gcc_assert (TREE_CODE (decl
) == VAR_DECL
4696 || TREE_CODE (decl
) == FUNCTION_DECL
);
4698 TREE_PUBLIC (decl
) = 1;
4700 if (SUPPORTS_ONE_ONLY
)
4702 #ifdef MAKE_DECL_ONE_ONLY
4703 MAKE_DECL_ONE_ONLY (decl
);
4705 DECL_ONE_ONLY (decl
) = 1;
4707 else if (TREE_CODE (decl
) == VAR_DECL
4708 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4709 DECL_COMMON (decl
) = 1;
4712 gcc_assert (SUPPORTS_WEAK
);
4713 DECL_WEAK (decl
) = 1;
4718 init_varasm_once (void)
4720 in_named_htab
= htab_create_ggc (31, in_named_entry_hash
,
4721 in_named_entry_eq
, NULL
);
4722 const_desc_htab
= htab_create_ggc (1009, const_desc_hash
,
4723 const_desc_eq
, NULL
);
4725 const_alias_set
= new_alias_set ();
4728 static enum tls_model
4729 decl_tls_model (tree decl
)
4731 enum tls_model kind
;
4732 tree attr
= lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl
));
4737 attr
= TREE_VALUE (TREE_VALUE (attr
));
4738 gcc_assert (TREE_CODE (attr
) == STRING_CST
);
4740 if (!strcmp (TREE_STRING_POINTER (attr
), "local-exec"))
4741 kind
= TLS_MODEL_LOCAL_EXEC
;
4742 else if (!strcmp (TREE_STRING_POINTER (attr
), "initial-exec"))
4743 kind
= TLS_MODEL_INITIAL_EXEC
;
4744 else if (!strcmp (TREE_STRING_POINTER (attr
), "local-dynamic"))
4745 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
4746 else if (!strcmp (TREE_STRING_POINTER (attr
), "global-dynamic"))
4747 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4753 is_local
= targetm
.binds_local_p (decl
);
4757 kind
= TLS_MODEL_LOCAL_EXEC
;
4759 kind
= TLS_MODEL_INITIAL_EXEC
;
4761 /* Local dynamic is inefficient when we're not combining the
4762 parts of the address. */
4763 else if (optimize
&& is_local
)
4764 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
4766 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4767 if (kind
< flag_tls_default
)
4768 kind
= flag_tls_default
;
4773 /* Select a set of attributes for section NAME based on the properties
4774 of DECL and whether or not RELOC indicates that DECL's initializer
4775 might contain runtime relocations.
4777 We make the section read-only and executable for a function decl,
4778 read-only for a const data decl, and writable for a non-const data decl. */
4781 default_section_type_flags (tree decl
, const char *name
, int reloc
)
4783 return default_section_type_flags_1 (decl
, name
, reloc
, flag_pic
);
4787 default_section_type_flags_1 (tree decl
, const char *name
, int reloc
,
4792 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4793 flags
= SECTION_CODE
;
4794 else if (decl
&& decl_readonly_section_1 (decl
, reloc
, shlib
))
4796 else if (current_function_decl
4798 && cfun
->unlikely_text_section_name
4799 && strcmp (name
, cfun
->unlikely_text_section_name
) == 0)
4800 flags
= SECTION_CODE
;
4802 && (!current_function_decl
|| !cfun
)
4803 && strcmp (name
, UNLIKELY_EXECUTED_TEXT_SECTION_NAME
) == 0)
4804 flags
= SECTION_CODE
;
4806 flags
= SECTION_WRITE
;
4808 if (decl
&& DECL_ONE_ONLY (decl
))
4809 flags
|= SECTION_LINKONCE
;
4811 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4812 flags
|= SECTION_TLS
| SECTION_WRITE
;
4814 if (strcmp (name
, ".bss") == 0
4815 || strncmp (name
, ".bss.", 5) == 0
4816 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4817 || strcmp (name
, ".sbss") == 0
4818 || strncmp (name
, ".sbss.", 6) == 0
4819 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
4820 flags
|= SECTION_BSS
;
4822 if (strcmp (name
, ".tdata") == 0
4823 || strncmp (name
, ".tdata.", 7) == 0
4824 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0)
4825 flags
|= SECTION_TLS
;
4827 if (strcmp (name
, ".tbss") == 0
4828 || strncmp (name
, ".tbss.", 6) == 0
4829 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4830 flags
|= SECTION_TLS
| SECTION_BSS
;
4832 /* These three sections have special ELF types. They are neither
4833 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4834 want to print a section type (@progbits or @nobits). If someone
4835 is silly enough to emit code or TLS variables to one of these
4836 sections, then don't handle them specially. */
4837 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
4838 && (strcmp (name
, ".init_array") == 0
4839 || strcmp (name
, ".fini_array") == 0
4840 || strcmp (name
, ".preinit_array") == 0))
4841 flags
|= SECTION_NOTYPE
;
4846 /* Output assembly to switch to section NAME with attribute FLAGS.
4847 Four variants for common object file formats. */
4850 default_no_named_section (const char *name ATTRIBUTE_UNUSED
,
4851 unsigned int flags ATTRIBUTE_UNUSED
,
4852 tree decl ATTRIBUTE_UNUSED
)
4854 /* Some object formats don't support named sections at all. The
4855 front-end should already have flagged this as an error. */
4860 default_elf_asm_named_section (const char *name
, unsigned int flags
,
4861 tree decl ATTRIBUTE_UNUSED
)
4863 char flagchars
[10], *f
= flagchars
;
4865 /* If we have already declared this section, we can use an
4866 abbreviated form to switch back to it -- unless this section is
4867 part of a COMDAT groups, in which case GAS requires the full
4868 declaration every time. */
4869 if (!(HAVE_GAS_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
4870 && ! named_section_first_declaration (name
))
4872 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
4876 if (!(flags
& SECTION_DEBUG
))
4878 if (flags
& SECTION_WRITE
)
4880 if (flags
& SECTION_CODE
)
4882 if (flags
& SECTION_SMALL
)
4884 if (flags
& SECTION_MERGE
)
4886 if (flags
& SECTION_STRINGS
)
4888 if (flags
& SECTION_TLS
)
4890 if (HAVE_GAS_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
4894 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
4896 if (!(flags
& SECTION_NOTYPE
))
4901 if (flags
& SECTION_BSS
)
4907 #ifdef ASM_COMMENT_START
4908 /* On platforms that use "@" as the assembly comment character,
4910 if (strcmp (ASM_COMMENT_START
, "@") == 0)
4913 fprintf (asm_out_file
, format
, type
);
4915 if (flags
& SECTION_ENTSIZE
)
4916 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
4917 if (HAVE_GAS_COMDAT_GROUP
&& (flags
& SECTION_LINKONCE
))
4918 fprintf (asm_out_file
, ",%s,comdat",
4919 lang_hooks
.decls
.comdat_group (decl
));
4922 putc ('\n', asm_out_file
);
4926 default_coff_asm_named_section (const char *name
, unsigned int flags
,
4927 tree decl ATTRIBUTE_UNUSED
)
4929 char flagchars
[8], *f
= flagchars
;
4931 if (flags
& SECTION_WRITE
)
4933 if (flags
& SECTION_CODE
)
4937 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
4941 default_pe_asm_named_section (const char *name
, unsigned int flags
,
4944 default_coff_asm_named_section (name
, flags
, decl
);
4946 if (flags
& SECTION_LINKONCE
)
4948 /* Functions may have been compiled at various levels of
4949 optimization so we can't use `same_size' here.
4950 Instead, have the linker pick one. */
4951 fprintf (asm_out_file
, "\t.linkonce %s\n",
4952 (flags
& SECTION_CODE
? "discard" : "same_size"));
4956 /* The lame default section selector. */
4959 default_select_section (tree decl
, int reloc
,
4960 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
4962 bool readonly
= false;
4966 if (decl_readonly_section (decl
, reloc
))
4969 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4971 if (! ((flag_pic
&& reloc
)
4972 || !TREE_READONLY (decl
)
4973 || TREE_SIDE_EFFECTS (decl
)
4974 || !TREE_CONSTANT (decl
)))
4977 else if (TREE_CODE (decl
) == STRING_CST
)
4979 else if (! (flag_pic
&& reloc
))
4983 readonly_data_section ();
4988 /* A helper function for default_elf_select_section and
4989 default_elf_unique_section. Categorizes the DECL. */
4991 enum section_category
4996 SECCAT_RODATA_MERGE_STR
,
4997 SECCAT_RODATA_MERGE_STR_INIT
,
4998 SECCAT_RODATA_MERGE_CONST
,
5003 /* To optimize loading of shared programs, define following subsections
5005 _REL Contains data that has relocations, so they get grouped
5006 together and dynamic linker will visit fewer pages in memory.
5007 _RO Contains data that is otherwise read-only. This is useful
5008 with prelinking as most relocations won't be dynamically
5009 linked and thus stay read only.
5010 _LOCAL Marks data containing relocations only to local objects.
5011 These relocations will get fully resolved by prelinking. */
5013 SECCAT_DATA_REL_LOCAL
,
5015 SECCAT_DATA_REL_RO_LOCAL
,
5025 static enum section_category
5026 categorize_decl_for_section (tree
, int, int);
5028 static enum section_category
5029 categorize_decl_for_section (tree decl
, int reloc
, int shlib
)
5031 enum section_category ret
;
5033 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5035 else if (TREE_CODE (decl
) == STRING_CST
)
5037 if (flag_mudflap
) /* or !flag_merge_constants */
5038 return SECCAT_RODATA
;
5040 return SECCAT_RODATA_MERGE_STR
;
5042 else if (TREE_CODE (decl
) == VAR_DECL
)
5044 if (DECL_INITIAL (decl
) == NULL
5045 || DECL_INITIAL (decl
) == error_mark_node
5046 || (flag_zero_initialized_in_bss
5047 /* Leave constant zeroes in .rodata so they can be shared. */
5048 && !TREE_READONLY (decl
)
5049 && initializer_zerop (DECL_INITIAL (decl
))))
5051 else if (! TREE_READONLY (decl
)
5052 || TREE_SIDE_EFFECTS (decl
)
5053 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
5055 if (shlib
&& (reloc
& 2))
5056 ret
= SECCAT_DATA_REL
;
5057 else if (shlib
&& reloc
)
5058 ret
= SECCAT_DATA_REL_LOCAL
;
5062 else if (shlib
&& (reloc
& 2))
5063 ret
= SECCAT_DATA_REL_RO
;
5064 else if (shlib
&& reloc
)
5065 ret
= SECCAT_DATA_REL_RO_LOCAL
;
5066 else if (reloc
|| flag_merge_constants
< 2)
5067 /* C and C++ don't allow different variables to share the same
5068 location. -fmerge-all-constants allows even that (at the
5069 expense of not conforming). */
5070 ret
= SECCAT_RODATA
;
5071 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
5072 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
5074 ret
= SECCAT_RODATA_MERGE_CONST
;
5076 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
5078 if ((shlib
&& reloc
)
5079 || TREE_SIDE_EFFECTS (decl
)
5080 || ! TREE_CONSTANT (decl
))
5083 ret
= SECCAT_RODATA
;
5086 ret
= SECCAT_RODATA
;
5088 /* There are no read-only thread-local sections. */
5089 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
5091 /* Note that this would be *just* SECCAT_BSS, except that there's
5092 no concept of a read-only thread-local-data section. */
5093 if (ret
== SECCAT_BSS
5094 || (flag_zero_initialized_in_bss
5095 && initializer_zerop (DECL_INITIAL (decl
))))
5101 /* If the target uses small data sections, select it. */
5102 else if (targetm
.in_small_data_p (decl
))
5104 if (ret
== SECCAT_BSS
)
5106 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
5107 ret
= SECCAT_SRODATA
;
5116 decl_readonly_section (tree decl
, int reloc
)
5118 return decl_readonly_section_1 (decl
, reloc
, flag_pic
);
5122 decl_readonly_section_1 (tree decl
, int reloc
, int shlib
)
5124 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5127 case SECCAT_RODATA_MERGE_STR
:
5128 case SECCAT_RODATA_MERGE_STR_INIT
:
5129 case SECCAT_RODATA_MERGE_CONST
:
5130 case SECCAT_SRODATA
:
5139 /* Select a section based on the above categorization. */
5142 default_elf_select_section (tree decl
, int reloc
,
5143 unsigned HOST_WIDE_INT align
)
5145 default_elf_select_section_1 (decl
, reloc
, align
, flag_pic
);
5149 default_elf_select_section_1 (tree decl
, int reloc
,
5150 unsigned HOST_WIDE_INT align
, int shlib
)
5153 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5156 /* We're not supposed to be called on FUNCTION_DECLs. */
5159 readonly_data_section ();
5161 case SECCAT_RODATA_MERGE_STR
:
5162 mergeable_string_section (decl
, align
, 0);
5164 case SECCAT_RODATA_MERGE_STR_INIT
:
5165 mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
5167 case SECCAT_RODATA_MERGE_CONST
:
5168 mergeable_constant_section (DECL_MODE (decl
), align
, 0);
5170 case SECCAT_SRODATA
:
5176 case SECCAT_DATA_REL
:
5177 sname
= ".data.rel";
5179 case SECCAT_DATA_REL_LOCAL
:
5180 sname
= ".data.rel.local";
5182 case SECCAT_DATA_REL_RO
:
5183 sname
= ".data.rel.ro";
5185 case SECCAT_DATA_REL_RO_LOCAL
:
5186 sname
= ".data.rel.ro.local";
5195 #ifdef BSS_SECTION_ASM_OP
5214 named_section (decl
, sname
, reloc
);
5217 /* Construct a unique section name based on the decl name and the
5218 categorization performed above. */
5221 default_unique_section (tree decl
, int reloc
)
5223 default_unique_section_1 (decl
, reloc
, flag_pic
);
5227 default_unique_section_1 (tree decl
, int reloc
, int shlib
)
5229 bool one_only
= DECL_ONE_ONLY (decl
);
5230 const char *prefix
, *name
;
5234 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5237 prefix
= one_only
? ".gnu.linkonce.t." : ".text.";
5240 case SECCAT_RODATA_MERGE_STR
:
5241 case SECCAT_RODATA_MERGE_STR_INIT
:
5242 case SECCAT_RODATA_MERGE_CONST
:
5243 prefix
= one_only
? ".gnu.linkonce.r." : ".rodata.";
5245 case SECCAT_SRODATA
:
5246 prefix
= one_only
? ".gnu.linkonce.s2." : ".sdata2.";
5249 case SECCAT_DATA_REL
:
5250 case SECCAT_DATA_REL_LOCAL
:
5251 case SECCAT_DATA_REL_RO
:
5252 case SECCAT_DATA_REL_RO_LOCAL
:
5253 prefix
= one_only
? ".gnu.linkonce.d." : ".data.";
5256 prefix
= one_only
? ".gnu.linkonce.s." : ".sdata.";
5259 prefix
= one_only
? ".gnu.linkonce.b." : ".bss.";
5262 prefix
= one_only
? ".gnu.linkonce.sb." : ".sbss.";
5265 prefix
= one_only
? ".gnu.linkonce.td." : ".tdata.";
5268 prefix
= one_only
? ".gnu.linkonce.tb." : ".tbss.";
5273 plen
= strlen (prefix
);
5275 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5276 name
= targetm
.strip_name_encoding (name
);
5277 nlen
= strlen (name
);
5279 string
= alloca (nlen
+ plen
+ 1);
5280 memcpy (string
, prefix
, plen
);
5281 memcpy (string
+ plen
, name
, nlen
+ 1);
5283 DECL_SECTION_NAME (decl
) = build_string (nlen
+ plen
, string
);
5287 default_select_rtx_section (enum machine_mode mode ATTRIBUTE_UNUSED
,
5289 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
)
5292 switch (GET_CODE (x
))
5304 readonly_data_section ();
5308 default_elf_select_rtx_section (enum machine_mode mode
, rtx x
,
5309 unsigned HOST_WIDE_INT align
)
5311 /* ??? Handle small data here somehow. */
5314 switch (GET_CODE (x
))
5318 named_section (NULL_TREE
, ".data.rel.ro", 3);
5322 named_section (NULL_TREE
, ".data.rel.ro.local", 1);
5329 mergeable_constant_section (mode
, align
, 0);
5332 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5335 default_encode_section_info (tree decl
, rtx rtl
, int first ATTRIBUTE_UNUSED
)
5340 /* Careful not to prod global register variables. */
5343 symbol
= XEXP (rtl
, 0);
5344 if (GET_CODE (symbol
) != SYMBOL_REF
)
5348 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5349 flags
|= SYMBOL_FLAG_FUNCTION
;
5350 if (targetm
.binds_local_p (decl
))
5351 flags
|= SYMBOL_FLAG_LOCAL
;
5352 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
5353 flags
|= decl_tls_model (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
5354 else if (targetm
.in_small_data_p (decl
))
5355 flags
|= SYMBOL_FLAG_SMALL
;
5356 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5357 being PUBLIC, the thing *must* be defined in this translation unit.
5358 Prevent this buglet from being propagated into rtl code as well. */
5359 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
5360 flags
|= SYMBOL_FLAG_EXTERNAL
;
5362 SYMBOL_REF_FLAGS (symbol
) = flags
;
5365 /* By default, we do nothing for encode_section_info, so we need not
5366 do anything but discard the '*' marker. */
5369 default_strip_name_encoding (const char *str
)
5371 return str
+ (*str
== '*');
5374 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5375 wrt cross-module name binding. */
5378 default_binds_local_p (tree exp
)
5380 return default_binds_local_p_1 (exp
, flag_shlib
);
5384 default_binds_local_p_1 (tree exp
, int shlib
)
5388 /* A non-decl is an entry in the constant pool. */
5391 /* Static variables are always local. */
5392 else if (! TREE_PUBLIC (exp
))
5394 /* A variable is local if the user explicitly tells us so. */
5395 else if (DECL_VISIBILITY_SPECIFIED (exp
) && DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
)
5397 /* Otherwise, variables defined outside this object may not be local. */
5398 else if (DECL_EXTERNAL (exp
))
5400 /* Linkonce and weak data are never local. */
5401 else if (DECL_ONE_ONLY (exp
) || DECL_WEAK (exp
))
5403 /* If none of the above and visibility is not default, make local. */
5404 else if (DECL_VISIBILITY (exp
) != VISIBILITY_DEFAULT
)
5406 /* If PIC, then assume that any global name can be overridden by
5407 symbols resolved from other modules. */
5410 /* Uninitialized COMMON variable may be unified with symbols
5411 resolved from other modules. */
5412 else if (DECL_COMMON (exp
)
5413 && (DECL_INITIAL (exp
) == NULL
5414 || DECL_INITIAL (exp
) == error_mark_node
))
5416 /* Otherwise we're left with initialized (or non-common) global data
5417 which is of necessity defined locally. */
5424 /* Determine whether or not a pointer mode is valid. Assume defaults
5425 of ptr_mode or Pmode - can be overridden. */
5427 default_valid_pointer_mode (enum machine_mode mode
)
5429 return (mode
== ptr_mode
|| mode
== Pmode
);
5432 /* Default function to output code that will globalize a label. A
5433 target must define GLOBAL_ASM_OP or provide its own function to
5434 globalize a label. */
5435 #ifdef GLOBAL_ASM_OP
5437 default_globalize_label (FILE * stream
, const char *name
)
5439 fputs (GLOBAL_ASM_OP
, stream
);
5440 assemble_name (stream
, name
);
5441 putc ('\n', stream
);
5443 #endif /* GLOBAL_ASM_OP */
5445 /* Default function to output a label for unwind information. The
5446 default is to do nothing. A target that needs nonlocal labels for
5447 unwind information must provide its own function to do this. */
5449 default_emit_unwind_label (FILE * stream ATTRIBUTE_UNUSED
,
5450 tree decl ATTRIBUTE_UNUSED
,
5451 int for_eh ATTRIBUTE_UNUSED
,
5452 int empty ATTRIBUTE_UNUSED
)
5456 /* This is how to output an internal numbered label where PREFIX is
5457 the class of label and LABELNO is the number within the class. */
5460 default_internal_label (FILE *stream
, const char *prefix
,
5461 unsigned long labelno
)
5463 char *const buf
= alloca (40 + strlen (prefix
));
5464 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
5465 ASM_OUTPUT_INTERNAL_LABEL (stream
, buf
);
5468 /* This is the default behavior at the beginning of a file. It's
5469 controlled by two other target-hook toggles. */
5471 default_file_start (void)
5473 if (targetm
.file_start_app_off
&& !flag_verbose_asm
)
5474 fputs (ASM_APP_OFF
, asm_out_file
);
5476 if (targetm
.file_start_file_directive
)
5477 output_file_directive (asm_out_file
, main_input_filename
);
5480 /* This is a generic routine suitable for use as TARGET_ASM_FILE_END
5481 which emits a special section directive used to indicate whether or
5482 not this object file needs an executable stack. This is primarily
5483 a GNU extension to ELF but could be used on other targets. */
5485 int trampolines_created
;
5488 file_end_indicate_exec_stack (void)
5490 unsigned int flags
= SECTION_DEBUG
;
5491 if (trampolines_created
)
5492 flags
|= SECTION_CODE
;
5494 named_section_flags (".note.GNU-stack", flags
);
5497 #include "gt-varasm.h"