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
;
68 extern struct obstack permanent_obstack
;
69 #define obstack_chunk_alloc xmalloc
72 struct constant_descriptor
;
76 #define MAX_RTX_HASH_TABLE 61
80 /* Hash facility for making memory-constants
81 from constant rtl-expressions. It is used on RISC machines
82 where immediate integer arguments and constant addresses are restricted
83 so that such constants must be stored in memory.
85 This pool of constants is reinitialized for each function
86 so each function gets its own constants-pool that comes right before
88 struct constant_descriptor
**x_const_rtx_hash_table
;
89 struct pool_constant
**x_const_rtx_sym_hash_table
;
91 /* Pointers to first and last constant in pool. */
92 struct pool_constant
*x_first_pool
, *x_last_pool
;
94 /* Current offset in constant pool (does not include any machine-specific
96 HOST_WIDE_INT x_pool_offset
;
98 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
99 They are chained through the CONST_DOUBLE_CHAIN. */
100 rtx x_const_double_chain
;
103 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
104 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
105 #define first_pool (cfun->varasm->x_first_pool)
106 #define last_pool (cfun->varasm->x_last_pool)
107 #define pool_offset (cfun->varasm->x_pool_offset)
108 #define const_double_chain (cfun->varasm->x_const_double_chain)
110 /* Number for making the label on the next
111 constant that is stored in memory. */
115 /* Number for making the label on the next
116 static variable internal to a function. */
120 /* Carry information from ASM_DECLARE_OBJECT_NAME
121 to ASM_FINISH_DECLARE_OBJECT. */
123 int size_directive_output
;
125 /* The last decl for which assemble_variable was called,
126 if it did ASM_DECLARE_OBJECT_NAME.
127 If the last call to assemble_variable didn't do that,
130 tree last_assemble_variable_decl
;
132 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
133 So giving constant the alias set for the type will allow such
134 initializations to appear to conflict with the load of the constant. We
135 avoid this by giving all constants an alias set for just constants.
136 Since there will be no stores to that alias set, nothing will ever
137 conflict with them. */
139 static HOST_WIDE_INT const_alias_set
;
141 static const char *strip_reg_name
PARAMS ((const char *));
142 static int contains_pointers_p
PARAMS ((tree
));
143 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
144 static int const_hash
PARAMS ((tree
));
145 static int compare_constant
PARAMS ((tree
,
146 struct constant_descriptor
*));
147 static const unsigned char *compare_constant_1
PARAMS ((tree
, const unsigned char *));
148 static struct constant_descriptor
*record_constant
PARAMS ((tree
));
149 static void record_constant_1
PARAMS ((tree
));
150 static tree copy_constant
PARAMS ((tree
));
151 static void output_constant_def_contents
PARAMS ((tree
, int, int));
152 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
153 struct rtx_const
*));
154 static int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
155 static int compare_constant_rtx
PARAMS ((enum machine_mode
, rtx
,
156 struct constant_descriptor
*));
157 static struct constant_descriptor
*record_constant_rtx
PARAMS ((enum machine_mode
,
159 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
160 static void mark_constant_pool
PARAMS ((void));
161 static void mark_constants
PARAMS ((rtx
));
162 static int mark_constant
PARAMS ((rtx
*current_rtx
, void *data
));
163 static int output_addressed_constants
PARAMS ((tree
));
164 static void output_after_function_constants
PARAMS ((void));
165 static unsigned HOST_WIDE_INT array_size_for_constructor
PARAMS ((tree
));
166 static unsigned min_align
PARAMS ((unsigned, unsigned));
167 static void output_constructor
PARAMS ((tree
, HOST_WIDE_INT
,
169 static void globalize_decl
PARAMS ((tree
));
170 static int in_named_entry_eq
PARAMS ((const PTR
, const PTR
));
171 static hashval_t in_named_entry_hash
PARAMS ((const PTR
));
172 #ifdef ASM_OUTPUT_BSS
173 static void asm_output_bss
PARAMS ((FILE *, tree
, const char *, int, int));
175 #ifdef BSS_SECTION_ASM_OP
176 #ifdef ASM_OUTPUT_ALIGNED_BSS
177 static void asm_output_aligned_bss
PARAMS ((FILE *, tree
, const char *,
180 #endif /* BSS_SECTION_ASM_OP */
181 static void mark_pool_constant
PARAMS ((struct pool_constant
*));
182 static void mark_const_hash_entry
PARAMS ((void *));
183 static int mark_const_str_htab_1
PARAMS ((void **, void *));
184 static void mark_const_str_htab
PARAMS ((void *));
185 static hashval_t const_str_htab_hash
PARAMS ((const void *x
));
186 static int const_str_htab_eq
PARAMS ((const void *x
, const void *y
));
187 static void const_str_htab_del
PARAMS ((void *));
188 static void asm_emit_uninitialised
PARAMS ((tree
, const char*, int, int));
189 static void resolve_unique_section
PARAMS ((tree
, int, int));
190 static void mark_weak
PARAMS ((tree
));
192 static enum in_section
{ no_section
, in_text
, in_data
, in_named
193 #ifdef BSS_SECTION_ASM_OP
196 #ifdef CTORS_SECTION_ASM_OP
199 #ifdef DTORS_SECTION_ASM_OP
202 #ifdef EXTRA_SECTIONS
205 } in_section
= no_section
;
207 /* Return a non-zero value if DECL has a section attribute. */
208 #ifndef IN_NAMED_SECTION
209 #define IN_NAMED_SECTION(DECL) \
210 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
211 && DECL_SECTION_NAME (DECL) != NULL_TREE)
214 /* Text of section name when in_section == in_named. */
215 static const char *in_named_name
;
217 /* Hash table of flags that have been used for a particular named section. */
219 struct in_named_entry
226 static htab_t in_named_htab
;
228 /* Define functions like text_section for any extra sections. */
229 #ifdef EXTRA_SECTION_FUNCTIONS
230 EXTRA_SECTION_FUNCTIONS
233 /* Tell assembler to switch to text section. */
238 if (in_section
!= in_text
)
243 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
245 in_section
= in_text
;
249 /* Tell assembler to switch to data section. */
254 if (in_section
!= in_data
)
256 if (flag_shared_data
)
258 #ifdef SHARED_SECTION_ASM_OP
259 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
261 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
265 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
267 in_section
= in_data
;
270 /* Tell assembler to ALWAYS switch to data section, in case
271 it's not sure where it is. */
274 force_data_section ()
276 in_section
= no_section
;
280 /* Tell assembler to switch to read-only data section. This is normally
284 readonly_data_section ()
286 #ifdef READONLY_DATA_SECTION
287 READONLY_DATA_SECTION (); /* Note this can call data_section. */
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 && (flag_function_or_data_sections
471 || (targetm
.have_named_sections
472 && DECL_ONE_ONLY (decl
))))
473 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 ASM_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.
573 RELOC is the `reloc' argument to SELECT_SECTION. */
576 variable_section (decl
, reloc
)
580 if (IN_NAMED_SECTION (decl
))
581 named_section (decl
, NULL
, reloc
);
584 /* C++ can have const variables that get initialized from constructors,
585 and thus can not be in a readonly section. We prevent this by
586 verifying that the initial value is constant for objects put in a
589 error_mark_node is used by the C front end to indicate that the
590 initializer has not been seen yet. In this case, we assume that
591 the initializer must be constant.
593 C++ uses error_mark_node for variables that have complicated
594 initializers, but these variables go in BSS so we won't be called
597 #ifdef SELECT_SECTION
598 SELECT_SECTION (decl
, reloc
, DECL_ALIGN (decl
));
600 if (DECL_READONLY_SECTION (decl
, reloc
))
601 readonly_data_section ();
608 /* Tell assembler to switch to the section for the exception handling
612 default_exception_section ()
614 if (targetm
.have_named_sections
)
615 named_section (NULL_TREE
, ".gcc_except_table", 0);
619 readonly_data_section ();
622 /* Tell assembler to switch to the section for string merging. */
625 mergeable_string_section (decl
, align
, flags
)
626 tree decl ATTRIBUTE_UNUSED
;
627 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
628 unsigned int flags ATTRIBUTE_UNUSED
;
630 #ifdef HAVE_GAS_SHF_MERGE
631 if (flag_merge_constants
632 && TREE_CODE (decl
) == STRING_CST
633 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
635 && TREE_STRING_LENGTH (decl
) >= int_size_in_bytes (TREE_TYPE (decl
)))
637 enum machine_mode mode
;
638 unsigned int modesize
;
643 mode
= TYPE_MODE (TREE_TYPE (TREE_TYPE (decl
)));
644 modesize
= GET_MODE_BITSIZE (mode
);
645 if (modesize
>= 8 && modesize
<= 256
646 && (modesize
& (modesize
- 1)) == 0)
648 if (align
< modesize
)
651 str
= TREE_STRING_POINTER (decl
);
652 len
= TREE_STRING_LENGTH (decl
);
653 unit
= GET_MODE_SIZE (mode
);
655 /* Check for embedded NUL characters. */
656 for (i
= 0; i
< len
; i
+= unit
)
658 for (j
= 0; j
< unit
; j
++)
659 if (str
[i
+ j
] != '\0')
666 sprintf (name
, ".rodata.str%d.%d", modesize
/ 8,
668 flags
|= (modesize
/ 8) | SECTION_MERGE
| SECTION_STRINGS
;
669 if (!i
&& modesize
< align
)
671 /* A "" string with requested alignment greater than
672 character size might cause a problem:
673 if some other string required even bigger
674 alignment than "", then linker might think the
675 "" is just part of padding after some other string
676 and not put it into the hash table initially.
677 But this means "" could have smaller alignment
679 #ifdef ASM_OUTPUT_SECTION_START
680 named_section_flags (name
, flags
);
681 ASM_OUTPUT_SECTION_START (asm_out_file
);
683 readonly_data_section ();
688 named_section_flags (name
, flags
);
694 readonly_data_section ();
697 /* Tell assembler to switch to the section for constant merging. */
700 mergeable_constant_section (mode
, align
, flags
)
701 enum machine_mode mode ATTRIBUTE_UNUSED
;
702 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED
;
703 unsigned int flags ATTRIBUTE_UNUSED
;
705 #ifdef HAVE_GAS_SHF_MERGE
706 unsigned int modesize
= GET_MODE_BITSIZE (mode
);
708 if (flag_merge_constants
714 && (align
& (align
- 1)) == 0)
718 sprintf (name
, ".rodata.cst%d", (int) (align
/ 8));
719 flags
|= (align
/ 8) | SECTION_MERGE
;
720 named_section_flags (name
, flags
);
724 readonly_data_section ();
727 /* Given NAME, a putative register name, discard any customary prefixes. */
730 strip_reg_name (name
)
733 #ifdef REGISTER_PREFIX
734 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
735 name
+= strlen (REGISTER_PREFIX
);
737 if (name
[0] == '%' || name
[0] == '#')
742 /* Decode an `asm' spec for a declaration as a register name.
743 Return the register number, or -1 if nothing specified,
744 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
745 or -3 if ASMSPEC is `cc' and is not recognized,
746 or -4 if ASMSPEC is `memory' and is not recognized.
747 Accept an exact spelling or a decimal number.
748 Prefixes such as % are optional. */
751 decode_reg_name (asmspec
)
758 /* Get rid of confusing prefixes. */
759 asmspec
= strip_reg_name (asmspec
);
761 /* Allow a decimal number as a "register name". */
762 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
763 if (! ISDIGIT (asmspec
[i
]))
765 if (asmspec
[0] != 0 && i
< 0)
768 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
774 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
776 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
779 #ifdef ADDITIONAL_REGISTER_NAMES
781 static const struct { const char *const name
; const int number
; } table
[]
782 = ADDITIONAL_REGISTER_NAMES
;
784 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
785 if (! strcmp (asmspec
, table
[i
].name
))
786 return table
[i
].number
;
788 #endif /* ADDITIONAL_REGISTER_NAMES */
790 if (!strcmp (asmspec
, "memory"))
793 if (!strcmp (asmspec
, "cc"))
802 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
803 have static storage duration. In other words, it should not be an
804 automatic variable, including PARM_DECLs.
806 There is, however, one exception: this function handles variables
807 explicitly placed in a particular register by the user.
809 ASMSPEC, if not 0, is the string which the user specified as the
810 assembler symbol name.
812 This is never called for PARM_DECL nodes. */
815 make_decl_rtl (decl
, asmspec
)
819 int top_level
= (DECL_CONTEXT (decl
) == NULL_TREE
);
820 const char *name
= 0;
821 const char *new_name
= 0;
825 /* Check that we are not being given an automatic variable. */
826 /* A weak alias has TREE_PUBLIC set but not the other bits. */
827 if (TREE_CODE (decl
) == PARM_DECL
828 || TREE_CODE (decl
) == RESULT_DECL
829 || (TREE_CODE (decl
) == VAR_DECL
830 && !TREE_STATIC (decl
)
831 && !TREE_PUBLIC (decl
)
832 && !DECL_EXTERNAL (decl
)
833 && !DECL_REGISTER (decl
)))
835 /* And that we were not given a type or a label. */
836 else if (TREE_CODE (decl
) == TYPE_DECL
837 || TREE_CODE (decl
) == LABEL_DECL
)
840 /* For a duplicate declaration, we can be called twice on the
841 same DECL node. Don't discard the RTL already made. */
842 if (DECL_RTL_SET_P (decl
))
844 /* If the old RTL had the wrong mode, fix the mode. */
845 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
846 SET_DECL_RTL (decl
, adjust_address_nv (DECL_RTL (decl
),
847 DECL_MODE (decl
), 0));
849 /* ??? Another way to do this would be to do what halfpic.c does
850 and maintain a hashed table of such critters. */
851 /* ??? Another way to do this would be to pass a flag bit to
852 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
853 /* Let the target reassign the RTL if it wants.
854 This is necessary, for example, when one machine specific
855 decl attribute overrides another. */
856 #ifdef REDO_SECTION_INFO_P
857 if (REDO_SECTION_INFO_P (decl
))
858 ENCODE_SECTION_INFO (decl
);
863 new_name
= name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
865 reg_number
= decode_reg_name (asmspec
);
866 if (reg_number
== -2)
868 /* ASMSPEC is given, and not the name of a register. Mark the
869 name with a star so assemble_name won't munge it. */
870 char *starred
= alloca (strlen (asmspec
) + 2);
872 strcpy (starred
+ 1, asmspec
);
876 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
878 /* First detect errors in declaring global registers. */
879 if (reg_number
== -1)
880 error_with_decl (decl
, "register name not specified for `%s'");
881 else if (reg_number
< 0)
882 error_with_decl (decl
, "invalid register name for `%s'");
883 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
884 error_with_decl (decl
,
885 "data type of `%s' isn't suitable for a register");
886 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
887 error_with_decl (decl
,
888 "register specified for `%s' isn't suitable for data type");
889 /* Now handle properly declared static register variables. */
894 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
896 DECL_INITIAL (decl
) = 0;
897 error ("global register variable has initial value");
899 if (TREE_THIS_VOLATILE (decl
))
900 warning ("volatile register variables don't work as you might wish");
902 /* If the user specified one of the eliminables registers here,
903 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
904 confused with that register and be eliminated. This usage is
905 somewhat suspect... */
907 SET_DECL_RTL (decl
, gen_rtx_raw_REG (DECL_MODE (decl
), reg_number
));
908 ORIGINAL_REGNO (DECL_RTL (decl
)) = reg_number
;
909 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
911 if (TREE_STATIC (decl
))
913 /* Make this register global, so not usable for anything
915 #ifdef ASM_DECLARE_REGISTER_GLOBAL
916 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
918 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
920 globalize_reg (reg_number
+ --nregs
);
923 /* As a register variable, it has no section. */
928 /* Now handle ordinary static variables and functions (in memory).
929 Also handle vars declared register invalidly. */
931 if (reg_number
>= 0 || reg_number
== -3)
932 error_with_decl (decl
,
933 "register name given for non-register variable `%s'");
935 /* Specifying a section attribute on a variable forces it into a
936 non-.bss section, and thus it cannot be common. */
937 if (TREE_CODE (decl
) == VAR_DECL
938 && DECL_SECTION_NAME (decl
) != NULL_TREE
939 && DECL_INITIAL (decl
) == NULL_TREE
940 && DECL_COMMON (decl
))
941 DECL_COMMON (decl
) = 0;
943 /* Can't use just the variable's own name for a variable
944 whose scope is less than the whole file, unless it's a member
945 of a local class (which will already be unambiguous).
946 Concatenate a distinguishing number. */
947 if (!top_level
&& !TREE_PUBLIC (decl
)
948 && ! (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
950 && name
== IDENTIFIER_POINTER (DECL_NAME (decl
)))
954 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
959 if (name
!= new_name
)
961 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (new_name
));
962 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
965 /* If this variable is to be treated as volatile, show its
966 tree node has side effects. */
967 if ((flag_volatile_global
&& TREE_CODE (decl
) == VAR_DECL
968 && TREE_PUBLIC (decl
))
969 || ((flag_volatile_static
&& TREE_CODE (decl
) == VAR_DECL
970 && (TREE_PUBLIC (decl
) || TREE_STATIC (decl
)))))
971 TREE_SIDE_EFFECTS (decl
) = 1;
973 x
= gen_rtx_MEM (DECL_MODE (decl
), gen_rtx_SYMBOL_REF (Pmode
, name
));
974 SYMBOL_REF_WEAK (XEXP (x
, 0)) = DECL_WEAK (decl
);
975 if (TREE_CODE (decl
) != FUNCTION_DECL
)
976 set_mem_attributes (x
, decl
, 1);
977 SET_DECL_RTL (decl
, x
);
979 /* Optionally set flags or add text to the name to record information
980 such as that it is a function name.
981 If the name is changed, the macro ASM_OUTPUT_LABELREF
982 will have to know how to strip this information. */
983 #ifdef ENCODE_SECTION_INFO
984 ENCODE_SECTION_INFO (decl
);
988 /* Make the rtl for variable VAR be volatile.
989 Use this only for static variables. */
992 make_var_volatile (var
)
995 if (GET_CODE (DECL_RTL (var
)) != MEM
)
998 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
1001 /* Output alignment directive to align for constant expression EXP. */
1004 assemble_constant_align (exp
)
1009 /* Align the location counter as required by EXP's data type. */
1010 align
= TYPE_ALIGN (TREE_TYPE (exp
));
1011 #ifdef CONSTANT_ALIGNMENT
1012 align
= CONSTANT_ALIGNMENT (exp
, align
);
1015 if (align
> BITS_PER_UNIT
)
1017 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1021 /* Output a string of literal assembler code
1022 for an `asm' keyword used between functions. */
1025 assemble_asm (string
)
1030 if (TREE_CODE (string
) == ADDR_EXPR
)
1031 string
= TREE_OPERAND (string
, 0);
1033 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
1036 /* Record an element in the table of global destructors. SYMBOL is
1037 a SYMBOL_REF of the function to be called; PRIORITY is a number
1038 between 0 and MAX_INIT_PRIORITY. */
1041 default_stabs_asm_out_destructor (symbol
, priority
)
1043 int priority ATTRIBUTE_UNUSED
;
1045 /* Tell GNU LD that this is part of the static destructor set.
1046 This will work for any system that uses stabs, most usefully
1048 fprintf (asm_out_file
, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
1049 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1050 fputc ('\n', asm_out_file
);
1054 default_named_section_asm_out_destructor (symbol
, priority
)
1058 const char *section
= ".dtors";
1061 /* ??? This only works reliably with the GNU linker. */
1062 if (priority
!= DEFAULT_INIT_PRIORITY
)
1064 sprintf (buf
, ".dtors.%.5u",
1065 /* Invert the numbering so the linker puts us in the proper
1066 order; constructors are run from right to left, and the
1067 linker sorts in increasing order. */
1068 MAX_INIT_PRIORITY
- priority
);
1072 named_section_flags (section
, SECTION_WRITE
);
1073 assemble_align (POINTER_SIZE
);
1074 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1077 #ifdef DTORS_SECTION_ASM_OP
1081 if (in_section
!= in_dtors
)
1083 in_section
= in_dtors
;
1084 fputs (DTORS_SECTION_ASM_OP
, asm_out_file
);
1085 fputc ('\n', asm_out_file
);
1090 default_dtor_section_asm_out_destructor (symbol
, priority
)
1092 int priority ATTRIBUTE_UNUSED
;
1095 assemble_align (POINTER_SIZE
);
1096 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1100 /* Likewise for global constructors. */
1103 default_stabs_asm_out_constructor (symbol
, priority
)
1105 int priority ATTRIBUTE_UNUSED
;
1107 /* Tell GNU LD that this is part of the static destructor set.
1108 This will work for any system that uses stabs, most usefully
1110 fprintf (asm_out_file
, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
1111 assemble_name (asm_out_file
, XSTR (symbol
, 0));
1112 fputc ('\n', asm_out_file
);
1116 default_named_section_asm_out_constructor (symbol
, priority
)
1120 const char *section
= ".ctors";
1123 /* ??? This only works reliably with the GNU linker. */
1124 if (priority
!= DEFAULT_INIT_PRIORITY
)
1126 sprintf (buf
, ".ctors.%.5u",
1127 /* Invert the numbering so the linker puts us in the proper
1128 order; constructors are run from right to left, and the
1129 linker sorts in increasing order. */
1130 MAX_INIT_PRIORITY
- priority
);
1134 named_section_flags (section
, SECTION_WRITE
);
1135 assemble_align (POINTER_SIZE
);
1136 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1139 #ifdef CTORS_SECTION_ASM_OP
1143 if (in_section
!= in_ctors
)
1145 in_section
= in_ctors
;
1146 fputs (CTORS_SECTION_ASM_OP
, asm_out_file
);
1147 fputc ('\n', asm_out_file
);
1152 default_ctor_section_asm_out_constructor (symbol
, priority
)
1154 int priority ATTRIBUTE_UNUSED
;
1157 assemble_align (POINTER_SIZE
);
1158 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, POINTER_SIZE
, 1);
1162 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1163 a non-zero value if the constant pool should be output before the
1164 start of the function, or a zero value if the pool should output
1165 after the end of the function. The default is to put it before the
1168 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1169 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1172 /* Output assembler code for the constant pool of a function and associated
1173 with defining the name of the function. DECL describes the function.
1174 NAME is the function's name. For the constant pool, we use the current
1175 constant pool data. */
1178 assemble_start_function (decl
, fnname
)
1184 /* The following code does not need preprocessing in the assembler. */
1188 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1189 output_constant_pool (fnname
, decl
);
1191 resolve_unique_section (decl
, 0, flag_function_sections
);
1192 function_section (decl
);
1194 /* Tell assembler to move to target machine's alignment for functions. */
1195 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1196 if (align
< force_align_functions_log
)
1197 align
= force_align_functions_log
;
1200 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1203 /* Handle a user-specified function alignment.
1204 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1205 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1206 if (align_functions_log
> align
)
1208 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1209 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1210 align_functions_log
, align_functions
-1);
1212 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1216 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1217 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1220 (*debug_hooks
->begin_function
) (decl
);
1222 /* Make function name accessible from other files, if appropriate. */
1224 if (TREE_PUBLIC (decl
))
1226 if (! first_global_object_name
)
1231 STRIP_NAME_ENCODING (p
, fnname
);
1232 name
= permalloc (strlen (p
) + 1);
1235 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
1236 first_global_object_name
= name
;
1238 weak_global_object_name
= name
;
1241 globalize_decl (decl
);
1244 /* Do any machine/system dependent processing of the function name */
1245 #ifdef ASM_DECLARE_FUNCTION_NAME
1246 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1248 /* Standard thing is just output label for the function. */
1249 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1250 #endif /* ASM_DECLARE_FUNCTION_NAME */
1253 /* Output assembler code associated with defining the size of the
1254 function. DECL describes the function. NAME is the function's name. */
1257 assemble_end_function (decl
, fnname
)
1261 #ifdef ASM_DECLARE_FUNCTION_SIZE
1262 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1264 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1266 output_constant_pool (fnname
, decl
);
1267 function_section (decl
); /* need to switch back */
1270 /* Output any constants which should appear after the function. */
1271 output_after_function_constants ();
1274 /* Assemble code to leave SIZE bytes of zeros. */
1277 assemble_zeros (size
)
1280 /* Do no output if -fsyntax-only. */
1281 if (flag_syntax_only
)
1284 #ifdef ASM_NO_SKIP_IN_TEXT
1285 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1286 so we must output 0s explicitly in the text section. */
1287 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1290 for (i
= 0; i
< size
; i
++)
1291 assemble_integer (const0_rtx
, 1, BITS_PER_UNIT
, 1);
1296 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1299 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1302 assemble_align (align
)
1305 if (align
> BITS_PER_UNIT
)
1307 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1311 /* Assemble a string constant with the specified C string as contents. */
1314 assemble_string (p
, size
)
1321 /* If the string is very long, split it up. */
1325 int thissize
= size
- pos
;
1326 if (thissize
> maximum
)
1329 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1337 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1338 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1339 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1341 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1342 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1343 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1345 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1346 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1350 #if defined ASM_OUTPUT_ALIGNED_BSS
1351 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1352 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1354 #if defined ASM_OUTPUT_BSS
1355 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1356 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1362 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1363 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1364 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1366 #if defined ASM_OUTPUT_ALIGNED_COMMON
1367 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1368 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1370 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1371 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1376 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1379 int size ATTRIBUTE_UNUSED
;
1380 int rounded ATTRIBUTE_UNUSED
;
1388 destination
= asm_dest_local
;
1390 if (TREE_PUBLIC (decl
))
1392 #if defined ASM_EMIT_BSS
1393 if (! DECL_COMMON (decl
))
1394 destination
= asm_dest_bss
;
1397 destination
= asm_dest_common
;
1400 if (destination
== asm_dest_bss
)
1401 globalize_decl (decl
);
1402 resolve_unique_section (decl
, 0, flag_data_sections
);
1404 if (flag_shared_data
)
1406 switch (destination
)
1408 #ifdef ASM_OUTPUT_SHARED_BSS
1410 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1413 #ifdef ASM_OUTPUT_SHARED_COMMON
1414 case asm_dest_common
:
1415 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1418 #ifdef ASM_OUTPUT_SHARED_LOCAL
1419 case asm_dest_local
:
1420 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1428 switch (destination
)
1432 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1435 case asm_dest_common
:
1436 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1438 case asm_dest_local
:
1439 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1448 /* Assemble everything that is needed for a variable or function declaration.
1449 Not used for automatic variables, and not used for function definitions.
1450 Should not be called for variables of incomplete structure type.
1452 TOP_LEVEL is nonzero if this variable has file scope.
1453 AT_END is nonzero if this is the special handling, at end of compilation,
1454 to define things that have had only tentative definitions.
1455 DONT_OUTPUT_DATA if nonzero means don't actually output the
1456 initial value (that will be done by the caller). */
1459 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1461 int top_level ATTRIBUTE_UNUSED
;
1462 int at_end ATTRIBUTE_UNUSED
;
1463 int dont_output_data
;
1470 last_assemble_variable_decl
= 0;
1472 /* Normally no need to say anything here for external references,
1473 since assemble_external is called by the language-specific code
1474 when a declaration is first seen. */
1476 if (DECL_EXTERNAL (decl
))
1479 /* Output no assembler code for a function declaration.
1480 Only definitions of functions output anything. */
1482 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1485 /* Do nothing for global register variables. */
1486 if (DECL_RTL_SET_P (decl
) && GET_CODE (DECL_RTL (decl
)) == REG
)
1488 TREE_ASM_WRITTEN (decl
) = 1;
1492 /* If type was incomplete when the variable was declared,
1493 see if it is complete now. */
1495 if (DECL_SIZE (decl
) == 0)
1496 layout_decl (decl
, 0);
1498 /* Still incomplete => don't allocate it; treat the tentative defn
1499 (which is what it must have been) as an `extern' reference. */
1501 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1503 error_with_file_and_line (DECL_SOURCE_FILE (decl
),
1504 DECL_SOURCE_LINE (decl
),
1505 "storage size of `%s' isn't known",
1506 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1507 TREE_ASM_WRITTEN (decl
) = 1;
1511 /* The first declaration of a variable that comes through this function
1512 decides whether it is global (in C, has external linkage)
1513 or local (in C, has internal linkage). So do nothing more
1514 if this function has already run. */
1516 if (TREE_ASM_WRITTEN (decl
))
1519 /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN. */
1520 decl_rtl
= DECL_RTL (decl
);
1522 TREE_ASM_WRITTEN (decl
) = 1;
1524 /* Do no output if -fsyntax-only. */
1525 if (flag_syntax_only
)
1530 if (! dont_output_data
1531 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1533 error_with_decl (decl
, "size of variable `%s' is too large");
1537 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1538 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1539 && ! first_global_object_name
1540 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1541 || DECL_INITIAL (decl
) == error_mark_node
))
1542 && ! DECL_WEAK (decl
)
1543 && ! DECL_ONE_ONLY (decl
))
1548 STRIP_NAME_ENCODING (p
, name
);
1549 xname
= permalloc (strlen (p
) + 1);
1551 first_global_object_name
= xname
;
1554 /* Compute the alignment of this data. */
1556 align
= DECL_ALIGN (decl
);
1558 /* In the case for initialing an array whose length isn't specified,
1559 where we have not yet been able to do the layout,
1560 figure out the proper alignment now. */
1561 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1562 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1563 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1565 /* Some object file formats have a maximum alignment which they support.
1566 In particular, a.out format supports a maximum alignment of 4. */
1567 #ifndef MAX_OFILE_ALIGNMENT
1568 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1570 if (align
> MAX_OFILE_ALIGNMENT
)
1572 warning_with_decl (decl
,
1573 "alignment of `%s' is greater than maximum object file alignment. Using %d",
1574 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1575 align
= MAX_OFILE_ALIGNMENT
;
1578 /* On some machines, it is good to increase alignment sometimes. */
1579 if (! DECL_USER_ALIGN (decl
))
1581 #ifdef DATA_ALIGNMENT
1582 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1584 #ifdef CONSTANT_ALIGNMENT
1585 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1586 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1590 /* Reset the alignment in case we have made it tighter, so we can benefit
1591 from it in get_pointer_alignment. */
1592 DECL_ALIGN (decl
) = align
;
1593 set_mem_align (decl_rtl
, align
);
1595 /* Handle uninitialized definitions. */
1597 if ((DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
)
1598 /* If the target can't output uninitialized but not common global data
1599 in .bss, then we have to use .data. */
1600 #if ! defined ASM_EMIT_BSS
1601 && DECL_COMMON (decl
)
1603 && DECL_SECTION_NAME (decl
) == NULL_TREE
1604 && ! dont_output_data
)
1606 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1607 unsigned HOST_WIDE_INT rounded
= size
;
1609 /* Don't allocate zero bytes of common,
1610 since that means "undefined external" in the linker. */
1614 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1615 so that each uninitialized object starts on such a boundary. */
1616 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1617 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1618 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1620 /* Don't continue this line--convex cc version 4.1 would lose. */
1621 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1622 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN (decl
) / BITS_PER_UNIT
> rounded
)
1624 (decl
, "requested alignment for %s is greater than implemented alignment of %d",rounded
);
1627 asm_emit_uninitialised (decl
, name
, size
, rounded
);
1632 /* Handle initialized definitions.
1633 Also handle uninitialized global definitions if -fno-common and the
1634 target doesn't support ASM_OUTPUT_BSS. */
1636 /* First make the assembler name(s) global if appropriate. */
1637 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1638 globalize_decl (decl
);
1640 /* Output any data that we will need to use the address of. */
1641 if (DECL_INITIAL (decl
) == error_mark_node
)
1642 reloc
= contains_pointers_p (TREE_TYPE (decl
)) ? 3 : 0;
1643 else if (DECL_INITIAL (decl
))
1644 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1646 /* Switch to the appropriate section. */
1647 resolve_unique_section (decl
, reloc
, flag_data_sections
);
1648 variable_section (decl
, reloc
);
1650 /* dbxout.c needs to know this. */
1651 if (in_text_section ())
1652 DECL_IN_TEXT_SECTION (decl
) = 1;
1654 /* Output the alignment of this data. */
1655 if (align
> BITS_PER_UNIT
)
1657 ASM_OUTPUT_ALIGN (asm_out_file
,
1658 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1661 /* Do any machine/system dependent processing of the object. */
1662 #ifdef ASM_DECLARE_OBJECT_NAME
1663 last_assemble_variable_decl
= decl
;
1664 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1666 /* Standard thing is just output label for the object. */
1667 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1668 #endif /* ASM_DECLARE_OBJECT_NAME */
1670 if (!dont_output_data
)
1672 if (DECL_INITIAL (decl
) && DECL_INITIAL (decl
) != error_mark_node
)
1673 /* Output the actual data. */
1674 output_constant (DECL_INITIAL (decl
),
1675 tree_low_cst (DECL_SIZE_UNIT (decl
), 1),
1678 /* Leave space for it. */
1679 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1683 /* Return 1 if type TYPE contains any pointers. */
1686 contains_pointers_p (type
)
1689 switch (TREE_CODE (type
))
1692 case REFERENCE_TYPE
:
1693 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1694 so I'll play safe and return 1. */
1700 case QUAL_UNION_TYPE
:
1703 /* For a type that has fields, see if the fields have pointers. */
1704 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1705 if (TREE_CODE (fields
) == FIELD_DECL
1706 && contains_pointers_p (TREE_TYPE (fields
)))
1712 /* An array type contains pointers if its element type does. */
1713 return contains_pointers_p (TREE_TYPE (type
));
1720 /* Output something to declare an external symbol to the assembler.
1721 (Most assemblers don't need this, so we normally output nothing.)
1722 Do nothing if DECL is not external. */
1725 assemble_external (decl
)
1726 tree decl ATTRIBUTE_UNUSED
;
1728 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1729 main body of this code is only rarely exercised. To provide some
1730 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1731 open. If it's not, we should not be calling this function. */
1735 #ifdef ASM_OUTPUT_EXTERNAL
1736 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1738 rtx rtl
= DECL_RTL (decl
);
1740 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1741 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1743 /* Some systems do require some output. */
1744 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1745 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1751 /* Similar, for calling a library function FUN. */
1754 assemble_external_libcall (fun
)
1755 rtx fun ATTRIBUTE_UNUSED
;
1757 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1758 /* Declare library function name external when first used, if nec. */
1759 if (! SYMBOL_REF_USED (fun
))
1761 SYMBOL_REF_USED (fun
) = 1;
1762 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1767 /* Declare the label NAME global. */
1770 assemble_global (name
)
1771 const char *name ATTRIBUTE_UNUSED
;
1773 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1776 /* Assemble a label named NAME. */
1779 assemble_label (name
)
1782 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1785 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1786 If NAME starts with a *, the rest of NAME is output verbatim.
1787 Otherwise NAME is transformed in an implementation-defined way
1788 (usually by the addition of an underscore).
1789 Many macros in the tm file are defined to call this function. */
1792 assemble_name (file
, name
)
1796 const char *real_name
;
1799 STRIP_NAME_ENCODING (real_name
, name
);
1801 id
= maybe_get_identifier (real_name
);
1803 TREE_SYMBOL_REFERENCED (id
) = 1;
1806 fputs (&name
[1], file
);
1808 ASM_OUTPUT_LABELREF (file
, name
);
1811 /* Allocate SIZE bytes writable static space with a gensym name
1812 and return an RTX to refer to its address. */
1815 assemble_static_space (size
)
1819 const char *namestring
;
1823 if (flag_shared_data
)
1827 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1829 namestring
= ggc_strdup (name
);
1831 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1833 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1834 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1837 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1838 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1841 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1842 so that each uninitialized object starts on such a boundary. */
1843 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1844 int rounded ATTRIBUTE_UNUSED
1845 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1846 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1847 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1848 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1855 /* Assemble the static constant template for function entry trampolines.
1856 This is done at most once per compilation.
1857 Returns an RTX for the address of the template. */
1859 #ifdef TRAMPOLINE_TEMPLATE
1861 assemble_trampoline_template ()
1867 /* By default, put trampoline templates in read-only data section. */
1869 #ifdef TRAMPOLINE_SECTION
1870 TRAMPOLINE_SECTION ();
1872 readonly_data_section ();
1875 /* Write the assembler code to define one. */
1876 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1879 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1882 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LTRAMP", 0);
1883 TRAMPOLINE_TEMPLATE (asm_out_file
);
1885 /* Record the rtl to refer to it. */
1886 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1887 name
= ggc_strdup (label
);
1888 return gen_rtx_SYMBOL_REF (Pmode
, name
);
1892 /* A and B are either alignments or offsets. Return the minimum alignment
1893 that may be assumed after adding the two together. */
1895 static inline unsigned
1899 return (a
| b
) & -(a
| b
);
1902 /* Return the assembler directive for creating a given kind of integer
1903 object. SIZE is the number of bytes in the object and ALIGNED_P
1904 indicates whether it is known to be aligned. Return NULL if the
1905 assembly dialect has no such directive.
1907 The returned string should be printed at the start of a new line and
1908 be followed immediately by the object's initial value. */
1911 integer_asm_op (size
, aligned_p
)
1915 struct asm_int_op
*ops
;
1918 ops
= &targetm
.asm_out
.aligned_op
;
1920 ops
= &targetm
.asm_out
.unaligned_op
;
1925 return targetm
.asm_out
.byte_op
;
1939 /* Use directive OP to assemble an integer object X. Print OP at the
1940 start of the line, followed immediately by the value of X. */
1943 assemble_integer_with_op (op
, x
)
1947 fputs (op
, asm_out_file
);
1948 output_addr_const (asm_out_file
, x
);
1949 fputc ('\n', asm_out_file
);
1952 /* The default implementation of the asm_out.integer target hook. */
1955 default_assemble_integer (x
, size
, aligned_p
)
1956 rtx x ATTRIBUTE_UNUSED
;
1957 unsigned int size ATTRIBUTE_UNUSED
;
1958 int aligned_p ATTRIBUTE_UNUSED
;
1960 const char *op
= integer_asm_op (size
, aligned_p
);
1961 return op
&& (assemble_integer_with_op (op
, x
), true);
1964 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
1965 the alignment of the integer in bits. Return 1 if we were able to output
1966 the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
1970 assemble_integer (x
, size
, align
, force
)
1978 aligned_p
= (align
>= MIN (size
* BITS_PER_UNIT
, BIGGEST_ALIGNMENT
));
1980 /* See if the target hook can handle this kind of object. */
1981 if ((*targetm
.asm_out
.integer
) (x
, size
, aligned_p
))
1984 /* If the object is a multi-byte one, try splitting it up. Split
1985 it into words it if is multi-word, otherwise split it into bytes. */
1988 enum machine_mode omode
, imode
;
1989 unsigned int subalign
;
1990 unsigned int subsize
, i
;
1992 subsize
= size
> UNITS_PER_WORD
? UNITS_PER_WORD
: 1;
1993 subalign
= MIN (align
, subsize
* BITS_PER_UNIT
);
1994 omode
= mode_for_size (subsize
* BITS_PER_UNIT
, MODE_INT
, 0);
1995 imode
= mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1997 for (i
= 0; i
< size
; i
+= subsize
)
1999 rtx partial
= simplify_subreg (omode
, x
, imode
, i
);
2000 if (!partial
|| !assemble_integer (partial
, subsize
, subalign
, 0))
2006 /* If we've printed some of it, but not all of it, there's no going
2019 assemble_real (d
, mode
, align
)
2021 enum machine_mode mode
;
2026 unsigned int nalign
= min_align (align
, 32);
2028 switch (BITS_PER_UNIT
)
2034 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2035 assemble_integer (GEN_INT (l
), 4, align
, 1);
2038 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2039 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2040 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2043 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
2044 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2045 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2046 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
2049 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d
, data
);
2050 assemble_integer (GEN_INT (data
[0]), 4, align
, 1);
2051 assemble_integer (GEN_INT (data
[1]), 4, nalign
, 1);
2052 assemble_integer (GEN_INT (data
[2]), 4, nalign
, 1);
2053 assemble_integer (GEN_INT (data
[3]), 4, nalign
, 1);
2064 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2065 assemble_integer (GEN_INT (l
), 2, align
, 1);
2068 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2069 assemble_integer (GEN_INT (data
[0]), 2, align
, 1);
2070 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2081 REAL_VALUE_TO_TARGET_SINGLE (d
, l
);
2082 assemble_integer (GEN_INT (l
), 1, align
, 1);
2085 REAL_VALUE_TO_TARGET_DOUBLE (d
, data
);
2086 assemble_integer (GEN_INT (data
[0]), 1, align
, 1);
2087 assemble_integer (GEN_INT (data
[1]), 1, nalign
, 1);
2099 /* Here we combine duplicate floating constants to make
2100 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
2102 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2103 For an integer, I0 is the low-order word and I1 is the high-order word.
2104 For a real number, I0 is the word with the low address
2105 and I1 is the word with the high address. */
2108 immed_double_const (i0
, i1
, mode
)
2109 HOST_WIDE_INT i0
, i1
;
2110 enum machine_mode mode
;
2114 if (GET_MODE_CLASS (mode
) == MODE_INT
2115 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
2117 /* We clear out all bits that don't belong in MODE, unless they and our
2118 sign bit are all one. So we get either a reasonable negative value
2119 or a reasonable unsigned value for this mode. */
2120 int width
= GET_MODE_BITSIZE (mode
);
2121 if (width
< HOST_BITS_PER_WIDE_INT
2122 && ((i0
& ((HOST_WIDE_INT
) (-1) << (width
- 1)))
2123 != ((HOST_WIDE_INT
) (-1) << (width
- 1))))
2124 i0
&= ((HOST_WIDE_INT
) 1 << width
) - 1, i1
= 0;
2125 else if (width
== HOST_BITS_PER_WIDE_INT
2126 && ! (i1
== ~0 && i0
< 0))
2128 else if (width
> 2 * HOST_BITS_PER_WIDE_INT
)
2129 /* We cannot represent this value as a constant. */
2132 /* If this would be an entire word for the target, but is not for
2133 the host, then sign-extend on the host so that the number will look
2134 the same way on the host that it would on the target.
2136 For example, when building a 64 bit alpha hosted 32 bit sparc
2137 targeted compiler, then we want the 32 bit unsigned value -1 to be
2138 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2139 The later confuses the sparc backend. */
2141 if (width
< HOST_BITS_PER_WIDE_INT
2142 && (i0
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
2143 i0
|= ((HOST_WIDE_INT
) (-1) << width
);
2145 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2147 ??? Strictly speaking, this is wrong if we create a CONST_INT
2148 for a large unsigned constant with the size of MODE being
2149 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2150 wider mode. In that case we will mis-interpret it as a negative
2153 Unfortunately, the only alternative is to make a CONST_DOUBLE
2154 for any constant in any mode if it is an unsigned constant larger
2155 than the maximum signed integer in an int on the host. However,
2156 doing this will break everyone that always expects to see a CONST_INT
2157 for SImode and smaller.
2159 We have always been making CONST_INTs in this case, so nothing new
2162 if (width
<= HOST_BITS_PER_WIDE_INT
)
2163 i1
= (i0
< 0) ? ~(HOST_WIDE_INT
) 0 : 0;
2165 /* If this integer fits in one word, return a CONST_INT. */
2166 if ((i1
== 0 && i0
>= 0)
2167 || (i1
== ~0 && i0
< 0))
2168 return GEN_INT (i0
);
2170 /* We use VOIDmode for integers. */
2174 /* Search the chain for an existing CONST_DOUBLE with the right value.
2175 If one is found, return it. */
2177 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2178 if (CONST_DOUBLE_LOW (r
) == i0
&& CONST_DOUBLE_HIGH (r
) == i1
2179 && GET_MODE (r
) == mode
)
2182 /* No; make a new one and add it to the chain. */
2183 r
= gen_rtx_CONST_DOUBLE (mode
, i0
, i1
);
2185 /* Don't touch const_double_chain if not inside any function. */
2186 if (current_function_decl
!= 0)
2188 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2189 const_double_chain
= r
;
2195 /* Return a CONST_DOUBLE for a specified `double' value
2196 and machine mode. */
2199 immed_real_const_1 (d
, mode
)
2201 enum machine_mode mode
;
2203 union real_extract u
;
2206 /* Get the desired `double' value as a sequence of ints
2207 since that is how they are stored in a CONST_DOUBLE. */
2211 /* Detect special cases. Check for NaN first, because some ports
2212 (specifically the i386) do not emit correct ieee-fp code by default, and
2213 thus will generate a core dump here if we pass a NaN to REAL_VALUES_EQUAL
2214 and if REAL_VALUES_EQUAL does a floating point comparison. */
2215 if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_IDENTICAL (dconst0
, d
))
2216 return CONST0_RTX (mode
);
2217 else if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_EQUAL (dconst1
, d
))
2218 return CONST1_RTX (mode
);
2219 else if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_EQUAL (dconst2
, d
))
2220 return CONST2_RTX (mode
);
2222 if (sizeof u
== sizeof (HOST_WIDE_INT
))
2223 return immed_double_const (u
.i
[0], 0, mode
);
2224 if (sizeof u
== 2 * sizeof (HOST_WIDE_INT
))
2225 return immed_double_const (u
.i
[0], u
.i
[1], mode
);
2227 /* The rest of this function handles the case where
2228 a float value requires more than 2 ints of space.
2229 It will be deleted as dead code on machines that don't need it. */
2231 /* Search the chain for an existing CONST_DOUBLE with the right value.
2232 If one is found, return it. */
2234 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2235 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
)
2236 && GET_MODE (r
) == mode
)
2239 /* No; make a new one and add it to the chain.
2241 We may be called by an optimizer which may be discarding any memory
2242 allocated during its processing (such as combine and loop). However,
2243 we will be leaving this constant on the chain, so we cannot tolerate
2245 r
= rtx_alloc (CONST_DOUBLE
);
2247 memcpy ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
);
2249 /* If we aren't inside a function, don't put r on the
2250 const_double_chain. */
2251 if (current_function_decl
!= 0)
2253 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2254 const_double_chain
= r
;
2257 CONST_DOUBLE_CHAIN (r
) = NULL_RTX
;
2262 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2263 which must be a REAL_CST tree node. */
2266 immed_real_const (exp
)
2269 return immed_real_const_1 (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)));
2272 /* At the end of a function, forget the memory-constants
2273 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2274 Also clear out real_constant_chain and clear out all the chain-pointers. */
2277 clear_const_double_mem ()
2281 for (r
= const_double_chain
; r
; r
= next
)
2283 next
= CONST_DOUBLE_CHAIN (r
);
2284 CONST_DOUBLE_CHAIN (r
) = 0;
2286 const_double_chain
= 0;
2289 /* Given an expression EXP with a constant value,
2290 reduce it to the sum of an assembler symbol and an integer.
2291 Store them both in the structure *VALUE.
2292 Abort if EXP does not reduce. */
2297 HOST_WIDE_INT offset
;
2301 decode_addr_const (exp
, value
)
2303 struct addr_const
*value
;
2305 tree target
= TREE_OPERAND (exp
, 0);
2311 if (TREE_CODE (target
) == COMPONENT_REF
2312 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2315 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2316 target
= TREE_OPERAND (target
, 0);
2318 else if (TREE_CODE (target
) == ARRAY_REF
2319 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2321 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2322 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2323 target
= TREE_OPERAND (target
, 0);
2329 switch (TREE_CODE (target
))
2333 x
= DECL_RTL (target
);
2337 x
= gen_rtx_MEM (FUNCTION_MODE
,
2338 gen_rtx_LABEL_REF (VOIDmode
,
2339 label_rtx (TREE_OPERAND (exp
, 0))));
2347 /* This constant should have been output already, but we can't simply
2348 use TREE_CST_RTL since INTEGER_CST doesn't have one. */
2349 x
= output_constant_def (target
, 1);
2356 if (GET_CODE (x
) != MEM
)
2361 value
->offset
= offset
;
2364 /* We do RTX_UNSPEC + XINT (blah), so nothing can go after RTX_UNSPEC. */
2365 enum kind
{ RTX_UNKNOWN
, RTX_DOUBLE
, RTX_INT
, RTX_VECTOR
, RTX_UNSPEC
};
2368 ENUM_BITFIELD(kind
) kind
: 16;
2369 ENUM_BITFIELD(machine_mode
) mode
: 16;
2371 union real_extract du
;
2372 struct addr_const addr
;
2373 struct {HOST_WIDE_INT high
, low
;} di
;
2375 /* The max vector size we have is 8 wide. This should be enough. */
2376 HOST_WIDE_INT veclo
[16];
2377 HOST_WIDE_INT vechi
[16];
2381 /* Uniquize all constants that appear in memory.
2382 Each constant in memory thus far output is recorded
2383 in `const_hash_table' with a `struct constant_descriptor'
2384 that contains a polish representation of the value of
2387 We cannot store the trees in the hash table
2388 because the trees may be temporary. */
2390 struct constant_descriptor
2392 struct constant_descriptor
*next
;
2395 /* Make sure the data is reasonably aligned. */
2398 unsigned char contents
[1];
2399 #ifdef HAVE_LONG_DOUBLE
2408 #define MAX_HASH_TABLE 1009
2409 static struct constant_descriptor
*const_hash_table
[MAX_HASH_TABLE
];
2411 /* We maintain a hash table of STRING_CST values. Unless we are asked to force
2412 out a string constant, we defer output of the constants until we know
2413 they are actually used. This will be if something takes its address or if
2414 there is a usage of the string in the RTL of a function. */
2416 #define STRHASH(x) ((hashval_t) ((long) (x) >> 3))
2418 struct deferred_string
2425 static htab_t const_str_htab
;
2427 /* Mark a const_hash_table descriptor for GC. */
2430 mark_const_hash_entry (ptr
)
2433 struct constant_descriptor
*desc
= * (struct constant_descriptor
**) ptr
;
2437 ggc_mark_rtx (desc
->rtl
);
2442 /* Mark the hash-table element X (which is really a pointer to an
2443 struct deferred_string *). */
2446 mark_const_str_htab_1 (x
, data
)
2448 void *data ATTRIBUTE_UNUSED
;
2450 ggc_mark_tree (((struct deferred_string
*) *x
)->exp
);
2454 /* Mark a const_str_htab for GC. */
2457 mark_const_str_htab (htab
)
2460 htab_traverse (*((htab_t
*) htab
), mark_const_str_htab_1
, NULL
);
2463 /* Returns a hash code for X (which is a really a
2464 struct deferred_string *). */
2467 const_str_htab_hash (x
)
2470 return STRHASH (((const struct deferred_string
*) x
)->label
);
2473 /* Returns non-zero if the value represented by X (which is really a
2474 struct deferred_string *) is the same as that given by Y
2475 (which is really a char *). */
2478 const_str_htab_eq (x
, y
)
2482 return (((const struct deferred_string
*) x
)->label
== (const char *) y
);
2485 /* Delete the hash table entry dfsp. */
2488 const_str_htab_del (dfsp
)
2494 /* Compute a hash code for a constant expression. */
2502 enum tree_code code
= TREE_CODE (exp
);
2504 /* Either set P and LEN to the address and len of something to hash and
2505 exit the switch or return a value. */
2510 p
= (char *) &TREE_INT_CST (exp
);
2511 len
= sizeof TREE_INT_CST (exp
);
2515 p
= (char *) &TREE_REAL_CST (exp
);
2516 len
= sizeof TREE_REAL_CST (exp
);
2520 p
= TREE_STRING_POINTER (exp
);
2521 len
= TREE_STRING_LENGTH (exp
);
2525 return (const_hash (TREE_REALPART (exp
)) * 5
2526 + const_hash (TREE_IMAGPART (exp
)));
2529 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2533 len
= int_size_in_bytes (TREE_TYPE (exp
));
2534 tmp
= (char *) alloca (len
);
2535 get_set_constructor_bytes (exp
, (unsigned char *) tmp
, len
);
2543 /* For record type, include the type in the hashing.
2544 We do not do so for array types
2545 because (1) the sizes of the elements are sufficient
2546 and (2) distinct array types can have the same constructor.
2547 Instead, we include the array size because the constructor could
2549 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2550 hi
= ((unsigned long) TREE_TYPE (exp
) & ((1 << HASHBITS
) - 1))
2553 hi
= ((5 + int_size_in_bytes (TREE_TYPE (exp
)))
2554 & ((1 << HASHBITS
) - 1)) % MAX_HASH_TABLE
;
2556 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2557 if (TREE_VALUE (link
))
2559 = (hi
* 603 + const_hash (TREE_VALUE (link
))) % MAX_HASH_TABLE
;
2567 struct addr_const value
;
2569 decode_addr_const (exp
, &value
);
2570 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2572 /* Don't hash the address of the SYMBOL_REF;
2573 only use the offset and the symbol name. */
2575 p
= XSTR (value
.base
, 0);
2576 for (i
= 0; p
[i
] != 0; i
++)
2577 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2579 else if (GET_CODE (value
.base
) == LABEL_REF
)
2580 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2584 hi
&= (1 << HASHBITS
) - 1;
2585 hi
%= MAX_HASH_TABLE
;
2591 return (const_hash (TREE_OPERAND (exp
, 0)) * 9
2592 + const_hash (TREE_OPERAND (exp
, 1)));
2596 case NON_LVALUE_EXPR
:
2597 return const_hash (TREE_OPERAND (exp
, 0)) * 7 + 2;
2600 /* A language specific constant. Just hash the code. */
2601 return (int) code
% MAX_HASH_TABLE
;
2604 /* Compute hashing function */
2606 for (i
= 0; i
< len
; i
++)
2607 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2609 hi
&= (1 << HASHBITS
) - 1;
2610 hi
%= MAX_HASH_TABLE
;
2614 /* Compare a constant expression EXP with a constant-descriptor DESC.
2615 Return 1 if DESC describes a constant with the same value as EXP. */
2618 compare_constant (exp
, desc
)
2620 struct constant_descriptor
*desc
;
2622 return 0 != compare_constant_1 (exp
, desc
->u
.contents
);
2625 /* Compare constant expression EXP with a substring P of a constant descriptor.
2626 If they match, return a pointer to the end of the substring matched.
2627 If they do not match, return 0.
2629 Since descriptors are written in polish prefix notation,
2630 this function can be used recursively to test one operand of EXP
2631 against a subdescriptor, and if it succeeds it returns the
2632 address of the subdescriptor for the next operand. */
2634 static const unsigned char *
2635 compare_constant_1 (exp
, p
)
2637 const unsigned char *p
;
2639 const unsigned char *strp
;
2641 enum tree_code code
= TREE_CODE (exp
);
2643 if (code
!= (enum tree_code
) *p
++)
2646 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2647 switch, or return the result of the comparison. */
2652 /* Integer constants are the same only if the same width of type. */
2653 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2656 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2657 len
= sizeof TREE_INT_CST (exp
);
2661 /* Real constants are the same only if the same width of type. */
2662 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2665 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2666 len
= sizeof TREE_REAL_CST (exp
);
2670 if (flag_writable_strings
)
2673 if ((enum machine_mode
) *p
++ != TYPE_MODE (TREE_TYPE (exp
)))
2676 strp
= (const unsigned char *) TREE_STRING_POINTER (exp
);
2677 len
= TREE_STRING_LENGTH (exp
);
2678 if (memcmp ((char *) &TREE_STRING_LENGTH (exp
), p
,
2679 sizeof TREE_STRING_LENGTH (exp
)))
2682 p
+= sizeof TREE_STRING_LENGTH (exp
);
2686 p
= compare_constant_1 (TREE_REALPART (exp
), p
);
2690 return compare_constant_1 (TREE_IMAGPART (exp
), p
);
2693 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2695 int xlen
= len
= int_size_in_bytes (TREE_TYPE (exp
));
2696 unsigned char *tmp
= (unsigned char *) alloca (len
);
2698 get_set_constructor_bytes (exp
, tmp
, len
);
2699 strp
= (unsigned char *) tmp
;
2700 if (memcmp ((char *) &xlen
, p
, sizeof xlen
))
2709 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2711 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2712 int have_purpose
= 0;
2714 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2715 if (TREE_PURPOSE (link
))
2718 if (memcmp ((char *) &length
, p
, sizeof length
))
2723 /* For record constructors, insist that the types match.
2724 For arrays, just verify both constructors are for arrays.
2725 Then insist that either both or none have any TREE_PURPOSE
2727 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2728 type
= TREE_TYPE (exp
);
2732 if (memcmp ((char *) &type
, p
, sizeof type
))
2735 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2737 if (memcmp ((char *) &mode
, p
, sizeof mode
))
2745 if (memcmp ((char *) &have_purpose
, p
, sizeof have_purpose
))
2748 p
+= sizeof have_purpose
;
2750 /* For arrays, insist that the size in bytes match. */
2751 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2753 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2755 if (memcmp ((char *) &size
, p
, sizeof size
))
2761 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2763 if (TREE_VALUE (link
))
2765 if ((p
= compare_constant_1 (TREE_VALUE (link
), p
)) == 0)
2772 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2778 if (TREE_PURPOSE (link
)
2779 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2781 if (memcmp ((char *) &TREE_PURPOSE (link
), p
,
2782 sizeof TREE_PURPOSE (link
)))
2785 p
+= sizeof TREE_PURPOSE (link
);
2787 else if (TREE_PURPOSE (link
))
2789 if ((p
= compare_constant_1 (TREE_PURPOSE (link
), p
)) == 0)
2792 else if (have_purpose
)
2796 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2809 struct addr_const value
;
2811 decode_addr_const (exp
, &value
);
2812 strp
= (unsigned char *) &value
.offset
;
2813 len
= sizeof value
.offset
;
2814 /* Compare the offset. */
2816 if (*p
++ != *strp
++)
2819 /* Compare symbol name. */
2820 strp
= (const unsigned char *) XSTR (value
.base
, 0);
2821 len
= strlen ((const char *) strp
) + 1;
2828 p
= compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2832 return compare_constant_1 (TREE_OPERAND (exp
, 1), p
);
2836 case NON_LVALUE_EXPR
:
2837 return compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2841 tree
new = (*lang_hooks
.expand_constant
) (exp
);
2844 return compare_constant_1 (new, p
);
2850 /* Compare constant contents. */
2852 if (*p
++ != *strp
++)
2858 /* Construct a constant descriptor for the expression EXP.
2859 It is up to the caller to enter the descriptor in the hash table. */
2861 static struct constant_descriptor
*
2862 record_constant (exp
)
2865 struct constant_descriptor
*next
= 0;
2870 /* Make a struct constant_descriptor. The first three pointers will
2871 be filled in later. Here we just leave space for them. */
2873 obstack_grow (&permanent_obstack
, (char *) &next
, sizeof next
);
2874 obstack_grow (&permanent_obstack
, (char *) &label
, sizeof label
);
2875 obstack_grow (&permanent_obstack
, (char *) &rtl
, sizeof rtl
);
2877 /* Align the descriptor for the data payload. */
2878 pad
= (offsetof (struct constant_descriptor
, u
)
2879 - offsetof(struct constant_descriptor
, rtl
)
2880 - sizeof(next
->rtl
));
2882 obstack_blank (&permanent_obstack
, pad
);
2884 record_constant_1 (exp
);
2885 return (struct constant_descriptor
*) obstack_finish (&permanent_obstack
);
2888 /* Add a description of constant expression EXP
2889 to the object growing in `permanent_obstack'.
2890 No need to return its address; the caller will get that
2891 from the obstack when the object is complete. */
2894 record_constant_1 (exp
)
2897 const unsigned char *strp
;
2899 enum tree_code code
= TREE_CODE (exp
);
2901 obstack_1grow (&permanent_obstack
, (unsigned int) code
);
2906 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2907 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2908 len
= sizeof TREE_INT_CST (exp
);
2912 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2913 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2914 len
= sizeof TREE_REAL_CST (exp
);
2918 if (flag_writable_strings
)
2921 obstack_1grow (&permanent_obstack
, TYPE_MODE (TREE_TYPE (exp
)));
2922 strp
= (const unsigned char *) TREE_STRING_POINTER (exp
);
2923 len
= TREE_STRING_LENGTH (exp
);
2924 obstack_grow (&permanent_obstack
, (char *) &TREE_STRING_LENGTH (exp
),
2925 sizeof TREE_STRING_LENGTH (exp
));
2929 record_constant_1 (TREE_REALPART (exp
));
2930 record_constant_1 (TREE_IMAGPART (exp
));
2934 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2936 int nbytes
= int_size_in_bytes (TREE_TYPE (exp
));
2937 obstack_grow (&permanent_obstack
, &nbytes
, sizeof (nbytes
));
2938 obstack_blank (&permanent_obstack
, nbytes
);
2939 get_set_constructor_bytes
2940 (exp
, (unsigned char *) permanent_obstack
.next_free
-nbytes
,
2947 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2948 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2950 int have_purpose
= 0;
2952 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2953 if (TREE_PURPOSE (link
))
2956 obstack_grow (&permanent_obstack
, (char *) &length
, sizeof length
);
2958 /* For record constructors, insist that the types match.
2959 For arrays, just verify both constructors are for arrays
2960 of the same mode. Then insist that either both or none
2961 have any TREE_PURPOSE values. */
2962 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2963 type
= TREE_TYPE (exp
);
2967 obstack_grow (&permanent_obstack
, (char *) &type
, sizeof type
);
2968 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2969 obstack_grow (&permanent_obstack
, &mode
, sizeof mode
);
2971 obstack_grow (&permanent_obstack
, (char *) &have_purpose
,
2972 sizeof have_purpose
);
2974 /* For arrays, insist that the size in bytes match. */
2975 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2977 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2978 obstack_grow (&permanent_obstack
, (char *) &size
, sizeof size
);
2981 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2983 if (TREE_VALUE (link
))
2984 record_constant_1 (TREE_VALUE (link
));
2989 obstack_grow (&permanent_obstack
,
2990 (char *) &zero
, sizeof zero
);
2993 if (TREE_PURPOSE (link
)
2994 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2995 obstack_grow (&permanent_obstack
,
2996 (char *) &TREE_PURPOSE (link
),
2997 sizeof TREE_PURPOSE (link
));
2998 else if (TREE_PURPOSE (link
))
2999 record_constant_1 (TREE_PURPOSE (link
));
3000 else if (have_purpose
)
3004 obstack_grow (&permanent_obstack
,
3005 (char *) &zero
, sizeof zero
);
3013 struct addr_const value
;
3015 decode_addr_const (exp
, &value
);
3016 /* Record the offset. */
3017 obstack_grow (&permanent_obstack
,
3018 (char *) &value
.offset
, sizeof value
.offset
);
3020 switch (GET_CODE (value
.base
))
3023 /* Record the symbol name. */
3024 obstack_grow (&permanent_obstack
, XSTR (value
.base
, 0),
3025 strlen (XSTR (value
.base
, 0)) + 1);
3028 /* Record the address of the CODE_LABEL. It may not have
3029 been emitted yet, so it's UID may be zero. But pointer
3030 identity is good enough. */
3031 obstack_grow (&permanent_obstack
, &XEXP (value
.base
, 0),
3043 record_constant_1 (TREE_OPERAND (exp
, 0));
3044 record_constant_1 (TREE_OPERAND (exp
, 1));
3049 case NON_LVALUE_EXPR
:
3050 record_constant_1 (TREE_OPERAND (exp
, 0));
3055 tree
new = (*lang_hooks
.expand_constant
) (exp
);
3058 record_constant_1 (new);
3063 /* Record constant contents. */
3064 obstack_grow (&permanent_obstack
, strp
, len
);
3067 /* Record a list of constant expressions that were passed to
3068 output_constant_def but that could not be output right away. */
3070 struct deferred_constant
3072 struct deferred_constant
*next
;
3078 static struct deferred_constant
*deferred_constants
;
3080 /* Another list of constants which should be output after the
3082 static struct deferred_constant
*after_function_constants
;
3084 /* Nonzero means defer output of addressed subconstants
3085 (i.e., those for which output_constant_def is called.) */
3086 static int defer_addressed_constants_flag
;
3088 /* Start deferring output of subconstants. */
3091 defer_addressed_constants ()
3093 defer_addressed_constants_flag
++;
3096 /* Stop deferring output of subconstants,
3097 and output now all those that have been deferred. */
3100 output_deferred_addressed_constants ()
3102 struct deferred_constant
*p
, *next
;
3104 defer_addressed_constants_flag
--;
3106 if (defer_addressed_constants_flag
> 0)
3109 for (p
= deferred_constants
; p
; p
= next
)
3111 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
3116 deferred_constants
= 0;
3119 /* Output any constants which should appear after a function. */
3122 output_after_function_constants ()
3124 struct deferred_constant
*p
, *next
;
3126 for (p
= after_function_constants
; p
; p
= next
)
3128 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
3133 after_function_constants
= 0;
3136 /* Make a copy of the whole tree structure for a constant.
3137 This handles the same types of nodes that compare_constant
3138 and record_constant handle. */
3144 switch (TREE_CODE (exp
))
3147 /* For ADDR_EXPR, we do not want to copy the decl whose address
3148 is requested. We do want to copy constants though. */
3149 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
3150 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
3151 copy_constant (TREE_OPERAND (exp
, 0)));
3153 return copy_node (exp
);
3158 return copy_node (exp
);
3161 return build_complex (TREE_TYPE (exp
),
3162 copy_constant (TREE_REALPART (exp
)),
3163 copy_constant (TREE_IMAGPART (exp
)));
3167 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
3168 copy_constant (TREE_OPERAND (exp
, 0)),
3169 copy_constant (TREE_OPERAND (exp
, 1)));
3173 case NON_LVALUE_EXPR
:
3174 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
3175 copy_constant (TREE_OPERAND (exp
, 0)));
3179 tree copy
= copy_node (exp
);
3180 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
3183 CONSTRUCTOR_ELTS (copy
) = list
;
3184 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3185 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
3186 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
3187 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3188 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
3198 /* Return an rtx representing a reference to constant data in memory
3199 for the constant expression EXP.
3201 If assembler code for such a constant has already been output,
3202 return an rtx to refer to it.
3203 Otherwise, output such a constant in memory (or defer it for later)
3204 and generate an rtx for it.
3206 If DEFER is non-zero, the output of string constants can be deferred
3207 and output only if referenced in the function after all optimizations.
3209 The TREE_CST_RTL of EXP is set up to point to that rtx.
3210 The const_hash_table records which constants already have label strings. */
3213 output_constant_def (exp
, defer
)
3218 struct constant_descriptor
*desc
;
3219 struct deferred_string
**defstr
;
3223 int after_function
= 0;
3227 /* We can't just use the saved RTL if this is a defererred string constant
3228 and we are not to defer anymode. */
3229 if (TREE_CODE (exp
) != INTEGER_CST
&& TREE_CST_RTL (exp
)
3230 && (defer
|| !STRING_POOL_ADDRESS_P (XEXP (TREE_CST_RTL (exp
), 0))))
3231 return TREE_CST_RTL (exp
);
3233 /* Make sure any other constants whose addresses appear in EXP
3234 are assigned label numbers. */
3236 reloc
= output_addressed_constants (exp
);
3238 /* Compute hash code of EXP. Search the descriptors for that hash code
3239 to see if any of them describes EXP. If yes, the descriptor records
3240 the label number already assigned. */
3242 hash
= const_hash (exp
) % MAX_HASH_TABLE
;
3244 for (desc
= const_hash_table
[hash
]; desc
; desc
= desc
->next
)
3245 if (compare_constant (exp
, desc
))
3250 /* No constant equal to EXP is known to have been output.
3251 Make a constant descriptor to enter EXP in the hash table.
3252 Assign the label number and record it in the descriptor for
3253 future calls to this function to find. */
3255 /* Create a string containing the label name, in LABEL. */
3256 labelno
= const_labelno
++;
3257 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
3259 desc
= record_constant (exp
);
3260 desc
->next
= const_hash_table
[hash
];
3261 desc
->label
= ggc_strdup (label
);
3262 const_hash_table
[hash
] = desc
;
3264 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3266 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
3267 gen_rtx_SYMBOL_REF (Pmode
, desc
->label
));
3269 set_mem_attributes (rtl
, exp
, 1);
3270 set_mem_alias_set (rtl
, 0);
3271 set_mem_alias_set (rtl
, const_alias_set
);
3278 if (TREE_CODE (exp
) != INTEGER_CST
)
3279 TREE_CST_RTL (exp
) = rtl
;
3281 /* Optionally set flags or add text to the name to record information
3282 such as that it is a function name. If the name is changed, the macro
3283 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3284 #ifdef ENCODE_SECTION_INFO
3285 /* A previously-processed constant would already have section info
3289 /* Take care not to invoque ENCODE_SECTION_INFO for constants
3290 which don't have a TREE_CST_RTL. */
3291 if (TREE_CODE (exp
) != INTEGER_CST
)
3292 ENCODE_SECTION_INFO (exp
);
3295 desc
->label
= XSTR (XEXP (desc
->rtl
, 0), 0);
3299 #ifdef CONSTANT_AFTER_FUNCTION_P
3300 if (current_function_decl
!= 0
3301 && CONSTANT_AFTER_FUNCTION_P (exp
))
3306 && STRING_POOL_ADDRESS_P (XEXP (rtl
, 0))
3307 && (!defer
|| defer_addressed_constants_flag
|| after_function
))
3309 defstr
= (struct deferred_string
**)
3310 htab_find_slot_with_hash (const_str_htab
, desc
->label
,
3311 STRHASH (desc
->label
), NO_INSERT
);
3314 /* If the string is currently deferred but we need to output it now,
3315 remove it from deferred string hash table. */
3317 labelno
= (*defstr
)->labelno
;
3318 STRING_POOL_ADDRESS_P (XEXP (rtl
, 0)) = 0;
3319 htab_clear_slot (const_str_htab
, (void **) defstr
);
3323 /* If this is the first time we've seen this particular constant,
3324 output it (or defer its output for later). */
3327 if (defer_addressed_constants_flag
|| after_function
)
3329 struct deferred_constant
*p
3330 = (struct deferred_constant
*)
3331 xmalloc (sizeof (struct deferred_constant
));
3333 p
->exp
= copy_constant (exp
);
3335 p
->labelno
= labelno
;
3338 p
->next
= after_function_constants
;
3339 after_function_constants
= p
;
3343 p
->next
= deferred_constants
;
3344 deferred_constants
= p
;
3349 /* Do no output if -fsyntax-only. */
3350 if (! flag_syntax_only
)
3352 if (TREE_CODE (exp
) != STRING_CST
3354 || flag_writable_strings
3355 || (defstr
= (struct deferred_string
**)
3356 htab_find_slot_with_hash (const_str_htab
,
3358 STRHASH (desc
->label
),
3360 output_constant_def_contents (exp
, reloc
, labelno
);
3363 struct deferred_string
*p
;
3365 p
= (struct deferred_string
*)
3366 xmalloc (sizeof (struct deferred_string
));
3368 p
->exp
= copy_constant (exp
);
3369 p
->label
= desc
->label
;
3370 p
->labelno
= labelno
;
3372 STRING_POOL_ADDRESS_P (XEXP (rtl
, 0)) = 1;
3381 /* Now output assembler code to define the label for EXP,
3382 and follow it with the data of EXP. */
3385 output_constant_def_contents (exp
, reloc
, labelno
)
3392 /* Align the location counter as required by EXP's data type. */
3393 align
= TYPE_ALIGN (TREE_TYPE (exp
));
3394 #ifdef CONSTANT_ALIGNMENT
3395 align
= CONSTANT_ALIGNMENT (exp
, align
);
3398 if (IN_NAMED_SECTION (exp
))
3399 named_section (exp
, NULL
, reloc
);
3402 /* First switch to text section, except for writable strings. */
3403 #ifdef SELECT_SECTION
3404 SELECT_SECTION (exp
, reloc
, align
);
3406 if (((TREE_CODE (exp
) == STRING_CST
) && flag_writable_strings
)
3407 || (flag_pic
&& reloc
))
3410 readonly_data_section ();
3414 if (align
> BITS_PER_UNIT
)
3416 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3419 /* Output the label itself. */
3420 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", labelno
);
3422 /* Output the value of EXP. */
3423 output_constant (exp
,
3424 (TREE_CODE (exp
) == STRING_CST
3425 ? MAX (TREE_STRING_LENGTH (exp
),
3426 int_size_in_bytes (TREE_TYPE (exp
)))
3427 : int_size_in_bytes (TREE_TYPE (exp
))),
3432 /* Structure to represent sufficient information about a constant so that
3433 it can be output when the constant pool is output, so that function
3434 integration can be done, and to simplify handling on machines that reference
3435 constant pool as base+displacement. */
3437 struct pool_constant
3439 struct constant_descriptor
*desc
;
3440 struct pool_constant
*next
, *next_sym
;
3442 enum machine_mode mode
;
3445 HOST_WIDE_INT offset
;
3449 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3450 The argument is XSTR (... , 0) */
3452 #define SYMHASH(LABEL) \
3453 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3455 /* Initialize constant pool hashing for a new function. */
3458 init_varasm_status (f
)
3461 struct varasm_status
*p
;
3462 p
= (struct varasm_status
*) xmalloc (sizeof (struct varasm_status
));
3464 p
->x_const_rtx_hash_table
3465 = ((struct constant_descriptor
**)
3466 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct constant_descriptor
*)));
3467 p
->x_const_rtx_sym_hash_table
3468 = ((struct pool_constant
**)
3469 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct pool_constant
*)));
3471 p
->x_first_pool
= p
->x_last_pool
= 0;
3472 p
->x_pool_offset
= 0;
3473 p
->x_const_double_chain
= 0;
3476 /* Mark PC for GC. */
3479 mark_pool_constant (pc
)
3480 struct pool_constant
*pc
;
3485 ggc_mark_rtx (pc
->constant
);
3486 ggc_mark_rtx (pc
->desc
->rtl
);
3491 /* Mark P for GC. */
3494 mark_varasm_status (p
)
3495 struct varasm_status
*p
;
3500 mark_pool_constant (p
->x_first_pool
);
3501 ggc_mark_rtx (p
->x_const_double_chain
);
3504 /* Clear out all parts of the state in F that can safely be discarded
3505 after the function has been compiled, to let garbage collection
3506 reclaim the memory. */
3509 free_varasm_status (f
)
3512 struct varasm_status
*p
;
3517 /* Clear out the hash tables. */
3518 for (i
= 0; i
< MAX_RTX_HASH_TABLE
; ++i
)
3520 struct constant_descriptor
*cd
;
3522 cd
= p
->x_const_rtx_hash_table
[i
];
3525 struct constant_descriptor
*next
= cd
->next
;
3532 free (p
->x_const_rtx_hash_table
);
3533 free (p
->x_const_rtx_sym_hash_table
);
3540 /* Express an rtx for a constant integer (perhaps symbolic)
3541 as the sum of a symbol or label plus an explicit integer.
3542 They are stored into VALUE. */
3545 decode_rtx_const (mode
, x
, value
)
3546 enum machine_mode mode
;
3548 struct rtx_const
*value
;
3550 /* Clear the whole structure, including any gaps. */
3551 memset (value
, 0, sizeof (struct rtx_const
));
3553 value
->kind
= RTX_INT
; /* Most usual kind. */
3556 switch (GET_CODE (x
))
3559 value
->kind
= RTX_DOUBLE
;
3560 if (GET_MODE (x
) != VOIDmode
)
3562 value
->mode
= GET_MODE (x
);
3563 memcpy ((char *) &value
->un
.du
,
3564 (char *) &CONST_DOUBLE_LOW (x
), sizeof value
->un
.du
);
3568 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
3569 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
3578 units
= CONST_VECTOR_NUNITS (x
);
3579 value
->kind
= RTX_VECTOR
;
3582 for (i
= 0; i
< units
; ++i
)
3584 elt
= CONST_VECTOR_ELT (x
, i
);
3585 if (GET_MODE_CLASS (mode
) == MODE_VECTOR_INT
)
3587 value
->un
.veclo
[i
] = (HOST_WIDE_INT
) INTVAL (elt
);
3588 value
->un
.vechi
[i
] = 0;
3590 else if (GET_MODE_CLASS (mode
) == MODE_VECTOR_FLOAT
)
3592 value
->un
.veclo
[i
] = (HOST_WIDE_INT
) CONST_DOUBLE_LOW (elt
);
3593 value
->un
.vechi
[i
] = (HOST_WIDE_INT
) CONST_DOUBLE_HIGH (elt
);
3602 value
->un
.addr
.offset
= INTVAL (x
);
3608 value
->un
.addr
.base
= x
;
3613 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3615 value
->un
.addr
.base
= XEXP (x
, 0);
3616 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
3618 else if (GET_CODE (x
) == MINUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3620 value
->un
.addr
.base
= XEXP (x
, 0);
3621 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
3625 value
->un
.addr
.base
= x
;
3626 value
->un
.addr
.offset
= 0;
3631 value
->kind
= RTX_UNKNOWN
;
3635 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0
3636 && GET_CODE (value
->un
.addr
.base
) == UNSPEC
)
3638 /* For a simple UNSPEC, the base is set to the
3639 operand, the kind field is set to the index of
3640 the unspec expression.
3641 Together with the code below, in case that
3642 the operand is a SYMBOL_REF or LABEL_REF,
3643 the address of the string or the code_label
3644 is taken as base. */
3645 if (XVECLEN (value
->un
.addr
.base
, 0) == 1)
3647 value
->kind
= RTX_UNSPEC
+ XINT (value
->un
.addr
.base
, 1);
3648 value
->un
.addr
.base
= XVECEXP (value
->un
.addr
.base
, 0, 0);
3652 if (value
->kind
> RTX_DOUBLE
&& value
->un
.addr
.base
!= 0)
3653 switch (GET_CODE (value
->un
.addr
.base
))
3656 /* Use the string's address, not the SYMBOL_REF's address,
3657 for the sake of addresses of library routines. */
3658 value
->un
.addr
.base
= (rtx
) XSTR (value
->un
.addr
.base
, 0);
3662 /* For a LABEL_REF, compare labels. */
3663 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
3670 /* Given a MINUS expression, simplify it if both sides
3671 include the same symbol. */
3674 simplify_subtraction (x
)
3677 struct rtx_const val0
, val1
;
3679 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
3680 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
3682 if (val0
.kind
> RTX_DOUBLE
3683 && val0
.kind
== val1
.kind
3684 && val0
.un
.addr
.base
== val1
.un
.addr
.base
)
3685 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
3690 /* Compute a hash code for a constant RTL expression. */
3693 const_hash_rtx (mode
, x
)
3694 enum machine_mode mode
;
3700 struct rtx_const value
;
3701 decode_rtx_const (mode
, x
, &value
);
3703 /* Compute hashing function */
3705 for (i
= 0; i
< sizeof value
/ sizeof (int); i
++)
3706 hi
+= ((int *) &value
)[i
];
3708 hi
&= (1 << HASHBITS
) - 1;
3709 hi
%= MAX_RTX_HASH_TABLE
;
3713 /* Compare a constant rtl object X with a constant-descriptor DESC.
3714 Return 1 if DESC describes a constant with the same value as X. */
3717 compare_constant_rtx (mode
, x
, desc
)
3718 enum machine_mode mode
;
3720 struct constant_descriptor
*desc
;
3722 int *p
= (int *) desc
->u
.contents
;
3725 struct rtx_const value
;
3727 decode_rtx_const (mode
, x
, &value
);
3728 strp
= (int *) &value
;
3729 len
= sizeof value
/ sizeof (int);
3731 /* Compare constant contents. */
3733 if (*p
++ != *strp
++)
3739 /* Construct a constant descriptor for the rtl-expression X.
3740 It is up to the caller to enter the descriptor in the hash table. */
3742 static struct constant_descriptor
*
3743 record_constant_rtx (mode
, x
)
3744 enum machine_mode mode
;
3747 struct constant_descriptor
*ptr
;
3749 ptr
= ((struct constant_descriptor
*)
3750 xcalloc (1, (offsetof (struct constant_descriptor
, u
)
3751 + sizeof (struct rtx_const
))));
3752 decode_rtx_const (mode
, x
, (struct rtx_const
*) ptr
->u
.contents
);
3757 /* Given a constant rtx X, return a MEM for the location in memory at which
3758 this constant has been placed. Return 0 if it not has been placed yet. */
3761 mem_for_const_double (x
)
3764 enum machine_mode mode
= GET_MODE (x
);
3765 struct constant_descriptor
*desc
;
3767 for (desc
= const_rtx_hash_table
[const_hash_rtx (mode
, x
)]; desc
;
3769 if (compare_constant_rtx (mode
, x
, desc
))
3775 /* Given a constant rtx X, make (or find) a memory constant for its value
3776 and return a MEM rtx to refer to it in memory. */
3779 force_const_mem (mode
, x
)
3780 enum machine_mode mode
;
3784 struct constant_descriptor
*desc
;
3787 struct pool_constant
*pool
;
3790 /* Compute hash code of X. Search the descriptors for that hash code
3791 to see if any of them describes X. If yes, we have an rtx to use. */
3792 hash
= const_hash_rtx (mode
, x
);
3793 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3794 if (compare_constant_rtx (mode
, x
, desc
))
3797 /* No constant equal to X is known to have been output.
3798 Make a constant descriptor to enter X in the hash table
3799 and make a MEM for it. */
3800 desc
= record_constant_rtx (mode
, x
);
3801 desc
->next
= const_rtx_hash_table
[hash
];
3802 const_rtx_hash_table
[hash
] = desc
;
3804 /* Align the location counter as required by EXP's data type. */
3805 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3806 #ifdef CONSTANT_ALIGNMENT
3807 align
= CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode
, 0), x
), align
);
3810 pool_offset
+= (align
/ BITS_PER_UNIT
) - 1;
3811 pool_offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3813 if (GET_CODE (x
) == LABEL_REF
)
3814 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3816 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3817 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3821 pool
->labelno
= const_labelno
;
3822 pool
->align
= align
;
3823 pool
->offset
= pool_offset
;
3830 last_pool
->next
= pool
;
3833 pool_offset
+= GET_MODE_SIZE (mode
);
3835 /* Create a string containing the label name, in LABEL. */
3836 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3840 /* Construct the SYMBOL_REF and the MEM. */
3842 pool
->desc
->rtl
= def
3843 = gen_rtx_MEM (mode
, gen_rtx_SYMBOL_REF (Pmode
, ggc_strdup (label
)));
3844 set_mem_alias_set (def
, const_alias_set
);
3845 set_mem_attributes (def
, type_for_mode (mode
, 0), 1);
3846 RTX_UNCHANGING_P (def
) = 1;
3848 /* Add label to symbol hash table. */
3849 hash
= SYMHASH (XSTR (XEXP (def
, 0), 0));
3850 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3851 const_rtx_sym_hash_table
[hash
] = pool
;
3853 /* Mark the symbol_ref as belonging to this constants pool. */
3854 CONSTANT_POOL_ADDRESS_P (XEXP (def
, 0)) = 1;
3855 current_function_uses_const_pool
= 1;
3860 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3861 the corresponding pool_constant structure. */
3863 static struct pool_constant
*
3864 find_pool_constant (f
, addr
)
3868 struct pool_constant
*pool
;
3869 const char *label
= XSTR (addr
, 0);
3871 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3872 pool
= pool
->next_sym
)
3873 if (XSTR (XEXP (pool
->desc
->rtl
, 0), 0) == label
)
3879 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3882 get_pool_constant (addr
)
3885 return (find_pool_constant (cfun
, addr
))->constant
;
3888 /* Given a constant pool SYMBOL_REF, return the corresponding constant
3889 and whether it has been output or not. */
3892 get_pool_constant_mark (addr
, pmarked
)
3896 struct pool_constant
*pool
= find_pool_constant (cfun
, addr
);
3897 *pmarked
= (pool
->mark
!= 0);
3898 return pool
->constant
;
3901 /* Likewise, but for the constant pool of a specific function. */
3904 get_pool_constant_for_function (f
, addr
)
3908 return (find_pool_constant (f
, addr
))->constant
;
3911 /* Similar, return the mode. */
3914 get_pool_mode (addr
)
3917 return (find_pool_constant (cfun
, addr
))->mode
;
3921 get_pool_mode_for_function (f
, addr
)
3925 return (find_pool_constant (f
, addr
))->mode
;
3928 /* Similar, return the offset in the constant pool. */
3931 get_pool_offset (addr
)
3934 return (find_pool_constant (cfun
, addr
))->offset
;
3937 /* Return the size of the constant pool. */
3945 /* Write all the constants in the constant pool. */
3948 output_constant_pool (fnname
, fndecl
)
3949 const char *fnname ATTRIBUTE_UNUSED
;
3950 tree fndecl ATTRIBUTE_UNUSED
;
3952 struct pool_constant
*pool
;
3954 union real_extract u
;
3956 /* It is possible for gcc to call force_const_mem and then to later
3957 discard the instructions which refer to the constant. In such a
3958 case we do not need to output the constant. */
3959 mark_constant_pool ();
3961 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3962 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3965 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3974 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3975 whose CODE_LABEL has been deleted. This can occur if a jump table
3976 is eliminated by optimization. If so, write a constant of zero
3977 instead. Note that this can also happen by turning the
3978 CODE_LABEL into a NOTE. */
3979 /* ??? This seems completely and utterly wrong. Certainly it's
3980 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3981 functioning even with INSN_DELETED_P and friends. */
3984 switch (GET_CODE (x
))
3987 if (GET_CODE (XEXP (x
, 0)) != PLUS
3988 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3990 tmp
= XEXP (XEXP (x
, 0), 0);
3995 if (INSN_DELETED_P (tmp
)
3996 || (GET_CODE (tmp
) == NOTE
3997 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
4008 /* First switch to correct section. */
4009 #ifdef SELECT_RTX_SECTION
4010 SELECT_RTX_SECTION (pool
->mode
, x
, pool
->align
);
4012 readonly_data_section ();
4015 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4016 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
4017 pool
->align
, pool
->labelno
, done
);
4020 assemble_align (pool
->align
);
4022 /* Output the label. */
4023 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", pool
->labelno
);
4025 /* Output the value of the constant itself. */
4026 switch (GET_MODE_CLASS (pool
->mode
))
4029 if (GET_CODE (x
) != CONST_DOUBLE
)
4032 memcpy ((char *) &u
, (char *) &CONST_DOUBLE_LOW (x
), sizeof u
);
4033 assemble_real (u
.d
, pool
->mode
, pool
->align
);
4037 case MODE_PARTIAL_INT
:
4038 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), pool
->align
, 1);
4041 case MODE_VECTOR_FLOAT
:
4046 if (GET_CODE (x
) != CONST_VECTOR
)
4049 units
= CONST_VECTOR_NUNITS (x
);
4051 for (i
= 0; i
< units
; i
++)
4053 elt
= CONST_VECTOR_ELT (x
, i
);
4054 memcpy ((char *) &u
,
4055 (char *) &CONST_DOUBLE_LOW (elt
),
4057 assemble_real (u
.d
, GET_MODE_INNER (pool
->mode
), pool
->align
);
4062 case MODE_VECTOR_INT
:
4067 if (GET_CODE (x
) != CONST_VECTOR
)
4070 units
= CONST_VECTOR_NUNITS (x
);
4072 for (i
= 0; i
< units
; i
++)
4074 elt
= CONST_VECTOR_ELT (x
, i
);
4075 assemble_integer (elt
, GET_MODE_UNIT_SIZE (pool
->mode
),
4085 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
4090 #ifdef ASM_OUTPUT_POOL_EPILOGUE
4091 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
4094 /* Done with this pool. */
4095 first_pool
= last_pool
= 0;
4098 /* Look through the instructions for this function, and mark all the
4099 entries in the constant pool which are actually being used.
4100 Emit used deferred strings. */
4103 mark_constant_pool ()
4106 struct pool_constant
*pool
;
4108 if (first_pool
== 0 && htab_elements (const_str_htab
) == 0)
4111 for (pool
= first_pool
; pool
; pool
= pool
->next
)
4114 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
4116 mark_constants (PATTERN (insn
));
4118 for (insn
= current_function_epilogue_delay_list
;
4120 insn
= XEXP (insn
, 1))
4122 mark_constants (PATTERN (insn
));
4125 /* Look through appropriate parts of X, marking all entries in the
4126 constant pool which are actually being used. Entries that are only
4127 referenced by other constants are also marked as used. Emit
4128 deferred strings that are used. */
4135 const char *format_ptr
;
4140 if (GET_CODE (x
) == SYMBOL_REF
)
4142 mark_constant (&x
, NULL
);
4146 /* Insns may appear inside a SEQUENCE. Only check the patterns of
4147 insns, not any notes that may be attached. We don't want to mark
4148 a constant just because it happens to appear in a REG_EQUIV note. */
4151 mark_constants (PATTERN (x
));
4155 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
4157 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
4159 switch (*format_ptr
++)
4162 mark_constants (XEXP (x
, i
));
4166 if (XVEC (x
, i
) != 0)
4170 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
4171 mark_constants (XVECEXP (x
, i
, j
));
4190 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
4191 to as used. Emit referenced deferred strings. This function can
4192 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
4195 mark_constant (current_rtx
, data
)
4197 void *data ATTRIBUTE_UNUSED
;
4199 rtx x
= *current_rtx
;
4204 else if (GET_CODE (x
) == SYMBOL_REF
)
4206 if (CONSTANT_POOL_ADDRESS_P (x
))
4208 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
4209 if (pool
->mark
== 0) {
4211 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
4216 else if (STRING_POOL_ADDRESS_P (x
))
4218 struct deferred_string
**defstr
;
4220 defstr
= (struct deferred_string
**)
4221 htab_find_slot_with_hash (const_str_htab
, XSTR (x
, 0),
4222 STRHASH (XSTR (x
, 0)), NO_INSERT
);
4225 struct deferred_string
*p
= *defstr
;
4227 STRING_POOL_ADDRESS_P (x
) = 0;
4228 output_constant_def_contents (p
->exp
, 0, p
->labelno
);
4229 htab_clear_slot (const_str_htab
, (void **) defstr
);
4236 /* Find all the constants whose addresses are referenced inside of EXP,
4237 and make sure assembler code with a label has been output for each one.
4238 Indicate whether an ADDR_EXPR has been encountered. */
4241 output_addressed_constants (exp
)
4247 /* Give the front-end a chance to convert VALUE to something that
4248 looks more like a constant to the back-end. */
4249 exp
= (*lang_hooks
.expand_constant
) (exp
);
4251 switch (TREE_CODE (exp
))
4255 /* Go inside any operations that get_inner_reference can handle and see
4256 if what's inside is a constant: no need to do anything here for
4257 addresses of variables or functions. */
4258 for (tem
= TREE_OPERAND (exp
, 0); handled_component_p (tem
);
4259 tem
= TREE_OPERAND (tem
, 0))
4262 if (TREE_CODE_CLASS (TREE_CODE (tem
)) == 'c'
4263 || TREE_CODE (tem
) == CONSTRUCTOR
)
4264 output_constant_def (tem
, 0);
4266 if (TREE_PUBLIC (tem
))
4274 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
4275 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
4280 case NON_LVALUE_EXPR
:
4281 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
4285 for (tem
= CONSTRUCTOR_ELTS (exp
); tem
; tem
= TREE_CHAIN (tem
))
4286 if (TREE_VALUE (tem
) != 0)
4287 reloc
|= output_addressed_constants (TREE_VALUE (tem
));
4297 /* Return nonzero if VALUE is a valid constant-valued expression
4298 for use in initializing a static variable; one that can be an
4299 element of a "constant" initializer.
4301 Return null_pointer_node if the value is absolute;
4302 if it is relocatable, return the variable that determines the relocation.
4303 We assume that VALUE has been folded as much as possible;
4304 therefore, we do not need to check for such things as
4305 arithmetic-combinations of integers. */
4308 initializer_constant_valid_p (value
, endtype
)
4312 /* Give the front-end a chance to convert VALUE to something that
4313 looks more like a constant to the back-end. */
4314 value
= (*lang_hooks
.expand_constant
) (value
);
4316 switch (TREE_CODE (value
))
4319 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
4320 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
4321 && TREE_CONSTANT (value
)
4322 && CONSTRUCTOR_ELTS (value
))
4324 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
4327 return TREE_STATIC (value
) ? null_pointer_node
: 0;
4334 return null_pointer_node
;
4338 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
4340 case VIEW_CONVERT_EXPR
:
4341 case NON_LVALUE_EXPR
:
4342 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4346 /* Allow conversions between pointer types. */
4347 if (POINTER_TYPE_P (TREE_TYPE (value
))
4348 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4349 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4351 /* Allow conversions between real types. */
4352 if (FLOAT_TYPE_P (TREE_TYPE (value
))
4353 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4354 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4356 /* Allow length-preserving conversions between integer types. */
4357 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4358 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4359 && (TYPE_PRECISION (TREE_TYPE (value
))
4360 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4361 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4363 /* Allow conversions between other integer types only if
4365 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4366 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4368 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4370 if (inner
== null_pointer_node
)
4371 return null_pointer_node
;
4375 /* Allow (int) &foo provided int is as wide as a pointer. */
4376 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4377 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4378 && (TYPE_PRECISION (TREE_TYPE (value
))
4379 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4380 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4383 /* Likewise conversions from int to pointers, but also allow
4384 conversions from 0. */
4385 if (POINTER_TYPE_P (TREE_TYPE (value
))
4386 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4388 if (integer_zerop (TREE_OPERAND (value
, 0)))
4389 return null_pointer_node
;
4390 else if (TYPE_PRECISION (TREE_TYPE (value
))
4391 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
4392 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4396 /* Allow conversions to union types if the value inside is okay. */
4397 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
4398 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4403 if (! INTEGRAL_TYPE_P (endtype
)
4404 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4406 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4408 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4410 /* If either term is absolute, use the other terms relocation. */
4411 if (valid0
== null_pointer_node
)
4413 if (valid1
== null_pointer_node
)
4419 if (! INTEGRAL_TYPE_P (endtype
)
4420 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4422 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4424 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4426 /* Win if second argument is absolute. */
4427 if (valid1
== null_pointer_node
)
4429 /* Win if both arguments have the same relocation.
4430 Then the value is absolute. */
4431 if (valid0
== valid1
&& valid0
!= 0)
4432 return null_pointer_node
;
4434 /* Since GCC guarantees that string constants are unique in the
4435 generated code, a subtraction between two copies of the same
4436 constant string is absolute. */
4437 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
&&
4438 valid1
&& TREE_CODE (valid1
) == STRING_CST
&&
4439 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
4440 return null_pointer_node
;
4443 /* Support differences between labels. */
4444 if (INTEGRAL_TYPE_P (endtype
))
4447 op0
= TREE_OPERAND (value
, 0);
4448 op1
= TREE_OPERAND (value
, 1);
4450 /* Like STRIP_NOPS except allow the operand mode to widen.
4451 This works around a feature of fold that simplfies
4452 (int)(p1 - p2) to ((int)p1 - (int)p2) under the theory
4453 that the narrower operation is cheaper. */
4455 while (TREE_CODE (op0
) == NOP_EXPR
4456 || TREE_CODE (op0
) == CONVERT_EXPR
4457 || TREE_CODE (op0
) == NON_LVALUE_EXPR
)
4459 tree inner
= TREE_OPERAND (op0
, 0);
4460 if (inner
== error_mark_node
4461 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4462 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op0
)))
4463 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4468 while (TREE_CODE (op1
) == NOP_EXPR
4469 || TREE_CODE (op1
) == CONVERT_EXPR
4470 || TREE_CODE (op1
) == NON_LVALUE_EXPR
)
4472 tree inner
= TREE_OPERAND (op1
, 0);
4473 if (inner
== error_mark_node
4474 || ! INTEGRAL_MODE_P (TYPE_MODE (TREE_TYPE (inner
)))
4475 || (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (op1
)))
4476 > GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (inner
)))))
4481 if (TREE_CODE (op0
) == ADDR_EXPR
4482 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
4483 && TREE_CODE (op1
) == ADDR_EXPR
4484 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
4485 return null_pointer_node
;
4496 /* Output assembler code for constant EXP to FILE, with no label.
4497 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4498 Assumes output_addressed_constants has been done on EXP already.
4500 Generate exactly SIZE bytes of assembler data, padding at the end
4501 with zeros if necessary. SIZE must always be specified.
4503 SIZE is important for structure constructors,
4504 since trailing members may have been omitted from the constructor.
4505 It is also important for initialization of arrays from string constants
4506 since the full length of the string constant might not be wanted.
4507 It is also needed for initialization of unions, where the initializer's
4508 type is just one member, and that may not be as long as the union.
4510 There a case in which we would fail to output exactly SIZE bytes:
4511 for a structure constructor that wants to produce more than SIZE bytes.
4512 But such constructors will never be generated for any possible input.
4514 ALIGN is the alignment of the data in bits. */
4517 output_constant (exp
, size
, align
)
4522 enum tree_code code
;
4523 HOST_WIDE_INT thissize
;
4525 /* Some front-ends use constants other than the standard language-indepdent
4526 varieties, but which may still be output directly. Give the front-end a
4527 chance to convert EXP to a language-independent representation. */
4528 exp
= (*lang_hooks
.expand_constant
) (exp
);
4530 if (size
== 0 || flag_syntax_only
)
4533 /* Eliminate any conversions since we'll be outputting the underlying
4535 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
4536 || TREE_CODE (exp
) == NON_LVALUE_EXPR
4537 || TREE_CODE (exp
) == VIEW_CONVERT_EXPR
)
4538 exp
= TREE_OPERAND (exp
, 0);
4540 code
= TREE_CODE (TREE_TYPE (exp
));
4541 thissize
= int_size_in_bytes (TREE_TYPE (exp
));
4543 /* Allow a constructor with no elements for any data type.
4544 This means to fill the space with zeros. */
4545 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
4547 assemble_zeros (size
);
4551 if (TREE_CODE (exp
) == FDESC_EXPR
)
4553 #ifdef ASM_OUTPUT_FDESC
4554 HOST_WIDE_INT part
= tree_low_cst (TREE_OPERAND (exp
, 1), 0);
4555 tree decl
= TREE_OPERAND (exp
, 0);
4556 ASM_OUTPUT_FDESC (asm_out_file
, decl
, part
);
4563 /* Now output the underlying data. If we've handling the padding, return.
4564 Otherwise, break and ensure THISSIZE is the size written. */
4572 case REFERENCE_TYPE
:
4573 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4574 EXPAND_INITIALIZER
),
4576 error ("initializer for integer value is too complicated");
4580 if (TREE_CODE (exp
) != REAL_CST
)
4581 error ("initializer for floating value is not a floating constant");
4583 assemble_real (TREE_REAL_CST (exp
),
4584 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0),
4589 output_constant (TREE_REALPART (exp
), thissize
/ 2, align
);
4590 output_constant (TREE_IMAGPART (exp
), thissize
/ 2,
4591 min_align (align
, BITS_PER_UNIT
* (thissize
/ 2)));
4596 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4598 output_constructor (exp
, size
, align
);
4601 else if (TREE_CODE (exp
) == STRING_CST
)
4603 thissize
= MIN (TREE_STRING_LENGTH (exp
), size
);
4604 assemble_string (TREE_STRING_POINTER (exp
), thissize
);
4612 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4613 output_constructor (exp
, size
, align
);
4619 if (TREE_CODE (exp
) == INTEGER_CST
)
4620 assemble_integer (expand_expr (exp
, NULL_RTX
,
4621 VOIDmode
, EXPAND_INITIALIZER
),
4622 thissize
, align
, 1);
4623 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
4625 unsigned char *buffer
= (unsigned char *) alloca (thissize
);
4626 if (get_set_constructor_bytes (exp
, buffer
, thissize
))
4628 assemble_string ((char *) buffer
, thissize
);
4631 error ("unknown set constructor type");
4643 assemble_zeros (size
);
4647 /* Subroutine of output_constructor, used for computing the size of
4648 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4649 type with an unspecified upper bound. */
4651 static unsigned HOST_WIDE_INT
4652 array_size_for_constructor (val
)
4657 /* This code used to attempt to handle string constants that are not
4658 arrays of single-bytes, but nothing else does, so there's no point in
4660 if (TREE_CODE (val
) == STRING_CST
)
4661 return TREE_STRING_LENGTH (val
);
4663 max_index
= NULL_TREE
;
4664 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
4666 tree index
= TREE_PURPOSE (i
);
4668 if (TREE_CODE (index
) == RANGE_EXPR
)
4669 index
= TREE_OPERAND (index
, 1);
4670 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4674 if (max_index
== NULL_TREE
)
4677 /* Compute the total number of array elements. */
4678 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
4680 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
4681 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
4683 /* Multiply by the array element unit size to find number of bytes. */
4684 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4686 return tree_low_cst (i
, 1);
4689 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4690 Generate at least SIZE bytes, padding if necessary. */
4693 output_constructor (exp
, size
, align
)
4698 tree type
= TREE_TYPE (exp
);
4699 tree link
, field
= 0;
4701 /* Number of bytes output or skipped so far.
4702 In other words, current position within the constructor. */
4703 HOST_WIDE_INT total_bytes
= 0;
4704 /* Non-zero means BYTE contains part of a byte, to be output. */
4705 int byte_buffer_in_use
= 0;
4708 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4711 if (TREE_CODE (type
) == RECORD_TYPE
)
4712 field
= TYPE_FIELDS (type
);
4714 if (TREE_CODE (type
) == ARRAY_TYPE
4715 && TYPE_DOMAIN (type
) != 0)
4716 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4718 /* As LINK goes through the elements of the constant,
4719 FIELD goes through the structure fields, if the constant is a structure.
4720 if the constant is a union, then we override this,
4721 by getting the field from the TREE_LIST element.
4722 But the constant could also be an array. Then FIELD is zero.
4724 There is always a maximum of one element in the chain LINK for unions
4725 (even if the initializer in a source program incorrectly contains
4727 for (link
= CONSTRUCTOR_ELTS (exp
);
4729 link
= TREE_CHAIN (link
),
4730 field
= field
? TREE_CHAIN (field
) : 0)
4732 tree val
= TREE_VALUE (link
);
4735 /* The element in a union constructor specifies the proper field
4737 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4738 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4739 && TREE_PURPOSE (link
) != 0)
4740 field
= TREE_PURPOSE (link
);
4742 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4743 index
= TREE_PURPOSE (link
);
4745 /* Eliminate the marker that makes a cast not be an lvalue. */
4749 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4751 unsigned HOST_WIDE_INT fieldsize
4752 = int_size_in_bytes (TREE_TYPE (type
));
4753 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4754 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4755 HOST_WIDE_INT index
;
4756 unsigned int align2
= min_align (align
, fieldsize
* BITS_PER_UNIT
);
4758 for (index
= lo_index
; index
<= hi_index
; index
++)
4760 /* Output the element's initial value. */
4762 assemble_zeros (fieldsize
);
4764 output_constant (val
, fieldsize
, align2
);
4766 /* Count its size. */
4767 total_bytes
+= fieldsize
;
4770 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4772 /* An element that is not a bit-field. */
4774 unsigned HOST_WIDE_INT fieldsize
;
4775 /* Since this structure is static,
4776 we know the positions are constant. */
4777 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4778 unsigned int align2
;
4781 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4782 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4784 /* Output any buffered-up bit-fields preceding this element. */
4785 if (byte_buffer_in_use
)
4787 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4789 byte_buffer_in_use
= 0;
4792 /* Advance to offset of this element.
4793 Note no alignment needed in an array, since that is guaranteed
4794 if each element has the proper size. */
4795 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4797 assemble_zeros (pos
- total_bytes
);
4801 /* Find the alignment of this element. */
4802 align2
= min_align (align
, BITS_PER_UNIT
* pos
);
4804 /* Determine size this element should occupy. */
4809 /* If this is an array with an unspecified upper bound,
4810 the initializer determines the size. */
4811 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4812 but we cannot do this until the deprecated support for
4813 initializing zero-length array members is removed. */
4814 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4815 && TYPE_DOMAIN (TREE_TYPE (field
))
4816 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4818 fieldsize
= array_size_for_constructor (val
);
4819 /* Given a non-empty initialization, this field had
4821 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4824 else if (DECL_SIZE_UNIT (field
))
4826 /* ??? This can't be right. If the decl size overflows
4827 a host integer we will silently emit no data. */
4828 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4829 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4833 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4835 /* Output the element's initial value. */
4837 assemble_zeros (fieldsize
);
4839 output_constant (val
, fieldsize
, align2
);
4841 /* Count its size. */
4842 total_bytes
+= fieldsize
;
4844 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4845 error ("invalid initial value for member `%s'",
4846 IDENTIFIER_POINTER (DECL_NAME (field
)));
4849 /* Element that is a bit-field. */
4851 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4852 HOST_WIDE_INT end_offset
4853 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4856 val
= integer_zero_node
;
4858 /* If this field does not start in this (or, next) byte,
4860 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4862 /* Output remnant of any bit field in previous bytes. */
4863 if (byte_buffer_in_use
)
4865 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4867 byte_buffer_in_use
= 0;
4870 /* If still not at proper byte, advance to there. */
4871 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4873 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4874 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4878 if (! byte_buffer_in_use
)
4881 /* We must split the element into pieces that fall within
4882 separate bytes, and combine each byte with previous or
4883 following bit-fields. */
4885 /* next_offset is the offset n fbits from the beginning of
4886 the structure to the next bit of this element to be processed.
4887 end_offset is the offset of the first bit past the end of
4889 while (next_offset
< end_offset
)
4893 HOST_WIDE_INT value
;
4894 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4895 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4897 /* Advance from byte to byte
4898 within this element when necessary. */
4899 while (next_byte
!= total_bytes
)
4901 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4906 /* Number of bits we can process at once
4907 (all part of the same byte). */
4908 this_time
= MIN (end_offset
- next_offset
,
4909 BITS_PER_UNIT
- next_bit
);
4910 if (BYTES_BIG_ENDIAN
)
4912 /* On big-endian machine, take the most significant bits
4913 first (of the bits that are significant)
4914 and put them into bytes from the most significant end. */
4915 shift
= end_offset
- next_offset
- this_time
;
4917 /* Don't try to take a bunch of bits that cross
4918 the word boundary in the INTEGER_CST. We can
4919 only select bits from the LOW or HIGH part
4921 if (shift
< HOST_BITS_PER_WIDE_INT
4922 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4924 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4925 shift
= HOST_BITS_PER_WIDE_INT
;
4928 /* Now get the bits from the appropriate constant word. */
4929 if (shift
< HOST_BITS_PER_WIDE_INT
)
4930 value
= TREE_INT_CST_LOW (val
);
4931 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4933 value
= TREE_INT_CST_HIGH (val
);
4934 shift
-= HOST_BITS_PER_WIDE_INT
;
4939 /* Get the result. This works only when:
4940 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4941 byte
|= (((value
>> shift
)
4942 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4943 << (BITS_PER_UNIT
- this_time
- next_bit
));
4947 /* On little-endian machines,
4948 take first the least significant bits of the value
4949 and pack them starting at the least significant
4950 bits of the bytes. */
4951 shift
= next_offset
- int_bit_position (field
);
4953 /* Don't try to take a bunch of bits that cross
4954 the word boundary in the INTEGER_CST. We can
4955 only select bits from the LOW or HIGH part
4957 if (shift
< HOST_BITS_PER_WIDE_INT
4958 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4959 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4961 /* Now get the bits from the appropriate constant word. */
4962 if (shift
< HOST_BITS_PER_WIDE_INT
)
4963 value
= TREE_INT_CST_LOW (val
);
4964 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4966 value
= TREE_INT_CST_HIGH (val
);
4967 shift
-= HOST_BITS_PER_WIDE_INT
;
4972 /* Get the result. This works only when:
4973 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4974 byte
|= (((value
>> shift
)
4975 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4979 next_offset
+= this_time
;
4980 byte_buffer_in_use
= 1;
4985 if (byte_buffer_in_use
)
4987 assemble_integer (GEN_INT (byte
), 1, BITS_PER_UNIT
, 1);
4991 if (total_bytes
< size
)
4992 assemble_zeros (size
- total_bytes
);
4995 /* This TREE_LIST contains any weak symbol declarations waiting
4997 static tree weak_decls
;
4999 /* Mark DECL as weak. */
5005 DECL_WEAK (decl
) = 1;
5007 if (DECL_RTL_SET_P (decl
)
5008 && GET_CODE (DECL_RTL (decl
)) == MEM
5009 && XEXP (DECL_RTL (decl
), 0)
5010 && GET_CODE (XEXP (DECL_RTL (decl
), 0)) == SYMBOL_REF
)
5011 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = 1;
5014 /* Merge weak status between NEWDECL and OLDDECL. */
5017 merge_weak (newdecl
, olddecl
)
5021 if (DECL_WEAK (newdecl
) == DECL_WEAK (olddecl
))
5024 if (DECL_WEAK (newdecl
))
5028 /* NEWDECL is weak, but OLDDECL is not. */
5030 /* If we already output the OLDDECL, we're in trouble; we can't
5031 go back and make it weak. This error cannot caught in
5032 declare_weak because the NEWDECL and OLDDECL was not yet
5033 been merged; therefore, TREE_ASM_WRITTEN was not set. */
5034 if (TREE_ASM_WRITTEN (olddecl
))
5035 error_with_decl (newdecl
,
5036 "weak declaration of `%s' must precede definition");
5038 /* If we've already generated rtl referencing OLDDECL, we may
5039 have done so in a way that will not function properly with
5041 else if (TREE_USED (olddecl
)
5042 && TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (olddecl
)))
5043 warning_with_decl (newdecl
, "weak declaration of `%s' after first use results in unspecified behavior");
5047 /* We put the NEWDECL on the weak_decls list at some point.
5048 Replace it with the OLDDECL. */
5049 for (wd
= weak_decls
; wd
; wd
= TREE_CHAIN (wd
))
5050 if (TREE_VALUE (wd
) == newdecl
)
5052 TREE_VALUE (wd
) = olddecl
;
5055 /* We may not find the entry on the list. If NEWDECL is a
5056 weak alias, then we will have already called
5057 globalize_decl to remove the entry; in that case, we do
5058 not need to do anything. */
5061 /* Make the OLDDECL weak; it's OLDDECL that we'll be keeping. */
5062 mark_weak (olddecl
);
5065 /* OLDDECL was weak, but NEWDECL was not explicitly marked as
5066 weak. Just update NEWDECL to indicate that it's weak too. */
5067 mark_weak (newdecl
);
5070 /* Declare DECL to be a weak symbol. */
5076 if (! TREE_PUBLIC (decl
))
5077 error_with_decl (decl
, "weak declaration of `%s' must be public");
5078 else if (TREE_CODE (decl
) == FUNCTION_DECL
&& TREE_ASM_WRITTEN (decl
))
5079 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
5080 else if (SUPPORTS_WEAK
)
5082 if (! DECL_WEAK (decl
))
5083 weak_decls
= tree_cons (NULL
, decl
, weak_decls
);
5086 warning_with_decl (decl
, "weak declaration of `%s' not supported");
5091 /* Emit any pending weak declarations. */
5098 for (t
= weak_decls
; t
; t
= TREE_CHAIN (t
))
5100 tree decl
= TREE_VALUE (t
);
5101 const char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5103 if (! TREE_USED (decl
))
5106 #ifdef ASM_WEAKEN_DECL
5107 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, NULL
);
5109 #ifdef ASM_WEAKEN_LABEL
5110 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5112 #ifdef ASM_OUTPUT_WEAK_ALIAS
5113 warning ("only weak aliases are supported in this configuration");
5121 /* Emit the assembly bits to indicate that DECL is globally visible. */
5124 globalize_decl (decl
)
5127 const char *name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
5129 #if defined (ASM_WEAKEN_LABEL) || defined (ASM_WEAKEN_DECL)
5130 if (DECL_WEAK (decl
))
5134 #ifdef ASM_WEAKEN_DECL
5135 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, 0);
5137 ASM_WEAKEN_LABEL (asm_out_file
, name
);
5140 /* Remove this function from the pending weak list so that
5141 we do not emit multiple .weak directives for it. */
5142 for (p
= &weak_decls
; (t
= *p
) ; )
5144 if (DECL_ASSEMBLER_NAME (decl
) == DECL_ASSEMBLER_NAME (TREE_VALUE (t
)))
5145 *p
= TREE_CHAIN (t
);
5147 p
= &TREE_CHAIN (t
);
5153 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
5156 /* Emit an assembler directive to make the symbol for DECL an alias to
5157 the symbol for TARGET. */
5160 assemble_alias (decl
, target
)
5161 tree decl
, target ATTRIBUTE_UNUSED
;
5165 /* We must force creation of DECL_RTL for debug info generation, even though
5166 we don't use it here. */
5167 make_decl_rtl (decl
, NULL
);
5169 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
5171 #ifdef ASM_OUTPUT_DEF
5172 /* Make name accessible from other files, if appropriate. */
5173 if (TREE_PUBLIC (decl
))
5174 globalize_decl (decl
);
5176 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
5177 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
5179 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
5181 #else /* !ASM_OUTPUT_DEF */
5182 #if defined (ASM_OUTPUT_WEAK_ALIAS) || defined (ASM_WEAKEN_DECL)
5183 if (! DECL_WEAK (decl
))
5184 warning ("only weak aliases are supported in this configuration");
5186 #ifdef ASM_WEAKEN_DECL
5187 ASM_WEAKEN_DECL (asm_out_file
, decl
, name
, IDENTIFIER_POINTER (target
));
5189 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
5192 warning ("alias definitions not supported in this configuration; ignored");
5196 TREE_USED (decl
) = 1;
5197 TREE_ASM_WRITTEN (decl
) = 1;
5198 TREE_ASM_WRITTEN (DECL_ASSEMBLER_NAME (decl
)) = 1;
5201 /* Returns 1 if the target configuration supports defining public symbols
5202 so that one of them will be chosen at link time instead of generating a
5203 multiply-defined symbol error, whether through the use of weak symbols or
5204 a target-specific mechanism for having duplicates discarded. */
5207 supports_one_only ()
5209 if (SUPPORTS_ONE_ONLY
)
5211 return SUPPORTS_WEAK
;
5214 /* Set up DECL as a public symbol that can be defined in multiple
5215 translation units without generating a linker error. */
5218 make_decl_one_only (decl
)
5221 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
5224 TREE_PUBLIC (decl
) = 1;
5226 if (TREE_CODE (decl
) == VAR_DECL
5227 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
5228 DECL_COMMON (decl
) = 1;
5229 else if (SUPPORTS_ONE_ONLY
)
5231 #ifdef MAKE_DECL_ONE_ONLY
5232 MAKE_DECL_ONE_ONLY (decl
);
5234 DECL_ONE_ONLY (decl
) = 1;
5236 else if (SUPPORTS_WEAK
)
5237 DECL_WEAK (decl
) = 1;
5245 const_str_htab
= htab_create (128, const_str_htab_hash
, const_str_htab_eq
,
5246 const_str_htab_del
);
5247 in_named_htab
= htab_create (31, in_named_entry_hash
,
5248 in_named_entry_eq
, NULL
);
5250 ggc_add_root (const_hash_table
, MAX_HASH_TABLE
, sizeof const_hash_table
[0],
5251 mark_const_hash_entry
);
5252 ggc_add_root (&const_str_htab
, 1, sizeof const_str_htab
,
5253 mark_const_str_htab
);
5254 ggc_add_tree_root (&weak_decls
, 1);
5256 const_alias_set
= new_alias_set ();
5259 /* Select a set of attributes for section NAME based on the properties
5260 of DECL and whether or not RELOC indicates that DECL's initializer
5261 might contain runtime relocations.
5263 We make the section read-only and executable for a function decl,
5264 read-only for a const data decl, and writable for a non-const data decl. */
5267 default_section_type_flags (decl
, name
, reloc
)
5274 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
5275 flags
= SECTION_CODE
;
5276 else if (decl
&& DECL_READONLY_SECTION (decl
, reloc
))
5279 flags
= SECTION_WRITE
;
5281 if (decl
&& DECL_ONE_ONLY (decl
))
5282 flags
|= SECTION_LINKONCE
;
5284 if (strcmp (name
, ".bss") == 0
5285 || strncmp (name
, ".bss.", 5) == 0
5286 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
5287 || strcmp (name
, ".sbss") == 0
5288 || strncmp (name
, ".sbss.", 6) == 0
5289 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
5290 flags
|= SECTION_BSS
;
5295 /* Output assembly to switch to section NAME with attribute FLAGS.
5296 Four variants for common object file formats. */
5299 default_no_named_section (name
, flags
)
5300 const char *name ATTRIBUTE_UNUSED
;
5301 unsigned int flags ATTRIBUTE_UNUSED
;
5303 /* Some object formats don't support named sections at all. The
5304 front-end should already have flagged this as an error. */
5309 default_elf_asm_named_section (name
, flags
)
5313 char flagchars
[10], *f
= flagchars
;
5316 if (! named_section_first_declaration (name
))
5318 fprintf (asm_out_file
, "\t.section\t%s\n", name
);
5322 if (!(flags
& SECTION_DEBUG
))
5324 if (flags
& SECTION_WRITE
)
5326 if (flags
& SECTION_CODE
)
5328 if (flags
& SECTION_SMALL
)
5330 if (flags
& SECTION_MERGE
)
5332 if (flags
& SECTION_STRINGS
)
5336 if (flags
& SECTION_BSS
)
5341 if (flags
& SECTION_ENTSIZE
)
5342 fprintf (asm_out_file
, "\t.section\t%s,\"%s\",@%s,%d\n",
5343 name
, flagchars
, type
, flags
& SECTION_ENTSIZE
);
5345 fprintf (asm_out_file
, "\t.section\t%s,\"%s\",@%s\n",
5346 name
, flagchars
, type
);
5350 default_coff_asm_named_section (name
, flags
)
5354 char flagchars
[8], *f
= flagchars
;
5356 if (flags
& SECTION_WRITE
)
5358 if (flags
& SECTION_CODE
)
5362 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
5366 default_pe_asm_named_section (name
, flags
)
5370 default_coff_asm_named_section (name
, flags
);
5372 if (flags
& SECTION_LINKONCE
)
5374 /* Functions may have been compiled at various levels of
5375 optimization so we can't use `same_size' here.
5376 Instead, have the linker pick one. */
5377 fprintf (asm_out_file
, "\t.linkonce %s\n",
5378 (flags
& SECTION_CODE
? "discard" : "same_size"));
5382 /* Used for vtable gc in GNU binutils. Record that the pointer at OFFSET
5383 from SYMBOL is used in all classes derived from SYMBOL. */
5386 assemble_vtable_entry (symbol
, offset
)
5388 HOST_WIDE_INT offset
;
5390 fputs ("\t.vtable_entry ", asm_out_file
);
5391 output_addr_const (asm_out_file
, symbol
);
5392 fputs (", ", asm_out_file
);
5393 fprintf (asm_out_file
, HOST_WIDE_INT_PRINT_DEC
, offset
);
5394 fputc ('\n', asm_out_file
);
5397 /* Used for vtable gc in GNU binutils. Record the class hierarchy by noting
5398 that the vtable symbol CHILD is derived from the vtable symbol PARENT. */
5401 assemble_vtable_inherit (child
, parent
)
5404 fputs ("\t.vtable_inherit ", asm_out_file
);
5405 output_addr_const (asm_out_file
, child
);
5406 fputs (", ", asm_out_file
);
5407 output_addr_const (asm_out_file
, parent
);
5408 fputc ('\n', asm_out_file
);