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
3064 align
= CONSTANT_ALIGNMENT (make_tree ((*lang_hooks
.types
.type_for_mode
)
3065 (mode
, 0), x
), align
);
3068 pool_offset
+= (align
/ BITS_PER_UNIT
) - 1;
3069 pool_offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3071 if (GET_CODE (x
) == LABEL_REF
)
3072 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3074 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3075 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3079 pool
->labelno
= const_labelno
;
3080 pool
->align
= align
;
3081 pool
->offset
= pool_offset
;
3088 last_pool
->next
= pool
;
3091 pool_offset
+= GET_MODE_SIZE (mode
);
3093 /* Create a string containing the label name, in LABEL. */
3094 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3098 /* Construct the SYMBOL_REF and the MEM. */
3100 symbol
= gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
));
3101 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
3103 pool
->desc
->rtl
= def
= gen_rtx_MEM (mode
, symbol
);
3104 set_mem_attributes (def
, (*lang_hooks
.types
.type_for_mode
) (mode
, 0), 1);
3105 RTX_UNCHANGING_P (def
) = 1;
3107 /* Add label to symbol hash table. */
3108 hash
= SYMHASH (XSTR (symbol
, 0));
3109 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3110 const_rtx_sym_hash_table
[hash
] = pool
;
3112 /* Mark the symbol_ref as belonging to this constants pool. */
3113 CONSTANT_POOL_ADDRESS_P (symbol
) = 1;
3114 SYMBOL_REF_FLAGS (symbol
) = SYMBOL_FLAG_LOCAL
;
3115 current_function_uses_const_pool
= 1;
3120 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3121 the corresponding pool_constant structure. */
3123 static struct pool_constant
*
3124 find_pool_constant (f
, addr
)
3128 struct pool_constant
*pool
;
3129 const char *label
= XSTR (addr
, 0);
3131 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3132 pool
= pool
->next_sym
)
3133 if (XSTR (XEXP (pool
->desc
->rtl
, 0), 0) == label
)
3139 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3142 get_pool_constant (addr
)
3145 return (find_pool_constant (cfun
, addr
))->constant
;
3148 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3149 and whether it has been output or not. */
3152 get_pool_constant_mark (addr
, pmarked
)
3156 struct pool_constant
*pool
= find_pool_constant (cfun
, addr
);
3157 *pmarked
= (pool
->mark
!= 0);
3158 return pool
->constant
;
3161 /* Likewise, but for the constant pool of a specific function. */
3164 get_pool_constant_for_function (f
, addr
)
3168 return (find_pool_constant (f
, addr
))->constant
;
3171 /* Similar, return the mode. */
3174 get_pool_mode (addr
)
3177 return (find_pool_constant (cfun
, addr
))->mode
;
3181 get_pool_mode_for_function (f
, addr
)
3185 return (find_pool_constant (f
, addr
))->mode
;
3188 /* Similar, return the offset in the constant pool. */
3191 get_pool_offset (addr
)
3194 return (find_pool_constant (cfun
, addr
))->offset
;
3197 /* Return the size of the constant pool. */
3205 /* Write all the constants in the constant pool. */
3208 output_constant_pool (fnname
, fndecl
)
3209 const char *fnname ATTRIBUTE_UNUSED
;
3210 tree fndecl ATTRIBUTE_UNUSED
;
3212 struct pool_constant
*pool
;
3216 /* It is possible for gcc to call force_const_mem and then to later
3217 discard the instructions which refer to the constant. In such a
3218 case we do not need to output the constant. */
3219 mark_constant_pool ();
3221 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3222 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3225 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3234 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3235 whose CODE_LABEL has been deleted. This can occur if a jump table
3236 is eliminated by optimization. If so, write a constant of zero
3237 instead. Note that this can also happen by turning the
3238 CODE_LABEL into a NOTE. */
3239 /* ??? This seems completely and utterly wrong. Certainly it's
3240 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3241 functioning even with INSN_DELETED_P and friends. */
3244 switch (GET_CODE (x
))
3247 if (GET_CODE (XEXP (x
, 0)) != PLUS
3248 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3250 tmp
= XEXP (XEXP (x
, 0), 0);
3255 if (INSN_DELETED_P (tmp
)
3256 || (GET_CODE (tmp
) == NOTE
3257 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
3268 /* First switch to correct section. */
3269 (*targetm
.asm_out
.select_rtx_section
) (pool
->mode
, x
, pool
->align
);
3271 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3272 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3273 pool
->align
, pool
->labelno
, done
);
3276 assemble_align (pool
->align
);
3278 /* Output the label. */
3279 (*targetm
.asm_out
.internal_label
) (asm_out_file
, "LC", pool
->labelno
);
3281 /* Output the value of the constant itself. */
3282 switch (GET_MODE_CLASS (pool
->mode
))
3285 if (GET_CODE (x
) != CONST_DOUBLE
)
3288 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
3289 assemble_real (r
, pool
->mode
, pool
->align
);
3293 case MODE_PARTIAL_INT
:
3294 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), pool
->align
, 1);
3297 case MODE_VECTOR_FLOAT
:
3302 if (GET_CODE (x
) != CONST_VECTOR
)
3305 units
= CONST_VECTOR_NUNITS (x
);
3307 for (i
= 0; i
< units
; i
++)
3309 elt
= CONST_VECTOR_ELT (x
, i
);
3310 REAL_VALUE_FROM_CONST_DOUBLE (r
, elt
);
3311 assemble_real (r
, GET_MODE_INNER (pool
->mode
), pool
->align
);
3316 case MODE_VECTOR_INT
:
3321 if (GET_CODE (x
) != CONST_VECTOR
)
3324 units
= CONST_VECTOR_NUNITS (x
);
3326 for (i
= 0; i
< units
; i
++)
3328 elt
= CONST_VECTOR_ELT (x
, i
);
3329 assemble_integer (elt
, GET_MODE_UNIT_SIZE (pool
->mode
),
3339 /* Make sure all constants in SECTION_MERGE and not SECTION_STRINGS
3340 sections have proper size. */
3341 if (pool
->align
> GET_MODE_BITSIZE (pool
->mode
)
3342 && in_section
== in_named
3343 && get_named_section_flags (in_named_name
) & SECTION_MERGE
)
3344 assemble_align (pool
->align
);
3346 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3351 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3352 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3355 /* Done with this pool. */
3356 first_pool
= last_pool
= 0;
3359 /* Look through the instructions for this function, and mark all the
3360 entries in the constant pool which are actually being used. Emit
3361 deferred constants which have indeed been used. */
3364 mark_constant_pool ()
3368 struct pool_constant
*pool
;
3370 if (first_pool
== 0 && n_deferred_constants
== 0)
3373 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3376 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3378 mark_constants (PATTERN (insn
));
3380 for (link
= current_function_epilogue_delay_list
;
3382 link
= XEXP (link
, 1))
3384 insn
= XEXP (link
, 0);
3387 mark_constants (PATTERN (insn
));
3391 /* Look through appropriate parts of X, marking all entries in the
3392 constant pool which are actually being used. Entries that are only
3393 referenced by other constants are also marked as used. Emit
3394 deferred strings that are used. */
3401 const char *format_ptr
;
3406 if (GET_CODE (x
) == SYMBOL_REF
)
3408 mark_constant (&x
, NULL
);
3412 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3413 insns, not any notes that may be attached. We don't want to mark
3414 a constant just because it happens to appear in a REG_EQUIV note. */
3417 mark_constants (PATTERN (x
));
3421 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3423 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3425 switch (*format_ptr
++)
3428 mark_constants (XEXP (x
, i
));
3432 if (XVEC (x
, i
) != 0)
3436 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3437 mark_constants (XVECEXP (x
, i
, j
));
3457 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3458 to as used. Emit referenced deferred strings. This function can
3459 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3462 mark_constant (current_rtx
, data
)
3464 void *data ATTRIBUTE_UNUSED
;
3466 rtx x
= *current_rtx
;
3471 else if (GET_CODE (x
) == SYMBOL_REF
)
3473 if (CONSTANT_POOL_ADDRESS_P (x
))
3475 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
3476 if (pool
->mark
== 0)
3479 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
3484 else if (TREE_CONSTANT_POOL_ADDRESS_P (x
))
3486 tree exp
= SYMBOL_REF_DECL (x
);
3487 if (!TREE_ASM_WRITTEN (exp
))
3489 n_deferred_constants
--;
3490 output_constant_def_contents (x
);
3497 /* Find all the constants whose addresses are referenced inside of EXP,
3498 and make sure assembler code with a label has been output for each one.
3499 Indicate whether an ADDR_EXPR has been encountered. */
3502 output_addressed_constants (exp
)
3505 int reloc
= 0, reloc2
;
3508 /* Give the front-end a chance to convert VALUE to something that
3509 looks more like a constant to the back-end. */
3510 exp
= (*lang_hooks
.expand_constant
) (exp
);
3512 switch (TREE_CODE (exp
))
3516 /* Go inside any operations that get_inner_reference can handle and see
3517 if what's inside is a constant: no need to do anything here for
3518 addresses of variables or functions. */
3519 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
3520 tem
= TREE_OPERAND (tem
, 0))
3523 if (TREE_CODE_CLASS (TREE_CODE (tem
)) == 'c'
3524 || TREE_CODE (tem
) == CONSTRUCTOR
)
3525 output_constant_def (tem
, 0);
3527 if (TREE_PUBLIC (tem
))
3534 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3535 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
3539 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3540 reloc2
= output_addressed_constants (TREE_OPERAND (exp
, 1));
3541 /* The difference of two local labels is computable at link time. */
3542 if (reloc
== 1 && reloc2
== 1)
3550 case NON_LVALUE_EXPR
:
3551 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3555 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
3556 if (TREE_VALUE (tem
) != 0)
3557 reloc
|= output_addressed_constants (TREE_VALUE (tem
));
3567 /* Return nonzero if VALUE is a valid constant-valued expression
3568 for use in initializing a static variable; one that can be an
3569 element of a "constant" initializer.
3571 Return null_pointer_node if the value is absolute;
3572 if it is relocatable, return the variable that determines the relocation.
3573 We assume that VALUE has been folded as much as possible;
3574 therefore, we do not need to check for such things as
3575 arithmetic-combinations of integers. */
3578 initializer_constant_valid_p (value
, endtype
)
3582 /* Give the front-end a chance to convert VALUE to something that
3583 looks more like a constant to the back-end. */
3584 value
= (*lang_hooks
.expand_constant
) (value
);
3586 switch (TREE_CODE (value
))
3589 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
3590 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
3591 && TREE_CONSTANT (value
)
3592 && CONSTRUCTOR_ELTS (value
))
3594 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
3597 return TREE_STATIC (value
) ? null_pointer_node
: 0;
3604 return null_pointer_node
;
3608 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
3610 case VIEW_CONVERT_EXPR
:
3611 case NON_LVALUE_EXPR
:
3612 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3616 /* Allow conversions between pointer types. */
3617 if (POINTER_TYPE_P (TREE_TYPE (value
))
3618 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3619 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3621 /* Allow conversions between real types. */
3622 if (FLOAT_TYPE_P (TREE_TYPE (value
))
3623 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3624 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3626 /* Allow length-preserving conversions between integer types. */
3627 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3628 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3629 && (TYPE_PRECISION (TREE_TYPE (value
))
3630 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3631 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3633 /* Allow conversions between other integer types only if
3635 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3636 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3638 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3640 if (inner
== null_pointer_node
)
3641 return null_pointer_node
;
3645 /* Allow (int) &foo provided int is as wide as a pointer. */
3646 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3647 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3648 && (TYPE_PRECISION (TREE_TYPE (value
))
3649 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3650 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3653 /* Likewise conversions from int to pointers, but also allow
3654 conversions from 0. */
3655 if (POINTER_TYPE_P (TREE_TYPE (value
))
3656 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3658 if (integer_zerop (TREE_OPERAND (value
, 0)))
3659 return null_pointer_node
;
3660 else if (TYPE_PRECISION (TREE_TYPE (value
))
3661 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
3662 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3666 /* Allow conversions to union types if the value inside is okay. */
3667 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
3668 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3673 if (! INTEGRAL_TYPE_P (endtype
)
3674 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3676 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3678 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3680 /* If either term is absolute, use the other terms relocation. */
3681 if (valid0
== null_pointer_node
)
3683 if (valid1
== null_pointer_node
)
3689 if (! INTEGRAL_TYPE_P (endtype
)
3690 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3692 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3694 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3696 /* Win if second argument is absolute. */
3697 if (valid1
== null_pointer_node
)
3699 /* Win if both arguments have the same relocation.
3700 Then the value is absolute. */
3701 if (valid0
== valid1
&& valid0
!= 0)
3702 return null_pointer_node
;
3704 /* Since GCC guarantees that string constants are unique in the
3705 generated code, a subtraction between two copies of the same
3706 constant string is absolute. */
3707 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
&&
3708 valid1
&& TREE_CODE (valid1
) == STRING_CST
&&
3709 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
3710 return null_pointer_node
;
3713 /* Support differences between labels. */
3714 if (INTEGRAL_TYPE_P (endtype
))
3717 op0
= TREE_OPERAND (value
, 0);
3718 op1
= TREE_OPERAND (value
, 1);
3720 /* Like STRIP_NOPS except allow the operand mode to widen.
3721 This works around a feature of fold that simplifies
3722 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3723 that the narrower operation is cheaper. */
3725 while (TREE_CODE (op0
) == NOP_EXPR
3726 || TREE_CODE (op0
) == CONVERT_EXPR
3727 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3729 tree inner
= TREE_OPERAND (op0
, 0);
3730 if (inner
== error_mark_node
3731 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3732 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
3733 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3738 while (TREE_CODE (op1
) == NOP_EXPR
3739 || TREE_CODE (op1
) == CONVERT_EXPR
3740 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
3742 tree inner
= TREE_OPERAND (op1
, 0);
3743 if (inner
== error_mark_node
3744 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3745 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
3746 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3751 if (TREE_CODE (op0
) == ADDR_EXPR
3752 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
3753 && TREE_CODE (op1
) == ADDR_EXPR
3754 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
3755 return null_pointer_node
;
3766 /* Output assembler code for constant EXP to FILE, with no label.
3767 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3768 Assumes output_addressed_constants has been done on EXP already.
3770 Generate exactly SIZE bytes of assembler data, padding at the end
3771 with zeros if necessary. SIZE must always be specified.
3773 SIZE is important for structure constructors,
3774 since trailing members may have been omitted from the constructor.
3775 It is also important for initialization of arrays from string constants
3776 since the full length of the string constant might not be wanted.
3777 It is also needed for initialization of unions, where the initializer's
3778 type is just one member, and that may not be as long as the union.
3780 There a case in which we would fail to output exactly SIZE bytes:
3781 for a structure constructor that wants to produce more than SIZE bytes.
3782 But such constructors will never be generated for any possible input.
3784 ALIGN is the alignment of the data in bits. */
3787 output_constant (exp
, size
, align
)
3789 unsigned HOST_WIDE_INT size
;
3792 enum tree_code code
;
3793 unsigned HOST_WIDE_INT thissize
;
3795 /* Some front-ends use constants other than the standard language-independent
3796 varieties, but which may still be output directly. Give the front-end a
3797 chance to convert EXP to a language-independent representation. */
3798 exp
= (*lang_hooks
.expand_constant
) (exp
);
3800 if (size
== 0 || flag_syntax_only
)
3803 /* Eliminate any conversions since we'll be outputting the underlying
3805 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
3806 || TREE_CODE (exp
) == NON_LVALUE_EXPR
3807 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
3808 exp
= TREE_OPERAND (exp
, 0);
3810 code
= TREE_CODE (TREE_TYPE (exp
));
3811 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
3813 /* Allow a constructor with no elements for any data type.
3814 This means to fill the space with zeros. */
3815 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
3817 assemble_zeros (size
);
3821 if (TREE_CODE (exp
) == FDESC_EXPR
)
3823 #ifdef ASM_OUTPUT_FDESC
3824 HOST_WIDE_INT part
= tree_low_cst (TREE_OPERAND (exp
, 1), 0);
3825 tree decl
= TREE_OPERAND (exp
, 0);
3826 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
3833 /* Now output the underlying data. If we've handling the padding, return.
3834 Otherwise, break and ensure THISSIZE is the size written. */
3842 case REFERENCE_TYPE
:
3843 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
3844 EXPAND_INITIALIZER
),
3846 error ("initializer for integer value is too complicated");
3850 if (TREE_CODE (exp
) != REAL_CST
)
3851 error ("initializer for floating value is not a floating constant");
3853 assemble_real (TREE_REAL_CST (exp
),
3854 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0),
3859 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
3860 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
3861 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
3866 if (TREE_CODE (exp
) == CONSTRUCTOR
)
3868 output_constructor (exp
, size
, align
);
3871 else if (TREE_CODE (exp
) == STRING_CST
)
3873 thissize
= MIN ((unsigned HOST_WIDE_INT
)TREE_STRING_LENGTH (exp
),
3875 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
3877 else if (TREE_CODE (exp
) == VECTOR_CST
)
3881 unsigned int nalign
;
3882 enum machine_mode inner
;
3884 inner
= GET_MODE_INNER (TYPE_MODE (TREE_TYPE (exp
)));
3885 nalign
= MIN (align
, GET_MODE_ALIGNMENT (inner
));
3887 elt_size
= GET_MODE_UNIT_SIZE (TYPE_MODE (TREE_TYPE (exp
)));
3889 link
= TREE_VECTOR_CST_ELTS (exp
);
3890 output_constant (TREE_VALUE (link
), elt_size
, align
);
3891 while ((link
= TREE_CHAIN (link
)) != NULL
)
3892 output_constant (TREE_VALUE (link
), elt_size
, nalign
);
3900 if (TREE_CODE (exp
) == CONSTRUCTOR
)
3901 output_constructor (exp
, size
, align
);
3907 if (TREE_CODE (exp
) == INTEGER_CST
)
3908 assemble_integer (expand_expr (exp
, NULL_RTX
,
3909 VOIDmode
, EXPAND_INITIALIZER
),
3910 thissize
, align
, 1);
3911 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
3913 unsigned char *buffer
= (unsigned char *) alloca (thissize
);
3914 if (get_set_constructor_bytes (exp
, buffer
, thissize
))
3916 assemble_string ((char *) buffer
, thissize
);
3919 error ("unknown set constructor type");
3929 if (size
> thissize
)
3930 assemble_zeros (size
- thissize
);
3934 /* Subroutine of output_constructor, used for computing the size of
3935 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
3936 type with an unspecified upper bound. */
3938 static unsigned HOST_WIDE_INT
3939 array_size_for_constructor (val
)
3944 /* This code used to attempt to handle string constants that are not
3945 arrays of single-bytes, but nothing else does, so there's no point in
3947 if (TREE_CODE (val
) == STRING_CST
)
3948 return TREE_STRING_LENGTH (val
);
3950 max_index
= NULL_TREE
;
3951 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
3953 tree index
= TREE_PURPOSE (i
);
3955 if (TREE_CODE (index
) == RANGE_EXPR
)
3956 index
= TREE_OPERAND (index
, 1);
3957 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
3961 if (max_index
== NULL_TREE
)
3964 /* Compute the total number of array elements. */
3965 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
3967 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
3968 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
3970 /* Multiply by the array element unit size to find number of bytes. */
3971 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
3973 return tree_low_cst (i
, 1);
3976 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
3977 Generate at least SIZE bytes, padding if necessary. */
3980 output_constructor (exp
, size
, align
)
3982 unsigned HOST_WIDE_INT size
;
3985 tree type
= TREE_TYPE (exp
);
3986 tree link
, field
= 0;
3988 /* Number of bytes output or skipped so far.
3989 In other words, current position within the constructor. */
3990 HOST_WIDE_INT total_bytes
= 0;
3991 /* Nonzero means BYTE contains part of a byte, to be output. */
3992 int byte_buffer_in_use
= 0;
3995 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
3998 if (TREE_CODE (type
) == RECORD_TYPE
)
3999 field
= TYPE_FIELDS (type
);
4001 if (TREE_CODE (type
) == ARRAY_TYPE
4002 && TYPE_DOMAIN (type
) != 0)
4003 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4005 /* As LINK goes through the elements of the constant,
4006 FIELD goes through the structure fields, if the constant is a structure.
4007 if the constant is a union, then we override this,
4008 by getting the field from the TREE_LIST element.
4009 But the constant could also be an array. Then FIELD is zero.
4011 There is always a maximum of one element in the chain LINK for unions
4012 (even if the initializer in a source program incorrectly contains
4014 for (link
= CONSTRUCTOR_ELTS (exp
);
4016 link
= TREE_CHAIN (link
),
4017 field
= field
? TREE_CHAIN (field
) : 0)
4019 tree val
= TREE_VALUE (link
);
4022 /* The element in a union constructor specifies the proper field
4024 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4025 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4026 && TREE_PURPOSE (link
) != 0)
4027 field
= TREE_PURPOSE (link
);
4029 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4030 index
= TREE_PURPOSE (link
);
4032 /* Eliminate the marker that makes a cast not be an lvalue. */
4036 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4038 unsigned HOST_WIDE_INT fieldsize
4039 = int_size_in_bytes (TREE_TYPE (type
));
4040 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4041 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4042 HOST_WIDE_INT index
;
4043 unsigned int align2
= min_align (align
, fieldsize
* BITS_PER_UNIT
);
4045 for (index
= lo_index
; index
<= hi_index
; index
++)
4047 /* Output the element's initial value. */
4049 assemble_zeros (fieldsize
);
4051 output_constant (val
, fieldsize
, align2
);
4053 /* Count its size. */
4054 total_bytes
+= fieldsize
;
4057 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4059 /* An element that is not a bit-field. */
4061 unsigned HOST_WIDE_INT fieldsize
;
4062 /* Since this structure is static,
4063 we know the positions are constant. */
4064 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4065 unsigned int align2
;
4068 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4069 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4071 /* Output any buffered-up bit-fields preceding this element. */
4072 if (byte_buffer_in_use
)
4074 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4076 byte_buffer_in_use
= 0;
4079 /* Advance to offset of this element.
4080 Note no alignment needed in an array, since that is guaranteed
4081 if each element has the proper size. */
4082 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4084 assemble_zeros (pos
- total_bytes
);
4088 /* Find the alignment of this element. */
4089 align2
= min_align (align
, BITS_PER_UNIT
* pos
);
4091 /* Determine size this element should occupy. */
4096 /* If this is an array with an unspecified upper bound,
4097 the initializer determines the size. */
4098 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4099 but we cannot do this until the deprecated support for
4100 initializing zero-length array members is removed. */
4101 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4102 && TYPE_DOMAIN (TREE_TYPE (field
))
4103 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4105 fieldsize
= array_size_for_constructor (val
);
4106 /* Given a non-empty initialization, this field had
4108 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4111 else if (DECL_SIZE_UNIT (field
))
4113 /* ??? This can't be right. If the decl size overflows
4114 a host integer we will silently emit no data. */
4115 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4116 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4120 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4122 /* Output the element's initial value. */
4124 assemble_zeros (fieldsize
);
4126 output_constant (val
, fieldsize
, align2
);
4128 /* Count its size. */
4129 total_bytes
+= fieldsize
;
4131 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4132 error ("invalid initial value for member `%s'",
4133 IDENTIFIER_POINTER (DECL_NAME (field
)));
4136 /* Element that is a bit-field. */
4138 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4139 HOST_WIDE_INT end_offset
4140 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4143 val
= integer_zero_node
;
4145 /* If this field does not start in this (or, next) byte,
4147 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4149 /* Output remnant of any bit field in previous bytes. */
4150 if (byte_buffer_in_use
)
4152 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4154 byte_buffer_in_use
= 0;
4157 /* If still not at proper byte, advance to there. */
4158 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4160 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4161 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4165 if (! byte_buffer_in_use
)
4168 /* We must split the element into pieces that fall within
4169 separate bytes, and combine each byte with previous or
4170 following bit-fields. */
4172 /* next_offset is the offset n fbits from the beginning of
4173 the structure to the next bit of this element to be processed.
4174 end_offset is the offset of the first bit past the end of
4176 while (next_offset
< end_offset
)
4180 HOST_WIDE_INT value
;
4181 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4182 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4184 /* Advance from byte to byte
4185 within this element when necessary. */
4186 while (next_byte
!= total_bytes
)
4188 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4193 /* Number of bits we can process at once
4194 (all part of the same byte). */
4195 this_time
= MIN (end_offset
- next_offset
,
4196 BITS_PER_UNIT
- next_bit
);
4197 if (BYTES_BIG_ENDIAN
)
4199 /* On big-endian machine, take the most significant bits
4200 first (of the bits that are significant)
4201 and put them into bytes from the most significant end. */
4202 shift
= end_offset
- next_offset
- this_time
;
4204 /* Don't try to take a bunch of bits that cross
4205 the word boundary in the INTEGER_CST. We can
4206 only select bits from the LOW or HIGH part
4208 if (shift
< HOST_BITS_PER_WIDE_INT
4209 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4211 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4212 shift
= HOST_BITS_PER_WIDE_INT
;
4215 /* Now get the bits from the appropriate constant word. */
4216 if (shift
< HOST_BITS_PER_WIDE_INT
)
4217 value
= TREE_INT_CST_LOW (val
);
4218 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4220 value
= TREE_INT_CST_HIGH (val
);
4221 shift
-= HOST_BITS_PER_WIDE_INT
;
4226 /* Get the result. This works only when:
4227 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4228 byte
|= (((value
>> shift
)
4229 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4230 << (BITS_PER_UNIT
- this_time
- next_bit
));
4234 /* On little-endian machines,
4235 take first the least significant bits of the value
4236 and pack them starting at the least significant
4237 bits of the bytes. */
4238 shift
= next_offset
- int_bit_position (field
);
4240 /* Don't try to take a bunch of bits that cross
4241 the word boundary in the INTEGER_CST. We can
4242 only select bits from the LOW or HIGH part
4244 if (shift
< HOST_BITS_PER_WIDE_INT
4245 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4246 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4248 /* Now get the bits from the appropriate constant word. */
4249 if (shift
< HOST_BITS_PER_WIDE_INT
)
4250 value
= TREE_INT_CST_LOW (val
);
4251 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4253 value
= TREE_INT_CST_HIGH (val
);
4254 shift
-= HOST_BITS_PER_WIDE_INT
;
4259 /* Get the result. This works only when:
4260 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4261 byte
|= (((value
>> shift
)
4262 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4266 next_offset
+= this_time
;
4267 byte_buffer_in_use
= 1;
4272 if (byte_buffer_in_use
)
4274 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4278 if ((unsigned HOST_WIDE_INT
)total_bytes
< size
)
4279 assemble_zeros (size
- total_bytes
);
4282 /* This TREE_LIST contains any weak symbol declarations waiting
4284 static GTY(()) tree weak_decls
;
4286 /* Mark DECL as weak. */
4292 DECL_WEAK (decl
) = 1;
4294 if (DECL_RTL_SET_P (decl
)
4295 && GET_CODE (DECL_RTL (decl
)) == MEM
4296 && XEXP (DECL_RTL (decl
), 0)
4297 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
4298 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
4301 /* Merge weak status between NEWDECL and OLDDECL. */
4304 merge_weak (newdecl
, olddecl
)
4308 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
4311 if (DECL_WEAK (newdecl
))
4315 /* NEWDECL is weak, but OLDDECL is not. */
4317 /* If we already output the OLDDECL, we're in trouble; we can't
4318 go back and make it weak. This error cannot caught in
4319 declare_weak because the NEWDECL and OLDDECL was not yet
4320 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4321 if (TREE_ASM_WRITTEN (olddecl
))
4322 error_with_decl (newdecl
,
4323 "weak declaration of `%s' must precede definition");
4325 /* If we've already generated rtl referencing OLDDECL, we may
4326 have done so in a way that will not function properly with
4328 else if (TREE_USED (olddecl
)
4329 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)))
4330 warning_with_decl (newdecl
, "weak declaration of `%s' after first use results in unspecified behavior");
4334 /* We put the NEWDECL on the weak_decls list at some point.
4335 Replace it with the OLDDECL. */
4336 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
4337 if (TREE_VALUE (wd
) == newdecl
)
4339 TREE_VALUE (wd
) = olddecl
;
4342 /* We may not find the entry on the list. If NEWDECL is a
4343 weak alias, then we will have already called
4344 globalize_decl to remove the entry; in that case, we do
4345 not need to do anything. */
4348 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4349 mark_weak (olddecl
);
4352 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4353 weak. Just update NEWDECL to indicate that it's weak too. */
4354 mark_weak (newdecl
);
4357 /* Declare DECL to be a weak symbol. */
4363 if (! TREE_PUBLIC (decl
))
4364 error_with_decl (decl
, "weak declaration of `%s' must be public");
4365 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
4366 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4367 else if (SUPPORTS_WEAK
)
4369 if (! DECL_WEAK (decl
))
4370 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
4373 warning_with_decl (decl
, "weak declaration of `%s' not supported");
4378 /* Emit any pending weak declarations. */
4385 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
4387 tree decl
= TREE_VALUE (t
);
4388 #if defined (ASM_WEAKEN_DECL) || defined (ASM_WEAKEN_LABEL)
4389 const char *const name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4392 if (! TREE_USED (decl
))
4395 #ifdef ASM_WEAKEN_DECL
4396 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
4398 #ifdef ASM_WEAKEN_LABEL
4399 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4401 #ifdef ASM_OUTPUT_WEAK_ALIAS
4402 warning ("only weak aliases are supported in this configuration");
4410 /* Emit the assembly bits to indicate that DECL is globally visible. */
4413 globalize_decl (decl
)
4416 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
4418 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4419 if (DECL_WEAK (decl
))
4423 #ifdef ASM_WEAKEN_DECL
4424 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
4426 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4429 /* Remove this function from the pending weak list so that
4430 we do not emit multiple .weak directives for it. */
4431 for (p
= &weak_decls
; (t
= *p
) ; )
4433 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
4434 *p
= TREE_CHAIN (t
);
4436 p
= &TREE_CHAIN (t
);
4442 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, name
);
4445 /* Emit an assembler directive to make the symbol for DECL an alias to
4446 the symbol for TARGET. */
4449 assemble_alias (decl
, target
)
4450 tree decl
, target ATTRIBUTE_UNUSED
;
4454 /* We must force creation of DECL_RTL for debug info generation, even though
4455 we don't use it here. */
4456 make_decl_rtl (decl
, NULL
);
4458 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4460 #ifdef ASM_OUTPUT_DEF
4461 /* Make name accessible from other files, if appropriate. */
4463 if (TREE_PUBLIC (decl
))
4465 globalize_decl (decl
);
4466 maybe_assemble_visibility (decl
);
4469 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4470 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4472 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4474 #else /* !ASM_OUTPUT_DEF */
4475 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4476 if (! DECL_WEAK (decl
))
4477 warning ("only weak aliases are supported in this configuration");
4479 #ifdef ASM_WEAKEN_DECL
4480 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
4482 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4485 warning ("alias definitions not supported in this configuration; ignored");
4489 TREE_USED (decl
) = 1;
4490 TREE_ASM_WRITTEN (decl
) = 1;
4491 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
4494 /* Emit an assembler directive to set symbol for DECL visibility to
4495 the visibility type VIS, which must not be VISIBILITY_DEFAULT. */
4498 default_assemble_visibility (decl
, vis
)
4502 static const char * const visibility_types
[] = {
4503 NULL
, "internal", "hidden", "protected"
4506 const char *name
, *type
;
4508 name
= (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4509 type
= visibility_types
[vis
];
4511 #ifdef HAVE_GAS_HIDDEN
4512 fprintf (asm_out_file
, "\t.%s\t", type
);
4513 assemble_name (asm_out_file
, name
);
4514 fprintf (asm_out_file
, "\n");
4516 warning ("visibility attribute not supported in this configuration; ignored");
4520 /* A helper function to call assemble_visibility when needed for a decl. */
4523 maybe_assemble_visibility (decl
)
4526 enum symbol_visibility vis
= decl_visibility (decl
);
4528 if (vis
!= VISIBILITY_DEFAULT
)
4529 (* targetm
.asm_out
.visibility
) (decl
, vis
);
4532 /* Returns 1 if the target configuration supports defining public symbols
4533 so that one of them will be chosen at link time instead of generating a
4534 multiply-defined symbol error, whether through the use of weak symbols or
4535 a target-specific mechanism for having duplicates discarded. */
4538 supports_one_only ()
4540 if (SUPPORTS_ONE_ONLY
)
4542 return SUPPORTS_WEAK
;
4545 /* Set up DECL as a public symbol that can be defined in multiple
4546 translation units without generating a linker error. */
4549 make_decl_one_only (decl
)
4552 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4555 TREE_PUBLIC (decl
) = 1;
4557 if (TREE_CODE (decl
) == VAR_DECL
4558 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4559 DECL_COMMON (decl
) = 1;
4560 else if (SUPPORTS_ONE_ONLY
)
4562 #ifdef MAKE_DECL_ONE_ONLY
4563 MAKE_DECL_ONE_ONLY (decl
);
4565 DECL_ONE_ONLY (decl
) = 1;
4567 else if (SUPPORTS_WEAK
)
4568 DECL_WEAK (decl
) = 1;
4576 in_named_htab
= htab_create_ggc (31, in_named_entry_hash
,
4577 in_named_entry_eq
, NULL
);
4578 const_desc_htab
= htab_create_ggc (1009, const_desc_hash
,
4579 const_desc_eq
, NULL
);
4581 const_alias_set
= new_alias_set ();
4585 decl_tls_model (decl
)
4588 enum tls_model kind
;
4589 tree attr
= lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl
));
4594 attr
= TREE_VALUE (TREE_VALUE (attr
));
4595 if (TREE_CODE (attr
) != STRING_CST
)
4597 if (!strcmp (TREE_STRING_POINTER (attr
), "local-exec"))
4598 kind
= TLS_MODEL_LOCAL_EXEC
;
4599 else if (!strcmp (TREE_STRING_POINTER (attr
), "initial-exec"))
4600 kind
= TLS_MODEL_INITIAL_EXEC
;
4601 else if (!strcmp (TREE_STRING_POINTER (attr
), "local-dynamic"))
4602 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
4603 else if (!strcmp (TREE_STRING_POINTER (attr
), "global-dynamic"))
4604 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4610 is_local
= (*targetm
.binds_local_p
) (decl
);
4614 kind
= TLS_MODEL_LOCAL_EXEC
;
4616 kind
= TLS_MODEL_INITIAL_EXEC
;
4618 /* Local dynamic is inefficient when we're not combining the
4619 parts of the address. */
4620 else if (optimize
&& is_local
)
4621 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
4623 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4624 if (kind
< flag_tls_default
)
4625 kind
= flag_tls_default
;
4630 enum symbol_visibility
4631 decl_visibility (decl
)
4634 tree attr
= lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
));
4638 const char *which
= TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (attr
)));
4640 if (strcmp (which
, "default") == 0)
4641 return VISIBILITY_DEFAULT
;
4642 if (strcmp (which
, "internal") == 0)
4643 return VISIBILITY_INTERNAL
;
4644 if (strcmp (which
, "hidden") == 0)
4645 return VISIBILITY_HIDDEN
;
4646 if (strcmp (which
, "protected") == 0)
4647 return VISIBILITY_PROTECTED
;
4652 return VISIBILITY_DEFAULT
;
4655 /* Select a set of attributes for section NAME based on the properties
4656 of DECL and whether or not RELOC indicates that DECL's initializer
4657 might contain runtime relocations.
4659 We make the section read-only and executable for a function decl,
4660 read-only for a const data decl, and writable for a non-const data decl. */
4663 default_section_type_flags (decl
, name
, reloc
)
4668 return default_section_type_flags_1 (decl
, name
, reloc
, flag_pic
);
4672 default_section_type_flags_1 (decl
, name
, reloc
, shlib
)
4680 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4681 flags
= SECTION_CODE
;
4682 else if (decl
&& decl_readonly_section_1 (decl
, reloc
, shlib
))
4685 flags
= SECTION_WRITE
;
4687 if (decl
&& DECL_ONE_ONLY (decl
))
4688 flags
|= SECTION_LINKONCE
;
4690 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4691 flags
|= SECTION_TLS
| SECTION_WRITE
;
4693 if (strcmp (name
, ".bss") == 0
4694 || strncmp (name
, ".bss.", 5) == 0
4695 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4696 || strcmp (name
, ".sbss") == 0
4697 || strncmp (name
, ".sbss.", 6) == 0
4698 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0
4699 || strcmp (name
, ".tbss") == 0
4700 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4701 flags
|= SECTION_BSS
;
4703 if (strcmp (name
, ".tdata") == 0
4704 || strcmp (name
, ".tbss") == 0
4705 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0
4706 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4707 flags
|= SECTION_TLS
;
4709 /* These three sections have special ELF types. They are neither
4710 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4711 want to print a section type (@progbits or @nobits). If someone
4712 is silly enough to emit code or TLS variables to one of these
4713 sections, then don't handle them specially. */
4714 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
4715 && (strcmp (name
, ".init_array") == 0
4716 || strcmp (name
, ".fini_array") == 0
4717 || strcmp (name
, ".preinit_array") == 0))
4718 flags
|= SECTION_NOTYPE
;
4723 /* Output assembly to switch to section NAME with attribute FLAGS.
4724 Four variants for common object file formats. */
4727 default_no_named_section (name
, flags
)
4728 const char *name ATTRIBUTE_UNUSED
;
4729 unsigned int flags ATTRIBUTE_UNUSED
;
4731 /* Some object formats don't support named sections at all. The
4732 front-end should already have flagged this as an error. */
4737 default_elf_asm_named_section (name
, flags
)
4741 char flagchars
[10], *f
= flagchars
;
4743 if (! named_section_first_declaration (name
))
4745 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
4749 if (!(flags
& SECTION_DEBUG
))
4751 if (flags
& SECTION_WRITE
)
4753 if (flags
& SECTION_CODE
)
4755 if (flags
& SECTION_SMALL
)
4757 if (flags
& SECTION_MERGE
)
4759 if (flags
& SECTION_STRINGS
)
4761 if (flags
& SECTION_TLS
)
4765 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
4767 if (!(flags
& SECTION_NOTYPE
))
4771 if (flags
& SECTION_BSS
)
4776 fprintf (asm_out_file
, ",@%s", type
);
4778 if (flags
& SECTION_ENTSIZE
)
4779 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
4782 putc ('\n', asm_out_file
);
4786 default_coff_asm_named_section (name
, flags
)
4790 char flagchars
[8], *f
= flagchars
;
4792 if (flags
& SECTION_WRITE
)
4794 if (flags
& SECTION_CODE
)
4798 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
4802 default_pe_asm_named_section (name
, flags
)
4806 default_coff_asm_named_section (name
, flags
);
4808 if (flags
& SECTION_LINKONCE
)
4810 /* Functions may have been compiled at various levels of
4811 optimization so we can't use `same_size' here.
4812 Instead, have the linker pick one. */
4813 fprintf (asm_out_file
, "\t.linkonce %s\n",
4814 (flags
& SECTION_CODE
? "discard" : "same_size"));
4818 /* Used for vtable gc in GNU binutils. Record that the pointer at OFFSET
4819 from SYMBOL is used in all classes derived from SYMBOL. */
4822 assemble_vtable_entry (symbol
, offset
)
4824 HOST_WIDE_INT offset
;
4826 fputs ("\t.vtable_entry ", asm_out_file
);
4827 output_addr_const (asm_out_file
, symbol
);
4828 fprintf (asm_out_file
, ", " HOST_WIDE_INT_PRINT_DEC
"\n", offset
);
4831 /* Used for vtable gc in GNU binutils. Record the class hierarchy by noting
4832 that the vtable symbol CHILD is derived from the vtable symbol PARENT. */
4835 assemble_vtable_inherit (child
, parent
)
4838 fputs ("\t.vtable_inherit ", asm_out_file
);
4839 output_addr_const (asm_out_file
, child
);
4840 fputs (", ", asm_out_file
);
4841 output_addr_const (asm_out_file
, parent
);
4842 fputc ('\n', asm_out_file
);
4845 /* The lame default section selector. */
4848 default_select_section (decl
, reloc
, align
)
4851 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
4853 bool readonly
= false;
4857 if (decl_readonly_section (decl
, reloc
))
4860 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4862 if (! ((flag_pic
&& reloc
)
4863 || !TREE_READONLY (decl
)
4864 || TREE_SIDE_EFFECTS (decl
)
4865 || !TREE_CONSTANT (decl
)))
4868 else if (TREE_CODE (decl
) == STRING_CST
)
4869 readonly
= !flag_writable_strings
;
4870 else if (! (flag_pic
&& reloc
))
4874 readonly_data_section ();
4879 /* A helper function for default_elf_select_section and
4880 default_elf_unique_section. Categorizes the DECL. */
4882 enum section_category
4887 SECCAT_RODATA_MERGE_STR
,
4888 SECCAT_RODATA_MERGE_STR_INIT
,
4889 SECCAT_RODATA_MERGE_CONST
,
4894 /* To optimize loading of shared programs, define following subsections
4896 _REL Contains data that has relocations, so they get grouped
4897 together and dynamic linker will visit fewer pages in memory.
4898 _RO Contains data that is otherwise read-only. This is useful
4899 with prelinking as most relocations won't be dynamically
4900 linked and thus stay read only.
4901 _LOCAL Marks data containing relocations only to local objects.
4902 These relocations will get fully resolved by prelinking. */
4904 SECCAT_DATA_REL_LOCAL
,
4906 SECCAT_DATA_REL_RO_LOCAL
,
4916 static enum section_category
4917 categorize_decl_for_section
PARAMS ((tree
, int, int));
4919 static enum section_category
4920 categorize_decl_for_section (decl
, reloc
, shlib
)
4925 enum section_category ret
;
4927 if (TREE_CODE (decl
) == FUNCTION_DECL
)
4929 else if (TREE_CODE (decl
) == STRING_CST
)
4931 if (flag_writable_strings
)
4934 return SECCAT_RODATA_MERGE_STR
;
4936 else if (TREE_CODE (decl
) == VAR_DECL
)
4938 if (DECL_INITIAL (decl
) == NULL
4939 || DECL_INITIAL (decl
) == error_mark_node
)
4941 else if (! TREE_READONLY (decl
)
4942 || TREE_SIDE_EFFECTS (decl
)
4943 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
4945 if (shlib
&& (reloc
& 2))
4946 ret
= SECCAT_DATA_REL
;
4947 else if (shlib
&& reloc
)
4948 ret
= SECCAT_DATA_REL_LOCAL
;
4952 else if (shlib
&& (reloc
& 2))
4953 ret
= SECCAT_DATA_REL_RO
;
4954 else if (shlib
&& reloc
)
4955 ret
= SECCAT_DATA_REL_RO_LOCAL
;
4956 else if (reloc
|| flag_merge_constants
< 2)
4957 /* C and C++ don't allow different variables to share the same
4958 location. -fmerge-all-constants allows even that (at the
4959 expense of not conforming). */
4960 ret
= SECCAT_RODATA
;
4961 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
4962 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
4964 ret
= SECCAT_RODATA_MERGE_CONST
;
4966 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4968 if ((shlib
&& reloc
)
4969 || TREE_SIDE_EFFECTS (decl
)
4970 || ! TREE_CONSTANT (decl
))
4973 ret
= SECCAT_RODATA
;
4976 ret
= SECCAT_RODATA
;
4978 /* There are no read-only thread-local sections. */
4979 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4981 if (ret
== SECCAT_BSS
)
4987 /* If the target uses small data sections, select it. */
4988 else if ((*targetm
.in_small_data_p
) (decl
))
4990 if (ret
== SECCAT_BSS
)
4992 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
4993 ret
= SECCAT_SRODATA
;
5002 decl_readonly_section (decl
, reloc
)
5006 return decl_readonly_section_1 (decl
, reloc
, flag_pic
);
5010 decl_readonly_section_1 (decl
, reloc
, shlib
)
5015 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5018 case SECCAT_RODATA_MERGE_STR
:
5019 case SECCAT_RODATA_MERGE_STR_INIT
:
5020 case SECCAT_RODATA_MERGE_CONST
:
5021 case SECCAT_SRODATA
:
5030 /* Select a section based on the above categorization. */
5033 default_elf_select_section (decl
, reloc
, align
)
5036 unsigned HOST_WIDE_INT align
;
5038 default_elf_select_section_1 (decl
, reloc
, align
, flag_pic
);
5042 default_elf_select_section_1 (decl
, reloc
, align
, shlib
)
5045 unsigned HOST_WIDE_INT align
;
5048 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5051 /* We're not supposed to be called on FUNCTION_DECLs. */
5054 readonly_data_section ();
5056 case SECCAT_RODATA_MERGE_STR
:
5057 mergeable_string_section (decl
, align
, 0);
5059 case SECCAT_RODATA_MERGE_STR_INIT
:
5060 mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
5062 case SECCAT_RODATA_MERGE_CONST
:
5063 mergeable_constant_section (DECL_MODE (decl
), align
, 0);
5065 case SECCAT_SRODATA
:
5066 named_section (NULL_TREE
, ".sdata2", reloc
);
5071 case SECCAT_DATA_REL
:
5072 named_section (NULL_TREE
, ".data.rel", reloc
);
5074 case SECCAT_DATA_REL_LOCAL
:
5075 named_section (NULL_TREE
, ".data.rel.local", reloc
);
5077 case SECCAT_DATA_REL_RO
:
5078 named_section (NULL_TREE
, ".data.rel.ro", reloc
);
5080 case SECCAT_DATA_REL_RO_LOCAL
:
5081 named_section (NULL_TREE
, ".data.rel.ro.local", reloc
);
5084 named_section (NULL_TREE
, ".sdata", reloc
);
5087 named_section (NULL_TREE
, ".tdata", reloc
);
5090 #ifdef BSS_SECTION_ASM_OP
5093 named_section (NULL_TREE
, ".bss", reloc
);
5097 named_section (NULL_TREE
, ".sbss", reloc
);
5100 named_section (NULL_TREE
, ".tbss", reloc
);
5107 /* Construct a unique section name based on the decl name and the
5108 categorization performed above. */
5111 default_unique_section (decl
, reloc
)
5115 default_unique_section_1 (decl
, reloc
, flag_pic
);
5119 default_unique_section_1 (decl
, reloc
, shlib
)
5124 bool one_only
= DECL_ONE_ONLY (decl
);
5125 const char *prefix
, *name
;
5129 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5132 prefix
= one_only
? ".gnu.linkonce.t." : ".text.";
5135 case SECCAT_RODATA_MERGE_STR
:
5136 case SECCAT_RODATA_MERGE_STR_INIT
:
5137 case SECCAT_RODATA_MERGE_CONST
:
5138 prefix
= one_only
? ".gnu.linkonce.r." : ".rodata.";
5140 case SECCAT_SRODATA
:
5141 prefix
= one_only
? ".gnu.linkonce.s2." : ".sdata2.";
5144 case SECCAT_DATA_REL
:
5145 case SECCAT_DATA_REL_LOCAL
:
5146 case SECCAT_DATA_REL_RO
:
5147 case SECCAT_DATA_REL_RO_LOCAL
:
5148 prefix
= one_only
? ".gnu.linkonce.d." : ".data.";
5151 prefix
= one_only
? ".gnu.linkonce.s." : ".sdata.";
5154 prefix
= one_only
? ".gnu.linkonce.b." : ".bss.";
5157 prefix
= one_only
? ".gnu.linkonce.sb." : ".sbss.";
5160 prefix
= one_only
? ".gnu.linkonce.td." : ".tdata.";
5163 prefix
= one_only
? ".gnu.linkonce.tb." : ".tbss.";
5168 plen
= strlen (prefix
);
5170 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5171 name
= (* targetm
.strip_name_encoding
) (name
);
5172 nlen
= strlen (name
);
5174 string
= alloca (nlen
+ plen
+ 1);
5175 memcpy (string
, prefix
, plen
);
5176 memcpy (string
+ plen
, name
, nlen
+ 1);
5178 DECL_SECTION_NAME (decl
) = build_string (nlen
+ plen
, string
);
5182 default_select_rtx_section (mode
, x
, align
)
5183 enum machine_mode mode ATTRIBUTE_UNUSED
;
5185 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
5188 switch (GET_CODE (x
))
5200 readonly_data_section ();
5204 default_elf_select_rtx_section (mode
, x
, align
)
5205 enum machine_mode mode
;
5207 unsigned HOST_WIDE_INT align
;
5209 /* ??? Handle small data here somehow. */
5212 switch (GET_CODE (x
))
5216 named_section (NULL_TREE
, ".data.rel.ro", 3);
5220 named_section (NULL_TREE
, ".data.rel.ro.local", 1);
5227 mergeable_constant_section (mode
, align
, 0);
5230 /* Set the generally applicable flags on the SYMBOL_REF for EXP. */
5233 default_encode_section_info (decl
, rtl
, first
)
5236 int first ATTRIBUTE_UNUSED
;
5241 /* Careful not to prod global register variables. */
5242 if (GET_CODE (rtl
) != MEM
)
5244 symbol
= XEXP (rtl
, 0);
5245 if (GET_CODE (symbol
) != SYMBOL_REF
)
5249 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5250 flags
|= SYMBOL_FLAG_FUNCTION
;
5251 if ((*targetm
.binds_local_p
) (decl
))
5252 flags
|= SYMBOL_FLAG_LOCAL
;
5253 if ((*targetm
.in_small_data_p
) (decl
))
5254 flags
|= SYMBOL_FLAG_SMALL
;
5255 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
5256 flags
|= decl_tls_model (decl
) << SYMBOL_FLAG_TLS_SHIFT
;
5257 /* ??? Why is DECL_EXTERNAL ever set for non-PUBLIC names? Without
5258 being PUBLIC, the thing *must* be defined in this translation unit.
5259 Prevent this buglet from being propagated into rtl code as well. */
5260 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
5261 flags
|= SYMBOL_FLAG_EXTERNAL
;
5263 SYMBOL_REF_FLAGS (symbol
) = flags
;
5266 /* By default, we do nothing for encode_section_info, so we need not
5267 do anything but discard the '*' marker. */
5270 default_strip_name_encoding (str
)
5273 return str
+ (*str
== '*');
5276 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5277 wrt cross-module name binding. */
5280 default_binds_local_p (exp
)
5283 return default_binds_local_p_1 (exp
, flag_pic
);
5287 default_binds_local_p_1 (exp
, shlib
)
5293 /* A non-decl is an entry in the constant pool. */
5296 /* Static variables are always local. */
5297 else if (! TREE_PUBLIC (exp
))
5299 /* A variable is local if the user tells us so. */
5300 else if (decl_visibility (exp
) != VISIBILITY_DEFAULT
)
5302 /* Otherwise, variables defined outside this object may not be local. */
5303 else if (DECL_EXTERNAL (exp
))
5305 /* Linkonce and weak data are never local. */
5306 else if (DECL_ONE_ONLY (exp
) || DECL_WEAK (exp
))
5308 /* If PIC, then assume that any global name can be overridden by
5309 symbols resolved from other modules. */
5312 /* Uninitialized COMMON variable may be unified with symbols
5313 resolved from other modules. */
5314 else if (DECL_COMMON (exp
)
5315 && (DECL_INITIAL (exp
) == NULL
5316 || DECL_INITIAL (exp
) == error_mark_node
))
5318 /* Otherwise we're left with initialized (or non-common) global data
5319 which is of necessity defined locally. */
5326 /* Determine whether or not a pointer mode is valid. Assume defaults
5327 of ptr_mode or Pmode - can be overridden. */
5329 default_valid_pointer_mode (mode
)
5330 enum machine_mode mode
;
5332 return (mode
== ptr_mode
|| mode
== Pmode
);
5335 /* Default function to output code that will globalize a label. A
5336 target must define GLOBAL_ASM_OP or provide it's own function to
5337 globalize a label. */
5338 #ifdef GLOBAL_ASM_OP
5340 default_globalize_label (stream
, name
)
5344 fputs (GLOBAL_ASM_OP
, stream
);
5345 assemble_name (stream
, name
);
5346 putc ('\n', stream
);
5348 #endif /* GLOBAL_ASM_OP */
5350 /* This is how to output an internal numbered label where PREFIX is
5351 the class of label and LABELNO is the number within the class. */
5354 default_internal_label (stream
, prefix
, labelno
)
5357 unsigned long labelno
;
5359 char *const buf
= alloca (40 + strlen (prefix
));
5360 ASM_GENERATE_INTERNAL_LABEL (buf
, prefix
, labelno
);
5361 ASM_OUTPUT_LABEL (stream
, buf
);
5364 #include "gt-varasm.h"