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 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. */
37 #include "hard-reg-set.h"
46 #include "langhooks.h"
51 #ifdef XCOFF_DEBUGGING_INFO
52 #include "xcoffout.h" /* Needed for external data
53 declarations for e.g. AIX 4.x. */
56 #ifndef TRAMPOLINE_ALIGNMENT
57 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
61 #define ASM_STABS_OP "\t.stabs\t"
64 /* The (assembler) name of the first globally-visible object output. */
65 const char *first_global_object_name
;
66 const char *weak_global_object_name
;
69 struct constant_descriptor_rtx
;
73 #define MAX_RTX_HASH_TABLE 61
75 struct varasm_status
GTY(())
77 /* Hash facility for making memory-constants
78 from constant rtl-expressions. It is used on RISC machines
79 where immediate integer arguments and constant addresses are restricted
80 so that such constants must be stored in memory.
82 This pool of constants is reinitialized for each function
83 so each function gets its own constants-pool that comes right before
85 struct constant_descriptor_rtx
** GTY ((length ("MAX_RTX_HASH_TABLE")))
86 x_const_rtx_hash_table
;
87 struct pool_constant
** GTY ((length ("MAX_RTX_HASH_TABLE")))
88 x_const_rtx_sym_hash_table
;
90 /* Pointers to first and last constant in pool. */
91 struct pool_constant
*x_first_pool
;
92 struct pool_constant
*x_last_pool
;
94 /* Current offset in constant pool (does not include any machine-specific
96 HOST_WIDE_INT x_pool_offset
;
99 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
100 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
101 #define first_pool (cfun->varasm->x_first_pool)
102 #define last_pool (cfun->varasm->x_last_pool)
103 #define pool_offset (cfun->varasm->x_pool_offset)
105 /* Number for making the label on the next
106 constant that is stored in memory. */
110 /* Number for making the label on the next
111 static variable internal to a function. */
115 /* Carry information from ASM_DECLARE_OBJECT_NAME
116 to ASM_FINISH_DECLARE_OBJECT. */
118 int size_directive_output
;
120 /* The last decl for which assemble_variable was called,
121 if it did ASM_DECLARE_OBJECT_NAME.
122 If the last call to assemble_variable didn't do that,
125 tree last_assemble_variable_decl
;
127 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
128 So giving constant the alias set for the type will allow such
129 initializations to appear to conflict with the load of the constant. We
130 avoid this by giving all constants an alias set for just constants.
131 Since there will be no stores to that alias set, nothing will ever
132 conflict with them. */
134 static HOST_WIDE_INT const_alias_set
;
136 static const char *strip_reg_name
PARAMS ((const char *));
137 static int contains_pointers_p
PARAMS ((tree
));
138 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
139 static unsigned int const_hash
PARAMS ((tree
));
140 static unsigned int const_hash_1
PARAMS ((tree
));
141 static int compare_constant
PARAMS ((tree
, tree
));
142 static tree copy_constant
PARAMS ((tree
));
143 static void output_constant_def_contents
PARAMS ((tree
, int, int));
144 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
145 struct rtx_const
*));
146 static unsigned int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
147 static int compare_constant_rtx
148 PARAMS ((enum machine_mode
, rtx
, struct constant_descriptor_rtx
*));
149 static struct constant_descriptor_rtx
* record_constant_rtx
150 PARAMS ((enum machine_mode
, rtx
));
151 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
152 static void mark_constant_pool
PARAMS ((void));
153 static void mark_constants
PARAMS ((rtx
));
154 static int mark_constant
PARAMS ((rtx
*current_rtx
, void *data
));
155 static int output_addressed_constants
PARAMS ((tree
));
156 static void output_after_function_constants
PARAMS ((void));
157 static unsigned HOST_WIDE_INT array_size_for_constructor
PARAMS ((tree
));
158 static unsigned min_align
PARAMS ((unsigned, unsigned));
159 static void output_constructor
PARAMS ((tree
, HOST_WIDE_INT
,
161 static void globalize_decl
PARAMS ((tree
));
162 static void maybe_assemble_visibility
PARAMS ((tree
));
163 static int in_named_entry_eq
PARAMS ((const PTR
, const PTR
));
164 static hashval_t in_named_entry_hash
PARAMS ((const PTR
));
165 #ifdef ASM_OUTPUT_BSS
166 static void asm_output_bss
PARAMS ((FILE *, tree
, const char *, int, int));
168 #ifdef BSS_SECTION_ASM_OP
169 #ifdef ASM_OUTPUT_ALIGNED_BSS
170 static void asm_output_aligned_bss
PARAMS ((FILE *, tree
, const char *,
173 #endif /* BSS_SECTION_ASM_OP */
174 static hashval_t const_str_htab_hash
PARAMS ((const void *x
));
175 static int const_str_htab_eq
PARAMS ((const void *x
, const void *y
));
176 static bool asm_emit_uninitialised
PARAMS ((tree
, const char*, int, int));
177 static void resolve_unique_section
PARAMS ((tree
, int, int));
178 static void mark_weak
PARAMS ((tree
));
180 static enum in_section
{ no_section
, in_text
, in_data
, in_named
181 #ifdef BSS_SECTION_ASM_OP
184 #ifdef CTORS_SECTION_ASM_OP
187 #ifdef DTORS_SECTION_ASM_OP
190 #ifdef READONLY_DATA_SECTION_ASM_OP
193 #ifdef EXTRA_SECTIONS
196 } in_section
= no_section
;
198 /* Return a nonzero value if DECL has a section attribute. */
199 #ifndef IN_NAMED_SECTION
200 #define IN_NAMED_SECTION(DECL) \
201 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
202 && DECL_SECTION_NAME (DECL) != NULL_TREE)
205 /* Text of section name when in_section == in_named. */
206 static const char *in_named_name
;
208 /* Hash table of flags that have been used for a particular named section. */
210 struct in_named_entry
217 static htab_t in_named_htab
;
219 /* Define functions like text_section for any extra sections. */
220 #ifdef EXTRA_SECTION_FUNCTIONS
221 EXTRA_SECTION_FUNCTIONS
224 /* Tell assembler to switch to text section. */
229 if (in_section
!= in_text
)
231 in_section
= in_text
;
235 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
240 /* Tell assembler to switch to data section. */
245 if (in_section
!= in_data
)
247 in_section
= in_data
;
248 if (flag_shared_data
)
250 #ifdef SHARED_SECTION_ASM_OP
251 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
253 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
257 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
261 /* Tell assembler to ALWAYS switch to data section, in case
262 it's not sure where it is. */
265 force_data_section ()
267 in_section
= no_section
;
271 /* Tell assembler to switch to read-only data section. This is normally
275 readonly_data_section ()
277 #ifdef READONLY_DATA_SECTION
278 READONLY_DATA_SECTION (); /* Note this can call data_section. */
280 #ifdef READONLY_DATA_SECTION_ASM_OP
281 if (in_section
!= in_readonly_data
)
283 in_section
= in_readonly_data
;
284 fputs (READONLY_DATA_SECTION_ASM_OP
, asm_out_file
);
285 fputc ('\n', asm_out_file
);
293 /* Determine if we're in the text section. */
298 return in_section
== in_text
;
301 /* Determine if we're in the data section. */
306 return in_section
== in_data
;
309 /* Helper routines for maintaining in_named_htab. */
312 in_named_entry_eq (p1
, p2
)
316 const struct in_named_entry
*old
= p1
;
317 const char *new = p2
;
319 return strcmp (old
->name
, new) == 0;
323 in_named_entry_hash (p
)
326 const struct in_named_entry
*old
= p
;
327 return htab_hash_string (old
->name
);
330 /* If SECTION has been seen before as a named section, return the flags
331 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
332 set of flags for a section to have, so 0 does not mean that the section
333 has not been seen. */
336 get_named_section_flags (section
)
339 struct in_named_entry
**slot
;
341 slot
= (struct in_named_entry
**)
342 htab_find_slot_with_hash (in_named_htab
, section
,
343 htab_hash_string (section
), NO_INSERT
);
345 return slot
? (*slot
)->flags
: 0;
348 /* Returns true if the section has been declared before. Sets internal
349 flag on this section in in_named_hash so subsequent calls on this
350 section will return false. */
353 named_section_first_declaration (name
)
356 struct in_named_entry
**slot
;
358 slot
= (struct in_named_entry
**)
359 htab_find_slot_with_hash (in_named_htab
, name
,
360 htab_hash_string (name
), NO_INSERT
);
361 if (! (*slot
)->declared
)
363 (*slot
)->declared
= true;
373 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
374 different set of flags, return false. */
377 set_named_section_flags (section
, flags
)
381 struct in_named_entry
**slot
, *entry
;
383 slot
= (struct in_named_entry
**)
384 htab_find_slot_with_hash (in_named_htab
, section
,
385 htab_hash_string (section
), INSERT
);
390 entry
= (struct in_named_entry
*) xmalloc (sizeof (*entry
));
392 entry
->name
= ggc_strdup (section
);
393 entry
->flags
= flags
;
394 entry
->declared
= false;
396 else if (entry
->flags
!= flags
)
402 /* Tell assembler to change to section NAME with attributes FLAGS. */
405 named_section_flags (name
, flags
)
409 if (in_section
!= in_named
|| strcmp (name
, in_named_name
) != 0)
411 if (! set_named_section_flags (name
, flags
))
414 (*targetm
.asm_out
.named_section
) (name
, flags
);
416 if (flags
& SECTION_FORGET
)
417 in_section
= no_section
;
420 in_named_name
= ggc_strdup (name
);
421 in_section
= in_named
;
426 /* Tell assembler to change to section NAME for DECL.
427 If DECL is NULL, just switch to section NAME.
428 If NAME is NULL, get the name from DECL.
429 If RELOC is 1, the initializer for DECL contains relocs. */
432 named_section (decl
, name
, reloc
)
439 if (decl
!= NULL_TREE
&& !DECL_P (decl
))
442 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
444 flags
= (* targetm
.section_type_flags
) (decl
, name
, reloc
);
446 /* Sanity check user variables for flag changes. Non-user
447 section flag changes will abort in named_section_flags.
448 However, don't complain if SECTION_OVERRIDE is set.
449 We trust that the setter knows that it is safe to ignore
450 the default flags for this decl. */
451 if (decl
&& ! set_named_section_flags (name
, flags
))
453 flags
= get_named_section_flags (name
);
454 if ((flags
& SECTION_OVERRIDE
) == 0)
455 error_with_decl (decl
, "%s causes a section type conflict");
458 named_section_flags (name
, flags
);
461 /* If required, set DECL_SECTION_NAME to a unique name. */
464 resolve_unique_section (decl
, reloc
, flag_function_or_data_sections
)
466 int reloc ATTRIBUTE_UNUSED
;
467 int flag_function_or_data_sections
;
469 if (DECL_SECTION_NAME (decl
) == NULL_TREE
470 && targetm
.have_named_sections
471 && (flag_function_or_data_sections
472 || DECL_ONE_ONLY (decl
)))
473 (*targetm
.asm_out
.unique_section
) (decl
, reloc
);
476 #ifdef BSS_SECTION_ASM_OP
478 /* Tell the assembler to switch to the bss section. */
483 if (in_section
!= in_bss
)
485 #ifdef SHARED_BSS_SECTION_ASM_OP
486 if (flag_shared_data
)
487 fprintf (asm_out_file
, "%s\n", SHARED_BSS_SECTION_ASM_OP
);
490 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
496 #ifdef ASM_OUTPUT_BSS
498 /* Utility function for ASM_OUTPUT_BSS for targets to use if
499 they don't support alignments in .bss.
500 ??? It is believed that this function will work in most cases so such
501 support is localized here. */
504 asm_output_bss (file
, decl
, name
, size
, rounded
)
506 tree decl ATTRIBUTE_UNUSED
;
508 int size ATTRIBUTE_UNUSED
, rounded
;
510 (*targetm
.asm_out
.globalize_label
) (file
, name
);
512 #ifdef ASM_DECLARE_OBJECT_NAME
513 last_assemble_variable_decl
= decl
;
514 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
516 /* Standard thing is just output label for the object. */
517 ASM_OUTPUT_LABEL (file
, name
);
518 #endif /* ASM_DECLARE_OBJECT_NAME */
519 ASM_OUTPUT_SKIP (file
, rounded
? rounded
: 1);
524 #ifdef ASM_OUTPUT_ALIGNED_BSS
526 /* Utility function for targets to use in implementing
527 ASM_OUTPUT_ALIGNED_BSS.
528 ??? It is believed that this function will work in most cases so such
529 support is localized here. */
532 asm_output_aligned_bss (file
, decl
, name
, size
, align
)
534 tree decl ATTRIBUTE_UNUSED
;
539 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
540 #ifdef ASM_DECLARE_OBJECT_NAME
541 last_assemble_variable_decl
= decl
;
542 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
544 /* Standard thing is just output label for the object. */
545 ASM_OUTPUT_LABEL (file
, name
);
546 #endif /* ASM_DECLARE_OBJECT_NAME */
547 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
552 #endif /* BSS_SECTION_ASM_OP */
554 /* Switch to the section for function DECL.
556 If DECL is NULL_TREE, switch to the text section.
557 ??? It's not clear that we will ever be passed NULL_TREE, but it's
558 safer to handle it. */
561 function_section (decl
)
564 if (decl
!= NULL_TREE
565 && DECL_SECTION_NAME (decl
) != NULL_TREE
)
566 named_section (decl
, (char *) 0, 0);
571 /* Switch to section for variable DECL. RELOC is the same as the
572 argument to SELECT_SECTION. */
575 variable_section (decl
, reloc
)
579 if (IN_NAMED_SECTION (decl
))
580 named_section (decl
, NULL
, reloc
);
582 (*targetm
.asm_out
.select_section
) (decl
, reloc
, DECL_ALIGN (decl
));
585 /* Tell assembler to switch to the section for the exception handling
589 default_exception_section ()
591 if (targetm
.have_named_sections
)
592 named_section (NULL_TREE
, ".gcc_except_table", 0);
596 readonly_data_section ();
599 /* Tell assembler to switch to the section for string merging. */
602 mergeable_string_section (decl
, align
, flags
)
603 tree decl ATTRIBUTE_UNUSED
;
604 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
605 unsigned int flags ATTRIBUTE_UNUSED
;
607 #ifdef HAVE_GAS_SHF_MERGE
608 if (flag_merge_constants
609 && TREE_CODE (decl
) == STRING_CST
610 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
612 && TREE_STRING_LENGTH (decl
) >= int_size_in_bytes (TREE_TYPE (decl
)))
614 enum machine_mode mode
;
615 unsigned int modesize
;
620 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
621 modesize
= GET_MODE_BITSIZE (mode
);
622 if (modesize
>= 8 && modesize
<= 256
623 && (modesize
& (modesize
- 1)) == 0)
625 if (align
< modesize
)
628 str
= TREE_STRING_POINTER (decl
);
629 len
= TREE_STRING_LENGTH (decl
);
630 unit
= GET_MODE_SIZE (mode
);
632 /* Check for embedded NUL characters. */
633 for (i
= 0; i
< len
; i
+= unit
)
635 for (j
= 0; j
< unit
; j
++)
636 if (str
[i
+ j
] != '\0')
643 sprintf (name
, ".rodata.str%d.%d", modesize
/ 8,
645 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
646 if (!i
&& modesize
< align
)
648 /* A "" string with requested alignment greater than
649 character size might cause a problem:
650 if some other string required even bigger
651 alignment than "", then linker might think the
652 "" is just part of padding after some other string
653 and not put it into the hash table initially.
654 But this means "" could have smaller alignment
656 #ifdef ASM_OUTPUT_SECTION_START
657 named_section_flags (name
, flags
);
658 ASM_OUTPUT_SECTION_START (asm_out_file
);
660 readonly_data_section ();
665 named_section_flags (name
, flags
);
671 readonly_data_section ();
674 /* Tell assembler to switch to the section for constant merging. */
677 mergeable_constant_section (mode
, align
, flags
)
678 enum machine_mode mode ATTRIBUTE_UNUSED
;
679 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
680 unsigned int flags ATTRIBUTE_UNUSED
;
682 #ifdef HAVE_GAS_SHF_MERGE
683 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
685 if (flag_merge_constants
691 && (align
& (align
- 1)) == 0)
695 sprintf (name
, ".rodata.cst%d", (int) (align
/ 8));
696 flags
|= (align
/ 8) | SECTION_MERGE
;
697 named_section_flags (name
, flags
);
701 readonly_data_section ();
704 /* Given NAME, a putative register name, discard any customary prefixes. */
707 strip_reg_name (name
)
710 #ifdef REGISTER_PREFIX
711 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
712 name
+= strlen (REGISTER_PREFIX
);
714 if (name
[0] == '%' || name
[0] == '#')
719 /* Decode an `asm' spec for a declaration as a register name.
720 Return the register number, or -1 if nothing specified,
721 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
722 or -3 if ASMSPEC is `cc' and is not recognized,
723 or -4 if ASMSPEC is `memory' and is not recognized.
724 Accept an exact spelling or a decimal number.
725 Prefixes such as % are optional. */
728 decode_reg_name (asmspec
)
735 /* Get rid of confusing prefixes. */
736 asmspec
= strip_reg_name (asmspec
);
738 /* Allow a decimal number as a "register name". */
739 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
740 if (! ISDIGIT (asmspec
[i
]))
742 if (asmspec
[0] != 0 && i
< 0)
745 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
751 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
753 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
756 #ifdef ADDITIONAL_REGISTER_NAMES
758 static const struct { const char *const name
; const int number
; } table
[]
759 = ADDITIONAL_REGISTER_NAMES
;
761 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
762 if (! strcmp (asmspec
, table
[i
].name
))
763 return table
[i
].number
;
765 #endif /* ADDITIONAL_REGISTER_NAMES */
767 if (!strcmp (asmspec
, "memory"))
770 if (!strcmp (asmspec
, "cc"))
779 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
780 have static storage duration. In other words, it should not be an
781 automatic variable, including PARM_DECLs.
783 There is, however, one exception: this function handles variables
784 explicitly placed in a particular register by the user.
786 ASMSPEC, if not 0, is the string which the user specified as the
787 assembler symbol name.
789 This is never called for PARM_DECL nodes. */
792 make_decl_rtl (decl
, asmspec
)
796 int top_level
= (DECL_CONTEXT (decl
) == NULL_TREE
);
797 const char *name
= 0;
798 const char *new_name
= 0;
802 /* Check that we are not being given an automatic variable. */
803 /* A weak alias has TREE_PUBLIC set but not the other bits. */
804 if (TREE_CODE (decl
) == PARM_DECL
805 || TREE_CODE (decl
) == RESULT_DECL
806 || (TREE_CODE (decl
) == VAR_DECL
807 && !TREE_STATIC (decl
)
808 && !TREE_PUBLIC (decl
)
809 && !DECL_EXTERNAL (decl
)
810 && !DECL_REGISTER (decl
)))
812 /* And that we were not given a type or a label. */
813 else if (TREE_CODE (decl
) == TYPE_DECL
814 || TREE_CODE (decl
) == LABEL_DECL
)
817 /* For a duplicate declaration, we can be called twice on the
818 same DECL node. Don't discard the RTL already made. */
819 if (DECL_RTL_SET_P (decl
))
821 /* If the old RTL had the wrong mode, fix the mode. */
822 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
823 SET_DECL_RTL (decl
, adjust_address_nv (DECL_RTL (decl
),
824 DECL_MODE (decl
), 0));
826 /* ??? Another way to do this would be to maintain a hashed
827 table of such critters. Instead of adding stuff to a DECL
828 to give certain attributes to it, we could use an external
829 hash map from DECL to set of attributes. */
831 /* Let the target reassign the RTL if it wants.
832 This is necessary, for example, when one machine specific
833 decl attribute overrides another. */
834 (* targetm
.encode_section_info
) (decl
, false);
838 new_name
= name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
840 reg_number
= decode_reg_name (asmspec
);
841 if (reg_number
== -2)
843 /* ASMSPEC is given, and not the name of a register. Mark the
844 name with a star so assemble_name won't munge it. */
845 char *starred
= alloca (strlen (asmspec
) + 2);
847 strcpy (starred
+ 1, asmspec
);
851 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
853 /* First detect errors in declaring global registers. */
854 if (reg_number
== -1)
855 error_with_decl (decl
, "register name not specified for `%s'");
856 else if (reg_number
< 0)
857 error_with_decl (decl
, "invalid register name for `%s'");
858 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
859 error_with_decl (decl
,
860 "data type of `%s' isn't suitable for a register");
861 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
862 error_with_decl (decl
,
863 "register specified for `%s' isn't suitable for data type");
864 /* Now handle properly declared static register variables. */
869 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
871 DECL_INITIAL (decl
) = 0;
872 error ("global register variable has initial value");
874 if (TREE_THIS_VOLATILE (decl
))
875 warning ("volatile register variables don't work as you might wish");
877 /* If the user specified one of the eliminables registers here,
878 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
879 confused with that register and be eliminated. This usage is
880 somewhat suspect... */
882 SET_DECL_RTL (decl
, gen_rtx_raw_REG (DECL_MODE (decl
), reg_number
));
883 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
884 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
886 if (TREE_STATIC (decl
))
888 /* Make this register global, so not usable for anything
890 #ifdef ASM_DECLARE_REGISTER_GLOBAL
891 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
893 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
895 globalize_reg (reg_number
+ --nregs
);
898 /* As a register variable, it has no section. */
903 /* Now handle ordinary static variables and functions (in memory).
904 Also handle vars declared register invalidly. */
906 if (reg_number
>= 0 || reg_number
== -3)
907 error_with_decl (decl
,
908 "register name given for non-register variable `%s'");
910 /* Specifying a section attribute on a variable forces it into a
911 non-.bss section, and thus it cannot be common. */
912 if (TREE_CODE (decl
) == VAR_DECL
913 && DECL_SECTION_NAME (decl
) != NULL_TREE
914 && DECL_INITIAL (decl
) == NULL_TREE
915 && DECL_COMMON (decl
))
916 DECL_COMMON (decl
) = 0;
918 /* Variables can't be both common and weak. */
919 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_WEAK (decl
))
920 DECL_COMMON (decl
) = 0;
922 /* Can't use just the variable's own name for a variable
923 whose scope is less than the whole file, unless it's a member
924 of a local class (which will already be unambiguous).
925 Concatenate a distinguishing number. */
926 if (!top_level
&& !TREE_PUBLIC (decl
)
927 && ! (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
929 && name
== IDENTIFIER_POINTER (DECL_NAME (decl
)))
933 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
938 if (name
!= new_name
)
940 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (new_name
));
941 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
944 /* If this variable is to be treated as volatile, show its
945 tree node has side effects. */
946 if ((flag_volatile_global
&& TREE_CODE (decl
) == VAR_DECL
947 && TREE_PUBLIC (decl
))
948 || ((flag_volatile_static
&& TREE_CODE (decl
) == VAR_DECL
949 && (TREE_PUBLIC (decl
) || TREE_STATIC (decl
)))))
950 TREE_SIDE_EFFECTS (decl
) = 1;
952 x
= gen_rtx_MEM (DECL_MODE (decl
), gen_rtx_SYMBOL_REF (Pmode
, name
));
953 SYMBOL_REF_WEAK (XEXP (x
, 0)) = DECL_WEAK (decl
);
954 if (TREE_CODE (decl
) != FUNCTION_DECL
)
955 set_mem_attributes (x
, decl
, 1);
956 SET_DECL_RTL (decl
, x
);
958 /* Optionally set flags or add text to the name to record information
959 such as that it is a function name.
960 If the name is changed, the macro ASM_OUTPUT_LABELREF
961 will have to know how to strip this information. */
962 (* targetm
.encode_section_info
) (decl
, true);
965 /* Make the rtl for variable VAR be volatile.
966 Use this only for static variables. */
969 make_var_volatile (var
)
972 if (GET_CODE (DECL_RTL (var
)) != MEM
)
975 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
978 /* Output alignment directive to align for constant expression EXP. */
981 assemble_constant_align (exp
)
986 /* Align the location counter as required by EXP's data type. */
987 align
= TYPE_ALIGN (TREE_TYPE (exp
));
988 #ifdef CONSTANT_ALIGNMENT
989 align
= CONSTANT_ALIGNMENT (exp
, align
);
992 if (align
> BITS_PER_UNIT
)
994 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
998 /* Output a string of literal assembler code
999 for an `asm' keyword used between functions. */
1002 assemble_asm (string
)
1007 if (TREE_CODE (string
) == ADDR_EXPR
)
1008 string
= TREE_OPERAND (string
, 0);
1010 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
1013 /* Record an element in the table of global destructors. SYMBOL is
1014 a SYMBOL_REF of the function to be called; PRIORITY is a number
1015 between 0 and MAX_INIT_PRIORITY. */
1018 default_stabs_asm_out_destructor (symbol
, priority
)
1020 int priority ATTRIBUTE_UNUSED
;
1022 /* Tell GNU LD that this is part of the static destructor set.
1023 This will work for any system that uses stabs, most usefully
1025 fprintf (asm_out_file
, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
1026 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1027 fputc ('\n', asm_out_file
);
1031 default_named_section_asm_out_destructor (symbol
, priority
)
1035 const char *section
= ".dtors";
1038 /* ??? This only works reliably with the GNU linker. */
1039 if (priority
!= DEFAULT_INIT_PRIORITY
)
1041 sprintf (buf
, ".dtors.%.5u",
1042 /* Invert the numbering so the linker puts us in the proper
1043 order; constructors are run from right to left, and the
1044 linker sorts in increasing order. */
1045 MAX_INIT_PRIORITY
- priority
);
1049 named_section_flags (section
, SECTION_WRITE
);
1050 assemble_align (POINTER_SIZE
);
1051 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1054 #ifdef DTORS_SECTION_ASM_OP
1058 if (in_section
!= in_dtors
)
1060 in_section
= in_dtors
;
1061 fputs (DTORS_SECTION_ASM_OP
, asm_out_file
);
1062 fputc ('\n', asm_out_file
);
1067 default_dtor_section_asm_out_destructor (symbol
, priority
)
1069 int priority ATTRIBUTE_UNUSED
;
1072 assemble_align (POINTER_SIZE
);
1073 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1077 /* Likewise for global constructors. */
1080 default_stabs_asm_out_constructor (symbol
, priority
)
1082 int priority ATTRIBUTE_UNUSED
;
1084 /* Tell GNU LD that this is part of the static destructor set.
1085 This will work for any system that uses stabs, most usefully
1087 fprintf (asm_out_file
, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
1088 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1089 fputc ('\n', asm_out_file
);
1093 default_named_section_asm_out_constructor (symbol
, priority
)
1097 const char *section
= ".ctors";
1100 /* ??? This only works reliably with the GNU linker. */
1101 if (priority
!= DEFAULT_INIT_PRIORITY
)
1103 sprintf (buf
, ".ctors.%.5u",
1104 /* Invert the numbering so the linker puts us in the proper
1105 order; constructors are run from right to left, and the
1106 linker sorts in increasing order. */
1107 MAX_INIT_PRIORITY
- priority
);
1111 named_section_flags (section
, SECTION_WRITE
);
1112 assemble_align (POINTER_SIZE
);
1113 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1116 #ifdef CTORS_SECTION_ASM_OP
1120 if (in_section
!= in_ctors
)
1122 in_section
= in_ctors
;
1123 fputs (CTORS_SECTION_ASM_OP
, asm_out_file
);
1124 fputc ('\n', asm_out_file
);
1129 default_ctor_section_asm_out_constructor (symbol
, priority
)
1131 int priority ATTRIBUTE_UNUSED
;
1134 assemble_align (POINTER_SIZE
);
1135 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1139 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1140 a nonzero value if the constant pool should be output before the
1141 start of the function, or a zero value if the pool should output
1142 after the end of the function. The default is to put it before the
1145 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1146 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1149 /* Output assembler code for the constant pool of a function and associated
1150 with defining the name of the function. DECL describes the function.
1151 NAME is the function's name. For the constant pool, we use the current
1152 constant pool data. */
1155 assemble_start_function (decl
, fnname
)
1161 /* The following code does not need preprocessing in the assembler. */
1165 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1166 output_constant_pool (fnname
, decl
);
1168 resolve_unique_section (decl
, 0, flag_function_sections
);
1169 function_section (decl
);
1171 /* Tell assembler to move to target machine's alignment for functions. */
1172 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1173 if (align
< force_align_functions_log
)
1174 align
= force_align_functions_log
;
1177 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1180 /* Handle a user-specified function alignment.
1181 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1182 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1183 if (align_functions_log
> align
1184 && cfun
->function_frequency
!= FUNCTION_FREQUENCY_UNLIKELY_EXECUTED
)
1186 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1187 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1188 align_functions_log
, align_functions
- 1);
1190 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1194 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1195 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1198 (*debug_hooks
->begin_function
) (decl
);
1200 /* Make function name accessible from other files, if appropriate. */
1202 if (TREE_PUBLIC (decl
))
1204 if (! first_global_object_name
)
1209 p
= (* targetm
.strip_name_encoding
) (fnname
);
1212 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
1213 first_global_object_name
= name
;
1215 weak_global_object_name
= name
;
1218 globalize_decl (decl
);
1220 maybe_assemble_visibility (decl
);
1223 /* Do any machine/system dependent processing of the function name */
1224 #ifdef ASM_DECLARE_FUNCTION_NAME
1225 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1227 /* Standard thing is just output label for the function. */
1228 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1229 #endif /* ASM_DECLARE_FUNCTION_NAME */
1232 /* Output assembler code associated with defining the size of the
1233 function. DECL describes the function. NAME is the function's name. */
1236 assemble_end_function (decl
, fnname
)
1240 #ifdef ASM_DECLARE_FUNCTION_SIZE
1241 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1243 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1245 output_constant_pool (fnname
, decl
);
1246 function_section (decl
); /* need to switch back */
1249 /* Output any constants which should appear after the function. */
1250 output_after_function_constants ();
1253 /* Assemble code to leave SIZE bytes of zeros. */
1256 assemble_zeros (size
)
1259 /* Do no output if -fsyntax-only. */
1260 if (flag_syntax_only
)
1263 #ifdef ASM_NO_SKIP_IN_TEXT
1264 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1265 so we must output 0s explicitly in the text section. */
1266 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1269 for (i
= 0; i
< size
; i
++)
1270 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1275 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1278 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1281 assemble_align (align
)
1284 if (align
> BITS_PER_UNIT
)
1286 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1290 /* Assemble a string constant with the specified C string as contents. */
1293 assemble_string (p
, size
)
1300 /* If the string is very long, split it up. */
1304 int thissize
= size
- pos
;
1305 if (thissize
> maximum
)
1308 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1316 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1317 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1318 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1320 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1321 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1322 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1324 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1325 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1329 #if defined ASM_OUTPUT_ALIGNED_BSS
1330 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1331 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1333 #if defined ASM_OUTPUT_BSS
1334 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1335 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1341 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1342 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1343 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1345 #if defined ASM_OUTPUT_ALIGNED_COMMON
1346 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1347 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1349 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1350 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1355 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1358 int size ATTRIBUTE_UNUSED
;
1359 int rounded ATTRIBUTE_UNUSED
;
1367 destination
= asm_dest_local
;
1369 /* ??? We should handle .bss via select_section mechanisms rather than
1370 via special target hooks. That would eliminate this special case. */
1371 if (TREE_PUBLIC (decl
))
1373 if (!DECL_COMMON (decl
))
1375 destination
= asm_dest_bss
;
1380 destination
= asm_dest_common
;
1383 if (destination
== asm_dest_bss
)
1384 globalize_decl (decl
);
1385 resolve_unique_section (decl
, 0, flag_data_sections
);
1387 if (flag_shared_data
)
1389 switch (destination
)
1391 #ifdef ASM_OUTPUT_SHARED_BSS
1393 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1396 #ifdef ASM_OUTPUT_SHARED_COMMON
1397 case asm_dest_common
:
1398 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1401 #ifdef ASM_OUTPUT_SHARED_LOCAL
1402 case asm_dest_local
:
1403 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1411 switch (destination
)
1415 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1418 case asm_dest_common
:
1419 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1421 case asm_dest_local
:
1422 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1431 /* Assemble everything that is needed for a variable or function declaration.
1432 Not used for automatic variables, and not used for function definitions.
1433 Should not be called for variables of incomplete structure type.
1435 TOP_LEVEL is nonzero if this variable has file scope.
1436 AT_END is nonzero if this is the special handling, at end of compilation,
1437 to define things that have had only tentative definitions.
1438 DONT_OUTPUT_DATA if nonzero means don't actually output the
1439 initial value (that will be done by the caller). */
1442 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1444 int top_level ATTRIBUTE_UNUSED
;
1445 int at_end ATTRIBUTE_UNUSED
;
1446 int dont_output_data
;
1453 last_assemble_variable_decl
= 0;
1455 /* Normally no need to say anything here for external references,
1456 since assemble_external is called by the language-specific code
1457 when a declaration is first seen. */
1459 if (DECL_EXTERNAL (decl
))
1462 /* Output no assembler code for a function declaration.
1463 Only definitions of functions output anything. */
1465 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1468 /* Do nothing for global register variables. */
1469 if (DECL_RTL_SET_P (decl
) && GET_CODE (DECL_RTL (decl
)) == REG
)
1471 TREE_ASM_WRITTEN (decl
) = 1;
1475 /* If type was incomplete when the variable was declared,
1476 see if it is complete now. */
1478 if (DECL_SIZE (decl
) == 0)
1479 layout_decl (decl
, 0);
1481 /* Still incomplete => don't allocate it; treat the tentative defn
1482 (which is what it must have been) as an `extern' reference. */
1484 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1486 error_with_file_and_line (DECL_SOURCE_FILE (decl
),
1487 DECL_SOURCE_LINE (decl
),
1488 "storage size of `%s' isn't known",
1489 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1490 TREE_ASM_WRITTEN (decl
) = 1;
1494 /* The first declaration of a variable that comes through this function
1495 decides whether it is global (in C, has external linkage)
1496 or local (in C, has internal linkage). So do nothing more
1497 if this function has already run. */
1499 if (TREE_ASM_WRITTEN (decl
))
1502 /* Make sure targetm.encode_section_info is invoked before we set
1504 decl_rtl
= DECL_RTL (decl
);
1506 TREE_ASM_WRITTEN (decl
) = 1;
1508 /* Do no output if -fsyntax-only. */
1509 if (flag_syntax_only
)
1514 if (! dont_output_data
1515 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1517 error_with_decl (decl
, "size of variable `%s' is too large");
1521 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1522 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1523 && ! first_global_object_name
1524 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1525 || DECL_INITIAL (decl
) == error_mark_node
))
1526 && ! DECL_WEAK (decl
)
1527 && ! DECL_ONE_ONLY (decl
))
1532 p
= (* targetm
.strip_name_encoding
) (name
);
1533 xname
= xstrdup (p
);
1534 first_global_object_name
= xname
;
1537 /* Compute the alignment of this data. */
1539 align
= DECL_ALIGN (decl
);
1541 /* In the case for initialing an array whose length isn't specified,
1542 where we have not yet been able to do the layout,
1543 figure out the proper alignment now. */
1544 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1545 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1546 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1548 /* Some object file formats have a maximum alignment which they support.
1549 In particular, a.out format supports a maximum alignment of 4. */
1550 #ifndef MAX_OFILE_ALIGNMENT
1551 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1553 if (align
> MAX_OFILE_ALIGNMENT
)
1555 warning_with_decl (decl
,
1556 "alignment of `%s' is greater than maximum object file alignment. Using %d",
1557 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1558 align
= MAX_OFILE_ALIGNMENT
;
1561 /* On some machines, it is good to increase alignment sometimes. */
1562 if (! DECL_USER_ALIGN (decl
))
1564 #ifdef DATA_ALIGNMENT
1565 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1567 #ifdef CONSTANT_ALIGNMENT
1568 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1569 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1573 /* Reset the alignment in case we have made it tighter, so we can benefit
1574 from it in get_pointer_alignment. */
1575 DECL_ALIGN (decl
) = align
;
1576 set_mem_align (decl_rtl
, align
);
1578 if (TREE_PUBLIC (decl
))
1579 maybe_assemble_visibility (decl
);
1581 /* Output any data that we will need to use the address of. */
1582 if (DECL_INITIAL (decl
) == error_mark_node
)
1583 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1584 else if (DECL_INITIAL (decl
))
1585 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1586 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1588 /* Handle uninitialized definitions. */
1590 /* If the decl has been given an explicit section name, then it
1591 isn't common, and shouldn't be handled as such. */
1592 if (DECL_SECTION_NAME (decl
) || dont_output_data
)
1594 /* We don't implement common thread-local data at present. */
1595 else if (DECL_THREAD_LOCAL (decl
))
1597 if (DECL_COMMON (decl
))
1598 sorry ("thread-local COMMON data not implemented");
1600 else if (DECL_INITIAL (decl
) == 0
1601 || DECL_INITIAL (decl
) == error_mark_node
1602 || (flag_zero_initialized_in_bss
1603 && initializer_zerop (DECL_INITIAL (decl
))))
1605 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1606 unsigned HOST_WIDE_INT rounded
= size
;
1608 /* Don't allocate zero bytes of common,
1609 since that means "undefined external" in the linker. */
1613 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1614 so that each uninitialized object starts on such a boundary. */
1615 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1616 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1617 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1619 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1620 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN (decl
) / BITS_PER_UNIT
> rounded
)
1622 (decl
, "requested alignment for %s is greater than implemented alignment of %d",rounded
);
1625 /* If the target cannot output uninitialized but not common global data
1626 in .bss, then we have to use .data, so fall through. */
1627 if (asm_emit_uninitialised (decl
, name
, size
, rounded
))
1631 /* Handle initialized definitions.
1632 Also handle uninitialized global definitions if -fno-common and the
1633 target doesn't support ASM_OUTPUT_BSS. */
1635 /* First make the assembler name(s) global if appropriate. */
1636 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1637 globalize_decl (decl
);
1639 /* Switch to the appropriate section. */
1640 variable_section (decl
, reloc
);
1642 /* dbxout.c needs to know this. */
1643 if (in_text_section ())
1644 DECL_IN_TEXT_SECTION (decl
) = 1;
1646 /* Output the alignment of this data. */
1647 if (align
> BITS_PER_UNIT
)
1649 ASM_OUTPUT_ALIGN (asm_out_file
,
1650 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1653 /* Do any machine/system dependent processing of the object. */
1654 #ifdef ASM_DECLARE_OBJECT_NAME
1655 last_assemble_variable_decl
= decl
;
1656 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1658 /* Standard thing is just output label for the object. */
1659 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1660 #endif /* ASM_DECLARE_OBJECT_NAME */
1662 if (!dont_output_data
)
1664 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
1665 /* Output the actual data. */
1666 output_constant (DECL_INITIAL (decl
),
1667 tree_low_cst (DECL_SIZE_UNIT (decl
), 1),
1670 /* Leave space for it. */
1671 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1675 /* Return 1 if type TYPE contains any pointers. */
1678 contains_pointers_p (type
)
1681 switch (TREE_CODE (type
))
1684 case REFERENCE_TYPE
:
1685 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1686 so I'll play safe and return 1. */
1692 case QUAL_UNION_TYPE
:
1695 /* For a type that has fields, see if the fields have pointers. */
1696 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1697 if (TREE_CODE (fields
) == FIELD_DECL
1698 && contains_pointers_p (TREE_TYPE (fields
)))
1704 /* An array type contains pointers if its element type does. */
1705 return contains_pointers_p (TREE_TYPE (type
));
1712 /* Output something to declare an external symbol to the assembler.
1713 (Most assemblers don't need this, so we normally output nothing.)
1714 Do nothing if DECL is not external. */
1717 assemble_external (decl
)
1718 tree decl ATTRIBUTE_UNUSED
;
1720 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1721 main body of this code is only rarely exercised. To provide some
1722 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1723 open. If it's not, we should not be calling this function. */
1727 #ifdef ASM_OUTPUT_EXTERNAL
1728 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1730 rtx rtl
= DECL_RTL (decl
);
1732 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1733 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1735 /* Some systems do require some output. */
1736 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1737 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1743 /* Similar, for calling a library function FUN. */
1746 assemble_external_libcall (fun
)
1747 rtx fun ATTRIBUTE_UNUSED
;
1749 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1750 /* Declare library function name external when first used, if nec. */
1751 if (! SYMBOL_REF_USED (fun
))
1753 SYMBOL_REF_USED (fun
) = 1;
1754 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1759 /* Assemble a label named NAME. */
1762 assemble_label (name
)
1765 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1768 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1769 If NAME starts with a *, the rest of NAME is output verbatim.
1770 Otherwise NAME is transformed in an implementation-defined way
1771 (usually by the addition of an underscore).
1772 Many macros in the tm file are defined to call this function. */
1775 assemble_name (file
, name
)
1779 const char *real_name
;
1782 real_name
= (* targetm
.strip_name_encoding
) (name
);
1784 id
= maybe_get_identifier (real_name
);
1786 TREE_SYMBOL_REFERENCED (id
) = 1;
1789 fputs (&name
[1], file
);
1791 ASM_OUTPUT_LABELREF (file
, name
);
1794 /* Allocate SIZE bytes writable static space with a gensym name
1795 and return an RTX to refer to its address. */
1798 assemble_static_space (size
)
1802 const char *namestring
;
1806 if (flag_shared_data
)
1810 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1812 namestring
= ggc_strdup (name
);
1814 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1816 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1817 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1820 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1821 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1824 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1825 so that each uninitialized object starts on such a boundary. */
1826 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1827 int rounded ATTRIBUTE_UNUSED
1828 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1829 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1830 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1831 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1838 /* Assemble the static constant template for function entry trampolines.
1839 This is done at most once per compilation.
1840 Returns an RTX for the address of the template. */
1842 #ifdef TRAMPOLINE_TEMPLATE
1844 assemble_trampoline_template ()
1850 /* By default, put trampoline templates in read-only data section. */
1852 #ifdef TRAMPOLINE_SECTION
1853 TRAMPOLINE_SECTION ();
1855 readonly_data_section ();
1858 /* Write the assembler code to define one. */
1859 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1862 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1865 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LTRAMP", 0);
1866 TRAMPOLINE_TEMPLATE (asm_out_file
);
1868 /* Record the rtl to refer to it. */
1869 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1870 name
= ggc_strdup (label
);
1871 return gen_rtx_SYMBOL_REF (Pmode
, name
);
1875 /* A and B are either alignments or offsets. Return the minimum alignment
1876 that may be assumed after adding the two together. */
1878 static inline unsigned
1882 return (a
| b
) & -(a
| b
);
1885 /* Return the assembler directive for creating a given kind of integer
1886 object. SIZE is the number of bytes in the object and ALIGNED_P
1887 indicates whether it is known to be aligned. Return NULL if the
1888 assembly dialect has no such directive.
1890 The returned string should be printed at the start of a new line and
1891 be followed immediately by the object's initial value. */
1894 integer_asm_op (size
, aligned_p
)
1898 struct asm_int_op
*ops
;
1901 ops
= &targetm
.asm_out
.aligned_op
;
1903 ops
= &targetm
.asm_out
.unaligned_op
;
1908 return targetm
.asm_out
.byte_op
;
1922 /* Use directive OP to assemble an integer object X. Print OP at the
1923 start of the line, followed immediately by the value of X. */
1926 assemble_integer_with_op (op
, x
)
1930 fputs (op
, asm_out_file
);
1931 output_addr_const (asm_out_file
, x
);
1932 fputc ('\n', asm_out_file
);
1935 /* The default implementation of the asm_out.integer target hook. */
1938 default_assemble_integer (x
, size
, aligned_p
)
1939 rtx x ATTRIBUTE_UNUSED
;
1940 unsigned int size ATTRIBUTE_UNUSED
;
1941 int aligned_p ATTRIBUTE_UNUSED
;
1943 const char *op
= integer_asm_op (size
, aligned_p
);
1944 return op
&& (assemble_integer_with_op (op
, x
), true);
1947 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
1948 the alignment of the integer in bits. Return 1 if we were able to output
1949 the constant, otherwise 0. If FORCE is nonzero, abort if we can't output
1953 assemble_integer (x
, size
, align
, force
)
1961 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
1963 /* See if the target hook can handle this kind of object. */
1964 if ((*targetm
.asm_out
.integer
) (x
, size
, aligned_p
))
1967 /* If the object is a multi-byte one, try splitting it up. Split
1968 it into words it if is multi-word, otherwise split it into bytes. */
1971 enum machine_mode omode
, imode
;
1972 unsigned int subalign
;
1973 unsigned int subsize
, i
;
1975 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
1976 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
1977 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, MODE_INT
, 0);
1978 imode
= mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1980 for (i
= 0; i
< size
; i
+= subsize
)
1982 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
1983 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
1989 /* If we've printed some of it, but not all of it, there's no going
2002 assemble_real (d
, mode
, align
)
2004 enum machine_mode mode
;
2009 unsigned int nalign
= min_align (align
, 32);
2011 switch (BITS_PER_UNIT
)
2017 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2018 assemble_integer (GEN_INT (l
), 4, align
, 1);
2021 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2022 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2023 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2026 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
2027 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2028 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2029 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
2032 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
2033 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2034 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2035 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
2036 assemble_integer (GEN_INT (data
[3]), 4, nalign
, 1);
2047 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2048 assemble_integer (GEN_INT (l
), 2, align
, 1);
2051 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2052 assemble_integer (GEN_INT (data
[0]), 2, align
, 1);
2053 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2064 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2065 assemble_integer (GEN_INT (l
), 1, align
, 1);
2068 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2069 assemble_integer (GEN_INT (data
[0]), 1, align
, 1);
2070 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2082 /* Given an expression EXP with a constant value,
2083 reduce it to the sum of an assembler symbol and an integer.
2084 Store them both in the structure *VALUE.
2085 Abort if EXP does not reduce. */
2087 struct addr_const
GTY(())
2090 HOST_WIDE_INT offset
;
2094 decode_addr_const (exp
, value
)
2096 struct addr_const
*value
;
2098 tree target
= TREE_OPERAND (exp
, 0);
2104 if (TREE_CODE (target
) == COMPONENT_REF
2105 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2108 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2109 target
= TREE_OPERAND (target
, 0);
2111 else if (TREE_CODE (target
) == ARRAY_REF
2112 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2114 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2115 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2116 target
= TREE_OPERAND (target
, 0);
2122 switch (TREE_CODE (target
))
2126 x
= DECL_RTL (target
);
2130 x
= gen_rtx_MEM (FUNCTION_MODE
,
2131 gen_rtx_LABEL_REF (VOIDmode
,
2132 label_rtx (TREE_OPERAND (exp
, 0))));
2140 /* This constant should have been output already, but we can't simply
2141 use TREE_CST_RTL since INTEGER_CST doesn't have one. */
2142 x
= output_constant_def (target
, 1);
2149 if (GET_CODE (x
) != MEM
)
2154 value
->offset
= offset
;
2157 /* We do RTX_UNSPEC + XINT (blah), so nothing can go after RTX_UNSPEC. */
2158 enum kind
{ RTX_UNKNOWN
, RTX_DOUBLE
, RTX_VECTOR
, RTX_INT
, RTX_UNSPEC
};
2159 struct rtx_const
GTY(())
2161 ENUM_BITFIELD(kind
) kind
: 16;
2162 ENUM_BITFIELD(machine_mode
) mode
: 16;
2163 union rtx_const_un
{
2165 struct addr_const
GTY ((tag ("1"))) addr
;
2166 struct rtx_const_u_di
{
2169 } GTY ((tag ("0"))) di
;
2171 /* The max vector size we have is 16 wide; two variants for
2172 integral and floating point vectors. */
2173 struct rtx_const_int_vec
{
2176 } GTY ((tag ("2"))) int_vec
[16];
2178 REAL_VALUE_TYPE
GTY ((tag ("3"))) fp_vec
[8];
2180 } GTY ((desc ("%1.kind >= RTX_INT"), descbits ("1"))) un
;
2183 /* Uniquize all constants that appear in memory.
2184 Each constant in memory thus far output is recorded
2185 in `const_hash_table'. */
2187 struct constant_descriptor_tree
GTY(())
2189 /* More constant_descriptors with the same hash code. */
2190 struct constant_descriptor_tree
*next
;
2192 /* The label of the constant. */
2195 /* A MEM for the constant. */
2198 /* The value of the constant. */
2202 #define MAX_HASH_TABLE 1009
2203 static GTY(()) struct constant_descriptor_tree
*
2204 const_hash_table
[MAX_HASH_TABLE
];
2206 /* We maintain a hash table of STRING_CST values. Unless we are asked to force
2207 out a string constant, we defer output of the constants until we know
2208 they are actually used. This will be if something takes its address or if
2209 there is a usage of the string in the RTL of a function. */
2211 #define STRHASH(x) htab_hash_pointer (x)
2213 struct deferred_string
GTY(())
2220 static GTY ((param_is (struct deferred_string
))) htab_t const_str_htab
;
2222 /* Returns a hash code for X (which is a really a
2223 struct deferred_string *). */
2226 const_str_htab_hash (x
)
2229 return STRHASH (((const struct deferred_string
*) x
)->label
);
2232 /* Returns nonzero if the value represented by X (which is really a
2233 struct deferred_string *) is the same as that given by Y
2234 (which is really a char *). */
2237 const_str_htab_eq (x
, y
)
2241 return (((const struct deferred_string
*) x
)->label
== (const char *) y
);
2244 /* Compute a hash code for a constant expression. */
2250 return const_hash_1 (exp
) % MAX_HASH_TABLE
;
2260 enum tree_code code
= TREE_CODE (exp
);
2262 /* Either set P and LEN to the address and len of something to hash and
2263 exit the switch or return a value. */
2268 p
= (char *) &TREE_INT_CST (exp
);
2269 len
= sizeof TREE_INT_CST (exp
);
2273 return real_hash (TREE_REAL_CST_PTR (exp
));
2276 p
= TREE_STRING_POINTER (exp
);
2277 len
= TREE_STRING_LENGTH (exp
);
2281 return (const_hash_1 (TREE_REALPART (exp
)) * 5
2282 + const_hash_1 (TREE_IMAGPART (exp
)));
2285 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2289 len
= int_size_in_bytes (TREE_TYPE (exp
));
2290 tmp
= (char *) alloca (len
);
2291 get_set_constructor_bytes (exp
, (unsigned char *) tmp
, len
);
2299 hi
= 5 + int_size_in_bytes (TREE_TYPE (exp
));
2301 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2302 if (TREE_VALUE (link
))
2303 hi
= hi
* 603 + const_hash_1 (TREE_VALUE (link
));
2311 struct addr_const value
;
2313 decode_addr_const (exp
, &value
);
2314 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2316 /* Don't hash the address of the SYMBOL_REF;
2317 only use the offset and the symbol name. */
2319 p
= XSTR (value
.base
, 0);
2320 for (i
= 0; p
[i
] != 0; i
++)
2321 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2323 else if (GET_CODE (value
.base
) == LABEL_REF
)
2324 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2332 return (const_hash_1 (TREE_OPERAND (exp
, 0)) * 9
2333 + const_hash_1 (TREE_OPERAND (exp
, 1)));
2337 case NON_LVALUE_EXPR
:
2338 return const_hash_1 (TREE_OPERAND (exp
, 0)) * 7 + 2;
2341 /* A language specific constant. Just hash the code. */
2345 /* Compute hashing function */
2347 for (i
= 0; i
< len
; i
++)
2348 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2353 /* Compare t1 and t2, and return 1 only if they are known to result in
2354 the same bit pattern on output. */
2357 compare_constant (t1
, t2
)
2361 enum tree_code typecode
;
2363 if (t1
== NULL_TREE
)
2364 return t2
== NULL_TREE
;
2365 if (t2
== NULL_TREE
)
2368 if (TREE_CODE (t1
) != TREE_CODE (t2
))
2371 switch (TREE_CODE (t1
))
2374 /* Integer constants are the same only if the same width of type. */
2375 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2377 return tree_int_cst_equal (t1
, t2
);
2380 /* Real constants are the same only if the same width of type. */
2381 if (TYPE_PRECISION (TREE_TYPE (t1
)) != TYPE_PRECISION (TREE_TYPE (t2
)))
2384 return REAL_VALUES_IDENTICAL (TREE_REAL_CST (t1
), TREE_REAL_CST (t2
));
2387 if (flag_writable_strings
)
2390 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
)))
2393 return (TREE_STRING_LENGTH (t1
) == TREE_STRING_LENGTH (t2
)
2394 && ! memcmp (TREE_STRING_POINTER (t1
), TREE_STRING_POINTER (t2
),
2395 TREE_STRING_LENGTH (t1
)));
2398 return (compare_constant (TREE_REALPART (t1
), TREE_REALPART (t2
))
2399 && compare_constant (TREE_IMAGPART (t1
), TREE_IMAGPART (t2
)));
2402 typecode
= TREE_CODE (TREE_TYPE (t1
));
2403 if (typecode
!= TREE_CODE (TREE_TYPE (t2
)))
2406 if (typecode
== SET_TYPE
)
2408 int len
= int_size_in_bytes (TREE_TYPE (t2
));
2409 unsigned char *tmp1
, *tmp2
;
2411 if (int_size_in_bytes (TREE_TYPE (t1
)) != len
)
2414 tmp1
= (unsigned char *) alloca (len
);
2415 tmp2
= (unsigned char *) alloca (len
);
2417 if (get_set_constructor_bytes (t1
, tmp1
, len
) != NULL_TREE
)
2419 if (get_set_constructor_bytes (t2
, tmp2
, len
) != NULL_TREE
)
2422 return memcmp (tmp1
, tmp2
, len
) != 0;
2428 if (typecode
== ARRAY_TYPE
)
2430 HOST_WIDE_INT size_1
= int_size_in_bytes (TREE_TYPE (t1
));
2431 /* For arrays, check that the sizes all match. */
2432 if (TYPE_MODE (TREE_TYPE (t1
)) != TYPE_MODE (TREE_TYPE (t2
))
2434 || size_1
!= int_size_in_bytes (TREE_TYPE (t2
)))
2439 /* For record and union constructors, require exact type
2441 if (TREE_TYPE (t1
) != TREE_TYPE (t2
))
2445 for (l1
= CONSTRUCTOR_ELTS (t1
), l2
= CONSTRUCTOR_ELTS (t2
);
2447 l1
= TREE_CHAIN (l1
), l2
= TREE_CHAIN (l2
))
2449 /* Check that each value is the same... */
2450 if (! compare_constant (TREE_VALUE (l1
), TREE_VALUE (l2
)))
2452 /* ... and that they apply to the same fields! */
2453 if (typecode
== ARRAY_TYPE
)
2455 if (! compare_constant (TREE_PURPOSE (l1
),
2461 if (TREE_PURPOSE (l1
) != TREE_PURPOSE (l2
))
2466 return l1
== NULL_TREE
&& l2
== NULL_TREE
;
2472 struct addr_const value1
, value2
;
2474 decode_addr_const (t1
, &value1
);
2475 decode_addr_const (t2
, &value2
);
2476 return (value1
.offset
== value2
.offset
2477 && strcmp (XSTR (value1
.base
, 0), XSTR (value2
.base
, 0)) == 0);
2483 return (compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0))
2484 && compare_constant(TREE_OPERAND (t1
, 1), TREE_OPERAND (t2
, 1)));
2488 case NON_LVALUE_EXPR
:
2489 return compare_constant (TREE_OPERAND (t1
, 0), TREE_OPERAND (t2
, 0));
2494 nt1
= (*lang_hooks
.expand_constant
) (t1
);
2495 nt2
= (*lang_hooks
.expand_constant
) (t2
);
2496 if (nt1
!= t1
|| nt2
!= t2
)
2497 return compare_constant (nt1
, nt2
);
2503 /* Should not get here. */
2507 /* Record a list of constant expressions that were passed to
2508 output_constant_def but that could not be output right away. */
2510 struct deferred_constant
2512 struct deferred_constant
*next
;
2518 static struct deferred_constant
*deferred_constants
;
2520 /* Another list of constants which should be output after the
2522 static struct deferred_constant
*after_function_constants
;
2524 /* Nonzero means defer output of addressed subconstants
2525 (i.e., those for which output_constant_def is called.) */
2526 static int defer_addressed_constants_flag
;
2528 /* Start deferring output of subconstants. */
2531 defer_addressed_constants ()
2533 defer_addressed_constants_flag
++;
2536 /* Stop deferring output of subconstants,
2537 and output now all those that have been deferred. */
2540 output_deferred_addressed_constants ()
2542 struct deferred_constant
*p
, *next
;
2544 defer_addressed_constants_flag
--;
2546 if (defer_addressed_constants_flag
> 0)
2549 for (p
= deferred_constants
; p
; p
= next
)
2551 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2556 deferred_constants
= 0;
2559 /* Output any constants which should appear after a function. */
2562 output_after_function_constants ()
2564 struct deferred_constant
*p
, *next
;
2566 for (p
= after_function_constants
; p
; p
= next
)
2568 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2573 after_function_constants
= 0;
2576 /* Make a copy of the whole tree structure for a constant. This
2577 handles the same types of nodes that compare_constant handles. */
2583 switch (TREE_CODE (exp
))
2586 /* For ADDR_EXPR, we do not want to copy the decl whose address
2587 is requested. We do want to copy constants though. */
2588 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
2589 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2590 copy_constant (TREE_OPERAND (exp
, 0)));
2592 return copy_node (exp
);
2597 return copy_node (exp
);
2600 return build_complex (TREE_TYPE (exp
),
2601 copy_constant (TREE_REALPART (exp
)),
2602 copy_constant (TREE_IMAGPART (exp
)));
2606 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
2607 copy_constant (TREE_OPERAND (exp
, 0)),
2608 copy_constant (TREE_OPERAND (exp
, 1)));
2612 case NON_LVALUE_EXPR
:
2613 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2614 copy_constant (TREE_OPERAND (exp
, 0)));
2618 tree copy
= copy_node (exp
);
2619 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
2622 CONSTRUCTOR_ELTS (copy
) = list
;
2623 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2624 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
2625 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2626 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2627 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
2635 t
= (*lang_hooks
.expand_constant
) (exp
);
2637 return copy_constant (t
);
2644 /* Return an rtx representing a reference to constant data in memory
2645 for the constant expression EXP.
2647 If assembler code for such a constant has already been output,
2648 return an rtx to refer to it.
2649 Otherwise, output such a constant in memory (or defer it for later)
2650 and generate an rtx for it.
2652 If DEFER is nonzero, the output of string constants can be deferred
2653 and output only if referenced in the function after all optimizations.
2655 The TREE_CST_RTL of EXP is set up to point to that rtx.
2656 The const_hash_table records which constants already have label strings. */
2659 output_constant_def (exp
, defer
)
2664 struct constant_descriptor_tree
*desc
;
2665 struct deferred_string
**defstr
;
2669 int after_function
= 0;
2673 /* We can't just use the saved RTL if this is a deferred string constant
2674 and we are not to defer anymore. */
2675 if (TREE_CODE (exp
) != INTEGER_CST
&& TREE_CST_RTL (exp
)
2676 && (defer
|| !STRING_POOL_ADDRESS_P (XEXP (TREE_CST_RTL (exp
), 0))))
2677 return TREE_CST_RTL (exp
);
2679 /* Make sure any other constants whose addresses appear in EXP
2680 are assigned label numbers. */
2682 reloc
= output_addressed_constants (exp
);
2684 /* Compute hash code of EXP. Search the descriptors for that hash code
2685 to see if any of them describes EXP. If yes, the descriptor records
2686 the label number already assigned. */
2688 hash
= const_hash (exp
);
2690 for (desc
= const_hash_table
[hash
]; desc
; desc
= desc
->next
)
2691 if (compare_constant (exp
, desc
->value
))
2696 /* No constant equal to EXP is known to have been output.
2697 Make a constant descriptor to enter EXP in the hash table.
2698 Assign the label number and record it in the descriptor for
2699 future calls to this function to find. */
2701 /* Create a string containing the label name, in LABEL. */
2702 labelno
= const_labelno
++;
2703 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
2705 desc
= ggc_alloc (sizeof (*desc
));
2706 desc
->next
= const_hash_table
[hash
];
2707 desc
->label
= ggc_strdup (label
);
2708 desc
->value
= copy_constant (exp
);
2709 const_hash_table
[hash
] = desc
;
2711 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2713 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
2714 gen_rtx_SYMBOL_REF (Pmode
, desc
->label
));
2716 set_mem_attributes (rtl
, exp
, 1);
2717 set_mem_alias_set (rtl
, 0);
2718 set_mem_alias_set (rtl
, const_alias_set
);
2725 if (TREE_CODE (exp
) != INTEGER_CST
)
2726 TREE_CST_RTL (exp
) = rtl
;
2728 /* Optionally set flags or add text to the name to record information
2729 such as that it is a function name. If the name is changed, the macro
2730 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
2731 /* A previously-processed constant would already have section info
2735 /* Take care not to invoke targetm.encode_section_info for
2736 constants which don't have a TREE_CST_RTL. */
2737 if (TREE_CODE (exp
) != INTEGER_CST
)
2738 (*targetm
.encode_section_info
) (exp
, true);
2741 desc
->label
= XSTR (XEXP (desc
->rtl
, 0), 0);
2744 #ifdef CONSTANT_AFTER_FUNCTION_P
2745 if (current_function_decl
!= 0
2746 && CONSTANT_AFTER_FUNCTION_P (exp
))
2751 && STRING_POOL_ADDRESS_P (XEXP (rtl
, 0))
2752 && (!defer
|| defer_addressed_constants_flag
|| after_function
))
2754 defstr
= (struct deferred_string
**)
2755 htab_find_slot_with_hash (const_str_htab
, desc
->label
,
2756 STRHASH (desc
->label
), NO_INSERT
);
2759 /* If the string is currently deferred but we need to output it now,
2760 remove it from deferred string hash table. */
2762 labelno
= (*defstr
)->labelno
;
2763 STRING_POOL_ADDRESS_P (XEXP (rtl
, 0)) = 0;
2764 htab_clear_slot (const_str_htab
, (void **) defstr
);
2768 /* If this is the first time we've seen this particular constant,
2769 output it (or defer its output for later). */
2772 if (defer_addressed_constants_flag
|| after_function
)
2774 struct deferred_constant
*p
2775 = (struct deferred_constant
*)
2776 xmalloc (sizeof (struct deferred_constant
));
2778 p
->exp
= desc
->value
;
2780 p
->labelno
= labelno
;
2783 p
->next
= after_function_constants
;
2784 after_function_constants
= p
;
2788 p
->next
= deferred_constants
;
2789 deferred_constants
= p
;
2794 /* Do no output if -fsyntax-only. */
2795 if (! flag_syntax_only
)
2797 if (TREE_CODE (exp
) != STRING_CST
2799 || flag_writable_strings
2800 || (defstr
= (struct deferred_string
**)
2801 htab_find_slot_with_hash (const_str_htab
,
2803 STRHASH (desc
->label
),
2805 output_constant_def_contents (exp
, reloc
, labelno
);
2808 struct deferred_string
*p
;
2810 p
= (struct deferred_string
*)
2811 ggc_alloc (sizeof (struct deferred_string
));
2813 p
->exp
= desc
->value
;
2814 p
->label
= desc
->label
;
2815 p
->labelno
= labelno
;
2817 STRING_POOL_ADDRESS_P (XEXP (rtl
, 0)) = 1;
2826 /* Now output assembler code to define the label for EXP,
2827 and follow it with the data of EXP. */
2830 output_constant_def_contents (exp
, reloc
, labelno
)
2837 /* Align the location counter as required by EXP's data type. */
2838 align
= TYPE_ALIGN (TREE_TYPE (exp
));
2839 #ifdef CONSTANT_ALIGNMENT
2840 align
= CONSTANT_ALIGNMENT (exp
, align
);
2843 if (IN_NAMED_SECTION (exp
))
2844 named_section (exp
, NULL
, reloc
);
2846 (*targetm
.asm_out
.select_section
) (exp
, reloc
, align
);
2848 if (align
> BITS_PER_UNIT
)
2850 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
2853 /* Output the label itself. */
2854 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", labelno
);
2856 /* Output the value of EXP. */
2857 output_constant (exp
,
2858 (TREE_CODE (exp
) == STRING_CST
2859 ? MAX (TREE_STRING_LENGTH (exp
),
2860 int_size_in_bytes (TREE_TYPE (exp
)))
2861 : int_size_in_bytes (TREE_TYPE (exp
))),
2866 /* Used in the hash tables to avoid outputting the same constant
2867 twice. Unlike 'struct constant_descriptor_tree', RTX constants
2868 are output once per function, not once per file; there seems
2869 to be no reason for the difference. */
2871 struct constant_descriptor_rtx
GTY(())
2873 /* More constant_descriptors with the same hash code. */
2874 struct constant_descriptor_rtx
*next
;
2876 /* The label of the constant. */
2879 /* A MEM for the constant. */
2882 /* The value of the constant. */
2883 struct rtx_const value
;
2886 /* Structure to represent sufficient information about a constant so that
2887 it can be output when the constant pool is output, so that function
2888 integration can be done, and to simplify handling on machines that reference
2889 constant pool as base+displacement. */
2891 struct pool_constant
GTY(())
2893 struct constant_descriptor_rtx
*desc
;
2894 struct pool_constant
*next
;
2895 struct pool_constant
*next_sym
;
2897 enum machine_mode mode
;
2900 HOST_WIDE_INT offset
;
2904 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
2905 The argument is XSTR (... , 0) */
2907 #define SYMHASH(LABEL) (((unsigned long) (LABEL)) % MAX_RTX_HASH_TABLE)
2909 /* Initialize constant pool hashing for a new function. */
2912 init_varasm_status (f
)
2915 struct varasm_status
*p
;
2916 p
= (struct varasm_status
*) ggc_alloc (sizeof (struct varasm_status
));
2918 p
->x_const_rtx_hash_table
2919 = ((struct constant_descriptor_rtx
**)
2920 ggc_alloc_cleared (MAX_RTX_HASH_TABLE
2921 * sizeof (struct constant_descriptor_rtx
*)));
2922 p
->x_const_rtx_sym_hash_table
2923 = ((struct pool_constant
**)
2924 ggc_alloc_cleared (MAX_RTX_HASH_TABLE
2925 * sizeof (struct pool_constant
*)));
2927 p
->x_first_pool
= p
->x_last_pool
= 0;
2928 p
->x_pool_offset
= 0;
2932 /* Express an rtx for a constant integer (perhaps symbolic)
2933 as the sum of a symbol or label plus an explicit integer.
2934 They are stored into VALUE. */
2937 decode_rtx_const (mode
, x
, value
)
2938 enum machine_mode mode
;
2940 struct rtx_const
*value
;
2942 /* Clear the whole structure, including any gaps. */
2943 memset (value
, 0, sizeof (struct rtx_const
));
2945 value
->kind
= RTX_INT
; /* Most usual kind. */
2948 switch (GET_CODE (x
))
2951 value
->kind
= RTX_DOUBLE
;
2952 if (GET_MODE (x
) != VOIDmode
)
2954 const REAL_VALUE_TYPE
*r
= CONST_DOUBLE_REAL_VALUE (x
);
2956 value
->mode
= GET_MODE (x
);
2958 /* Copy the REAL_VALUE_TYPE by members so that we don't
2959 copy garbage from the original structure into our
2960 carefully cleaned hashing structure. */
2961 value
->un
.du
.class = r
->class;
2962 value
->un
.du
.sign
= r
->sign
;
2969 value
->un
.du
.exp
= r
->exp
;
2972 memcpy (value
->un
.du
.sig
, r
->sig
, sizeof (r
->sig
));
2980 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
2981 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
2989 units
= CONST_VECTOR_NUNITS (x
);
2990 value
->kind
= RTX_VECTOR
;
2993 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
)
2995 for (i
= 0; i
< units
; ++i
)
2997 rtx elt
= CONST_VECTOR_ELT (x
, i
);
2998 if (GET_CODE (elt
) == CONST_INT
)
3000 value
->un
.int_vec
[i
].low
= INTVAL (elt
);
3001 value
->un
.int_vec
[i
].high
= 0;
3005 value
->un
.int_vec
[i
].low
= CONST_DOUBLE_LOW (elt
);
3006 value
->un
.int_vec
[i
].high
= CONST_DOUBLE_HIGH (elt
);
3010 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
3012 for (i
= 0; i
< units
; ++i
)
3014 const REAL_VALUE_TYPE
*r
3015 = CONST_DOUBLE_REAL_VALUE (CONST_VECTOR_ELT (x
, i
));
3016 REAL_VALUE_TYPE
*d
= &value
->un
.fp_vec
[i
];
3018 /* Copy the REAL_VALUE_TYPE by members so that we don't
3019 copy garbage from the original structure into our
3020 carefully cleaned hashing structure. */
3021 d
->class = r
->class;
3032 memcpy (d
->sig
, r
->sig
, sizeof (r
->sig
));
3045 value
->un
.addr
.offset
= INTVAL (x
);
3051 value
->un
.addr
.base
= x
;
3056 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3058 value
->un
.addr
.base
= XEXP (x
, 0);
3059 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
3061 else if (GET_CODE (x
) == MINUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3063 value
->un
.addr
.base
= XEXP (x
, 0);
3064 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
3068 value
->un
.addr
.base
= x
;
3069 value
->un
.addr
.offset
= 0;
3074 value
->kind
= RTX_UNKNOWN
;
3078 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0
3079 && GET_CODE (value
->un
.addr
.base
) == UNSPEC
)
3081 /* For a simple UNSPEC, the base is set to the
3082 operand, the kind field is set to the index of
3083 the unspec expression.
3084 Together with the code below, in case that
3085 the operand is a SYMBOL_REF or LABEL_REF,
3086 the address of the string or the code_label
3087 is taken as base. */
3088 if (XVECLEN (value
->un
.addr
.base
, 0) == 1)
3090 value
->kind
= RTX_UNSPEC
+ XINT (value
->un
.addr
.base
, 1);
3091 value
->un
.addr
.base
= XVECEXP (value
->un
.addr
.base
, 0, 0);
3095 if (value
->kind
>= RTX_INT
&& value
->un
.addr
.base
!= 0)
3096 switch (GET_CODE (value
->un
.addr
.base
))
3100 /* Use the string's address, not the SYMBOL_REF's address,
3101 for the sake of addresses of library routines. */
3102 value
->un
.addr
.base
= (rtx
) XSTR (value
->un
.addr
.base
, 0);
3107 /* For a LABEL_REF, compare labels. */
3108 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
3115 /* Given a MINUS expression, simplify it if both sides
3116 include the same symbol. */
3119 simplify_subtraction (x
)
3122 struct rtx_const val0
, val1
;
3124 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
3125 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
3127 if (val0
.kind
>= RTX_INT
3128 && val0
.kind
== val1
.kind
3129 && val0
.un
.addr
.base
== val1
.un
.addr
.base
)
3130 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
3135 /* Compute a hash code for a constant RTL expression. */
3138 const_hash_rtx (mode
, x
)
3139 enum machine_mode mode
;
3143 struct rtx_const value
;
3144 unsigned int data
[sizeof(struct rtx_const
) / sizeof (unsigned int)];
3150 decode_rtx_const (mode
, x
, &u
.value
);
3152 /* Compute hashing function */
3154 for (i
= 0; i
< ARRAY_SIZE (u
.data
); i
++)
3155 hi
= hi
* 613 + u
.data
[i
];
3157 return hi
% MAX_RTX_HASH_TABLE
;
3160 /* Compare a constant rtl object X with a constant-descriptor DESC.
3161 Return 1 if DESC describes a constant with the same value as X. */
3164 compare_constant_rtx (mode
, x
, desc
)
3165 enum machine_mode mode
;
3167 struct constant_descriptor_rtx
*desc
;
3169 struct rtx_const value
;
3171 decode_rtx_const (mode
, x
, &value
);
3173 /* Compare constant contents. */
3174 return memcmp (&value
, &desc
->value
, sizeof (struct rtx_const
)) == 0;
3177 /* Construct a constant descriptor for the rtl-expression X.
3178 It is up to the caller to enter the descriptor in the hash table. */
3180 static struct constant_descriptor_rtx
*
3181 record_constant_rtx (mode
, x
)
3182 enum machine_mode mode
;
3185 struct constant_descriptor_rtx
*ptr
;
3187 ptr
= (struct constant_descriptor_rtx
*) ggc_alloc (sizeof (*ptr
));
3188 decode_rtx_const (mode
, x
, &ptr
->value
);
3193 /* Given a constant rtx X, return a MEM for the location in memory at which
3194 this constant has been placed. Return 0 if it not has been placed yet. */
3197 mem_for_const_double (x
)
3200 enum machine_mode mode
= GET_MODE (x
);
3201 struct constant_descriptor_rtx
*desc
;
3203 for (desc
= const_rtx_hash_table
[const_hash_rtx (mode
, x
)]; desc
;
3205 if (compare_constant_rtx (mode
, x
, desc
))
3211 /* Given a constant rtx X, make (or find) a memory constant for its value
3212 and return a MEM rtx to refer to it in memory. */
3215 force_const_mem (mode
, x
)
3216 enum machine_mode mode
;
3220 struct constant_descriptor_rtx
*desc
;
3223 struct pool_constant
*pool
;
3226 /* Compute hash code of X. Search the descriptors for that hash code
3227 to see if any of them describes X. If yes, we have an rtx to use. */
3228 hash
= const_hash_rtx (mode
, x
);
3229 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3230 if (compare_constant_rtx (mode
, x
, desc
))
3233 /* No constant equal to X is known to have been output.
3234 Make a constant descriptor to enter X in the hash table
3235 and make a MEM for it. */
3236 desc
= record_constant_rtx (mode
, x
);
3237 desc
->next
= const_rtx_hash_table
[hash
];
3238 const_rtx_hash_table
[hash
] = desc
;
3240 /* Align the location counter as required by EXP's data type. */
3241 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3242 #ifdef CONSTANT_ALIGNMENT
3243 align
= CONSTANT_ALIGNMENT (make_tree ((*lang_hooks
.types
.type_for_mode
)
3244 (mode
, 0), x
), align
);
3247 pool_offset
+= (align
/ BITS_PER_UNIT
) - 1;
3248 pool_offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3250 if (GET_CODE (x
) == LABEL_REF
)
3251 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3253 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3254 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3258 pool
->labelno
= const_labelno
;
3259 pool
->align
= align
;
3260 pool
->offset
= pool_offset
;
3267 last_pool
->next
= pool
;
3270 pool_offset
+= GET_MODE_SIZE (mode
);
3272 /* Create a string containing the label name, in LABEL. */
3273 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3277 /* Construct the SYMBOL_REF and the MEM. */
3279 pool
->desc
->rtl
= def
3280 = gen_rtx_MEM (mode
, gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
)));
3281 set_mem_alias_set (def
, const_alias_set
);
3282 set_mem_attributes (def
, (*lang_hooks
.types
.type_for_mode
) (mode
, 0), 1);
3283 RTX_UNCHANGING_P (def
) = 1;
3285 /* Add label to symbol hash table. */
3286 hash
= SYMHASH (XSTR (XEXP (def
, 0), 0));
3287 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3288 const_rtx_sym_hash_table
[hash
] = pool
;
3290 /* Mark the symbol_ref as belonging to this constants pool. */
3291 CONSTANT_POOL_ADDRESS_P (XEXP (def
, 0)) = 1;
3292 current_function_uses_const_pool
= 1;
3297 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3298 the corresponding pool_constant structure. */
3300 static struct pool_constant
*
3301 find_pool_constant (f
, addr
)
3305 struct pool_constant
*pool
;
3306 const char *label
= XSTR (addr
, 0);
3308 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3309 pool
= pool
->next_sym
)
3310 if (XSTR (XEXP (pool
->desc
->rtl
, 0), 0) == label
)
3316 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3319 get_pool_constant (addr
)
3322 return (find_pool_constant (cfun
, addr
))->constant
;
3325 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3326 and whether it has been output or not. */
3329 get_pool_constant_mark (addr
, pmarked
)
3333 struct pool_constant
*pool
= find_pool_constant (cfun
, addr
);
3334 *pmarked
= (pool
->mark
!= 0);
3335 return pool
->constant
;
3338 /* Likewise, but for the constant pool of a specific function. */
3341 get_pool_constant_for_function (f
, addr
)
3345 return (find_pool_constant (f
, addr
))->constant
;
3348 /* Similar, return the mode. */
3351 get_pool_mode (addr
)
3354 return (find_pool_constant (cfun
, addr
))->mode
;
3358 get_pool_mode_for_function (f
, addr
)
3362 return (find_pool_constant (f
, addr
))->mode
;
3365 /* Similar, return the offset in the constant pool. */
3368 get_pool_offset (addr
)
3371 return (find_pool_constant (cfun
, addr
))->offset
;
3374 /* Return the size of the constant pool. */
3382 /* Write all the constants in the constant pool. */
3385 output_constant_pool (fnname
, fndecl
)
3386 const char *fnname ATTRIBUTE_UNUSED
;
3387 tree fndecl ATTRIBUTE_UNUSED
;
3389 struct pool_constant
*pool
;
3393 /* It is possible for gcc to call force_const_mem and then to later
3394 discard the instructions which refer to the constant. In such a
3395 case we do not need to output the constant. */
3396 mark_constant_pool ();
3398 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3399 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3402 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3411 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3412 whose CODE_LABEL has been deleted. This can occur if a jump table
3413 is eliminated by optimization. If so, write a constant of zero
3414 instead. Note that this can also happen by turning the
3415 CODE_LABEL into a NOTE. */
3416 /* ??? This seems completely and utterly wrong. Certainly it's
3417 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3418 functioning even with INSN_DELETED_P and friends. */
3421 switch (GET_CODE (x
))
3424 if (GET_CODE (XEXP (x
, 0)) != PLUS
3425 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3427 tmp
= XEXP (XEXP (x
, 0), 0);
3432 if (INSN_DELETED_P (tmp
)
3433 || (GET_CODE (tmp
) == NOTE
3434 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
3445 /* First switch to correct section. */
3446 (*targetm
.asm_out
.select_rtx_section
) (pool
->mode
, x
, pool
->align
);
3448 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3449 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3450 pool
->align
, pool
->labelno
, done
);
3453 assemble_align (pool
->align
);
3455 /* Output the label. */
3456 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", pool
->labelno
);
3458 /* Output the value of the constant itself. */
3459 switch (GET_MODE_CLASS (pool
->mode
))
3462 if (GET_CODE (x
) != CONST_DOUBLE
)
3465 REAL_VALUE_FROM_CONST_DOUBLE (r
, x
);
3466 assemble_real (r
, pool
->mode
, pool
->align
);
3470 case MODE_PARTIAL_INT
:
3471 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), pool
->align
, 1);
3474 case MODE_VECTOR_FLOAT
:
3479 if (GET_CODE (x
) != CONST_VECTOR
)
3482 units
= CONST_VECTOR_NUNITS (x
);
3484 for (i
= 0; i
< units
; i
++)
3486 elt
= CONST_VECTOR_ELT (x
, i
);
3487 REAL_VALUE_FROM_CONST_DOUBLE (r
, elt
);
3488 assemble_real (r
, GET_MODE_INNER (pool
->mode
), pool
->align
);
3493 case MODE_VECTOR_INT
:
3498 if (GET_CODE (x
) != CONST_VECTOR
)
3501 units
= CONST_VECTOR_NUNITS (x
);
3503 for (i
= 0; i
< units
; i
++)
3505 elt
= CONST_VECTOR_ELT (x
, i
);
3506 assemble_integer (elt
, GET_MODE_UNIT_SIZE (pool
->mode
),
3516 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3521 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3522 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3525 /* Done with this pool. */
3526 first_pool
= last_pool
= 0;
3529 /* Look through the instructions for this function, and mark all the
3530 entries in the constant pool which are actually being used.
3531 Emit used deferred strings. */
3534 mark_constant_pool ()
3538 struct pool_constant
*pool
;
3540 if (first_pool
== 0 && htab_elements (const_str_htab
) == 0)
3543 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3546 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3548 mark_constants (PATTERN (insn
));
3550 for (link
= current_function_epilogue_delay_list
;
3552 link
= XEXP (link
, 1))
3554 insn
= XEXP (link
, 0);
3557 mark_constants (PATTERN (insn
));
3561 /* Look through appropriate parts of X, marking all entries in the
3562 constant pool which are actually being used. Entries that are only
3563 referenced by other constants are also marked as used. Emit
3564 deferred strings that are used. */
3571 const char *format_ptr
;
3576 if (GET_CODE (x
) == SYMBOL_REF
)
3578 mark_constant (&x
, NULL
);
3582 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3583 insns, not any notes that may be attached. We don't want to mark
3584 a constant just because it happens to appear in a REG_EQUIV note. */
3587 mark_constants (PATTERN (x
));
3591 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3593 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3595 switch (*format_ptr
++)
3598 mark_constants (XEXP (x
, i
));
3602 if (XVEC (x
, i
) != 0)
3606 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3607 mark_constants (XVECEXP (x
, i
, j
));
3627 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3628 to as used. Emit referenced deferred strings. This function can
3629 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
3632 mark_constant (current_rtx
, data
)
3634 void *data ATTRIBUTE_UNUSED
;
3636 rtx x
= *current_rtx
;
3641 else if (GET_CODE (x
) == SYMBOL_REF
)
3643 if (CONSTANT_POOL_ADDRESS_P (x
))
3645 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
3646 if (pool
->mark
== 0)
3649 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
3654 else if (STRING_POOL_ADDRESS_P (x
))
3656 struct deferred_string
**defstr
;
3658 defstr
= (struct deferred_string
**)
3659 htab_find_slot_with_hash (const_str_htab
, XSTR (x
, 0),
3660 STRHASH (XSTR (x
, 0)), NO_INSERT
);
3663 struct deferred_string
*p
= *defstr
;
3665 STRING_POOL_ADDRESS_P (x
) = 0;
3666 output_constant_def_contents (p
->exp
, 0, p
->labelno
);
3667 htab_clear_slot (const_str_htab
, (void **) defstr
);
3674 /* Find all the constants whose addresses are referenced inside of EXP,
3675 and make sure assembler code with a label has been output for each one.
3676 Indicate whether an ADDR_EXPR has been encountered. */
3679 output_addressed_constants (exp
)
3685 /* Give the front-end a chance to convert VALUE to something that
3686 looks more like a constant to the back-end. */
3687 exp
= (*lang_hooks
.expand_constant
) (exp
);
3689 switch (TREE_CODE (exp
))
3693 /* Go inside any operations that get_inner_reference can handle and see
3694 if what's inside is a constant: no need to do anything here for
3695 addresses of variables or functions. */
3696 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
3697 tem
= TREE_OPERAND (tem
, 0))
3700 if (TREE_CODE_CLASS (TREE_CODE (tem
)) == 'c'
3701 || TREE_CODE (tem
) == CONSTRUCTOR
)
3702 output_constant_def (tem
, 0);
3704 if (TREE_PUBLIC (tem
))
3712 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3713 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
3718 case NON_LVALUE_EXPR
:
3719 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3723 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
3724 if (TREE_VALUE (tem
) != 0)
3725 reloc
|= output_addressed_constants (TREE_VALUE (tem
));
3735 /* Return nonzero if VALUE is a valid constant-valued expression
3736 for use in initializing a static variable; one that can be an
3737 element of a "constant" initializer.
3739 Return null_pointer_node if the value is absolute;
3740 if it is relocatable, return the variable that determines the relocation.
3741 We assume that VALUE has been folded as much as possible;
3742 therefore, we do not need to check for such things as
3743 arithmetic-combinations of integers. */
3746 initializer_constant_valid_p (value
, endtype
)
3750 /* Give the front-end a chance to convert VALUE to something that
3751 looks more like a constant to the back-end. */
3752 value
= (*lang_hooks
.expand_constant
) (value
);
3754 switch (TREE_CODE (value
))
3757 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
3758 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
3759 && TREE_CONSTANT (value
)
3760 && CONSTRUCTOR_ELTS (value
))
3762 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
3765 return TREE_STATIC (value
) ? null_pointer_node
: 0;
3772 return null_pointer_node
;
3776 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
3778 case VIEW_CONVERT_EXPR
:
3779 case NON_LVALUE_EXPR
:
3780 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3784 /* Allow conversions between pointer types. */
3785 if (POINTER_TYPE_P (TREE_TYPE (value
))
3786 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3787 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3789 /* Allow conversions between real types. */
3790 if (FLOAT_TYPE_P (TREE_TYPE (value
))
3791 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3792 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3794 /* Allow length-preserving conversions between integer types. */
3795 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3796 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3797 && (TYPE_PRECISION (TREE_TYPE (value
))
3798 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3799 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3801 /* Allow conversions between other integer types only if
3803 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3804 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3806 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3808 if (inner
== null_pointer_node
)
3809 return null_pointer_node
;
3813 /* Allow (int) &foo provided int is as wide as a pointer. */
3814 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3815 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3816 && (TYPE_PRECISION (TREE_TYPE (value
))
3817 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3818 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3821 /* Likewise conversions from int to pointers, but also allow
3822 conversions from 0. */
3823 if (POINTER_TYPE_P (TREE_TYPE (value
))
3824 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3826 if (integer_zerop (TREE_OPERAND (value
, 0)))
3827 return null_pointer_node
;
3828 else if (TYPE_PRECISION (TREE_TYPE (value
))
3829 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
3830 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3834 /* Allow conversions to union types if the value inside is okay. */
3835 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
3836 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3841 if (! INTEGRAL_TYPE_P (endtype
)
3842 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3844 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3846 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3848 /* If either term is absolute, use the other terms relocation. */
3849 if (valid0
== null_pointer_node
)
3851 if (valid1
== null_pointer_node
)
3857 if (! INTEGRAL_TYPE_P (endtype
)
3858 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
3860 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3862 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
3864 /* Win if second argument is absolute. */
3865 if (valid1
== null_pointer_node
)
3867 /* Win if both arguments have the same relocation.
3868 Then the value is absolute. */
3869 if (valid0
== valid1
&& valid0
!= 0)
3870 return null_pointer_node
;
3872 /* Since GCC guarantees that string constants are unique in the
3873 generated code, a subtraction between two copies of the same
3874 constant string is absolute. */
3875 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
&&
3876 valid1
&& TREE_CODE (valid1
) == STRING_CST
&&
3877 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
3878 return null_pointer_node
;
3881 /* Support differences between labels. */
3882 if (INTEGRAL_TYPE_P (endtype
))
3885 op0
= TREE_OPERAND (value
, 0);
3886 op1
= TREE_OPERAND (value
, 1);
3888 /* Like STRIP_NOPS except allow the operand mode to widen.
3889 This works around a feature of fold that simplfies
3890 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
3891 that the narrower operation is cheaper. */
3893 while (TREE_CODE (op0
) == NOP_EXPR
3894 || TREE_CODE (op0
) == CONVERT_EXPR
3895 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
3897 tree inner
= TREE_OPERAND (op0
, 0);
3898 if (inner
== error_mark_node
3899 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3900 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
3901 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3906 while (TREE_CODE (op1
) == NOP_EXPR
3907 || TREE_CODE (op1
) == CONVERT_EXPR
3908 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
3910 tree inner
= TREE_OPERAND (op1
, 0);
3911 if (inner
== error_mark_node
3912 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
3913 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
3914 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
3919 if (TREE_CODE (op0
) == ADDR_EXPR
3920 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
3921 && TREE_CODE (op1
) == ADDR_EXPR
3922 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
3923 return null_pointer_node
;
3934 /* Output assembler code for constant EXP to FILE, with no label.
3935 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3936 Assumes output_addressed_constants has been done on EXP already.
3938 Generate exactly SIZE bytes of assembler data, padding at the end
3939 with zeros if necessary. SIZE must always be specified.
3941 SIZE is important for structure constructors,
3942 since trailing members may have been omitted from the constructor.
3943 It is also important for initialization of arrays from string constants
3944 since the full length of the string constant might not be wanted.
3945 It is also needed for initialization of unions, where the initializer's
3946 type is just one member, and that may not be as long as the union.
3948 There a case in which we would fail to output exactly SIZE bytes:
3949 for a structure constructor that wants to produce more than SIZE bytes.
3950 But such constructors will never be generated for any possible input.
3952 ALIGN is the alignment of the data in bits. */
3955 output_constant (exp
, size
, align
)
3960 enum tree_code code
;
3961 HOST_WIDE_INT thissize
;
3963 /* Some front-ends use constants other than the standard language-indepdent
3964 varieties, but which may still be output directly. Give the front-end a
3965 chance to convert EXP to a language-independent representation. */
3966 exp
= (*lang_hooks
.expand_constant
) (exp
);
3968 if (size
== 0 || flag_syntax_only
)
3971 /* Eliminate any conversions since we'll be outputting the underlying
3973 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
3974 || TREE_CODE (exp
) == NON_LVALUE_EXPR
3975 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
3976 exp
= TREE_OPERAND (exp
, 0);
3978 code
= TREE_CODE (TREE_TYPE (exp
));
3979 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
3981 /* Allow a constructor with no elements for any data type.
3982 This means to fill the space with zeros. */
3983 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
3985 assemble_zeros (size
);
3989 if (TREE_CODE (exp
) == FDESC_EXPR
)
3991 #ifdef ASM_OUTPUT_FDESC
3992 HOST_WIDE_INT part
= tree_low_cst (TREE_OPERAND (exp
, 1), 0);
3993 tree decl
= TREE_OPERAND (exp
, 0);
3994 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
4001 /* Now output the underlying data. If we've handling the padding, return.
4002 Otherwise, break and ensure THISSIZE is the size written. */
4010 case REFERENCE_TYPE
:
4011 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4012 EXPAND_INITIALIZER
),
4014 error ("initializer for integer value is too complicated");
4018 if (TREE_CODE (exp
) != REAL_CST
)
4019 error ("initializer for floating value is not a floating constant");
4021 assemble_real (TREE_REAL_CST (exp
),
4022 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0),
4027 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
4028 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
4029 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
4034 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4036 output_constructor (exp
, size
, align
);
4039 else if (TREE_CODE (exp
) == STRING_CST
)
4041 thissize
= MIN (TREE_STRING_LENGTH (exp
), size
);
4042 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
4050 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4051 output_constructor (exp
, size
, align
);
4057 if (TREE_CODE (exp
) == INTEGER_CST
)
4058 assemble_integer (expand_expr (exp
, NULL_RTX
,
4059 VOIDmode
, EXPAND_INITIALIZER
),
4060 thissize
, align
, 1);
4061 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
4063 unsigned char *buffer
= (unsigned char *) alloca (thissize
);
4064 if (get_set_constructor_bytes (exp
, buffer
, thissize
))
4066 assemble_string ((char *) buffer
, thissize
);
4069 error ("unknown set constructor type");
4081 assemble_zeros (size
);
4085 /* Subroutine of output_constructor, used for computing the size of
4086 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4087 type with an unspecified upper bound. */
4089 static unsigned HOST_WIDE_INT
4090 array_size_for_constructor (val
)
4095 /* This code used to attempt to handle string constants that are not
4096 arrays of single-bytes, but nothing else does, so there's no point in
4098 if (TREE_CODE (val
) == STRING_CST
)
4099 return TREE_STRING_LENGTH (val
);
4101 max_index
= NULL_TREE
;
4102 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
4104 tree index
= TREE_PURPOSE (i
);
4106 if (TREE_CODE (index
) == RANGE_EXPR
)
4107 index
= TREE_OPERAND (index
, 1);
4108 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4112 if (max_index
== NULL_TREE
)
4115 /* Compute the total number of array elements. */
4116 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
4118 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
4119 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
4121 /* Multiply by the array element unit size to find number of bytes. */
4122 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4124 return tree_low_cst (i
, 1);
4127 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4128 Generate at least SIZE bytes, padding if necessary. */
4131 output_constructor (exp
, size
, align
)
4136 tree type
= TREE_TYPE (exp
);
4137 tree link
, field
= 0;
4139 /* Number of bytes output or skipped so far.
4140 In other words, current position within the constructor. */
4141 HOST_WIDE_INT total_bytes
= 0;
4142 /* Non-zero means BYTE contains part of a byte, to be output. */
4143 int byte_buffer_in_use
= 0;
4146 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4149 if (TREE_CODE (type
) == RECORD_TYPE
)
4150 field
= TYPE_FIELDS (type
);
4152 if (TREE_CODE (type
) == ARRAY_TYPE
4153 && TYPE_DOMAIN (type
) != 0)
4154 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4156 /* As LINK goes through the elements of the constant,
4157 FIELD goes through the structure fields, if the constant is a structure.
4158 if the constant is a union, then we override this,
4159 by getting the field from the TREE_LIST element.
4160 But the constant could also be an array. Then FIELD is zero.
4162 There is always a maximum of one element in the chain LINK for unions
4163 (even if the initializer in a source program incorrectly contains
4165 for (link
= CONSTRUCTOR_ELTS (exp
);
4167 link
= TREE_CHAIN (link
),
4168 field
= field
? TREE_CHAIN (field
) : 0)
4170 tree val
= TREE_VALUE (link
);
4173 /* The element in a union constructor specifies the proper field
4175 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4176 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4177 && TREE_PURPOSE (link
) != 0)
4178 field
= TREE_PURPOSE (link
);
4180 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4181 index
= TREE_PURPOSE (link
);
4183 /* Eliminate the marker that makes a cast not be an lvalue. */
4187 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4189 unsigned HOST_WIDE_INT fieldsize
4190 = int_size_in_bytes (TREE_TYPE (type
));
4191 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4192 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4193 HOST_WIDE_INT index
;
4194 unsigned int align2
= min_align (align
, fieldsize
* BITS_PER_UNIT
);
4196 for (index
= lo_index
; index
<= hi_index
; index
++)
4198 /* Output the element's initial value. */
4200 assemble_zeros (fieldsize
);
4202 output_constant (val
, fieldsize
, align2
);
4204 /* Count its size. */
4205 total_bytes
+= fieldsize
;
4208 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4210 /* An element that is not a bit-field. */
4212 unsigned HOST_WIDE_INT fieldsize
;
4213 /* Since this structure is static,
4214 we know the positions are constant. */
4215 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4216 unsigned int align2
;
4219 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4220 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4222 /* Output any buffered-up bit-fields preceding this element. */
4223 if (byte_buffer_in_use
)
4225 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4227 byte_buffer_in_use
= 0;
4230 /* Advance to offset of this element.
4231 Note no alignment needed in an array, since that is guaranteed
4232 if each element has the proper size. */
4233 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4235 assemble_zeros (pos
- total_bytes
);
4239 /* Find the alignment of this element. */
4240 align2
= min_align (align
, BITS_PER_UNIT
* pos
);
4242 /* Determine size this element should occupy. */
4247 /* If this is an array with an unspecified upper bound,
4248 the initializer determines the size. */
4249 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4250 but we cannot do this until the deprecated support for
4251 initializing zero-length array members is removed. */
4252 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4253 && TYPE_DOMAIN (TREE_TYPE (field
))
4254 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4256 fieldsize
= array_size_for_constructor (val
);
4257 /* Given a non-empty initialization, this field had
4259 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4262 else if (DECL_SIZE_UNIT (field
))
4264 /* ??? This can't be right. If the decl size overflows
4265 a host integer we will silently emit no data. */
4266 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4267 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4271 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4273 /* Output the element's initial value. */
4275 assemble_zeros (fieldsize
);
4277 output_constant (val
, fieldsize
, align2
);
4279 /* Count its size. */
4280 total_bytes
+= fieldsize
;
4282 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4283 error ("invalid initial value for member `%s'",
4284 IDENTIFIER_POINTER (DECL_NAME (field
)));
4287 /* Element that is a bit-field. */
4289 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4290 HOST_WIDE_INT end_offset
4291 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4294 val
= integer_zero_node
;
4296 /* If this field does not start in this (or, next) byte,
4298 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4300 /* Output remnant of any bit field in previous bytes. */
4301 if (byte_buffer_in_use
)
4303 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4305 byte_buffer_in_use
= 0;
4308 /* If still not at proper byte, advance to there. */
4309 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4311 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4312 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4316 if (! byte_buffer_in_use
)
4319 /* We must split the element into pieces that fall within
4320 separate bytes, and combine each byte with previous or
4321 following bit-fields. */
4323 /* next_offset is the offset n fbits from the beginning of
4324 the structure to the next bit of this element to be processed.
4325 end_offset is the offset of the first bit past the end of
4327 while (next_offset
< end_offset
)
4331 HOST_WIDE_INT value
;
4332 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4333 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4335 /* Advance from byte to byte
4336 within this element when necessary. */
4337 while (next_byte
!= total_bytes
)
4339 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4344 /* Number of bits we can process at once
4345 (all part of the same byte). */
4346 this_time
= MIN (end_offset
- next_offset
,
4347 BITS_PER_UNIT
- next_bit
);
4348 if (BYTES_BIG_ENDIAN
)
4350 /* On big-endian machine, take the most significant bits
4351 first (of the bits that are significant)
4352 and put them into bytes from the most significant end. */
4353 shift
= end_offset
- next_offset
- this_time
;
4355 /* Don't try to take a bunch of bits that cross
4356 the word boundary in the INTEGER_CST. We can
4357 only select bits from the LOW or HIGH part
4359 if (shift
< HOST_BITS_PER_WIDE_INT
4360 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4362 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4363 shift
= HOST_BITS_PER_WIDE_INT
;
4366 /* Now get the bits from the appropriate constant word. */
4367 if (shift
< HOST_BITS_PER_WIDE_INT
)
4368 value
= TREE_INT_CST_LOW (val
);
4369 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4371 value
= TREE_INT_CST_HIGH (val
);
4372 shift
-= HOST_BITS_PER_WIDE_INT
;
4377 /* Get the result. This works only when:
4378 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4379 byte
|= (((value
>> shift
)
4380 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4381 << (BITS_PER_UNIT
- this_time
- next_bit
));
4385 /* On little-endian machines,
4386 take first the least significant bits of the value
4387 and pack them starting at the least significant
4388 bits of the bytes. */
4389 shift
= next_offset
- int_bit_position (field
);
4391 /* Don't try to take a bunch of bits that cross
4392 the word boundary in the INTEGER_CST. We can
4393 only select bits from the LOW or HIGH part
4395 if (shift
< HOST_BITS_PER_WIDE_INT
4396 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4397 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4399 /* Now get the bits from the appropriate constant word. */
4400 if (shift
< HOST_BITS_PER_WIDE_INT
)
4401 value
= TREE_INT_CST_LOW (val
);
4402 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4404 value
= TREE_INT_CST_HIGH (val
);
4405 shift
-= HOST_BITS_PER_WIDE_INT
;
4410 /* Get the result. This works only when:
4411 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4412 byte
|= (((value
>> shift
)
4413 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4417 next_offset
+= this_time
;
4418 byte_buffer_in_use
= 1;
4423 if (byte_buffer_in_use
)
4425 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4429 if (total_bytes
< size
)
4430 assemble_zeros (size
- total_bytes
);
4433 /* This TREE_LIST contains any weak symbol declarations waiting
4435 static GTY(()) tree weak_decls
;
4437 /* Mark DECL as weak. */
4443 DECL_WEAK (decl
) = 1;
4445 if (DECL_RTL_SET_P (decl
)
4446 && GET_CODE (DECL_RTL (decl
)) == MEM
4447 && XEXP (DECL_RTL (decl
), 0)
4448 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
4449 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
4452 /* Merge weak status between NEWDECL and OLDDECL. */
4455 merge_weak (newdecl
, olddecl
)
4459 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
4462 if (DECL_WEAK (newdecl
))
4466 /* NEWDECL is weak, but OLDDECL is not. */
4468 /* If we already output the OLDDECL, we're in trouble; we can't
4469 go back and make it weak. This error cannot caught in
4470 declare_weak because the NEWDECL and OLDDECL was not yet
4471 been merged; therefore, TREE_ASM_WRITTEN was not set. */
4472 if (TREE_ASM_WRITTEN (olddecl
))
4473 error_with_decl (newdecl
,
4474 "weak declaration of `%s' must precede definition");
4476 /* If we've already generated rtl referencing OLDDECL, we may
4477 have done so in a way that will not function properly with
4479 else if (TREE_USED (olddecl
)
4480 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)))
4481 warning_with_decl (newdecl
, "weak declaration of `%s' after first use results in unspecified behavior");
4485 /* We put the NEWDECL on the weak_decls list at some point.
4486 Replace it with the OLDDECL. */
4487 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
4488 if (TREE_VALUE (wd
) == newdecl
)
4490 TREE_VALUE (wd
) = olddecl
;
4493 /* We may not find the entry on the list. If NEWDECL is a
4494 weak alias, then we will have already called
4495 globalize_decl to remove the entry; in that case, we do
4496 not need to do anything. */
4499 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
4500 mark_weak (olddecl
);
4503 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
4504 weak. Just update NEWDECL to indicate that it's weak too. */
4505 mark_weak (newdecl
);
4508 /* Declare DECL to be a weak symbol. */
4514 if (! TREE_PUBLIC (decl
))
4515 error_with_decl (decl
, "weak declaration of `%s' must be public");
4516 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
4517 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4518 else if (SUPPORTS_WEAK
)
4520 if (! DECL_WEAK (decl
))
4521 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
4524 warning_with_decl (decl
, "weak declaration of `%s' not supported");
4529 /* Emit any pending weak declarations. */
4536 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
4538 tree decl
= TREE_VALUE (t
);
4539 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4541 if (! TREE_USED (decl
))
4544 #ifdef ASM_WEAKEN_DECL
4545 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
4547 #ifdef ASM_WEAKEN_LABEL
4548 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4550 #ifdef ASM_OUTPUT_WEAK_ALIAS
4551 warning ("only weak aliases are supported in this configuration");
4559 /* Emit the assembly bits to indicate that DECL is globally visible. */
4562 globalize_decl (decl
)
4565 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
4567 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
4568 if (DECL_WEAK (decl
))
4572 #ifdef ASM_WEAKEN_DECL
4573 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
4575 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4578 /* Remove this function from the pending weak list so that
4579 we do not emit multiple .weak directives for it. */
4580 for (p
= &weak_decls
; (t
= *p
) ; )
4582 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
4583 *p
= TREE_CHAIN (t
);
4585 p
= &TREE_CHAIN (t
);
4591 (*targetm
.asm_out
.globalize_label
) (asm_out_file
, name
);
4594 /* Emit an assembler directive to make the symbol for DECL an alias to
4595 the symbol for TARGET. */
4598 assemble_alias (decl
, target
)
4599 tree decl
, target ATTRIBUTE_UNUSED
;
4603 /* We must force creation of DECL_RTL for debug info generation, even though
4604 we don't use it here. */
4605 make_decl_rtl (decl
, NULL
);
4607 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4609 #ifdef ASM_OUTPUT_DEF
4610 /* Make name accessible from other files, if appropriate. */
4612 if (TREE_PUBLIC (decl
))
4614 globalize_decl (decl
);
4615 maybe_assemble_visibility (decl
);
4618 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4619 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4621 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4623 #else /* !ASM_OUTPUT_DEF */
4624 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
4625 if (! DECL_WEAK (decl
))
4626 warning ("only weak aliases are supported in this configuration");
4628 #ifdef ASM_WEAKEN_DECL
4629 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
4631 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4634 warning ("alias definitions not supported in this configuration; ignored");
4638 TREE_USED (decl
) = 1;
4639 TREE_ASM_WRITTEN (decl
) = 1;
4640 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
4643 /* Emit an assembler directive to set symbol for DECL visibility to
4647 default_assemble_visibility (decl
, visibility_type
)
4649 const char *visibility_type ATTRIBUTE_UNUSED
;
4653 name
= (* targetm
.strip_name_encoding
)
4654 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4656 #ifdef HAVE_GAS_HIDDEN
4657 fprintf (asm_out_file
, "\t.%s\t%s\n", visibility_type
, name
);
4659 warning ("visibility attribute not supported in this configuration; ignored");
4663 /* A helper function to call assemble_visibility when needed for a decl. */
4666 maybe_assemble_visibility (decl
)
4669 tree visibility
= lookup_attribute ("visibility", DECL_ATTRIBUTES (decl
));
4673 = TREE_STRING_POINTER (TREE_VALUE (TREE_VALUE (visibility
)));
4674 (* targetm
.asm_out
.visibility
) (decl
, type
);
4678 /* Returns 1 if the target configuration supports defining public symbols
4679 so that one of them will be chosen at link time instead of generating a
4680 multiply-defined symbol error, whether through the use of weak symbols or
4681 a target-specific mechanism for having duplicates discarded. */
4684 supports_one_only ()
4686 if (SUPPORTS_ONE_ONLY
)
4688 return SUPPORTS_WEAK
;
4691 /* Set up DECL as a public symbol that can be defined in multiple
4692 translation units without generating a linker error. */
4695 make_decl_one_only (decl
)
4698 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4701 TREE_PUBLIC (decl
) = 1;
4703 if (TREE_CODE (decl
) == VAR_DECL
4704 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4705 DECL_COMMON (decl
) = 1;
4706 else if (SUPPORTS_ONE_ONLY
)
4708 #ifdef MAKE_DECL_ONE_ONLY
4709 MAKE_DECL_ONE_ONLY (decl
);
4711 DECL_ONE_ONLY (decl
) = 1;
4713 else if (SUPPORTS_WEAK
)
4714 DECL_WEAK (decl
) = 1;
4722 const_str_htab
= htab_create_ggc (128, const_str_htab_hash
,
4723 const_str_htab_eq
, NULL
);
4724 in_named_htab
= htab_create (31, in_named_entry_hash
,
4725 in_named_entry_eq
, NULL
);
4727 const_alias_set
= new_alias_set ();
4731 decl_tls_model (decl
)
4734 enum tls_model kind
;
4735 tree attr
= lookup_attribute ("tls_model", DECL_ATTRIBUTES (decl
));
4740 attr
= TREE_VALUE (TREE_VALUE (attr
));
4741 if (TREE_CODE (attr
) != STRING_CST
)
4743 if (!strcmp (TREE_STRING_POINTER (attr
), "local-exec"))
4744 kind
= TLS_MODEL_LOCAL_EXEC
;
4745 else if (!strcmp (TREE_STRING_POINTER (attr
), "initial-exec"))
4746 kind
= TLS_MODEL_INITIAL_EXEC
;
4747 else if (!strcmp (TREE_STRING_POINTER (attr
), "local-dynamic"))
4748 kind
= optimize
? TLS_MODEL_LOCAL_DYNAMIC
: TLS_MODEL_GLOBAL_DYNAMIC
;
4749 else if (!strcmp (TREE_STRING_POINTER (attr
), "global-dynamic"))
4750 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4756 is_local
= (*targetm
.binds_local_p
) (decl
);
4760 kind
= TLS_MODEL_LOCAL_EXEC
;
4762 kind
= TLS_MODEL_INITIAL_EXEC
;
4764 /* Local dynamic is inefficient when we're not combining the
4765 parts of the address. */
4766 else if (optimize
&& is_local
)
4767 kind
= TLS_MODEL_LOCAL_DYNAMIC
;
4769 kind
= TLS_MODEL_GLOBAL_DYNAMIC
;
4770 if (kind
< flag_tls_default
)
4771 kind
= flag_tls_default
;
4776 /* Select a set of attributes for section NAME based on the properties
4777 of DECL and whether or not RELOC indicates that DECL's initializer
4778 might contain runtime relocations.
4780 We make the section read-only and executable for a function decl,
4781 read-only for a const data decl, and writable for a non-const data decl. */
4784 default_section_type_flags (decl
, name
, reloc
)
4789 return default_section_type_flags_1 (decl
, name
, reloc
, flag_pic
);
4793 default_section_type_flags_1 (decl
, name
, reloc
, shlib
)
4801 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4802 flags
= SECTION_CODE
;
4803 else if (decl
&& decl_readonly_section_1 (decl
, reloc
, shlib
))
4806 flags
= SECTION_WRITE
;
4808 if (decl
&& DECL_ONE_ONLY (decl
))
4809 flags
|= SECTION_LINKONCE
;
4811 if (decl
&& TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
4812 flags
|= SECTION_TLS
| SECTION_WRITE
;
4814 if (strcmp (name
, ".bss") == 0
4815 || strncmp (name
, ".bss.", 5) == 0
4816 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4817 || strcmp (name
, ".sbss") == 0
4818 || strncmp (name
, ".sbss.", 6) == 0
4819 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0
4820 || strcmp (name
, ".tbss") == 0
4821 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4822 flags
|= SECTION_BSS
;
4824 if (strcmp (name
, ".tdata") == 0
4825 || strcmp (name
, ".tbss") == 0
4826 || strncmp (name
, ".gnu.linkonce.td.", 17) == 0
4827 || strncmp (name
, ".gnu.linkonce.tb.", 17) == 0)
4828 flags
|= SECTION_TLS
;
4830 /* These three sections have special ELF types. They are neither
4831 SHT_PROGBITS nor SHT_NOBITS, so when changing sections we don't
4832 want to print a section type (@progbits or @nobits). If someone
4833 is silly enough to emit code or TLS variables to one of these
4834 sections, then don't handle them specially. */
4835 if (!(flags
& (SECTION_CODE
| SECTION_BSS
| SECTION_TLS
))
4836 && (strcmp (name
, ".init_array") == 0
4837 || strcmp (name
, ".fini_array") == 0
4838 || strcmp (name
, ".preinit_array") == 0))
4839 flags
|= SECTION_NOTYPE
;
4844 /* Output assembly to switch to section NAME with attribute FLAGS.
4845 Four variants for common object file formats. */
4848 default_no_named_section (name
, flags
)
4849 const char *name ATTRIBUTE_UNUSED
;
4850 unsigned int flags ATTRIBUTE_UNUSED
;
4852 /* Some object formats don't support named sections at all. The
4853 front-end should already have flagged this as an error. */
4858 default_elf_asm_named_section (name
, flags
)
4862 char flagchars
[10], *f
= flagchars
;
4864 if (! named_section_first_declaration (name
))
4866 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
4870 if (!(flags
& SECTION_DEBUG
))
4872 if (flags
& SECTION_WRITE
)
4874 if (flags
& SECTION_CODE
)
4876 if (flags
& SECTION_SMALL
)
4878 if (flags
& SECTION_MERGE
)
4880 if (flags
& SECTION_STRINGS
)
4882 if (flags
& SECTION_TLS
)
4886 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"", name
, flagchars
);
4888 if (!(flags
& SECTION_NOTYPE
))
4892 if (flags
& SECTION_BSS
)
4897 fprintf (asm_out_file
, ",@%s", type
);
4899 if (flags
& SECTION_ENTSIZE
)
4900 fprintf (asm_out_file
, ",%d", flags
& SECTION_ENTSIZE
);
4903 putc ('\n', asm_out_file
);
4907 default_coff_asm_named_section (name
, flags
)
4911 char flagchars
[8], *f
= flagchars
;
4913 if (flags
& SECTION_WRITE
)
4915 if (flags
& SECTION_CODE
)
4919 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
4923 default_pe_asm_named_section (name
, flags
)
4927 default_coff_asm_named_section (name
, flags
);
4929 if (flags
& SECTION_LINKONCE
)
4931 /* Functions may have been compiled at various levels of
4932 optimization so we can't use `same_size' here.
4933 Instead, have the linker pick one. */
4934 fprintf (asm_out_file
, "\t.linkonce %s\n",
4935 (flags
& SECTION_CODE
? "discard" : "same_size"));
4939 /* Used for vtable gc in GNU binutils. Record that the pointer at OFFSET
4940 from SYMBOL is used in all classes derived from SYMBOL. */
4943 assemble_vtable_entry (symbol
, offset
)
4945 HOST_WIDE_INT offset
;
4947 fputs ("\t.vtable_entry ", asm_out_file
);
4948 output_addr_const (asm_out_file
, symbol
);
4949 fputs (", ", asm_out_file
);
4950 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_DEC
, offset
);
4951 fputc ('\n', asm_out_file
);
4954 /* Used for vtable gc in GNU binutils. Record the class hierarchy by noting
4955 that the vtable symbol CHILD is derived from the vtable symbol PARENT. */
4958 assemble_vtable_inherit (child
, parent
)
4961 fputs ("\t.vtable_inherit ", asm_out_file
);
4962 output_addr_const (asm_out_file
, child
);
4963 fputs (", ", asm_out_file
);
4964 output_addr_const (asm_out_file
, parent
);
4965 fputc ('\n', asm_out_file
);
4968 /* The lame default section selector. */
4971 default_select_section (decl
, reloc
, align
)
4974 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
4976 bool readonly
= false;
4980 if (decl_readonly_section (decl
, reloc
))
4983 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
4985 if (! ((flag_pic
&& reloc
)
4986 || !TREE_READONLY (decl
)
4987 || TREE_SIDE_EFFECTS (decl
)
4988 || !TREE_CONSTANT (decl
)))
4991 else if (TREE_CODE (decl
) == STRING_CST
)
4992 readonly
= !flag_writable_strings
;
4993 else if (! (flag_pic
&& reloc
))
4997 readonly_data_section ();
5002 /* A helper function for default_elf_select_section and
5003 default_elf_unique_section. Categorizes the DECL. */
5005 enum section_category
5010 SECCAT_RODATA_MERGE_STR
,
5011 SECCAT_RODATA_MERGE_STR_INIT
,
5012 SECCAT_RODATA_MERGE_CONST
,
5017 /* To optimize loading of shared programs, define following subsections
5019 _REL Contains data that has relocations, so they get grouped
5020 together and dynamic linker will visit fewer pages in memory.
5021 _RO Contains data that is otherwise read-only. This is useful
5022 with prelinking as most relocations won't be dynamically
5023 linked and thus stay read only.
5024 _LOCAL Marks data containing relocations only to local objects.
5025 These relocations will get fully resolved by prelinking. */
5027 SECCAT_DATA_REL_LOCAL
,
5029 SECCAT_DATA_REL_RO_LOCAL
,
5039 static enum section_category
5040 categorize_decl_for_section
PARAMS ((tree
, int, int));
5042 static enum section_category
5043 categorize_decl_for_section (decl
, reloc
, shlib
)
5048 enum section_category ret
;
5050 if (TREE_CODE (decl
) == FUNCTION_DECL
)
5052 else if (TREE_CODE (decl
) == STRING_CST
)
5054 if (flag_writable_strings
)
5057 return SECCAT_RODATA_MERGE_STR
;
5059 else if (TREE_CODE (decl
) == VAR_DECL
)
5061 if (DECL_INITIAL (decl
) == NULL
5062 || DECL_INITIAL (decl
) == error_mark_node
)
5064 else if (! TREE_READONLY (decl
)
5065 || TREE_SIDE_EFFECTS (decl
)
5066 || ! TREE_CONSTANT (DECL_INITIAL (decl
)))
5068 if (shlib
&& (reloc
& 2))
5069 ret
= SECCAT_DATA_REL
;
5070 else if (shlib
&& reloc
)
5071 ret
= SECCAT_DATA_REL_LOCAL
;
5075 else if (shlib
&& (reloc
& 2))
5076 ret
= SECCAT_DATA_REL_RO
;
5077 else if (shlib
&& reloc
)
5078 ret
= SECCAT_DATA_REL_RO_LOCAL
;
5079 else if (flag_merge_constants
< 2)
5080 /* C and C++ don't allow different variables to share the same
5081 location. -fmerge-all-constants allows even that (at the
5082 expense of not conforming). */
5083 ret
= SECCAT_RODATA
;
5084 else if (TREE_CODE (DECL_INITIAL (decl
)) == STRING_CST
)
5085 ret
= SECCAT_RODATA_MERGE_STR_INIT
;
5087 ret
= SECCAT_RODATA_MERGE_CONST
;
5089 else if (TREE_CODE (decl
) == CONSTRUCTOR
)
5091 if ((shlib
&& reloc
)
5092 || TREE_SIDE_EFFECTS (decl
)
5093 || ! TREE_CONSTANT (decl
))
5096 ret
= SECCAT_RODATA
;
5099 ret
= SECCAT_RODATA
;
5101 /* There are no read-only thread-local sections. */
5102 if (TREE_CODE (decl
) == VAR_DECL
&& DECL_THREAD_LOCAL (decl
))
5104 if (ret
== SECCAT_BSS
)
5110 /* If the target uses small data sections, select it. */
5111 else if ((*targetm
.in_small_data_p
) (decl
))
5113 if (ret
== SECCAT_BSS
)
5115 else if (targetm
.have_srodata_section
&& ret
== SECCAT_RODATA
)
5116 ret
= SECCAT_SRODATA
;
5125 decl_readonly_section (decl
, reloc
)
5129 return decl_readonly_section_1 (decl
, reloc
, flag_pic
);
5133 decl_readonly_section_1 (decl
, reloc
, shlib
)
5138 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5141 case SECCAT_RODATA_MERGE_STR
:
5142 case SECCAT_RODATA_MERGE_STR_INIT
:
5143 case SECCAT_RODATA_MERGE_CONST
:
5144 case SECCAT_SRODATA
:
5153 /* Select a section based on the above categorization. */
5156 default_elf_select_section (decl
, reloc
, align
)
5159 unsigned HOST_WIDE_INT align
;
5161 default_elf_select_section_1 (decl
, reloc
, align
, flag_pic
);
5165 default_elf_select_section_1 (decl
, reloc
, align
, shlib
)
5168 unsigned HOST_WIDE_INT align
;
5171 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5174 /* We're not supposed to be called on FUNCTION_DECLs. */
5177 readonly_data_section ();
5179 case SECCAT_RODATA_MERGE_STR
:
5180 mergeable_string_section (decl
, align
, 0);
5182 case SECCAT_RODATA_MERGE_STR_INIT
:
5183 mergeable_string_section (DECL_INITIAL (decl
), align
, 0);
5185 case SECCAT_RODATA_MERGE_CONST
:
5186 mergeable_constant_section (DECL_MODE (decl
), align
, 0);
5188 case SECCAT_SRODATA
:
5189 named_section (NULL_TREE
, ".sdata2", reloc
);
5194 case SECCAT_DATA_REL
:
5195 named_section (NULL_TREE
, ".data.rel", reloc
);
5197 case SECCAT_DATA_REL_LOCAL
:
5198 named_section (NULL_TREE
, ".data.rel.local", reloc
);
5200 case SECCAT_DATA_REL_RO
:
5201 named_section (NULL_TREE
, ".data.rel.ro", reloc
);
5203 case SECCAT_DATA_REL_RO_LOCAL
:
5204 named_section (NULL_TREE
, ".data.rel.ro.local", reloc
);
5207 named_section (NULL_TREE
, ".sdata", reloc
);
5210 named_section (NULL_TREE
, ".tdata", reloc
);
5213 #ifdef BSS_SECTION_ASM_OP
5216 named_section (NULL_TREE
, ".bss", reloc
);
5220 named_section (NULL_TREE
, ".sbss", reloc
);
5223 named_section (NULL_TREE
, ".tbss", reloc
);
5230 /* Construct a unique section name based on the decl name and the
5231 categorization performed above. */
5234 default_unique_section (decl
, reloc
)
5238 default_unique_section_1 (decl
, reloc
, flag_pic
);
5242 default_unique_section_1 (decl
, reloc
, shlib
)
5247 bool one_only
= DECL_ONE_ONLY (decl
);
5248 const char *prefix
, *name
;
5252 switch (categorize_decl_for_section (decl
, reloc
, shlib
))
5255 prefix
= one_only
? ".gnu.linkonce.t." : ".text.";
5258 case SECCAT_RODATA_MERGE_STR
:
5259 case SECCAT_RODATA_MERGE_STR_INIT
:
5260 case SECCAT_RODATA_MERGE_CONST
:
5261 prefix
= one_only
? ".gnu.linkonce.r." : ".rodata.";
5263 case SECCAT_SRODATA
:
5264 prefix
= one_only
? ".gnu.linkonce.s2." : ".sdata2.";
5267 case SECCAT_DATA_REL
:
5268 case SECCAT_DATA_REL_LOCAL
:
5269 case SECCAT_DATA_REL_RO
:
5270 case SECCAT_DATA_REL_RO_LOCAL
:
5271 prefix
= one_only
? ".gnu.linkonce.d." : ".data.";
5274 prefix
= one_only
? ".gnu.linkonce.s." : ".sdata.";
5277 prefix
= one_only
? ".gnu.linkonce.b." : ".bss.";
5280 prefix
= one_only
? ".gnu.linkonce.sb." : ".sbss.";
5283 prefix
= one_only
? ".gnu.linkonce.td." : ".tdata.";
5286 prefix
= one_only
? ".gnu.linkonce.tb." : ".tbss.";
5291 plen
= strlen (prefix
);
5293 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5294 name
= (* targetm
.strip_name_encoding
) (name
);
5295 nlen
= strlen (name
);
5297 string
= alloca (nlen
+ plen
+ 1);
5298 memcpy (string
, prefix
, plen
);
5299 memcpy (string
+ plen
, name
, nlen
+ 1);
5301 DECL_SECTION_NAME (decl
) = build_string (nlen
+ plen
, string
);
5305 default_select_rtx_section (mode
, x
, align
)
5306 enum machine_mode mode ATTRIBUTE_UNUSED
;
5308 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
5311 switch (GET_CODE (x
))
5323 readonly_data_section ();
5327 default_elf_select_rtx_section (mode
, x
, align
)
5328 enum machine_mode mode
;
5330 unsigned HOST_WIDE_INT align
;
5332 /* ??? Handle small data here somehow. */
5335 switch (GET_CODE (x
))
5339 named_section (NULL_TREE
, ".data.rel.ro", 3);
5343 named_section (NULL_TREE
, ".data.rel.ro.local", 1);
5350 mergeable_constant_section (mode
, align
, 0);
5353 /* By default, we do nothing for encode_section_info, so we need not
5354 do anything but discard the '*' marker. */
5357 default_strip_name_encoding (str
)
5360 return str
+ (*str
== '*');
5363 /* Assume ELF-ish defaults, since that's pretty much the most liberal
5364 wrt cross-module name binding. */
5367 default_binds_local_p (exp
)
5370 return default_binds_local_p_1 (exp
, flag_pic
);
5374 default_binds_local_p_1 (exp
, shlib
)
5380 /* A non-decl is an entry in the constant pool. */
5383 /* Static variables are always local. */
5384 else if (! TREE_PUBLIC (exp
))
5386 /* A variable is local if the user tells us so. */
5387 else if (MODULE_LOCAL_P (exp
))
5389 /* Otherwise, variables defined outside this object may not be local. */
5390 else if (DECL_EXTERNAL (exp
))
5392 /* Linkonce and weak data are never local. */
5393 else if (DECL_ONE_ONLY (exp
) || DECL_WEAK (exp
))
5395 /* If PIC, then assume that any global name can be overridden by
5396 symbols resolved from other modules. */
5399 /* Uninitialized COMMON variable may be unified with symbols
5400 resolved from other modules. */
5401 else if (DECL_COMMON (exp
)
5402 && (DECL_INITIAL (exp
) == NULL
5403 || DECL_INITIAL (exp
) == error_mark_node
))
5405 /* Otherwise we're left with initialized (or non-common) global data
5406 which is of necessity defined locally. */
5413 /* Default function to output code that will globalize a label. A
5414 target must define GLOBAL_ASM_OP or provide it's own function to
5415 globalize a label. */
5416 #ifdef GLOBAL_ASM_OP
5418 default_globalize_label (stream
, name
)
5422 fputs (GLOBAL_ASM_OP
, stream
);
5423 assemble_name (stream
, name
);
5424 putc ('\n', stream
);
5426 #endif /* GLOBAL_ASM_OP */
5428 #include "gt-varasm.h"