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 Free Software Foundation, Inc.
5 This file is part of GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
32 #include "coretypes.h"
39 #include "hard-reg-set.h"
48 #include "langhooks.h"
53 #ifdef XCOFF_DEBUGGING_INFO
54 #include "xcoffout.h" /* Needed for external data
55 declarations for e.g. AIX 4.x. */
58 #ifndef TRAMPOLINE_ALIGNMENT
59 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
63 #define ASM_STABS_OP "\t.stabs\t"
66 /* The (assembler) name of the first globally-visible object output. */
67 const char *first_global_object_name
;
68 const char *weak_global_object_name
;
71 struct constant_descriptor_rtx
;
75 #define MAX_RTX_HASH_TABLE 61
77 struct varasm_status
GTY(())
79 /* Hash facility for making memory-constants
80 from constant rtl-expressions. It is used on RISC machines
81 where immediate integer arguments and constant addresses are restricted
82 so that such constants must be stored in memory.
84 This pool of constants is reinitialized for each function
85 so each function gets its own constants-pool that comes right before
87 struct constant_descriptor_rtx
** GTY ((length ("MAX_RTX_HASH_TABLE")))
88 x_const_rtx_hash_table
;
89 struct pool_constant
** GTY ((length ("MAX_RTX_HASH_TABLE")))
90 x_const_rtx_sym_hash_table
;
92 /* Pointers to first and last constant in pool. */
93 struct pool_constant
*x_first_pool
;
94 struct pool_constant
*x_last_pool
;
96 /* Current offset in constant pool (does not include any machine-specific
98 HOST_WIDE_INT x_pool_offset
;
100 /* Number of tree-constants deferred during the expansion of this
102 unsigned int deferred_constants
;
105 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
106 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
107 #define first_pool (cfun->varasm->x_first_pool)
108 #define last_pool (cfun->varasm->x_last_pool)
109 #define pool_offset (cfun->varasm->x_pool_offset)
110 #define n_deferred_constants (cfun->varasm->deferred_constants)
112 /* Number for making the label on the next
113 constant that is stored in memory. */
115 static GTY(()) int const_labelno
;
117 /* Number for making the label on the next
118 static variable internal to a function. */
120 static GTY(()) int var_labelno
;
122 /* Carry information from ASM_DECLARE_OBJECT_NAME
123 to ASM_FINISH_DECLARE_OBJECT. */
125 int size_directive_output
;
127 /* The last decl for which assemble_variable was called,
128 if it did ASM_DECLARE_OBJECT_NAME.
129 If the last call to assemble_variable didn't do that,
132 tree last_assemble_variable_decl
;
134 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
135 So giving constant the alias set for the type will allow such
136 initializations to appear to conflict with the load of the constant. We
137 avoid this by giving all constants an alias set for just constants.
138 Since there will be no stores to that alias set, nothing will ever
139 conflict with them. */
141 static HOST_WIDE_INT const_alias_set
;
143 static const char *strip_reg_name
PARAMS ((const char *));
144 static int contains_pointers_p
PARAMS ((tree
));
145 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
146 static hashval_t const_desc_hash
PARAMS ((const void *));
147 static int const_desc_eq
PARAMS ((const void *, const void *));
148 static hashval_t const_hash_1
PARAMS ((const tree
));
149 static int compare_constant
PARAMS ((const tree
, const tree
));
150 static tree copy_constant
PARAMS ((tree
));
151 static void output_constant_def_contents
PARAMS ((rtx
));
152 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
153 struct rtx_const
*));
154 static unsigned int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
155 static int compare_constant_rtx
156 PARAMS ((enum machine_mode
, rtx
, struct constant_descriptor_rtx
*));
157 static struct constant_descriptor_rtx
* record_constant_rtx
158 PARAMS ((enum machine_mode
, rtx
));
159 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
160 static void mark_constant_pool
PARAMS ((void));
161 static void mark_constants
PARAMS ((rtx
));
162 static int mark_constant
PARAMS ((rtx
*current_rtx
, void *data
));
163 static int output_addressed_constants
PARAMS ((tree
));
164 static unsigned HOST_WIDE_INT array_size_for_constructor
PARAMS ((tree
));
165 static unsigned min_align
PARAMS ((unsigned, unsigned));
166 static void output_constructor
PARAMS ((tree
, unsigned HOST_WIDE_INT
,
168 static void globalize_decl
PARAMS ((tree
));
169 static void maybe_assemble_visibility
PARAMS ((tree
));
170 static int in_named_entry_eq
PARAMS ((const PTR
, const PTR
));
171 static hashval_t in_named_entry_hash
PARAMS ((const PTR
));
172 #ifdef ASM_OUTPUT_BSS
173 static void asm_output_bss
PARAMS ((FILE *, tree
, const char *,
174 unsigned HOST_WIDE_INT
,
175 unsigned HOST_WIDE_INT
));
177 #ifdef BSS_SECTION_ASM_OP
178 #ifdef ASM_OUTPUT_ALIGNED_BSS
179 static void asm_output_aligned_bss
180 PARAMS ((FILE *, tree
, const char *,
181 unsigned HOST_WIDE_INT
, int)) ATTRIBUTE_UNUSED
;
183 #endif /* BSS_SECTION_ASM_OP */
184 static bool asm_emit_uninitialised
PARAMS ((tree
, const char*,
185 unsigned HOST_WIDE_INT
,
186 unsigned HOST_WIDE_INT
));
187 static void resolve_unique_section
PARAMS ((tree
, int, int));
188 static void mark_weak
PARAMS ((tree
));
190 enum in_section
{ no_section
, in_text
, in_data
, in_named
191 #ifdef BSS_SECTION_ASM_OP
194 #ifdef CTORS_SECTION_ASM_OP
197 #ifdef DTORS_SECTION_ASM_OP
200 #ifdef READONLY_DATA_SECTION_ASM_OP
203 #ifdef EXTRA_SECTIONS
207 static GTY(()) enum in_section in_section
= no_section
;
209 /* Return a nonzero value if DECL has a section attribute. */
210 #ifndef IN_NAMED_SECTION
211 #define IN_NAMED_SECTION(DECL) \
212 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
213 && DECL_SECTION_NAME (DECL) != NULL_TREE)
216 /* Text of section name when in_section == in_named. */
217 static GTY(()) const char *in_named_name
;
219 /* Hash table of flags that have been used for a particular named section. */
221 struct in_named_entry
GTY(())
228 static GTY((param_is (struct in_named_entry
))) htab_t in_named_htab
;
230 /* Define functions like text_section for any extra sections. */
231 #ifdef EXTRA_SECTION_FUNCTIONS
232 EXTRA_SECTION_FUNCTIONS
235 /* Tell assembler to switch to text section. */
240 if (in_section
!= in_text
)
242 in_section
= in_text
;
246 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
251 /* Tell assembler to switch to data section. */
256 if (in_section
!= in_data
)
258 in_section
= in_data
;
259 if (flag_shared_data
)
261 #ifdef SHARED_SECTION_ASM_OP
262 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
264 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
268 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
272 /* Tell assembler to switch to read-only data section. This is normally
276 readonly_data_section ()
278 #ifdef READONLY_DATA_SECTION
279 READONLY_DATA_SECTION (); /* Note this can call data_section. */
281 #ifdef READONLY_DATA_SECTION_ASM_OP
282 if (in_section
!= in_readonly_data
)
284 in_section
= in_readonly_data
;
285 fputs (READONLY_DATA_SECTION_ASM_OP
, asm_out_file
);
286 fputc ('\n', asm_out_file
);
294 /* Determine if we're in the text section. */
299 return in_section
== in_text
;
302 /* Determine if we're in the data section. */
307 return in_section
== in_data
;
310 /* Helper routines for maintaining in_named_htab. */
313 in_named_entry_eq (p1
, p2
)
317 const struct in_named_entry
*old
= p1
;
318 const char *new = p2
;
320 return strcmp (old
->name
, new) == 0;
324 in_named_entry_hash (p
)
327 const struct in_named_entry
*old
= p
;
328 return htab_hash_string (old
->name
);
331 /* If SECTION has been seen before as a named section, return the flags
332 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
333 set of flags for a section to have, so 0 does not mean that the section
334 has not been seen. */
337 get_named_section_flags (section
)
340 struct in_named_entry
**slot
;
342 slot
= (struct in_named_entry
**)
343 htab_find_slot_with_hash (in_named_htab
, section
,
344 htab_hash_string (section
), NO_INSERT
);
346 return slot
? (*slot
)->flags
: 0;
349 /* Returns true if the section has been declared before. Sets internal
350 flag on this section in in_named_hash so subsequent calls on this
351 section will return false. */
354 named_section_first_declaration (name
)
357 struct in_named_entry
**slot
;
359 slot
= (struct in_named_entry
**)
360 htab_find_slot_with_hash (in_named_htab
, name
,
361 htab_hash_string (name
), NO_INSERT
);
362 if (! (*slot
)->declared
)
364 (*slot
)->declared
= true;
374 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
375 different set of flags, return false. */
378 set_named_section_flags (section
, flags
)
382 struct in_named_entry
**slot
, *entry
;
384 slot
= (struct in_named_entry
**)
385 htab_find_slot_with_hash (in_named_htab
, section
,
386 htab_hash_string (section
), INSERT
);
391 entry
= (struct in_named_entry
*) ggc_alloc (sizeof (*entry
));
393 entry
->name
= ggc_strdup (section
);
394 entry
->flags
= flags
;
395 entry
->declared
= false;
397 else if (entry
->flags
!= flags
)
403 /* Tell assembler to change to section NAME with attributes FLAGS. */
406 named_section_flags (name
, flags
)
410 if (in_section
!= in_named
|| strcmp (name
, in_named_name
) != 0)
412 if (! set_named_section_flags (name
, flags
))
415 (*targetm
.asm_out
.named_section
) (name
, flags
);
417 if (flags
& SECTION_FORGET
)
418 in_section
= no_section
;
421 in_named_name
= ggc_strdup (name
);
422 in_section
= in_named
;
427 /* Tell assembler to change to section NAME for DECL.
428 If DECL is NULL, just switch to section NAME.
429 If NAME is NULL, get the name from DECL.
430 If RELOC is 1, the initializer for DECL contains relocs. */
433 named_section (decl
, name
, reloc
)
440 if (decl
!= NULL_TREE
&& !DECL_P (decl
))
443 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
445 flags
= (* targetm
.section_type_flags
) (decl
, name
, reloc
);
447 /* Sanity check user variables for flag changes. Non-user
448 section flag changes will abort in named_section_flags.
449 However, don't complain if SECTION_OVERRIDE is set.
450 We trust that the setter knows that it is safe to ignore
451 the default flags for this decl. */
452 if (decl
&& ! set_named_section_flags (name
, flags
))
454 flags
= get_named_section_flags (name
);
455 if ((flags
& SECTION_OVERRIDE
) == 0)
456 error_with_decl (decl
, "%s causes a section type conflict");
459 named_section_flags (name
, flags
);
462 /* If required, set DECL_SECTION_NAME to a unique name. */
465 resolve_unique_section (decl
, reloc
, flag_function_or_data_sections
)
467 int reloc ATTRIBUTE_UNUSED
;
468 int flag_function_or_data_sections
;
470 if (DECL_SECTION_NAME (decl
) == NULL_TREE
471 && targetm
.have_named_sections
472 && (flag_function_or_data_sections
473 || DECL_ONE_ONLY (decl
)))
474 (*targetm
.asm_out
.unique_section
) (decl
, reloc
);
477 #ifdef BSS_SECTION_ASM_OP
479 /* Tell the assembler to switch to the bss section. */
484 if (in_section
!= in_bss
)
486 #ifdef SHARED_BSS_SECTION_ASM_OP
487 if (flag_shared_data
)
488 fprintf (asm_out_file
, "%s\n", SHARED_BSS_SECTION_ASM_OP
);
491 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
497 #ifdef ASM_OUTPUT_BSS
499 /* Utility function for ASM_OUTPUT_BSS for targets to use if
500 they don't support alignments in .bss.
501 ??? It is believed that this function will work in most cases so such
502 support is localized here. */
505 asm_output_bss (file
, decl
, name
, size
, rounded
)
507 tree decl ATTRIBUTE_UNUSED
;
509 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
, rounded
;
511 (*targetm
.asm_out
.globalize_label
) (file
, name
);
513 #ifdef ASM_DECLARE_OBJECT_NAME
514 last_assemble_variable_decl
= decl
;
515 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
517 /* Standard thing is just output label for the object. */
518 ASM_OUTPUT_LABEL (file
, name
);
519 #endif /* ASM_DECLARE_OBJECT_NAME */
520 ASM_OUTPUT_SKIP (file
, rounded
? rounded
: 1);
525 #ifdef ASM_OUTPUT_ALIGNED_BSS
527 /* Utility function for targets to use in implementing
528 ASM_OUTPUT_ALIGNED_BSS.
529 ??? It is believed that this function will work in most cases so such
530 support is localized here. */
533 asm_output_aligned_bss (file
, decl
, name
, size
, align
)
535 tree decl ATTRIBUTE_UNUSED
;
537 unsigned HOST_WIDE_INT size
;
541 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
542 #ifdef ASM_DECLARE_OBJECT_NAME
543 last_assemble_variable_decl
= decl
;
544 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
546 /* Standard thing is just output label for the object. */
547 ASM_OUTPUT_LABEL (file
, name
);
548 #endif /* ASM_DECLARE_OBJECT_NAME */
549 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
554 #endif /* BSS_SECTION_ASM_OP */
556 /* Switch to the section for function DECL.
558 If DECL is NULL_TREE, switch to the text section.
559 ??? It's not clear that we will ever be passed NULL_TREE, but it's
560 safer to handle it. */
563 function_section (decl
)
566 if (decl
!= NULL_TREE
567 && DECL_SECTION_NAME (decl
) != NULL_TREE
)
568 named_section (decl
, (char *) 0, 0);
573 /* Switch to section for variable DECL. RELOC is the same as the
574 argument to SELECT_SECTION. */
577 variable_section (decl
, reloc
)
581 if (IN_NAMED_SECTION (decl
))
582 named_section (decl
, NULL
, reloc
);
584 (*targetm
.asm_out
.select_section
) (decl
, reloc
, DECL_ALIGN (decl
));
587 /* Tell assembler to switch to the section for string merging. */
590 mergeable_string_section (decl
, align
, flags
)
591 tree decl ATTRIBUTE_UNUSED
;
592 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
593 unsigned int flags ATTRIBUTE_UNUSED
;
595 #ifdef HAVE_GAS_SHF_MERGE
596 if (flag_merge_constants
597 && TREE_CODE (decl
) == STRING_CST
598 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
600 && TREE_STRING_LENGTH (decl
) >= int_size_in_bytes (TREE_TYPE (decl
)))
602 enum machine_mode mode
;
603 unsigned int modesize
;
608 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
609 modesize
= GET_MODE_BITSIZE (mode
);
610 if (modesize
>= 8 && modesize
<= 256
611 && (modesize
& (modesize
- 1)) == 0)
613 if (align
< modesize
)
616 str
= TREE_STRING_POINTER (decl
);
617 len
= TREE_STRING_LENGTH (decl
);
618 unit
= GET_MODE_SIZE (mode
);
620 /* Check for embedded NUL characters. */
621 for (i
= 0; i
< len
; i
+= unit
)
623 for (j
= 0; j
< unit
; j
++)
624 if (str
[i
+ j
] != '\0')
631 sprintf (name
, ".rodata.str%d.%d", modesize
/ 8,
633 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
634 if (!i
&& modesize
< align
)
636 /* A "" string with requested alignment greater than
637 character size might cause a problem:
638 if some other string required even bigger
639 alignment than "", then linker might think the
640 "" is just part of padding after some other string
641 and not put it into the hash table initially.
642 But this means "" could have smaller alignment
644 #ifdef ASM_OUTPUT_SECTION_START
645 named_section_flags (name
, flags
);
646 ASM_OUTPUT_SECTION_START (asm_out_file
);
648 readonly_data_section ();
653 named_section_flags (name
, flags
);
659 readonly_data_section ();
662 /* Tell assembler to switch to the section for constant merging. */
665 mergeable_constant_section (mode
, align
, flags
)
666 enum machine_mode mode ATTRIBUTE_UNUSED
;
667 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
668 unsigned int flags ATTRIBUTE_UNUSED
;
670 #ifdef HAVE_GAS_SHF_MERGE
671 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
673 if (flag_merge_constants
679 && (align
& (align
- 1)) == 0)
683 sprintf (name
, ".rodata.cst%d", (int) (align
/ 8));
684 flags
|= (align
/ 8) | SECTION_MERGE
;
685 named_section_flags (name
, flags
);
689 readonly_data_section ();
692 /* Given NAME, a putative register name, discard any customary prefixes. */
695 strip_reg_name (name
)
698 #ifdef REGISTER_PREFIX
699 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
700 name
+= strlen (REGISTER_PREFIX
);
702 if (name
[0] == '%' || name
[0] == '#')
707 /* Decode an `asm' spec for a declaration as a register name.
708 Return the register number, or -1 if nothing specified,
709 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
710 or -3 if ASMSPEC is `cc' and is not recognized,
711 or -4 if ASMSPEC is `memory' and is not recognized.
712 Accept an exact spelling or a decimal number.
713 Prefixes such as % are optional. */
716 decode_reg_name (asmspec
)
723 /* Get rid of confusing prefixes. */
724 asmspec
= strip_reg_name (asmspec
);
726 /* Allow a decimal number as a "register name". */
727 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
728 if (! ISDIGIT (asmspec
[i
]))
730 if (asmspec
[0] != 0 && i
< 0)
733 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
739 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
741 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
744 #ifdef ADDITIONAL_REGISTER_NAMES
746 static const struct { const char *const name
; const int number
; } table
[]
747 = ADDITIONAL_REGISTER_NAMES
;
749 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
750 if (! strcmp (asmspec
, table
[i
].name
))
751 return table
[i
].number
;
753 #endif /* ADDITIONAL_REGISTER_NAMES */
755 if (!strcmp (asmspec
, "memory"))
758 if (!strcmp (asmspec
, "cc"))
767 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
768 have static storage duration. In other words, it should not be an
769 automatic variable, including PARM_DECLs.
771 There is, however, one exception: this function handles variables
772 explicitly placed in a particular register by the user.
774 ASMSPEC, if not 0, is the string which the user specified as the
775 assembler symbol name.
777 This is never called for PARM_DECL nodes. */
780 make_decl_rtl (decl
, asmspec
)
784 int top_level
= (DECL_CONTEXT (decl
) == NULL_TREE
);
785 const char *name
= 0;
786 const char *new_name
= 0;
790 /* Check that we are not being given an automatic variable. */
791 /* A weak alias has TREE_PUBLIC set but not the other bits. */
792 if (TREE_CODE (decl
) == PARM_DECL
793 || TREE_CODE (decl
) == RESULT_DECL
794 || (TREE_CODE (decl
) == VAR_DECL
795 && !TREE_STATIC (decl
)
796 && !TREE_PUBLIC (decl
)
797 && !DECL_EXTERNAL (decl
)
798 && !DECL_REGISTER (decl
)))
800 /* And that we were not given a type or a label. */
801 else if (TREE_CODE (decl
) == TYPE_DECL
802 || TREE_CODE (decl
) == LABEL_DECL
)
805 /* For a duplicate declaration, we can be called twice on the
806 same DECL node. Don't discard the RTL already made. */
807 if (DECL_RTL_SET_P (decl
))
809 /* If the old RTL had the wrong mode, fix the mode. */
810 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
811 SET_DECL_RTL (decl
, adjust_address_nv (DECL_RTL (decl
),
812 DECL_MODE (decl
), 0));
814 /* ??? Another way to do this would be to maintain a hashed
815 table of such critters. Instead of adding stuff to a DECL
816 to give certain attributes to it, we could use an external
817 hash map from DECL to set of attributes. */
819 /* Let the target reassign the RTL if it wants.
820 This is necessary, for example, when one machine specific
821 decl attribute overrides another. */
822 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), false);
826 new_name
= name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
828 reg_number
= decode_reg_name (asmspec
);
829 if (reg_number
== -2)
831 /* ASMSPEC is given, and not the name of a register. Mark the
832 name with a star so assemble_name won't munge it. */
833 char *starred
= alloca (strlen (asmspec
) + 2);
835 strcpy (starred
+ 1, asmspec
);
839 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
841 /* First detect errors in declaring global registers. */
842 if (reg_number
== -1)
843 error_with_decl (decl
, "register name not specified for `%s'");
844 else if (reg_number
< 0)
845 error_with_decl (decl
, "invalid register name for `%s'");
846 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
847 error_with_decl (decl
,
848 "data type of `%s' isn't suitable for a register");
849 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
850 error_with_decl (decl
,
851 "register specified for `%s' isn't suitable for data type");
852 /* Now handle properly declared static register variables. */
857 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
859 DECL_INITIAL (decl
) = 0;
860 error ("global register variable has initial value");
862 if (TREE_THIS_VOLATILE (decl
))
863 warning ("volatile register variables don't work as you might wish");
865 /* If the user specified one of the eliminables registers here,
866 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
867 confused with that register and be eliminated. This usage is
868 somewhat suspect... */
870 SET_DECL_RTL (decl
, gen_rtx_raw_REG (DECL_MODE (decl
), reg_number
));
871 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
872 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
874 if (TREE_STATIC (decl
))
876 /* Make this register global, so not usable for anything
878 #ifdef ASM_DECLARE_REGISTER_GLOBAL
879 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
881 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
883 globalize_reg (reg_number
+ --nregs
);
886 /* As a register variable, it has no section. */
891 /* Now handle ordinary static variables and functions (in memory).
892 Also handle vars declared register invalidly. */
894 if (reg_number
>= 0 || reg_number
== -3)
895 error_with_decl (decl
,
896 "register name given for non-register variable `%s'");
898 /* Specifying a section attribute on a variable forces it into a
899 non-.bss section, and thus it cannot be common. */
900 if (TREE_CODE (decl
) == VAR_DECL
901 && DECL_SECTION_NAME (decl
) != NULL_TREE
902 && DECL_INITIAL (decl
) == NULL_TREE
903 && DECL_COMMON (decl
))
904 DECL_COMMON (decl
) = 0;
906 /* Variables can't be both common and weak. */
907 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_WEAK (decl
))
908 DECL_COMMON (decl
) = 0;
910 /* Can't use just the variable's own name for a variable
911 whose scope is less than the whole file, unless it's a member
912 of a local class (which will already be unambiguous).
913 Concatenate a distinguishing number. */
914 if (!top_level
&& !TREE_PUBLIC (decl
)
915 && ! (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
917 && name
== IDENTIFIER_POINTER (DECL_NAME (decl
)))
921 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
926 if (name
!= new_name
)
928 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (new_name
));
929 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
932 x
= gen_rtx_SYMBOL_REF (Pmode
, name
);
933 SYMBOL_REF_WEAK (x
) = DECL_WEAK (decl
);
934 SYMBOL_REF_DECL (x
) = decl
;
936 x
= gen_rtx_MEM (DECL_MODE (decl
), x
);
937 if (TREE_CODE (decl
) != FUNCTION_DECL
)
938 set_mem_attributes (x
, decl
, 1);
939 SET_DECL_RTL (decl
, x
);
941 /* Optionally set flags or add text to the name to record information
942 such as that it is a function name.
943 If the name is changed, the macro ASM_OUTPUT_LABELREF
944 will have to know how to strip this information. */
945 (* targetm
.encode_section_info
) (decl
, DECL_RTL (decl
), true);
948 /* Make the rtl for variable VAR be volatile.
949 Use this only for static variables. */
952 make_var_volatile (var
)
955 if (GET_CODE (DECL_RTL (var
)) != MEM
)
958 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
961 /* Output a string of literal assembler code
962 for an `asm' keyword used between functions. */
965 assemble_asm (string
)
970 if (TREE_CODE (string
) == ADDR_EXPR
)
971 string
= TREE_OPERAND (string
, 0);
973 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
976 /* Record an element in the table of global destructors. SYMBOL is
977 a SYMBOL_REF of the function to be called; PRIORITY is a number
978 between 0 and MAX_INIT_PRIORITY. */
981 default_stabs_asm_out_destructor (symbol
, priority
)
983 int priority ATTRIBUTE_UNUSED
;
985 /* Tell GNU LD that this is part of the static destructor set.
986 This will work for any system that uses stabs, most usefully
988 fprintf (asm_out_file
, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
989 assemble_name (asm_out_file
, XSTR (symbol
, 0));
990 fputc ('\n', asm_out_file
);
994 default_named_section_asm_out_destructor (symbol
, priority
)
998 const char *section
= ".dtors";
1001 /* ??? This only works reliably with the GNU linker. */
1002 if (priority
!= DEFAULT_INIT_PRIORITY
)
1004 sprintf (buf
, ".dtors.%.5u",
1005 /* Invert the numbering so the linker puts us in the proper
1006 order; constructors are run from right to left, and the
1007 linker sorts in increasing order. */
1008 MAX_INIT_PRIORITY
- priority
);
1012 named_section_flags (section
, SECTION_WRITE
);
1013 assemble_align (POINTER_SIZE
);
1014 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1017 #ifdef DTORS_SECTION_ASM_OP
1021 if (in_section
!= in_dtors
)
1023 in_section
= in_dtors
;
1024 fputs (DTORS_SECTION_ASM_OP
, asm_out_file
);
1025 fputc ('\n', asm_out_file
);
1030 default_dtor_section_asm_out_destructor (symbol
, priority
)
1032 int priority ATTRIBUTE_UNUSED
;
1035 assemble_align (POINTER_SIZE
);
1036 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1040 /* Likewise for global constructors. */
1043 default_stabs_asm_out_constructor (symbol
, priority
)
1045 int priority ATTRIBUTE_UNUSED
;
1047 /* Tell GNU LD that this is part of the static destructor set.
1048 This will work for any system that uses stabs, most usefully
1050 fprintf (asm_out_file
, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
1051 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1052 fputc ('\n', asm_out_file
);
1056 default_named_section_asm_out_constructor (symbol
, priority
)
1060 const char *section
= ".ctors";
1063 /* ??? This only works reliably with the GNU linker. */
1064 if (priority
!= DEFAULT_INIT_PRIORITY
)
1066 sprintf (buf
, ".ctors.%.5u",
1067 /* Invert the numbering so the linker puts us in the proper
1068 order; constructors are run from right to left, and the
1069 linker sorts in increasing order. */
1070 MAX_INIT_PRIORITY
- priority
);
1074 named_section_flags (section
, SECTION_WRITE
);
1075 assemble_align (POINTER_SIZE
);
1076 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1079 #ifdef CTORS_SECTION_ASM_OP
1083 if (in_section
!= in_ctors
)
1085 in_section
= in_ctors
;
1086 fputs (CTORS_SECTION_ASM_OP
, asm_out_file
);
1087 fputc ('\n', asm_out_file
);
1092 default_ctor_section_asm_out_constructor (symbol
, priority
)
1094 int priority ATTRIBUTE_UNUSED
;
1097 assemble_align (POINTER_SIZE
);
1098 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1102 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1103 a nonzero value if the constant pool should be output before the
1104 start of the function, or a zero value if the pool should output
1105 after the end of the function. The default is to put it before the
1108 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1109 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1112 /* Output assembler code for the constant pool of a function and associated
1113 with defining the name of the function. DECL describes the function.
1114 NAME is the function's name. For the constant pool, we use the current
1115 constant pool data. */
1118 assemble_start_function (decl
, fnname
)
1124 /* The following code does not need preprocessing in the assembler. */
1128 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1129 output_constant_pool (fnname
, decl
);
1131 resolve_unique_section (decl
, 0, flag_function_sections
);
1132 function_section (decl
);
1134 /* Tell assembler to move to target machine's alignment for functions. */
1135 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1136 if (align
< force_align_functions_log
)
1137 align
= force_align_functions_log
;
1140 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1143 /* Handle a user-specified function alignment.
1144 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1145 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1146 if (align_functions_log
> align
1147 && cfun
->function_frequency
!= FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
)
1149 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1150 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1151 align_functions_log
, align_functions
- 1);
1153 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1157 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1158 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1161 (*debug_hooks
->begin_function
) (decl
);
1163 /* Make function name accessible from other files, if appropriate. */
1165 if (TREE_PUBLIC (decl
))
1167 if (! first_global_object_name
)
1172 p
= (* targetm
.strip_name_encoding
) (fnname
);
1175 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
1176 first_global_object_name
= name
;
1178 weak_global_object_name
= name
;
1181 globalize_decl (decl
);
1183 maybe_assemble_visibility (decl
);
1186 /* Do any machine/system dependent processing of the function name */
1187 #ifdef ASM_DECLARE_FUNCTION_NAME
1188 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1190 /* Standard thing is just output label for the function. */
1191 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1192 #endif /* ASM_DECLARE_FUNCTION_NAME */
1195 /* Output assembler code associated with defining the size of the
1196 function. DECL describes the function. NAME is the function's name. */
1199 assemble_end_function (decl
, fnname
)
1203 #ifdef ASM_DECLARE_FUNCTION_SIZE
1204 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1206 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1208 output_constant_pool (fnname
, decl
);
1209 function_section (decl
); /* need to switch back */
1213 /* Assemble code to leave SIZE bytes of zeros. */
1216 assemble_zeros (size
)
1217 unsigned HOST_WIDE_INT size
;
1219 /* Do no output if -fsyntax-only. */
1220 if (flag_syntax_only
)
1223 #ifdef ASM_NO_SKIP_IN_TEXT
1224 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1225 so we must output 0s explicitly in the text section. */
1226 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1228 unsigned HOST_WIDE_INT i
;
1229 for (i
= 0; i
< size
; i
++)
1230 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1235 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1238 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1241 assemble_align (align
)
1244 if (align
> BITS_PER_UNIT
)
1246 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1250 /* Assemble a string constant with the specified C string as contents. */
1253 assemble_string (p
, size
)
1260 /* If the string is very long, split it up. */
1264 int thissize
= size
- pos
;
1265 if (thissize
> maximum
)
1268 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1276 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1277 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1278 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1280 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1281 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1282 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1284 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1285 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1289 #if defined ASM_OUTPUT_ALIGNED_BSS
1290 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1291 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1293 #if defined ASM_OUTPUT_BSS
1294 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1295 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1301 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1302 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1303 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1305 #if defined ASM_OUTPUT_ALIGNED_COMMON
1306 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1307 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1309 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1310 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1315 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1318 unsigned HOST_WIDE_INT size ATTRIBUTE_UNUSED
;
1319 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
;
1327 destination
= asm_dest_local
;
1329 /* ??? We should handle .bss via select_section mechanisms rather than
1330 via special target hooks. That would eliminate this special case. */
1331 if (TREE_PUBLIC (decl
))
1333 if (!DECL_COMMON (decl
))
1335 destination
= asm_dest_bss
;
1340 destination
= asm_dest_common
;
1343 if (destination
== asm_dest_bss
)
1344 globalize_decl (decl
);
1345 resolve_unique_section (decl
, 0, flag_data_sections
);
1347 if (flag_shared_data
)
1349 switch (destination
)
1351 #ifdef ASM_OUTPUT_SHARED_BSS
1353 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1356 #ifdef ASM_OUTPUT_SHARED_COMMON
1357 case asm_dest_common
:
1358 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1361 #ifdef ASM_OUTPUT_SHARED_LOCAL
1362 case asm_dest_local
:
1363 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1371 switch (destination
)
1375 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1378 case asm_dest_common
:
1379 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1381 case asm_dest_local
:
1382 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1391 /* Assemble everything that is needed for a variable or function declaration.
1392 Not used for automatic variables, and not used for function definitions.
1393 Should not be called for variables of incomplete structure type.
1395 TOP_LEVEL is nonzero if this variable has file scope.
1396 AT_END is nonzero if this is the special handling, at end of compilation,
1397 to define things that have had only tentative definitions.
1398 DONT_OUTPUT_DATA if nonzero means don't actually output the
1399 initial value (that will be done by the caller). */
1402 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1404 int top_level ATTRIBUTE_UNUSED
;
1405 int at_end ATTRIBUTE_UNUSED
;
1406 int dont_output_data
;
1413 last_assemble_variable_decl
= 0;
1415 /* Normally no need to say anything here for external references,
1416 since assemble_external is called by the language-specific code
1417 when a declaration is first seen. */
1419 if (DECL_EXTERNAL (decl
))
1422 /* Output no assembler code for a function declaration.
1423 Only definitions of functions output anything. */
1425 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1428 /* Do nothing for global register variables. */
1429 if (DECL_RTL_SET_P (decl
) && GET_CODE (DECL_RTL (decl
)) == REG
)
1431 TREE_ASM_WRITTEN (decl
) = 1;
1435 /* If type was incomplete when the variable was declared,
1436 see if it is complete now. */
1438 if (DECL_SIZE (decl
) == 0)
1439 layout_decl (decl
, 0);
1441 /* Still incomplete => don't allocate it; treat the tentative defn
1442 (which is what it must have been) as an `extern' reference. */
1444 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1446 error ("%Hstorage size of `%s' isn't known",
1447 &DECL_SOURCE_LOCATION (decl
),
1448 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1449 TREE_ASM_WRITTEN (decl
) = 1;
1453 /* The first declaration of a variable that comes through this function
1454 decides whether it is global (in C, has external linkage)
1455 or local (in C, has internal linkage). So do nothing more
1456 if this function has already run. */
1458 if (TREE_ASM_WRITTEN (decl
))
1461 /* Make sure targetm.encode_section_info is invoked before we set
1463 decl_rtl
= DECL_RTL (decl
);
1465 TREE_ASM_WRITTEN (decl
) = 1;
1467 /* Do no output if -fsyntax-only. */
1468 if (flag_syntax_only
)
1473 if (! dont_output_data
1474 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1476 error_with_decl (decl
, "size of variable `%s' is too large");
1480 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1481 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1482 && ! first_global_object_name
1483 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1484 || DECL_INITIAL (decl
) == error_mark_node
))
1485 && ! DECL_WEAK (decl
)
1486 && ! DECL_ONE_ONLY (decl
))
1491 p
= (* targetm
.strip_name_encoding
) (name
);
1492 xname
= xstrdup (p
);
1493 first_global_object_name
= xname
;
1496 /* Compute the alignment of this data. */
1498 align
= DECL_ALIGN (decl
);
1500 /* In the case for initialing an array whose length isn't specified,
1501 where we have not yet been able to do the layout,
1502 figure out the proper alignment now. */
1503 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1504 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1505 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1507 /* Some object file formats have a maximum alignment which they support.
1508 In particular, a.out format supports a maximum alignment of 4. */
1509 #ifndef MAX_OFILE_ALIGNMENT
1510 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1512 if (align
> MAX_OFILE_ALIGNMENT
)
1514 warning_with_decl (decl
,
1515 "alignment of `%s' is greater than maximum object file alignment. Using %d",
1516 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1517 align
= MAX_OFILE_ALIGNMENT
;
1520 /* On some machines, it is good to increase alignment sometimes. */
1521 if (! DECL_USER_ALIGN (decl
))
1523 #ifdef DATA_ALIGNMENT
1524 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1526 #ifdef CONSTANT_ALIGNMENT
1527 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1528 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1532 /* Reset the alignment in case we have made it tighter, so we can benefit
1533 from it in get_pointer_alignment. */
1534 DECL_ALIGN (decl
) = align
;
1535 set_mem_align (decl_rtl
, align
);
1537 if (TREE_PUBLIC (decl
))
1538 maybe_assemble_visibility (decl
);
1540 /* Output any data that we will need to use the address of. */
1541 if (DECL_INITIAL (decl
) == error_mark_node
)
1542 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1543 else if (DECL_INITIAL (decl
))
1544 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1545 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1547 /* Handle uninitialized definitions. */
1549 /* If the decl has been given an explicit section name, then it
1550 isn't common, and shouldn't be handled as such. */
1551 if (DECL_SECTION_NAME (decl
) || dont_output_data
)
1553 /* We don't implement common thread-local data at present. */
1554 else if (DECL_THREAD_LOCAL (decl
))
1556 if (DECL_COMMON (decl
))
1557 sorry ("thread-local COMMON data not implemented");
1559 else if (DECL_INITIAL (decl
) == 0
1560 || DECL_INITIAL (decl
) == error_mark_node
1561 || (flag_zero_initialized_in_bss
1562 /* Leave constant zeroes in .rodata so they can be shared. */
1563 && !TREE_READONLY (decl
)
1564 && initializer_zerop (DECL_INITIAL (decl
))))
1566 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1567 unsigned HOST_WIDE_INT rounded
= size
;
1569 /* Don't allocate zero bytes of common,
1570 since that means "undefined external" in the linker. */
1574 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1575 so that each uninitialized object starts on such a boundary. */
1576 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1577 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1578 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1580 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1581 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN (decl
) / BITS_PER_UNIT
> rounded
)
1583 (decl
, "requested alignment for %s is greater than implemented alignment of %d",rounded
);
1586 /* If the target cannot output uninitialized but not common global data
1587 in .bss, then we have to use .data, so fall through. */
1588 if (asm_emit_uninitialised (decl
, name
, size
, rounded
))
1592 /* Handle initialized definitions.
1593 Also handle uninitialized global definitions if -fno-common and the
1594 target doesn't support ASM_OUTPUT_BSS. */
1596 /* First make the assembler name(s) global if appropriate. */
1597 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1598 globalize_decl (decl
);
1600 /* Switch to the appropriate section. */
1601 variable_section (decl
, reloc
);
1603 /* dbxout.c needs to know this. */
1604 if (in_text_section ())
1605 DECL_IN_TEXT_SECTION (decl
) = 1;
1607 /* Output the alignment of this data. */
1608 if (align
> BITS_PER_UNIT
)
1610 ASM_OUTPUT_ALIGN (asm_out_file
,
1611 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1614 /* Do any machine/system dependent processing of the object. */
1615 #ifdef ASM_DECLARE_OBJECT_NAME
1616 last_assemble_variable_decl
= decl
;
1617 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1619 /* Standard thing is just output label for the object. */
1620 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1621 #endif /* ASM_DECLARE_OBJECT_NAME */
1623 if (!dont_output_data
)
1625 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
1626 /* Output the actual data. */
1627 output_constant (DECL_INITIAL (decl
),
1628 tree_low_cst (DECL_SIZE_UNIT (decl
), 1),
1631 /* Leave space for it. */
1632 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1636 /* Return 1 if type TYPE contains any pointers. */
1639 contains_pointers_p (type
)
1642 switch (TREE_CODE (type
))
1645 case REFERENCE_TYPE
:
1646 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1647 so I'll play safe and return 1. */
1653 case QUAL_UNION_TYPE
:
1656 /* For a type that has fields, see if the fields have pointers. */
1657 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1658 if (TREE_CODE (fields
) == FIELD_DECL
1659 && contains_pointers_p (TREE_TYPE (fields
)))
1665 /* An array type contains pointers if its element type does. */
1666 return contains_pointers_p (TREE_TYPE (type
));
1673 /* Output something to declare an external symbol to the assembler.
1674 (Most assemblers don't need this, so we normally output nothing.)
1675 Do nothing if DECL is not external. */
1678 assemble_external (decl
)
1679 tree decl ATTRIBUTE_UNUSED
;
1681 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1682 main body of this code is only rarely exercised. To provide some
1683 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1684 open. If it's not, we should not be calling this function. */
1688 #ifdef ASM_OUTPUT_EXTERNAL
1689 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1691 rtx rtl
= DECL_RTL (decl
);
1693 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1694 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1696 /* Some systems do require some output. */
1697 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1698 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1704 /* Similar, for calling a library function FUN. */
1707 assemble_external_libcall (fun
)
1708 rtx fun ATTRIBUTE_UNUSED
;
1710 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1711 /* Declare library function name external when first used, if nec. */
1712 if (! SYMBOL_REF_USED (fun
))
1714 SYMBOL_REF_USED (fun
) = 1;
1715 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1720 /* Assemble a label named NAME. */
1723 assemble_label (name
)
1726 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1729 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1730 If NAME starts with a *, the rest of NAME is output verbatim.
1731 Otherwise NAME is transformed in an implementation-defined way
1732 (usually by the addition of an underscore).
1733 Many macros in the tm file are defined to call this function. */
1736 assemble_name (file
, name
)
1740 const char *real_name
;
1743 real_name
= (* targetm
.strip_name_encoding
) (name
);
1745 id
= maybe_get_identifier (real_name
);
1747 TREE_SYMBOL_REFERENCED (id
) = 1;
1750 fputs (&name
[1], file
);
1752 ASM_OUTPUT_LABELREF (file
, name
);
1755 /* Allocate SIZE bytes writable static space with a gensym name
1756 and return an RTX to refer to its address. */
1759 assemble_static_space (size
)
1760 unsigned HOST_WIDE_INT size
;
1763 const char *namestring
;
1767 if (flag_shared_data
)
1771 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1773 namestring
= ggc_strdup (name
);
1775 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1776 SYMBOL_REF_FLAGS (x
) = SYMBOL_FLAG_LOCAL
;
1778 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1779 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1782 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1783 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1786 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1787 so that each uninitialized object starts on such a boundary. */
1788 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1789 unsigned HOST_WIDE_INT rounded ATTRIBUTE_UNUSED
1790 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1791 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1792 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1793 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1800 /* Assemble the static constant template for function entry trampolines.
1801 This is done at most once per compilation.
1802 Returns an RTX for the address of the template. */
1804 #ifdef TRAMPOLINE_TEMPLATE
1806 assemble_trampoline_template ()
1813 /* By default, put trampoline templates in read-only data section. */
1815 #ifdef TRAMPOLINE_SECTION
1816 TRAMPOLINE_SECTION ();
1818 readonly_data_section ();
1821 /* Write the assembler code to define one. */
1822 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1825 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1828 (*targetm
.asm_out
.internal_label
) (asm_out_file
, "LTRAMP", 0);
1829 TRAMPOLINE_TEMPLATE (asm_out_file
);
1831 /* Record the rtl to refer to it. */
1832 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1833 name
= ggc_strdup (label
);
1834 symbol
= gen_rtx_SYMBOL_REF (Pmode
, name
);
1835 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
1841 /* A and B are either alignments or offsets. Return the minimum alignment
1842 that may be assumed after adding the two together. */
1844 static inline unsigned
1848 return (a
| b
) & -(a
| b
);
1851 /* Return the assembler directive for creating a given kind of integer
1852 object. SIZE is the number of bytes in the object and ALIGNED_P
1853 indicates whether it is known to be aligned. Return NULL if the
1854 assembly dialect has no such directive.
1856 The returned string should be printed at the start of a new line and
1857 be followed immediately by the object's initial value. */
1860 integer_asm_op (size
, aligned_p
)
1864 struct asm_int_op
*ops
;
1867 ops
= &targetm
.asm_out
.aligned_op
;
1869 ops
= &targetm
.asm_out
.unaligned_op
;
1874 return targetm
.asm_out
.byte_op
;
1888 /* Use directive OP to assemble an integer object X. Print OP at the
1889 start of the line, followed immediately by the value of X. */
1892 assemble_integer_with_op (op
, x
)
1896 fputs (op
, asm_out_file
);
1897 output_addr_const (asm_out_file
, x
);
1898 fputc ('\n', asm_out_file
);
1901 /* The default implementation of the asm_out.integer target hook. */
1904 default_assemble_integer (x
, size
, aligned_p
)
1905 rtx x ATTRIBUTE_UNUSED
;
1906 unsigned int size ATTRIBUTE_UNUSED
;
1907 int aligned_p ATTRIBUTE_UNUSED
;
1909 const char *op
= integer_asm_op (size
, aligned_p
);
1910 return op
&& (assemble_integer_with_op (op
, x
), true);
1913 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
1914 the alignment of the integer in bits. Return 1 if we were able to output
1915 the constant, otherwise 0. If FORCE is nonzero, abort if we can't output
1919 assemble_integer (x
, size
, align
, force
)
1927 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
1929 /* See if the target hook can handle this kind of object. */
1930 if ((*targetm
.asm_out
.integer
) (x
, size
, aligned_p
))
1933 /* If the object is a multi-byte one, try splitting it up. Split
1934 it into words it if is multi-word, otherwise split it into bytes. */
1937 enum machine_mode omode
, imode
;
1938 unsigned int subalign
;
1939 unsigned int subsize
, i
;
1941 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
1942 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
1943 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, MODE_INT
, 0);
1944 imode
= mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1946 for (i
= 0; i
< size
; i
+= subsize
)
1948 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
1949 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
1955 /* If we've printed some of it, but not all of it, there's no going
1968 assemble_real (d
, mode
, align
)
1970 enum machine_mode mode
;
1975 unsigned int nalign
= min_align (align
, 32);
1977 switch (BITS_PER_UNIT
)
1983 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
1984 assemble_integer (GEN_INT (l
), 4, align
, 1);
1987 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
1988 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
1989 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
1992 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
1993 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
1994 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
1995 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
1998 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
1999 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2000 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2001 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
2002 assemble_integer (GEN_INT (data
[3]), 4, nalign
, 1);
2013 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2014 assemble_integer (GEN_INT (l
), 2, align
, 1);
2017 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2018 assemble_integer (GEN_INT (data
[0]), 2, align
, 1);
2019 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2030 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2031 assemble_integer (GEN_INT (l
), 1, align
, 1);
2034 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2035 assemble_integer (GEN_INT (data
[0]), 1, align
, 1);
2036 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2048 /* Given an expression EXP with a constant value,
2049 reduce it to the sum of an assembler symbol and an integer.
2050 Store them both in the structure *VALUE.
2051 Abort if EXP does not reduce. */
2053 struct addr_const
GTY(())
2056 HOST_WIDE_INT offset
;
2060 decode_addr_const (exp
, value
)
2062 struct addr_const
*value
;
2064 tree target
= TREE_OPERAND (exp
, 0);
2070 if (TREE_CODE (target
) == COMPONENT_REF
2071 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2074 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2075 target
= TREE_OPERAND (target
, 0);
2077 else if (TREE_CODE (target
) == ARRAY_REF
2078 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2080 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2081 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2082 target
= TREE_OPERAND (target
, 0);
2088 switch (TREE_CODE (target
))
2092 x
= DECL_RTL (target
);
2096 x
= gen_rtx_MEM (FUNCTION_MODE
,
2097 gen_rtx_LABEL_REF (VOIDmode
, force_label_rtx (target
)));
2105 x
= output_constant_def (target
, 1);
2112 if (GET_CODE (x
) != MEM
)
2117 value
->offset
= offset
;
2120 /* We do RTX_UNSPEC + XINT (blah), so nothing can go after RTX_UNSPEC. */
2121 enum kind
{ RTX_UNKNOWN
, RTX_DOUBLE
, RTX_VECTOR
, RTX_INT
, RTX_UNSPEC
};
2122 struct rtx_const
GTY(())
2124 ENUM_BITFIELD(kind
) kind
: 16;
2125 ENUM_BITFIELD(machine_mode
) mode
: 16;
2126 union rtx_const_un
{
2127 REAL_VALUE_TYPE
GTY ((tag ("4"))) du
;
2128 struct rtx_const_u_addr
{
2131 HOST_WIDE_INT offset
;
2132 } GTY ((tag ("1"))) addr
;
2133 struct rtx_const_u_di
{
2136 } GTY ((tag ("0"))) di
;
2138 /* The max vector size we have is 16 wide; two variants for
2139 integral and floating point vectors. */
2140 struct rtx_const_int_vec
{
2143 } GTY ((tag ("2"))) int_vec
[16];
2145 REAL_VALUE_TYPE
GTY ((tag ("3"))) fp_vec
[8];
2147 } GTY ((desc ("%1.kind >= RTX_INT"), descbits ("1"))) un
;
2150 /* Uniquize all constants that appear in memory.
2151 Each constant in memory thus far output is recorded
2152 in `const_hash_table'. */
2154 struct constant_descriptor_tree
GTY(())
2156 /* A MEM for the constant. */
2159 /* The value of the constant. */
2163 static GTY((param_is (struct constant_descriptor_tree
)))
2164 htab_t const_desc_htab
;
2166 static struct constant_descriptor_tree
* build_constant_desc
PARAMS ((tree
));
2167 static void maybe_output_constant_def_contents
2168 PARAMS ((struct constant_descriptor_tree
*, int));
2170 /* Compute a hash code for a constant expression. */
2173 const_desc_hash (ptr
)
2176 return const_hash_1 (((struct constant_descriptor_tree
*)ptr
)->value
);
2186 enum tree_code code
= TREE_CODE (exp
);
2188 /* Either set P and LEN to the address and len of something to hash and
2189 exit the switch or return a value. */
2194 p
= (char *) &TREE_INT_CST (exp
);
2195 len
= sizeof TREE_INT_CST (exp
);
2199 return real_hash (TREE_REAL_CST_PTR (exp
));
2202 p
= TREE_STRING_POINTER (exp
);
2203 len
= TREE_STRING_LENGTH (exp
);
2206 return (const_hash_1 (TREE_REALPART (exp
)) * 5
2207 + const_hash_1 (TREE_IMAGPART (exp
)));
2210 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2214 len
= int_size_in_bytes (TREE_TYPE (exp
));
2215 tmp
= (char *) alloca (len
);
2216 get_set_constructor_bytes (exp
, (unsigned char *) tmp
, len
);
2224 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
2226 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2227 if (TREE_VALUE (link
))
2228 hi
= hi
* 603 + const_hash_1 (TREE_VALUE (link
));
2236 struct addr_const value
;
2238 decode_addr_const (exp
, &value
);
2239 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2241 /* Don't hash the address of the SYMBOL_REF;
2242 only use the offset and the symbol name. */
2244 p
= XSTR (value
.base
, 0);
2245 for (i
= 0; p
[i
] != 0; i
++)
2246 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2248 else if (GET_CODE (value
.base
) == LABEL_REF
)
2249 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2257 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
2258 + const_hash_1 (TREE_OPERAND (exp
, 1)));
2262 case NON_LVALUE_EXPR
:
2263 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
2266 /* A language specific constant. Just hash the code. */
2270 /* Compute hashing function */
2272 for (i
= 0; i
< len
; i
++)
2273 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2278 /* Wrapper of compare_constant, for the htab interface. */
2280 const_desc_eq (p1
, p2
)
2284 return compare_constant (((struct constant_descriptor_tree
*)p1
)->value
,
2285 ((struct constant_descriptor_tree
*)p2
)->value
);
2288 /* Compare t1 and t2, and return 1 only if they are known to result in
2289 the same bit pattern on output. */
2292 compare_constant (t1
, t2
)
2296 enum tree_code typecode
;
2298 if (t1
== NULL_TREE
)
2299 return t2
== NULL_TREE
;
2300 if (t2
== NULL_TREE
)
2303 if (TREE_CODE (t1
) != TREE_CODE (t2
))
2306 switch (TREE_CODE (t1
))
2309 /* Integer constants are the same only if the same width of type. */
2310 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2312 return tree_int_cst_equal (t1
, t2
);
2315 /* Real constants are the same only if the same width of type. */
2316 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2319 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2322 if (flag_writable_strings
)
2325 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
2328 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2329 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2330 TREE_STRING_LENGTH (t1
)));
2333 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
2334 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
2337 typecode
= TREE_CODE (TREE_TYPE (t1
));
2338 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
2341 if (typecode
== SET_TYPE
)
2343 int len
= int_size_in_bytes (TREE_TYPE (t2
));
2344 unsigned char *tmp1
, *tmp2
;
2346 if (int_size_in_bytes (TREE_TYPE (t1
)) != len
)
2349 tmp1
= (unsigned char *) alloca (len
);
2350 tmp2
= (unsigned char *) alloca (len
);
2352 if (get_set_constructor_bytes (t1
, tmp1
, len
) != NULL_TREE
)
2354 if (get_set_constructor_bytes (t2
, tmp2
, len
) != NULL_TREE
)
2357 return memcmp (tmp1
, tmp2
, len
) != 0;
2363 if (typecode
== ARRAY_TYPE
)
2365 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
2366 /* For arrays, check that the sizes all match. */
2367 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
2369 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
)))
2374 /* For record and union constructors, require exact type
2376 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
2380 for (l1
= CONSTRUCTOR_ELTS (t1
), l2
= CONSTRUCTOR_ELTS (t2
);
2382 l1
= TREE_CHAIN (l1
), l2
= TREE_CHAIN (l2
))
2384 /* Check that each value is the same... */
2385 if (! compare_constant (TREE_VALUE (l1
), TREE_VALUE (l2
)))
2387 /* ... and that they apply to the same fields! */
2388 if (typecode
== ARRAY_TYPE
)
2390 if (! compare_constant (TREE_PURPOSE (l1
),
2396 if (TREE_PURPOSE (l1
) != TREE_PURPOSE (l2
))
2401 return l1
== NULL_TREE
&& l2
== NULL_TREE
;
2407 struct addr_const value1
, value2
;
2409 decode_addr_const (t1
, &value1
);
2410 decode_addr_const (t2
, &value2
);
2411 return (value1
.offset
== value2
.offset
2412 && strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
2418 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
2419 && compare_constant(TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
2423 case NON_LVALUE_EXPR
:
2424 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2429 nt1
= (*lang_hooks
.expand_constant
) (t1
);
2430 nt2
= (*lang_hooks
.expand_constant
) (t2
);
2431 if (nt1
!= t1
|| nt2
!= t2
)
2432 return compare_constant (nt1
, nt2
);
2438 /* Should not get here. */
2442 /* Make a copy of the whole tree structure for a constant. This
2443 handles the same types of nodes that compare_constant handles. */
2449 switch (TREE_CODE (exp
))
2452 /* For ADDR_EXPR, we do not want to copy the decl whose address
2453 is requested. We do want to copy constants though. */
2454 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
2455 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2456 copy_constant (TREE_OPERAND (exp
, 0)));
2458 return copy_node (exp
);
2463 return copy_node (exp
);
2466 return build_complex (TREE_TYPE (exp
),
2467 copy_constant (TREE_REALPART (exp
)),
2468 copy_constant (TREE_IMAGPART (exp
)));
2472 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
2473 copy_constant (TREE_OPERAND (exp
, 0)),
2474 copy_constant (TREE_OPERAND (exp
, 1)));
2478 case NON_LVALUE_EXPR
:
2479 case VIEW_CONVERT_EXPR
:
2480 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2481 copy_constant (TREE_OPERAND (exp
, 0)));
2485 tree copy
= copy_node (exp
);
2486 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
2489 CONSTRUCTOR_ELTS (copy
) = list
;
2490 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2491 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
2492 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2493 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2494 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
2502 t
= (*lang_hooks
.expand_constant
) (exp
);
2504 return copy_constant (t
);
2511 /* Subroutine of output_constant_def:
2512 No constant equal to EXP is known to have been output.
2513 Make a constant descriptor to enter EXP in the hash table.
2514 Assign the label number and construct RTL to refer to the
2515 constant's location in memory.
2516 Caller is responsible for updating the hash table. */
2518 static struct constant_descriptor_tree
*
2519 build_constant_desc (exp
)
2526 struct constant_descriptor_tree
*desc
;
2528 desc
= ggc_alloc (sizeof (*desc
));
2529 desc
->value
= copy_constant (exp
);
2531 /* Create a string containing the label name, in LABEL. */
2532 labelno
= const_labelno
++;
2533 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
2535 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2536 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
2537 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
2538 SYMBOL_REF_DECL (symbol
) = desc
->value
;
2539 TREE_CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
2541 rtl
= gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)), symbol
);
2542 set_mem_attributes (rtl
, exp
, 1);
2543 set_mem_alias_set (rtl
, 0);
2544 set_mem_alias_set (rtl
, const_alias_set
);
2546 /* Set flags or add text to the name to record information, such as
2547 that it is a local symbol. If the name is changed, the macro
2548 ASM_OUTPUT_LABELREF will have to know how to strip this
2549 information. This call might invalidate our local variable
2550 SYMBOL; we can't use it afterward. */
2552 (*targetm
.encode_section_info
) (exp
, rtl
, true);
2559 /* Return an rtx representing a reference to constant data in memory
2560 for the constant expression EXP.
2562 If assembler code for such a constant has already been output,
2563 return an rtx to refer to it.
2564 Otherwise, output such a constant in memory
2565 and generate an rtx for it.
2567 If DEFER is nonzero, this constant can be deferred and output only
2568 if referenced in the function after all optimizations.
2570 The const_hash_table records which constants already have label strings. */
2573 output_constant_def (exp
, defer
)
2577 struct constant_descriptor_tree
*desc
;
2578 struct constant_descriptor_tree key
;
2581 /* Look up EXP in the table of constant descriptors. If we didn't find
2582 it, create a new one. */
2584 loc
= htab_find_slot (const_desc_htab
, &key
, INSERT
);
2589 desc
= build_constant_desc (exp
);
2593 maybe_output_constant_def_contents (desc
, defer
);
2597 /* Subroutine of output_constant_def: Decide whether or not we need to
2598 output the constant DESC now, and if so, do it. */
2600 maybe_output_constant_def_contents (desc
, defer
)
2601 struct constant_descriptor_tree
*desc
;
2604 rtx symbol
= XEXP (desc
->rtl
, 0);
2605 tree exp
= desc
->value
;
2607 if (flag_syntax_only
)
2610 if (TREE_ASM_WRITTEN (exp
))
2611 /* Already output; don't do it again. */
2614 /* The only constants that cannot safely be deferred, assuming the
2615 context allows it, are strings under flag_writable_strings. */
2616 if (defer
&& (TREE_CODE (exp
) != STRING_CST
|| !flag_writable_strings
))
2618 /* Increment n_deferred_constants if it exists. It needs to be at
2619 least as large as the number of constants actually referred to
2620 by the function. If it's too small we'll stop looking too early
2621 and fail to emit constants; if it's too large we'll only look
2622 through the entire function when we could have stopped earlier. */
2624 n_deferred_constants
++;
2628 output_constant_def_contents (symbol
);
2631 /* We must output the constant data referred to by SYMBOL; do so. */
2634 output_constant_def_contents (symbol
)
2637 tree exp
= SYMBOL_REF_DECL (symbol
);
2638 const char *label
= XSTR (symbol
, 0);
2640 /* Make sure any other constants whose addresses appear in EXP
2641 are assigned label numbers. */
2642 int reloc
= output_addressed_constants (exp
);
2644 /* Align the location counter as required by EXP's data type. */
2645 int align
= TYPE_ALIGN (TREE_TYPE (exp
));
2646 #ifdef CONSTANT_ALIGNMENT
2647 align
= CONSTANT_ALIGNMENT (exp
, align
);
2650 /* We are no longer deferring this constant. */
2651 TREE_ASM_WRITTEN (exp
) = 1;
2653 if (IN_NAMED_SECTION (exp
))
2654 named_section (exp
, NULL
, reloc
);
2656 (*targetm
.asm_out
.select_section
) (exp
, reloc
, align
);
2658 if (align
> BITS_PER_UNIT
)
2660 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2663 /* Output the label itself. */
2664 ASM_OUTPUT_LABEL (asm_out_file
, label
);
2666 /* Output the value of EXP. */
2667 output_constant (exp
,
2668 (TREE_CODE (exp
) == STRING_CST
2669 ? MAX (TREE_STRING_LENGTH (exp
),
2670 int_size_in_bytes (TREE_TYPE (exp
)))
2671 : int_size_in_bytes (TREE_TYPE (exp
))),
2676 /* A constant which was deferred in its original location has been
2677 inserted by the RTL inliner into a different function. The
2678 current function's deferred constant count must be incremented. */
2680 notice_rtl_inlining_of_deferred_constant ()
2682 n_deferred_constants
++;
2685 /* Used in the hash tables to avoid outputting the same constant
2686 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2687 are output once per function, not once per file; there seems
2688 to be no reason for the difference. */
2690 struct constant_descriptor_rtx
GTY(())
2692 /* More constant_descriptors with the same hash code. */
2693 struct constant_descriptor_rtx
*next
;
2695 /* A MEM for the constant. */
2698 /* The value of the constant. */
2699 struct rtx_const value
;
2702 /* Structure to represent sufficient information about a constant so that
2703 it can be output when the constant pool is output, so that function
2704 integration can be done, and to simplify handling on machines that reference
2705 constant pool as base+displacement. */
2707 struct pool_constant
GTY(())
2709 struct constant_descriptor_rtx
*desc
;
2710 struct pool_constant
*next
;
2711 struct pool_constant
*next_sym
;
2713 enum machine_mode mode
;
2716 HOST_WIDE_INT offset
;
2720 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
2721 The argument is XSTR (... , 0) */
2723 #define SYMHASH(LABEL) (((unsigned long) (LABEL)) % MAX_RTX_HASH_TABLE)
2725 /* Initialize constant pool hashing for a new function. */
2728 init_varasm_status (f
)
2731 struct varasm_status
*p
;
2732 p
= (struct varasm_status
*) ggc_alloc (sizeof (struct varasm_status
));
2734 p
->x_const_rtx_hash_table
2735 = ((struct constant_descriptor_rtx
**)
2736 ggc_alloc_cleared (MAX_RTX_HASH_TABLE
2737 * sizeof (struct constant_descriptor_rtx
*)));
2738 p
->x_const_rtx_sym_hash_table
2739 = ((struct pool_constant
**)
2740 ggc_alloc_cleared (MAX_RTX_HASH_TABLE
2741 * sizeof (struct pool_constant
*)));
2743 p
->x_first_pool
= p
->x_last_pool
= 0;
2744 p
->x_pool_offset
= 0;
2745 p
->deferred_constants
= 0;
2749 /* Express an rtx for a constant integer (perhaps symbolic)
2750 as the sum of a symbol or label plus an explicit integer.
2751 They are stored into VALUE. */
2754 decode_rtx_const (mode
, x
, value
)
2755 enum machine_mode mode
;
2757 struct rtx_const
*value
;
2759 /* Clear the whole structure, including any gaps. */
2760 memset (value
, 0, sizeof (struct rtx_const
));
2762 value
->kind
= RTX_INT
; /* Most usual kind. */
2765 switch (GET_CODE (x
))
2768 value
->kind
= RTX_DOUBLE
;
2769 if (GET_MODE (x
) != VOIDmode
)
2771 const REAL_VALUE_TYPE
*r
= CONST_DOUBLE_REAL_VALUE (x
);
2773 value
->mode
= GET_MODE (x
);
2775 /* Copy the REAL_VALUE_TYPE by members so that we don't
2776 copy garbage from the original structure into our
2777 carefully cleaned hashing structure. */
2778 value
->un
.du
.class = r
->class;
2779 value
->un
.du
.sign
= r
->sign
;
2786 value
->un
.du
.exp
= r
->exp
;
2789 memcpy (value
->un
.du
.sig
, r
->sig
, sizeof (r
->sig
));
2797 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
2798 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
2806 units
= CONST_VECTOR_NUNITS (x
);
2807 value
->kind
= RTX_VECTOR
;
2810 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
)
2812 for (i
= 0; i
< units
; ++i
)
2814 rtx elt
= CONST_VECTOR_ELT (x
, i
);
2815 if (GET_CODE (elt
) == CONST_INT
)
2817 value
->un
.int_vec
[i
].low
= INTVAL (elt
);
2818 value
->un
.int_vec
[i
].high
= 0;
2822 value
->un
.int_vec
[i
].low
= CONST_DOUBLE_LOW (elt
);
2823 value
->un
.int_vec
[i
].high
= CONST_DOUBLE_HIGH (elt
);
2827 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
2829 for (i
= 0; i
< units
; ++i
)
2831 const REAL_VALUE_TYPE
*r
2832 = CONST_DOUBLE_REAL_VALUE (CONST_VECTOR_ELT (x
, i
));
2833 REAL_VALUE_TYPE
*d
= &value
->un
.fp_vec
[i
];
2835 /* Copy the REAL_VALUE_TYPE by members so that we don't
2836 copy garbage from the original structure into our
2837 carefully cleaned hashing structure. */
2838 d
->class = r
->class;
2849 memcpy (d
->sig
, r
->sig
, sizeof (r
->sig
));
2862 value
->un
.addr
.offset
= INTVAL (x
);
2868 value
->un
.addr
.base
= x
;
2873 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
2875 value
->un
.addr
.base
= XEXP (x
, 0);
2876 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
2878 else if (GET_CODE (x
) == MINUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
2880 value
->un
.addr
.base
= XEXP (x
, 0);
2881 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
2885 value
->un
.addr
.base
= x
;
2886 value
->un
.addr
.offset
= 0;
2891 value
->kind
= RTX_UNKNOWN
;
2895 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0
2896 && GET_CODE (value
->un
.addr
.base
) == UNSPEC
)
2898 /* For a simple UNSPEC, the base is set to the
2899 operand, the kind field is set to the index of
2900 the unspec expression.
2901 Together with the code below, in case that
2902 the operand is a SYMBOL_REF or LABEL_REF,
2903 the address of the string or the code_label
2904 is taken as base. */
2905 if (XVECLEN (value
->un
.addr
.base
, 0) == 1)
2907 value
->kind
= RTX_UNSPEC
+ XINT (value
->un
.addr
.base
, 1);
2908 value
->un
.addr
.base
= XVECEXP (value
->un
.addr
.base
, 0, 0);
2912 if (value
->kind
>= RTX_INT
&& value
->un
.addr
.base
!= 0)
2913 switch (GET_CODE (value
->un
.addr
.base
))
2916 /* Use the string's address, not the SYMBOL_REF's address,
2917 for the sake of addresses of library routines. */
2918 value
->un
.addr
.symbol
= XSTR (value
->un
.addr
.base
, 0);
2919 value
->un
.addr
.base
= NULL_RTX
;
2923 /* For a LABEL_REF, compare labels. */
2924 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
2931 /* Given a MINUS expression, simplify it if both sides
2932 include the same symbol. */
2935 simplify_subtraction (x
)
2938 struct rtx_const val0
, val1
;
2940 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
2941 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
2943 if (val0
.kind
>= RTX_INT
2944 && val0
.kind
== val1
.kind
2945 && val0
.un
.addr
.base
== val1
.un
.addr
.base
2946 && val0
.un
.addr
.symbol
== val1
.un
.addr
.symbol
)
2947 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
2952 /* Compute a hash code for a constant RTL expression. */
2955 const_hash_rtx (mode
, x
)
2956 enum machine_mode mode
;
2960 struct rtx_const value
;
2961 unsigned int data
[sizeof(struct rtx_const
) / sizeof (unsigned int)];
2967 decode_rtx_const (mode
, x
, &u
.value
);
2969 /* Compute hashing function */
2971 for (i
= 0; i
< ARRAY_SIZE (u
.data
); i
++)
2972 hi
= hi
* 613 + u
.data
[i
];
2974 return hi
% MAX_RTX_HASH_TABLE
;
2977 /* Compare a constant rtl object X with a constant-descriptor DESC.
2978 Return 1 if DESC describes a constant with the same value as X. */
2981 compare_constant_rtx (mode
, x
, desc
)
2982 enum machine_mode mode
;
2984 struct constant_descriptor_rtx
*desc
;
2986 struct rtx_const value
;
2988 decode_rtx_const (mode
, x
, &value
);
2990 /* Compare constant contents. */
2991 return memcmp (&value
, &desc
->value
, sizeof (struct rtx_const
)) == 0;
2994 /* Construct a constant descriptor for the rtl-expression X.
2995 It is up to the caller to enter the descriptor in the hash table. */
2997 static struct constant_descriptor_rtx
*
2998 record_constant_rtx (mode
, x
)
2999 enum machine_mode mode
;
3002 struct constant_descriptor_rtx
*ptr
;
3004 ptr
= (struct constant_descriptor_rtx
*) ggc_alloc (sizeof (*ptr
));
3005 decode_rtx_const (mode
, x
, &ptr
->value
);
3010 /* Given a constant rtx X, return a MEM for the location in memory at which
3011 this constant has been placed. Return 0 if it not has been placed yet. */
3014 mem_for_const_double (x
)
3017 enum machine_mode mode
= GET_MODE (x
);
3018 struct constant_descriptor_rtx
*desc
;
3020 for (desc
= const_rtx_hash_table
[const_hash_rtx (mode
, x
)]; desc
;
3022 if (compare_constant_rtx (mode
, x
, desc
))
3028 /* Given a constant rtx X, make (or find) a memory constant for its value
3029 and return a MEM rtx to refer to it in memory. */
3032 force_const_mem (mode
, x
)
3033 enum machine_mode mode
;
3037 struct constant_descriptor_rtx
*desc
;
3040 struct pool_constant
*pool
;
3043 /* If we're not allowed to drop X into the constant pool, don't. */
3044 if ((*targetm
.cannot_force_const_mem
) (x
))
3047 /* Compute hash code of X. Search the descriptors for that hash code
3048 to see if any of them describes X. If yes, we have an rtx to use. */
3049 hash
= const_hash_rtx (mode
, x
);
3050 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3051 if (compare_constant_rtx (mode
, x
, desc
))
3054 /* No constant equal to X is known to have been output.
3055 Make a constant descriptor to enter X in the hash table
3056 and make a MEM for it. */
3057 desc
= record_constant_rtx (mode
, x
);
3058 desc
->next
= const_rtx_hash_table
[hash
];
3059 const_rtx_hash_table
[hash
] = desc
;
3061 /* Align the location counter as required by EXP's data type. */
3062 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3063 #ifdef CONSTANT_ALIGNMENT
3065 tree type
= (*lang_hooks
.types
.type_for_mode
) (mode
, 0);
3066 if (type
!= NULL_TREE
)
3067 align
= CONSTANT_ALIGNMENT (make_tree (type
, x
), align
);
3071 pool_offset
+= (align
/ BITS_PER_UNIT
) - 1;
3072 pool_offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3074 if (GET_CODE (x
) == LABEL_REF
)
3075 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3077 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3078 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3082 pool
->labelno
= const_labelno
;
3083 pool
->align
= align
;
3084 pool
->offset
= pool_offset
;
3091 last_pool
->next
= pool
;
3094 pool_offset
+= GET_MODE_SIZE (mode
);
3096 /* Create a string containing the label name, in LABEL. */
3097 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3101 /* Construct the SYMBOL_REF and the MEM. */
3103 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3104 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
3106 pool
->desc
->rtl
= def
= gen_rtx_MEM (mode
, symbol
);
3107 set_mem_attributes (def
, (*lang_hooks
.types
.type_for_mode
) (mode
, 0), 1);
3108 RTX_UNCHANGING_P (def
) = 1;
3110 /* Add label to symbol hash table. */
3111 hash
= SYMHASH (XSTR (symbol
, 0));
3112 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3113 const_rtx_sym_hash_table
[hash
] = pool
;
3115 /* Mark the symbol_ref as belonging to this constants pool. */
3116 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3117 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
3118 current_function_uses_const_pool
= 1;
3123 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3124 the corresponding pool_constant structure. */
3126 static struct pool_constant
*
3127 find_pool_constant (f
, addr
)
3131 struct pool_constant
*pool
;
3132 const char *label
= XSTR (addr
, 0);
3134 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3135 pool
= pool
->next_sym
)
3136 if (XSTR (XEXP (pool
->desc
->rtl
, 0), 0) == label
)
3142 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3145 get_pool_constant (addr
)
3148 return (find_pool_constant (cfun
, addr
))->constant
;
3151 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3152 and whether it has been output or not. */
3155 get_pool_constant_mark (addr
, pmarked
)
3159 struct pool_constant
*pool
= find_pool_constant (cfun
, addr
);
3160 *pmarked
= (pool
->mark
!= 0);
3161 return pool
->constant
;
3164 /* Likewise, but for the constant pool of a specific function. */
3167 get_pool_constant_for_function (f
, addr
)
3171 return (find_pool_constant (f
, addr
))->constant
;
3174 /* Similar, return the mode. */
3177 get_pool_mode (addr
)
3180 return (find_pool_constant (cfun
, addr
))->mode
;
3184 get_pool_mode_for_function (f
, addr
)
3188 return (find_pool_constant (f
, addr
))->mode
;
3191 /* Similar, return the offset in the constant pool. */
3194 get_pool_offset (addr
)
3197 return (find_pool_constant (cfun
, addr
))->offset
;
3200 /* Return the size of the constant pool. */
3208 /* Write all the constants in the constant pool. */
3211 output_constant_pool (fnname
, fndecl
)
3212 const char *fnname ATTRIBUTE_UNUSED
;
3213 tree fndecl ATTRIBUTE_UNUSED
;
3215 struct pool_constant
*pool
;
3219 /* It is possible for gcc to call force_const_mem and then to later
3220 discard the instructions which refer to the constant. In such a
3221 case we do not need to output the constant. */
3222 mark_constant_pool ();
3224 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3225 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3228 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3237 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3238 whose CODE_LABEL has been deleted. This can occur if a jump table
3239 is eliminated by optimization. If so, write a constant of zero
3240 instead. Note that this can also happen by turning the
3241 CODE_LABEL into a NOTE. */
3242 /* ??? This seems completely and utterly wrong. Certainly it's
3243 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3244 functioning even with INSN_DELETED_P and friends. */
3247 switch (GET_CODE (x
))
3250 if (GET_CODE (XEXP (x
, 0)) != PLUS
3251 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3253 tmp
= XEXP (XEXP (x
, 0), 0);
3258 if (INSN_DELETED_P (tmp
)
3259 || (GET_CODE (tmp
) == NOTE
3260 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
3271 /* First switch to correct section. */
3272 (*targetm
.asm_out
.select_rtx_section
) (pool
->mode
, x
, pool
->align
);
3274 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3275 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3276 pool
->align
, pool
->labelno
, done
);
3279 assemble_align (pool
->align
);
3281 /* Output the label. */
3282 (*targetm
.asm_out
.internal_label
) (asm_out_file
, "LC", pool
->labelno
);
3284 /* Output the value of the constant itself. */
3285 switch (GET_MODE_CLASS (pool
->mode
))
3288 if (GET_CODE (x
) != CONST_DOUBLE
)
3291 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
3292 assemble_real (r
, pool
->mode
, pool
->align
);
3296 case MODE_PARTIAL_INT
:
3297 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), pool
->align
, 1);
3300 case MODE_VECTOR_FLOAT
:
3305 if (GET_CODE (x
) != CONST_VECTOR
)
3308 units
= CONST_VECTOR_NUNITS (x
);
3310 for (i
= 0; i
< units
; i
++)
3312 elt
= CONST_VECTOR_ELT (x
, i
);
3313 REAL_VALUE_FROM_CONST_DOUBLE (r
, elt
);
3314 assemble_real (r
, GET_MODE_INNER (pool
->mode
), pool
->align
);
3319 case MODE_VECTOR_INT
:
3324 if (GET_CODE (x
) != CONST_VECTOR
)
3327 units
= CONST_VECTOR_NUNITS (x
);
3329 for (i
= 0; i
< units
; i
++)
3331 elt
= CONST_VECTOR_ELT (x
, i
);
3332 assemble_integer (elt
, GET_MODE_UNIT_SIZE (pool
->mode
),
3342 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3343 sections have proper size. */
3344 if (pool
->align
> GET_MODE_BITSIZE (pool
->mode
)
3345 && in_section
== in_named
3346 && get_named_section_flags (in_named_name
) & SECTION_MERGE
)
3347 assemble_align (pool
->align
);
3349 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3354 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3355 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3358 /* Done with this pool. */
3359 first_pool
= last_pool
= 0;
3362 /* Look through the instructions for this function, and mark all the
3363 entries in the constant pool which are actually being used. Emit
3364 deferred constants which have indeed been used. */
3367 mark_constant_pool ()
3371 struct pool_constant
*pool
;
3373 if (first_pool
== 0 && n_deferred_constants
== 0)
3376 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3379 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3381 mark_constants (PATTERN (insn
));
3383 for (link
= current_function_epilogue_delay_list
;
3385 link
= XEXP (link
, 1))
3387 insn
= XEXP (link
, 0);
3390 mark_constants (PATTERN (insn
));
3394 /* Look through appropriate parts of X, marking all entries in the
3395 constant pool which are actually being used. Entries that are only
3396 referenced by other constants are also marked as used. Emit
3397 deferred strings that are used. */
3404 const char *format_ptr
;
3409 if (GET_CODE (x
) == SYMBOL_REF
)
3411 mark_constant (&x
, NULL
);
3415 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3416 insns, not any notes that may be attached. We don't want to mark
3417 a constant just because it happens to appear in a REG_EQUIV note. */
3420 mark_constants (PATTERN (x
));
3424 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3426 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3428 switch (*format_ptr
++)
3431 mark_constants (XEXP (x
, i
));
3435 if (XVEC (x
, i
) != 0)
3439 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3440 mark_constants (XVECEXP (x
, i
, j
));
3460 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3461 to as used. Emit referenced deferred strings. This function can
3462 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3465 mark_constant (current_rtx
, data
)
3467 void *data ATTRIBUTE_UNUSED
;
3469 rtx x
= *current_rtx
;
3474 else if (GET_CODE (x
) == SYMBOL_REF
)
3476 if (CONSTANT_POOL_ADDRESS_P (x
))
3478 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
3479 if (pool
->mark
== 0)
3482 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
3487 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
3489 tree exp
= SYMBOL_REF_DECL (x
);
3490 if (!TREE_ASM_WRITTEN (exp
))
3492 n_deferred_constants
--;
3493 output_constant_def_contents (x
);
3500 /* Find all the constants whose addresses are referenced inside of EXP,
3501 and make sure assembler code with a label has been output for each one.
3502 Indicate whether an ADDR_EXPR has been encountered. */
3505 output_addressed_constants (exp
)
3508 int reloc
= 0, reloc2
;
3511 /* Give the front-end a chance to convert VALUE to something that
3512 looks more like a constant to the back-end. */
3513 exp
= (*lang_hooks
.expand_constant
) (exp
);
3515 switch (TREE_CODE (exp
))
3519 /* Go inside any operations that get_inner_reference can handle and see
3520 if what's inside is a constant: no need to do anything here for
3521 addresses of variables or functions. */
3522 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
3523 tem
= TREE_OPERAND (tem
, 0))
3526 if (TREE_CODE_CLASS (TREE_CODE (tem
)) == 'c'
3527 || TREE_CODE (tem
) == CONSTRUCTOR
)
3528 output_constant_def (tem
, 0);
3530 if (TREE_PUBLIC (tem
))
3537 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3538 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
3542 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3543 reloc2
= output_addressed_constants (TREE_OPERAND (exp
, 1));
3544 /* The difference of two local labels is computable at link time. */
3545 if (reloc
== 1 && reloc2
== 1)
3553 case NON_LVALUE_EXPR
:
3554 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3558 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
3559 if (TREE_VALUE (tem
) != 0)
3560 reloc
|= output_addressed_constants (TREE_VALUE (tem
));
3570 /* Return nonzero if VALUE is a valid constant-valued expression
3571 for use in initializing a static variable; one that can be an
3572 element of a "constant" initializer.
3574 Return null_pointer_node if the value is absolute;
3575 if it is relocatable, return the variable that determines the relocation.
3576 We assume that VALUE has been folded as much as possible;
3577 therefore, we do not need to check for such things as
3578 arithmetic-combinations of integers. */
3581 initializer_constant_valid_p (value
, endtype
)
3585 /* Give the front-end a chance to convert VALUE to something that
3586 looks more like a constant to the back-end. */
3587 value
= (*lang_hooks
.expand_constant
) (value
);
3589 switch (TREE_CODE (value
))
3592 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
3593 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
3594 && TREE_CONSTANT (value
)
3595 && CONSTRUCTOR_ELTS (value
))
3597 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
3600 return TREE_STATIC (value
) ? null_pointer_node
: 0;
3607 return null_pointer_node
;
3611 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
3613 case VIEW_CONVERT_EXPR
:
3614 case NON_LVALUE_EXPR
:
3615 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3619 /* Allow conversions between pointer types. */
3620 if (POINTER_TYPE_P (TREE_TYPE (value
))
3621 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3622 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3624 /* Allow conversions between real types. */
3625 if (FLOAT_TYPE_P (TREE_TYPE (value
))
3626 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3627 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3629 /* Allow length-preserving conversions between integer types. */
3630 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3631 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3632 && (TYPE_PRECISION (TREE_TYPE (value
))
3633 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3634 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3636 /* Allow conversions between other integer types only if
3638 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3639 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3641 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3643 if (inner
== null_pointer_node
)
3644 return null_pointer_node
;
3648 /* Allow (int) &foo provided int is as wide as a pointer. */
3649 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3650 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3651 && (TYPE_PRECISION (TREE_TYPE (value
))
3652 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3653 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3656 /* Likewise conversions from int to pointers, but also allow
3657 conversions from 0. */
3658 if (POINTER_TYPE_P (TREE_TYPE (value
))
3659 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3661 if (integer_zerop (TREE_OPERAND (value
, 0)))
3662 return null_pointer_node
;
3663 else if (TYPE_PRECISION (TREE_TYPE (value
))
3664 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
3665 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3669 /* Allow conversions to union types if the value inside is okay. */
3670 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
3671 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
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 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
3713 return null_pointer_node
;
3716 /* Support differences between labels. */
3717 if (INTEGRAL_TYPE_P (endtype
))
3720 op0
= TREE_OPERAND (value
, 0);
3721 op1
= TREE_OPERAND (value
, 1);
3723 /* Like STRIP_NOPS except allow the operand mode to widen.
3724 This works around a feature of fold that simplifies
3725 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3726 that the narrower operation is cheaper. */
3728 while (TREE_CODE (op0
) == NOP_EXPR
3729 || TREE_CODE (op0
) == CONVERT_EXPR
3730 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3732 tree inner
= TREE_OPERAND (op0
, 0);
3733 if (inner
== error_mark_node
3734 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3735 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
3736 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3741 while (TREE_CODE (op1
) == NOP_EXPR
3742 || TREE_CODE (op1
) == CONVERT_EXPR
3743 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
3745 tree inner
= TREE_OPERAND (op1
, 0);
3746 if (inner
== error_mark_node
3747 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3748 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
3749 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3754 if (TREE_CODE (op0
) == ADDR_EXPR
3755 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
3756 && TREE_CODE (op1
) == ADDR_EXPR
3757 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
3758 return null_pointer_node
;
3769 /* Output assembler code for constant EXP to FILE, with no label.
3770 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3771 Assumes output_addressed_constants has been done on EXP already.
3773 Generate exactly SIZE bytes of assembler data, padding at the end
3774 with zeros if necessary. SIZE must always be specified.
3776 SIZE is important for structure constructors,
3777 since trailing members may have been omitted from the constructor.
3778 It is also important for initialization of arrays from string constants
3779 since the full length of the string constant might not be wanted.
3780 It is also needed for initialization of unions, where the initializer's
3781 type is just one member, and that may not be as long as the union.
3783 There a case in which we would fail to output exactly SIZE bytes:
3784 for a structure constructor that wants to produce more than SIZE bytes.
3785 But such constructors will never be generated for any possible input.
3787 ALIGN is the alignment of the data in bits. */
3790 output_constant (exp
, size
, align
)
3792 unsigned HOST_WIDE_INT size
;
3795 enum tree_code code
;
3796 unsigned HOST_WIDE_INT thissize
;
3798 /* Some front-ends use constants other than the standard language-independent
3799 varieties, but which may still be output directly. Give the front-end a
3800 chance to convert EXP to a language-independent representation. */
3801 exp
= (*lang_hooks
.expand_constant
) (exp
);
3803 if (size
== 0 || flag_syntax_only
)
3806 /* Eliminate any conversions since we'll be outputting the underlying
3808 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
3809 || TREE_CODE (exp
) == NON_LVALUE_EXPR
3810 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
3811 exp
= TREE_OPERAND (exp
, 0);
3813 code
= TREE_CODE (TREE_TYPE (exp
));
3814 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
3816 /* Allow a constructor with no elements for any data type.
3817 This means to fill the space with zeros. */
3818 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
3820 assemble_zeros (size
);
3824 if (TREE_CODE (exp
) == FDESC_EXPR
)
3826 #ifdef ASM_OUTPUT_FDESC
3827 HOST_WIDE_INT part
= tree_low_cst (TREE_OPERAND (exp
, 1), 0);
3828 tree decl
= TREE_OPERAND (exp
, 0);
3829 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
3836 /* Now output the underlying data. If we've handling the padding, return.
3837 Otherwise, break and ensure THISSIZE is the size written. */
3845 case REFERENCE_TYPE
:
3846 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
3847 EXPAND_INITIALIZER
),
3849 error ("initializer for integer value is too complicated");
3853 if (TREE_CODE (exp
) != REAL_CST
)
3854 error ("initializer for floating value is not a floating constant");
3856 assemble_real (TREE_REAL_CST (exp
),
3857 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0),
3862 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
3863 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
3864 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
3869 if (TREE_CODE (exp
) == CONSTRUCTOR
)
3871 output_constructor (exp
, size
, align
);
3874 else if (TREE_CODE (exp
) == STRING_CST
)
3876 thissize
= MIN ((unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
),
3878 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
3880 else if (TREE_CODE (exp
) == VECTOR_CST
)
3884 unsigned int nalign
;
3885 enum machine_mode inner
;
3887 inner
= GET_MODE_INNER (TYPE_MODE (TREE_TYPE (exp
)));
3888 nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
3890 elt_size
= GET_MODE_UNIT_SIZE (TYPE_MODE (TREE_TYPE (exp
)));
3892 link
= TREE_VECTOR_CST_ELTS (exp
);
3893 output_constant (TREE_VALUE (link
), elt_size
, align
);
3894 while ((link
= TREE_CHAIN (link
)) != NULL
)
3895 output_constant (TREE_VALUE (link
), elt_size
, nalign
);
3903 if (TREE_CODE (exp
) == CONSTRUCTOR
)
3904 output_constructor (exp
, size
, align
);
3910 if (TREE_CODE (exp
) == INTEGER_CST
)
3911 assemble_integer (expand_expr (exp
, NULL_RTX
,
3912 VOIDmode
, EXPAND_INITIALIZER
),
3913 thissize
, align
, 1);
3914 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
3916 unsigned char *buffer
= (unsigned char *) alloca (thissize
);
3917 if (get_set_constructor_bytes (exp
, buffer
, thissize
))
3919 assemble_string ((char *) buffer
, thissize
);
3922 error ("unknown set constructor type");
3932 if (size
> thissize
)
3933 assemble_zeros (size
- thissize
);
3937 /* Subroutine of output_constructor, used for computing the size of
3938 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3939 type with an unspecified upper bound. */
3941 static unsigned HOST_WIDE_INT
3942 array_size_for_constructor (val
)
3947 /* This code used to attempt to handle string constants that are not
3948 arrays of single-bytes, but nothing else does, so there's no point in
3950 if (TREE_CODE (val
) == STRING_CST
)
3951 return TREE_STRING_LENGTH (val
);
3953 max_index
= NULL_TREE
;
3954 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
3956 tree index
= TREE_PURPOSE (i
);
3958 if (TREE_CODE (index
) == RANGE_EXPR
)
3959 index
= TREE_OPERAND (index
, 1);
3960 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
3964 if (max_index
== NULL_TREE
)
3967 /* Compute the total number of array elements. */
3968 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
3970 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
3971 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
3973 /* Multiply by the array element unit size to find number of bytes. */
3974 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
3976 return tree_low_cst (i
, 1);
3979 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3980 Generate at least SIZE bytes, padding if necessary. */
3983 output_constructor (exp
, size
, align
)
3985 unsigned HOST_WIDE_INT size
;
3988 tree type
= TREE_TYPE (exp
);
3989 tree link
, field
= 0;
3991 /* Number of bytes output or skipped so far.
3992 In other words, current position within the constructor. */
3993 HOST_WIDE_INT total_bytes
= 0;
3994 /* Nonzero means BYTE contains part of a byte, to be output. */
3995 int byte_buffer_in_use
= 0;
3998 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4001 if (TREE_CODE (type
) == RECORD_TYPE
)
4002 field
= TYPE_FIELDS (type
);
4004 if (TREE_CODE (type
) == ARRAY_TYPE
4005 && TYPE_DOMAIN (type
) != 0)
4006 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4008 /* As LINK goes through the elements of the constant,
4009 FIELD goes through the structure fields, if the constant is a structure.
4010 if the constant is a union, then we override this,
4011 by getting the field from the TREE_LIST element.
4012 But the constant could also be an array. Then FIELD is zero.
4014 There is always a maximum of one element in the chain LINK for unions
4015 (even if the initializer in a source program incorrectly contains
4017 for (link
= CONSTRUCTOR_ELTS (exp
);
4019 link
= TREE_CHAIN (link
),
4020 field
= field
? TREE_CHAIN (field
) : 0)
4022 tree val
= TREE_VALUE (link
);
4025 /* The element in a union constructor specifies the proper field
4027 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4028 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4029 && TREE_PURPOSE (link
) != 0)
4030 field
= TREE_PURPOSE (link
);
4032 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4033 index
= TREE_PURPOSE (link
);
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 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4114 else if (DECL_SIZE_UNIT (field
))
4116 /* ??? This can't be right. If the decl size overflows
4117 a host integer we will silently emit no data. */
4118 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4119 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4123 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4125 /* Output the element's initial value. */
4127 assemble_zeros (fieldsize
);
4129 output_constant (val
, fieldsize
, align2
);
4131 /* Count its size. */
4132 total_bytes
+= fieldsize
;
4134 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4135 error ("invalid initial value for member `%s'",
4136 IDENTIFIER_POINTER (DECL_NAME (field
)));
4139 /* Element that is a bit-field. */
4141 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4142 HOST_WIDE_INT end_offset
4143 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4146 val
= integer_zero_node
;
4148 /* If this field does not start in this (or, next) byte,
4150 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4152 /* Output remnant of any bit field in previous bytes. */
4153 if (byte_buffer_in_use
)
4155 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4157 byte_buffer_in_use
= 0;
4160 /* If still not at proper byte, advance to there. */
4161 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4163 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4164 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4168 if (! byte_buffer_in_use
)
4171 /* We must split the element into pieces that fall within
4172 separate bytes, and combine each byte with previous or
4173 following bit-fields. */
4175 /* next_offset is the offset n fbits from the beginning of
4176 the structure to the next bit of this element to be processed.
4177 end_offset is the offset of the first bit past the end of
4179 while (next_offset
< end_offset
)
4183 HOST_WIDE_INT value
;
4184 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4185 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4187 /* Advance from byte to byte
4188 within this element when necessary. */
4189 while (next_byte
!= total_bytes
)
4191 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4196 /* Number of bits we can process at once
4197 (all part of the same byte). */
4198 this_time
= MIN (end_offset
- next_offset
,
4199 BITS_PER_UNIT
- next_bit
);
4200 if (BYTES_BIG_ENDIAN
)
4202 /* On big-endian machine, take the most significant bits
4203 first (of the bits that are significant)
4204 and put them into bytes from the most significant end. */
4205 shift
= end_offset
- next_offset
- this_time
;
4207 /* Don't try to take a bunch of bits that cross
4208 the word boundary in the INTEGER_CST. We can
4209 only select bits from the LOW or HIGH part
4211 if (shift
< HOST_BITS_PER_WIDE_INT
4212 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4214 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4215 shift
= HOST_BITS_PER_WIDE_INT
;
4218 /* Now get the bits from the appropriate constant word. */
4219 if (shift
< HOST_BITS_PER_WIDE_INT
)
4220 value
= TREE_INT_CST_LOW (val
);
4221 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4223 value
= TREE_INT_CST_HIGH (val
);
4224 shift
-= HOST_BITS_PER_WIDE_INT
;
4229 /* Get the result. This works only when:
4230 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4231 byte
|= (((value
>> shift
)
4232 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4233 << (BITS_PER_UNIT
- this_time
- next_bit
));
4237 /* On little-endian machines,
4238 take first the least significant bits of the value
4239 and pack them starting at the least significant
4240 bits of the bytes. */
4241 shift
= next_offset
- int_bit_position (field
);
4243 /* Don't try to take a bunch of bits that cross
4244 the word boundary in the INTEGER_CST. We can
4245 only select bits from the LOW or HIGH part
4247 if (shift
< HOST_BITS_PER_WIDE_INT
4248 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4249 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4251 /* Now get the bits from the appropriate constant word. */
4252 if (shift
< HOST_BITS_PER_WIDE_INT
)
4253 value
= TREE_INT_CST_LOW (val
);
4254 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4256 value
= TREE_INT_CST_HIGH (val
);
4257 shift
-= HOST_BITS_PER_WIDE_INT
;
4262 /* Get the result. This works only when:
4263 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4264 byte
|= (((value
>> shift
)
4265 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4269 next_offset
+= this_time
;
4270 byte_buffer_in_use
= 1;
4275 if (byte_buffer_in_use
)
4277 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4281 if ((unsigned HOST_WIDE_INT
)total_bytes
< size
)
4282 assemble_zeros (size
- total_bytes
);
4285 /* This TREE_LIST contains any weak symbol declarations waiting
4287 static GTY(()) tree weak_decls
;
4289 /* Mark DECL as weak. */
4295 DECL_WEAK (decl
) = 1;
4297 if (DECL_RTL_SET_P (decl
)
4298 && GET_CODE (DECL_RTL (decl
)) == MEM
4299 && XEXP (DECL_RTL (decl
), 0)
4300 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
4301 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
4304 /* Merge weak status between NEWDECL and OLDDECL. */
4307 merge_weak (newdecl
, olddecl
)
4311 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
4314 if (DECL_WEAK (newdecl
))
4318 /* NEWDECL is weak, but OLDDECL is not. */
4320 /* If we already output the OLDDECL, we're in trouble; we can't
4321 go back and make it weak. This error cannot caught in
4322 declare_weak because the NEWDECL and OLDDECL was not yet
4323 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4324 if (TREE_ASM_WRITTEN (olddecl
))
4325 error_with_decl (newdecl
,
4326 "weak declaration of `%s' must precede definition");
4328 /* If we've already generated rtl referencing OLDDECL, we may
4329 have done so in a way that will not function properly with
4331 else if (TREE_USED (olddecl
)
4332 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)))
4333 warning_with_decl (newdecl
, "weak declaration of `%s' after first use results in unspecified behavior");
4337 /* We put the NEWDECL on the weak_decls list at some point.
4338 Replace it with the OLDDECL. */
4339 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
4340 if (TREE_VALUE (wd
) == newdecl
)
4342 TREE_VALUE (wd
) = olddecl
;
4345 /* We may not find the entry on the list. If NEWDECL is a
4346 weak alias, then we will have already called
4347 globalize_decl to remove the entry; in that case, we do
4348 not need to do anything. */
4351 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4352 mark_weak (olddecl
);
4355 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4356 weak. Just update NEWDECL to indicate that it's weak too. */
4357 mark_weak (newdecl
);
4360 /* Declare DECL to be a weak symbol. */
4366 if (! TREE_PUBLIC (decl
))
4367 error_with_decl (decl
, "weak declaration of `%s' must be public");
4368 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
4369 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4370 else if (SUPPORTS_WEAK
)
4372 if (! DECL_WEAK (decl
))
4373 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
4376 warning_with_decl (decl
, "weak declaration of `%s' not supported");
4381 /* Emit any pending weak declarations. */
4388 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
4390 tree decl
= TREE_VALUE (t
);
4391 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4392 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4395 if (! TREE_USED (decl
))
4398 #ifdef ASM_WEAKEN_DECL
4399 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
4401 #ifdef ASM_WEAKEN_LABEL
4402 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4404 #ifdef ASM_OUTPUT_WEAK_ALIAS
4405 warning ("only weak aliases are supported in this configuration");
4413 /* Emit the assembly bits to indicate that DECL is globally visible. */
4416 globalize_decl (decl
)
4419 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
4421 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4422 if (DECL_WEAK (decl
))
4426 #ifdef ASM_WEAKEN_DECL
4427 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
4429 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4432 /* Remove this function from the pending weak list so that
4433 we do not emit multiple .weak directives for it. */
4434 for (p
= &weak_decls
; (t
= *p
) ; )
4436 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
4437 *p
= TREE_CHAIN (t
);
4439 p
= &TREE_CHAIN (t
);
4445 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, name
);
4448 /* Emit an assembler directive to make the symbol for DECL an alias to
4449 the symbol for TARGET. */
4452 assemble_alias (decl
, target
)
4453 tree decl
, target ATTRIBUTE_UNUSED
;
4457 /* We must force creation of DECL_RTL for debug info generation, even though
4458 we don't use it here. */
4459 make_decl_rtl (decl
, NULL
);
4461 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4463 #ifdef ASM_OUTPUT_DEF
4464 /* Make name accessible from other files, if appropriate. */
4466 if (TREE_PUBLIC (decl
))
4468 globalize_decl (decl
);
4469 maybe_assemble_visibility (decl
);
4472 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4473 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4475 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4477 #else /* !ASM_OUTPUT_DEF */
4478 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4479 if (! DECL_WEAK (decl
))
4480 warning ("only weak aliases are supported in this configuration");
4482 #ifdef ASM_WEAKEN_DECL
4483 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
4485 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4488 warning ("alias definitions not supported in this configuration; ignored");
4492 TREE_USED (decl
) = 1;
4493 TREE_ASM_WRITTEN (decl
) = 1;
4494 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
4497 /* Emit an assembler directive to set symbol for DECL visibility to
4498 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4501 default_assemble_visibility (decl
, vis
)
4505 static const char * const visibility_types
[] = {
4506 NULL
, "internal", "hidden", "protected"
4509 const char *name
, *type
;
4511 name
= (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4512 type
= visibility_types
[vis
];
4514 #ifdef HAVE_GAS_HIDDEN
4515 fprintf (asm_out_file
, "\t.%s\t", type
);
4516 assemble_name (asm_out_file
, name
);
4517 fprintf (asm_out_file
, "\n");
4519 warning ("visibility attribute not supported in this configuration; ignored");
4523 /* A helper function to call assemble_visibility when needed for a decl. */
4526 maybe_assemble_visibility (decl
)
4529 enum symbol_visibility vis
= decl_visibility (decl
);
4531 if (vis
!= VISIBILITY_DEFAULT
)
4532 (* targetm
.asm_out
.visibility
) (decl
, vis
);
4535 /* Returns 1 if the target configuration supports defining public symbols
4536 so that one of them will be chosen at link time instead of generating a
4537 multiply-defined symbol error, whether through the use of weak symbols or
4538 a target-specific mechanism for having duplicates discarded. */
4541 supports_one_only ()
4543 if (SUPPORTS_ONE_ONLY
)
4545 return SUPPORTS_WEAK
;
4548 /* Set up DECL as a public symbol that can be defined in multiple
4549 translation units without generating a linker error. */
4552 make_decl_one_only (decl
)
4555 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4558 TREE_PUBLIC (decl
) = 1;
4560 if (TREE_CODE (decl
) == VAR_DECL
4561 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4562 DECL_COMMON (decl
) = 1;
4563 else if (SUPPORTS_ONE_ONLY
)
4565 #ifdef MAKE_DECL_ONE_ONLY
4566 MAKE_DECL_ONE_ONLY (decl
);
4568 DECL_ONE_ONLY (decl
) = 1;
4570 else if (SUPPORTS_WEAK
)
4571 DECL_WEAK (decl
) = 1;
4579 in_named_htab
= htab_create_ggc (31, in_named_entry_hash
,
4580 in_named_entry_eq
, NULL
);
4581 const_desc_htab
= htab_create_ggc (1009, const_desc_hash
,
4582 const_desc_eq
, NULL
);
4584 const_alias_set
= new_alias_set ();
4588 decl_tls_model (decl
)
4591 enum tls_model kind
;
4592 tree attr
= lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl
));
4597 attr
= TREE_VALUE (TREE_VALUE (attr
));
4598 if (TREE_CODE (attr
) != STRING_CST
)
4600 if (!strcmp (TREE_STRING_POINTER (attr
), "local-exec"))
4601 kind
= TLS_MODEL_LOCAL_EXEC
;
4602 else if (!strcmp (TREE_STRING_POINTER (attr
), "initial-exec"))
4603 kind
= TLS_MODEL_INITIAL_EXEC
;
4604 else if (!strcmp (TREE_STRING_POINTER (attr
), "local-dynamic"))
4605 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
4606 else if (!strcmp (TREE_STRING_POINTER (attr
), "global-dynamic"))
4607 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4613 is_local
= (*targetm
.binds_local_p
) (decl
);
4617 kind
= TLS_MODEL_LOCAL_EXEC
;
4619 kind
= TLS_MODEL_INITIAL_EXEC
;
4621 /* Local dynamic is inefficient when we're not combining the
4622 parts of the address. */
4623 else if (optimize
&& is_local
)
4624 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
4626 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4627 if (kind
< flag_tls_default
)
4628 kind
= flag_tls_default
;
4633 enum symbol_visibility
4634 decl_visibility (decl
)
4637 tree attr
= lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
));
4641 const char *which
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
4643 if (strcmp (which
, "default") == 0)
4644 return VISIBILITY_DEFAULT
;
4645 if (strcmp (which
, "internal") == 0)
4646 return VISIBILITY_INTERNAL
;
4647 if (strcmp (which
, "hidden") == 0)
4648 return VISIBILITY_HIDDEN
;
4649 if (strcmp (which
, "protected") == 0)
4650 return VISIBILITY_PROTECTED
;
4655 return VISIBILITY_DEFAULT
;
4658 /* Select a set of attributes for section NAME based on the properties
4659 of DECL and whether or not RELOC indicates that DECL's initializer
4660 might contain runtime relocations.
4662 We make the section read-only and executable for a function decl,
4663 read-only for a const data decl, and writable for a non-const data decl. */
4666 default_section_type_flags (decl
, name
, reloc
)
4671 return default_section_type_flags_1 (decl
, name
, reloc
, flag_pic
);
4675 default_section_type_flags_1 (decl
, name
, reloc
, shlib
)
4683 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4684 flags
= SECTION_CODE
;
4685 else if (decl
&& decl_readonly_section_1 (decl
, reloc
, shlib
))
4688 flags
= SECTION_WRITE
;
4690 if (decl
&& DECL_ONE_ONLY (decl
))
4691 flags
|= SECTION_LINKONCE
;
4693 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4694 flags
|= SECTION_TLS
| SECTION_WRITE
;
4696 if (strcmp (name
, ".bss") == 0
4697 || strncmp (name
, ".bss.", 5) == 0
4698 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4699 || strcmp (name
, ".sbss") == 0
4700 || strncmp (name
, ".sbss.", 6) == 0
4701 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0
4702 || strcmp (name
, ".tbss") == 0
4703 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4704 flags
|= SECTION_BSS
;
4706 if (strcmp (name
, ".tdata") == 0
4707 || strcmp (name
, ".tbss") == 0
4708 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0
4709 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4710 flags
|= SECTION_TLS
;
4712 /* These three sections have special ELF types. They are neither
4713 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4714 want to print a section type (@progbits or @nobits). If someone
4715 is silly enough to emit code or TLS variables to one of these
4716 sections, then don't handle them specially. */
4717 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
4718 && (strcmp (name
, ".init_array") == 0
4719 || strcmp (name
, ".fini_array") == 0
4720 || strcmp (name
, ".preinit_array") == 0))
4721 flags
|= SECTION_NOTYPE
;
4726 /* Output assembly to switch to section NAME with attribute FLAGS.
4727 Four variants for common object file formats. */
4730 default_no_named_section (name
, flags
)
4731 const char *name ATTRIBUTE_UNUSED
;
4732 unsigned int flags ATTRIBUTE_UNUSED
;
4734 /* Some object formats don't support named sections at all. The
4735 front-end should already have flagged this as an error. */
4740 default_elf_asm_named_section (name
, flags
)
4744 char flagchars
[10], *f
= flagchars
;
4746 if (! named_section_first_declaration (name
))
4748 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
4752 if (!(flags
& SECTION_DEBUG
))
4754 if (flags
& SECTION_WRITE
)
4756 if (flags
& SECTION_CODE
)
4758 if (flags
& SECTION_SMALL
)
4760 if (flags
& SECTION_MERGE
)
4762 if (flags
& SECTION_STRINGS
)
4764 if (flags
& SECTION_TLS
)
4768 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
4770 if (!(flags
& SECTION_NOTYPE
))
4774 if (flags
& SECTION_BSS
)
4779 fprintf (asm_out_file
, ",@%s", type
);
4781 if (flags
& SECTION_ENTSIZE
)
4782 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
4785 putc ('\n', asm_out_file
);
4789 default_coff_asm_named_section (name
, flags
)
4793 char flagchars
[8], *f
= flagchars
;
4795 if (flags
& SECTION_WRITE
)
4797 if (flags
& SECTION_CODE
)
4801 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
4805 default_pe_asm_named_section (name
, flags
)
4809 default_coff_asm_named_section (name
, flags
);
4811 if (flags
& SECTION_LINKONCE
)
4813 /* Functions may have been compiled at various levels of
4814 optimization so we can't use `same_size' here.
4815 Instead, have the linker pick one. */
4816 fprintf (asm_out_file
, "\t.linkonce %s\n",
4817 (flags
& SECTION_CODE
? "discard" : "same_size"));
4821 /* Used for vtable gc in GNU binutils. Record that the pointer at OFFSET
4822 from SYMBOL is used in all classes derived from SYMBOL. */
4825 assemble_vtable_entry (symbol
, offset
)
4827 HOST_WIDE_INT offset
;
4829 fputs ("\t.vtable_entry ", asm_out_file
);
4830 output_addr_const (asm_out_file
, symbol
);
4831 fprintf (asm_out_file
, ", " HOST_WIDE_INT_PRINT_DEC
"\n", offset
);
4834 /* Used for vtable gc in GNU binutils. Record the class hierarchy by noting
4835 that the vtable symbol CHILD is derived from the vtable symbol PARENT. */
4838 assemble_vtable_inherit (child
, parent
)
4841 fputs ("\t.vtable_inherit ", asm_out_file
);
4842 output_addr_const (asm_out_file
, child
);
4843 fputs (", ", asm_out_file
);
4844 output_addr_const (asm_out_file
, parent
);
4845 fputc ('\n', asm_out_file
);
4848 /* The lame default section selector. */
4851 default_select_section (decl
, reloc
, align
)
4854 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
4856 bool readonly
= false;
4860 if (decl_readonly_section (decl
, reloc
))
4863 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4865 if (! ((flag_pic
&& reloc
)
4866 || !TREE_READONLY (decl
)
4867 || TREE_SIDE_EFFECTS (decl
)
4868 || !TREE_CONSTANT (decl
)))
4871 else if (TREE_CODE (decl
) == STRING_CST
)
4872 readonly
= !flag_writable_strings
;
4873 else if (! (flag_pic
&& reloc
))
4877 readonly_data_section ();
4882 /* A helper function for default_elf_select_section and
4883 default_elf_unique_section. Categorizes the DECL. */
4885 enum section_category
4890 SECCAT_RODATA_MERGE_STR
,
4891 SECCAT_RODATA_MERGE_STR_INIT
,
4892 SECCAT_RODATA_MERGE_CONST
,
4897 /* To optimize loading of shared programs, define following subsections
4899 _REL Contains data that has relocations, so they get grouped
4900 together and dynamic linker will visit fewer pages in memory.
4901 _RO Contains data that is otherwise read-only. This is useful
4902 with prelinking as most relocations won't be dynamically
4903 linked and thus stay read only.
4904 _LOCAL Marks data containing relocations only to local objects.
4905 These relocations will get fully resolved by prelinking. */
4907 SECCAT_DATA_REL_LOCAL
,
4909 SECCAT_DATA_REL_RO_LOCAL
,
4919 static enum section_category
4920 categorize_decl_for_section
PARAMS ((tree
, int, int));
4922 static enum section_category
4923 categorize_decl_for_section (decl
, reloc
, shlib
)
4928 enum section_category ret
;
4930 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4932 else if (TREE_CODE (decl
) == STRING_CST
)
4934 if (flag_writable_strings
)
4937 return SECCAT_RODATA_MERGE_STR
;
4939 else if (TREE_CODE (decl
) == VAR_DECL
)
4941 if (DECL_INITIAL (decl
) == NULL
4942 || DECL_INITIAL (decl
) == error_mark_node
)
4944 else if (! TREE_READONLY (decl
)
4945 || TREE_SIDE_EFFECTS (decl
)
4946 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
4948 if (shlib
&& (reloc
& 2))
4949 ret
= SECCAT_DATA_REL
;
4950 else if (shlib
&& reloc
)
4951 ret
= SECCAT_DATA_REL_LOCAL
;
4955 else if (shlib
&& (reloc
& 2))
4956 ret
= SECCAT_DATA_REL_RO
;
4957 else if (shlib
&& reloc
)
4958 ret
= SECCAT_DATA_REL_RO_LOCAL
;
4959 else if (reloc
|| flag_merge_constants
< 2)
4960 /* C and C++ don't allow different variables to share the same
4961 location. -fmerge-all-constants allows even that (at the
4962 expense of not conforming). */
4963 ret
= SECCAT_RODATA
;
4964 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
4965 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
4967 ret
= SECCAT_RODATA_MERGE_CONST
;
4969 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4971 if ((shlib
&& reloc
)
4972 || TREE_SIDE_EFFECTS (decl
)
4973 || ! TREE_CONSTANT (decl
))
4976 ret
= SECCAT_RODATA
;
4979 ret
= SECCAT_RODATA
;
4981 /* There are no read-only thread-local sections. */
4982 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4984 if (ret
== SECCAT_BSS
)
4990 /* If the target uses small data sections, select it. */
4991 else if ((*targetm
.in_small_data_p
) (decl
))
4993 if (ret
== SECCAT_BSS
)
4995 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
4996 ret
= SECCAT_SRODATA
;
5005 decl_readonly_section (decl
, reloc
)
5009 return decl_readonly_section_1 (decl
, reloc
, flag_pic
);
5013 decl_readonly_section_1 (decl
, reloc
, shlib
)
5018 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5021 case SECCAT_RODATA_MERGE_STR
:
5022 case SECCAT_RODATA_MERGE_STR_INIT
:
5023 case SECCAT_RODATA_MERGE_CONST
:
5024 case SECCAT_SRODATA
:
5033 /* Select a section based on the above categorization. */
5036 default_elf_select_section (decl
, reloc
, align
)
5039 unsigned HOST_WIDE_INT align
;
5041 default_elf_select_section_1 (decl
, reloc
, align
, flag_pic
);
5045 default_elf_select_section_1 (decl
, reloc
, align
, shlib
)
5048 unsigned HOST_WIDE_INT align
;
5051 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5054 /* We're not supposed to be called on FUNCTION_DECLs. */
5057 readonly_data_section ();
5059 case SECCAT_RODATA_MERGE_STR
:
5060 mergeable_string_section (decl
, align
, 0);
5062 case SECCAT_RODATA_MERGE_STR_INIT
:
5063 mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
5065 case SECCAT_RODATA_MERGE_CONST
:
5066 mergeable_constant_section (DECL_MODE (decl
), align
, 0);
5068 case SECCAT_SRODATA
:
5069 named_section (NULL_TREE
, ".sdata2", reloc
);
5074 case SECCAT_DATA_REL
:
5075 named_section (NULL_TREE
, ".data.rel", reloc
);
5077 case SECCAT_DATA_REL_LOCAL
:
5078 named_section (NULL_TREE
, ".data.rel.local", reloc
);
5080 case SECCAT_DATA_REL_RO
:
5081 named_section (NULL_TREE
, ".data.rel.ro", reloc
);
5083 case SECCAT_DATA_REL_RO_LOCAL
:
5084 named_section (NULL_TREE
, ".data.rel.ro.local", reloc
);
5087 named_section (NULL_TREE
, ".sdata", reloc
);
5090 named_section (NULL_TREE
, ".tdata", reloc
);
5093 #ifdef BSS_SECTION_ASM_OP
5096 named_section (NULL_TREE
, ".bss", reloc
);
5100 named_section (NULL_TREE
, ".sbss", reloc
);
5103 named_section (NULL_TREE
, ".tbss", reloc
);
5110 /* Construct a unique section name based on the decl name and the
5111 categorization performed above. */
5114 default_unique_section (decl
, reloc
)
5118 default_unique_section_1 (decl
, reloc
, flag_pic
);
5122 default_unique_section_1 (decl
, reloc
, shlib
)
5127 bool one_only
= DECL_ONE_ONLY (decl
);
5128 const char *prefix
, *name
;
5132 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5135 prefix
= one_only
? ".gnu.linkonce.t." : ".text.";
5138 case SECCAT_RODATA_MERGE_STR
:
5139 case SECCAT_RODATA_MERGE_STR_INIT
:
5140 case SECCAT_RODATA_MERGE_CONST
:
5141 prefix
= one_only
? ".gnu.linkonce.r." : ".rodata.";
5143 case SECCAT_SRODATA
:
5144 prefix
= one_only
? ".gnu.linkonce.s2." : ".sdata2.";
5147 case SECCAT_DATA_REL
:
5148 case SECCAT_DATA_REL_LOCAL
:
5149 case SECCAT_DATA_REL_RO
:
5150 case SECCAT_DATA_REL_RO_LOCAL
:
5151 prefix
= one_only
? ".gnu.linkonce.d." : ".data.";
5154 prefix
= one_only
? ".gnu.linkonce.s." : ".sdata.";
5157 prefix
= one_only
? ".gnu.linkonce.b." : ".bss.";
5160 prefix
= one_only
? ".gnu.linkonce.sb." : ".sbss.";
5163 prefix
= one_only
? ".gnu.linkonce.td." : ".tdata.";
5166 prefix
= one_only
? ".gnu.linkonce.tb." : ".tbss.";
5171 plen
= strlen (prefix
);
5173 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5174 name
= (* targetm
.strip_name_encoding
) (name
);
5175 nlen
= strlen (name
);
5177 string
= alloca (nlen
+ plen
+ 1);
5178 memcpy (string
, prefix
, plen
);
5179 memcpy (string
+ plen
, name
, nlen
+ 1);
5181 DECL_SECTION_NAME (decl
) = build_string (nlen
+ plen
, string
);
5185 default_select_rtx_section (mode
, x
, align
)
5186 enum machine_mode mode ATTRIBUTE_UNUSED
;
5188 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
5191 switch (GET_CODE (x
))
5203 readonly_data_section ();
5207 default_elf_select_rtx_section (mode
, x
, align
)
5208 enum machine_mode mode
;
5210 unsigned HOST_WIDE_INT align
;
5212 /* ??? Handle small data here somehow. */
5215 switch (GET_CODE (x
))
5219 named_section (NULL_TREE
, ".data.rel.ro", 3);
5223 named_section (NULL_TREE
, ".data.rel.ro.local", 1);
5230 mergeable_constant_section (mode
, align
, 0);
5233 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5236 default_encode_section_info (decl
, rtl
, first
)
5239 int first ATTRIBUTE_UNUSED
;
5244 /* Careful not to prod global register variables. */
5245 if (GET_CODE (rtl
) != MEM
)
5247 symbol
= XEXP (rtl
, 0);
5248 if (GET_CODE (symbol
) != SYMBOL_REF
)
5252 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5253 flags
|= SYMBOL_FLAG_FUNCTION
;
5254 if ((*targetm
.binds_local_p
) (decl
))
5255 flags
|= SYMBOL_FLAG_LOCAL
;
5256 if ((*targetm
.in_small_data_p
) (decl
))
5257 flags
|= SYMBOL_FLAG_SMALL
;
5258 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
5259 flags
|= decl_tls_model (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
5260 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5261 being PUBLIC, the thing *must* be defined in this translation unit.
5262 Prevent this buglet from being propagated into rtl code as well. */
5263 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
5264 flags
|= SYMBOL_FLAG_EXTERNAL
;
5266 SYMBOL_REF_FLAGS (symbol
) = flags
;
5269 /* By default, we do nothing for encode_section_info, so we need not
5270 do anything but discard the '*' marker. */
5273 default_strip_name_encoding (str
)
5276 return str
+ (*str
== '*');
5279 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5280 wrt cross-module name binding. */
5283 default_binds_local_p (exp
)
5286 return default_binds_local_p_1 (exp
, flag_shlib
);
5290 default_binds_local_p_1 (exp
, shlib
)
5296 /* A non-decl is an entry in the constant pool. */
5299 /* Static variables are always local. */
5300 else if (! TREE_PUBLIC (exp
))
5302 /* A variable is local if the user tells us so. */
5303 else if (decl_visibility (exp
) != VISIBILITY_DEFAULT
)
5305 /* Otherwise, variables defined outside this object may not be local. */
5306 else if (DECL_EXTERNAL (exp
))
5308 /* Linkonce and weak data are never local. */
5309 else if (DECL_ONE_ONLY (exp
) || DECL_WEAK (exp
))
5311 /* If PIC, then assume that any global name can be overridden by
5312 symbols resolved from other modules. */
5315 /* Uninitialized COMMON variable may be unified with symbols
5316 resolved from other modules. */
5317 else if (DECL_COMMON (exp
)
5318 && (DECL_INITIAL (exp
) == NULL
5319 || DECL_INITIAL (exp
) == error_mark_node
))
5321 /* Otherwise we're left with initialized (or non-common) global data
5322 which is of necessity defined locally. */
5329 /* Determine whether or not a pointer mode is valid. Assume defaults
5330 of ptr_mode or Pmode - can be overridden. */
5332 default_valid_pointer_mode (mode
)
5333 enum machine_mode mode
;
5335 return (mode
== ptr_mode
|| mode
== Pmode
);
5338 /* Default function to output code that will globalize a label. A
5339 target must define GLOBAL_ASM_OP or provide it's own function to
5340 globalize a label. */
5341 #ifdef GLOBAL_ASM_OP
5343 default_globalize_label (stream
, name
)
5347 fputs (GLOBAL_ASM_OP
, stream
);
5348 assemble_name (stream
, name
);
5349 putc ('\n', stream
);
5351 #endif /* GLOBAL_ASM_OP */
5353 /* This is how to output an internal numbered label where PREFIX is
5354 the class of label and LABELNO is the number within the class. */
5357 default_internal_label (stream
, prefix
, labelno
)
5360 unsigned long labelno
;
5362 char *const buf
= alloca (40 + strlen (prefix
));
5363 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
5364 ASM_OUTPUT_LABEL (stream
, buf
);
5367 #include "gt-varasm.h"