1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 88, 89, 92-99, 2000 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This file handles generation of all the assembler code
23 *except* the instructions of a function.
24 This includes declarations of variables and their initial values.
26 We also output the assembler code for constants stored in memory
27 and are responsible for combining constants with the same value. */
38 #include "hard-reg-set.h"
50 #ifdef XCOFF_DEBUGGING_INFO
54 #ifndef TRAMPOLINE_ALIGNMENT
55 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
59 #define ASM_STABS_OP ".stabs"
62 /* Define the prefix to use when check_memory_usage_flag is enable. */
63 #ifdef NO_DOLLAR_IN_LABEL
64 #ifdef NO_DOT_IN_LABEL
65 #define CHKR_PREFIX "chkr_prefix_"
66 #else /* !NO_DOT_IN_LABEL */
67 #define CHKR_PREFIX "chkr."
69 #else /* !NO_DOLLAR_IN_LABEL */
70 #define CHKR_PREFIX "chkr$"
72 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
74 /* File in which assembler code is being written. */
76 extern FILE *asm_out_file
;
78 /* The (assembler) name of the first globally-visible object output. */
79 char *first_global_object_name
;
80 char *weak_global_object_name
;
82 extern struct obstack
*current_obstack
;
83 extern struct obstack
*saveable_obstack
;
84 extern struct obstack
*rtl_obstack
;
85 extern struct obstack permanent_obstack
;
86 #define obstack_chunk_alloc xmalloc
89 struct constant_descriptor
;
93 #define MAX_RTX_HASH_TABLE 61
97 /* Hash facility for making memory-constants
98 from constant rtl-expressions. It is used on RISC machines
99 where immediate integer arguments and constant addresses are restricted
100 so that such constants must be stored in memory.
102 This pool of constants is reinitialized for each function
103 so each function gets its own constants-pool that comes right before
105 struct constant_descriptor
**x_const_rtx_hash_table
;
106 struct pool_sym
**x_const_rtx_sym_hash_table
;
108 /* Pointers to first and last constant in pool. */
109 struct pool_constant
*x_first_pool
, *x_last_pool
;
111 /* Current offset in constant pool (does not include any machine-specific
115 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
116 They are chained through the CONST_DOUBLE_CHAIN.
117 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
118 In that case, CONST_DOUBLE_MEM is either a MEM,
119 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
120 rtx x_const_double_chain
;
123 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
124 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
125 #define first_pool (cfun->varasm->x_first_pool)
126 #define last_pool (cfun->varasm->x_last_pool)
127 #define pool_offset (cfun->varasm->x_pool_offset)
128 #define const_double_chain (cfun->varasm->x_const_double_chain)
130 /* Number for making the label on the next
131 constant that is stored in memory. */
135 /* Number for making the label on the next
136 static variable internal to a function. */
140 /* Carry information from ASM_DECLARE_OBJECT_NAME
141 to ASM_FINISH_DECLARE_OBJECT. */
143 int size_directive_output
;
145 /* The last decl for which assemble_variable was called,
146 if it did ASM_DECLARE_OBJECT_NAME.
147 If the last call to assemble_variable didn't do that,
150 tree last_assemble_variable_decl
;
152 static const char *strip_reg_name
PARAMS ((const char *));
153 static int contains_pointers_p
PARAMS ((tree
));
154 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
155 static int const_hash
PARAMS ((tree
));
156 static int compare_constant
PARAMS ((tree
,
157 struct constant_descriptor
*));
158 static char *compare_constant_1
PARAMS ((tree
, char *));
159 static struct constant_descriptor
*record_constant
PARAMS ((tree
));
160 static void record_constant_1
PARAMS ((tree
));
161 static tree copy_constant
PARAMS ((tree
));
162 static void output_constant_def_contents
PARAMS ((tree
, int, int));
163 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
164 struct rtx_const
*));
165 static int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
166 static int compare_constant_rtx
PARAMS ((enum machine_mode
, rtx
,
167 struct constant_descriptor
*));
168 static struct constant_descriptor
*record_constant_rtx
PARAMS ((enum machine_mode
,
170 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
171 static void mark_constant_pool
PARAMS ((void));
172 static void mark_constants
PARAMS ((rtx
));
173 static int output_addressed_constants
PARAMS ((tree
));
174 static void output_after_function_constants
PARAMS ((void));
175 static void output_constructor
PARAMS ((tree
, int));
176 #ifdef ASM_WEAKEN_LABEL
177 static void remove_from_pending_weak_list
PARAMS ((char *));
179 #ifdef ASM_OUTPUT_BSS
180 static void asm_output_bss
PARAMS ((FILE *, tree
, char *, int, int));
182 #ifdef BSS_SECTION_ASM_OP
183 #ifdef ASM_OUTPUT_ALIGNED_BSS
184 static void asm_output_aligned_bss
PARAMS ((FILE *, tree
, char *, int, int));
186 #endif /* BSS_SECTION_ASM_OP */
187 static void mark_pool_constant
PARAMS ((struct pool_constant
*));
188 static void mark_pool_sym_hash_table
PARAMS ((struct pool_sym
**));
189 static void mark_const_hash_entry
PARAMS ((void *));
190 static void asm_emit_uninitialised
PARAMS ((tree
, char *, int, int));
192 static enum in_section
{ no_section
, in_text
, in_data
, in_named
193 #ifdef BSS_SECTION_ASM_OP
196 #ifdef EH_FRAME_SECTION_ASM_OP
199 #ifdef EXTRA_SECTIONS
202 } in_section
= no_section
;
204 /* Return a non-zero value if DECL has a section attribute. */
205 #ifndef IN_NAMED_SECTION
206 #define IN_NAMED_SECTION(DECL) \
207 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
208 && DECL_SECTION_NAME (DECL) != NULL_TREE)
211 /* Text of section name when in_section == in_named. */
212 static char *in_named_name
;
214 /* Define functions like text_section for any extra sections. */
215 #ifdef EXTRA_SECTION_FUNCTIONS
216 EXTRA_SECTION_FUNCTIONS
219 /* Tell assembler to switch to text section. */
224 if (in_section
!= in_text
)
226 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
227 in_section
= in_text
;
231 /* Tell assembler to switch to data section. */
236 if (in_section
!= in_data
)
238 if (flag_shared_data
)
240 #ifdef SHARED_SECTION_ASM_OP
241 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
243 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
247 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
249 in_section
= in_data
;
252 /* Tell assembler to ALWAYS switch to data section, in case
253 it's not sure where it it. */
256 force_data_section ()
258 in_section
= no_section
;
262 /* Tell assembler to switch to read-only data section. This is normally
266 readonly_data_section ()
268 #ifdef READONLY_DATA_SECTION
269 READONLY_DATA_SECTION (); /* Note this can call data_section. */
275 /* Determine if we're in the text section. */
280 return in_section
== in_text
;
283 /* Determine if we're in the data section. */
288 return in_section
== in_data
;
291 /* Tell assembler to change to section NAME for DECL.
292 If DECL is NULL, just switch to section NAME.
293 If NAME is NULL, get the name from DECL.
294 If RELOC is 1, the initializer for DECL contains relocs. */
297 named_section (decl
, name
, reloc
)
300 int reloc ATTRIBUTE_UNUSED
;
302 if (decl
!= NULL_TREE
303 && TREE_CODE_CLASS (TREE_CODE (decl
)) != 'd')
306 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
308 if (in_section
!= in_named
|| strcmp (name
, in_named_name
))
310 #ifdef ASM_OUTPUT_SECTION_NAME
311 ASM_OUTPUT_SECTION_NAME (asm_out_file
, decl
, name
, reloc
);
313 /* Section attributes are not supported if this macro isn't provided -
314 some host formats don't support them at all. The front-end should
315 already have flagged this as an error. */
319 in_named_name
= ggc_alloc_string (name
, -1);
320 in_section
= in_named
;
324 #ifdef ASM_OUTPUT_SECTION_NAME
325 #ifndef UNIQUE_SECTION
326 #define UNIQUE_SECTION(DECL,RELOC) \
332 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL)); \
333 /* Strip off any encoding in name. */ \
334 STRIP_NAME_ENCODING (name, name); \
336 len = strlen (name) + 1; \
337 string = alloca (len + 1); \
338 sprintf (string, ".%s", name); \
340 DECL_SECTION_NAME (DECL) = build_string (len, string); \
343 #ifndef UNIQUE_SECTION_P
344 #define UNIQUE_SECTION_P(DECL) 0
348 #ifdef BSS_SECTION_ASM_OP
350 /* Tell the assembler to switch to the bss section. */
355 if (in_section
!= in_bss
)
357 #ifdef SHARED_BSS_SECTION_ASM_OP
358 if (flag_shared_data
)
359 fprintf (asm_out_file
, "%s\n", SHARED_BSS_SECTION_ASM_OP
);
362 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
368 #ifdef ASM_OUTPUT_BSS
370 /* Utility function for ASM_OUTPUT_BSS for targets to use if
371 they don't support alignments in .bss.
372 ??? It is believed that this function will work in most cases so such
373 support is localized here. */
376 asm_output_bss (file
, decl
, name
, size
, rounded
)
378 tree decl ATTRIBUTE_UNUSED
;
380 int size ATTRIBUTE_UNUSED
, rounded
;
382 ASM_GLOBALIZE_LABEL (file
, name
);
384 #ifdef ASM_DECLARE_OBJECT_NAME
385 last_assemble_variable_decl
= decl
;
386 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
388 /* Standard thing is just output label for the object. */
389 ASM_OUTPUT_LABEL (file
, name
);
390 #endif /* ASM_DECLARE_OBJECT_NAME */
391 ASM_OUTPUT_SKIP (file
, rounded
);
396 #ifdef ASM_OUTPUT_ALIGNED_BSS
398 /* Utility function for targets to use in implementing
399 ASM_OUTPUT_ALIGNED_BSS.
400 ??? It is believed that this function will work in most cases so such
401 support is localized here. */
404 asm_output_aligned_bss (file
, decl
, name
, size
, align
)
410 ASM_GLOBALIZE_LABEL (file
, name
);
412 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
413 #ifdef ASM_DECLARE_OBJECT_NAME
414 last_assemble_variable_decl
= decl
;
415 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
417 /* Standard thing is just output label for the object. */
418 ASM_OUTPUT_LABEL (file
, name
);
419 #endif /* ASM_DECLARE_OBJECT_NAME */
420 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
425 #endif /* BSS_SECTION_ASM_OP */
427 #ifdef EH_FRAME_SECTION_ASM_OP
431 if (in_section
!= in_eh_frame
)
433 fprintf (asm_out_file
, "%s\n", EH_FRAME_SECTION_ASM_OP
);
434 in_section
= in_eh_frame
;
439 /* Switch to the section for function DECL.
441 If DECL is NULL_TREE, switch to the text section.
442 ??? It's not clear that we will ever be passed NULL_TREE, but it's
443 safer to handle it. */
446 function_section (decl
)
449 if (decl
!= NULL_TREE
450 && DECL_SECTION_NAME (decl
) != NULL_TREE
)
451 named_section (decl
, (char *) 0, 0);
456 /* Switch to section for variable DECL.
458 RELOC is the `reloc' argument to SELECT_SECTION. */
461 variable_section (decl
, reloc
)
465 if (IN_NAMED_SECTION (decl
))
466 named_section (decl
, NULL
, reloc
);
469 /* C++ can have const variables that get initialized from constructors,
470 and thus can not be in a readonly section. We prevent this by
471 verifying that the initial value is constant for objects put in a
474 error_mark_node is used by the C front end to indicate that the
475 initializer has not been seen yet. In this case, we assume that
476 the initializer must be constant.
478 C++ uses error_mark_node for variables that have complicated
479 initializers, but these variables go in BSS so we won't be called
482 #ifdef SELECT_SECTION
483 SELECT_SECTION (decl
, reloc
);
485 if (DECL_READONLY_SECTION (decl
, reloc
))
486 readonly_data_section ();
493 /* Tell assembler to switch to the section for the exception handling
499 #if defined (EXCEPTION_SECTION)
500 EXCEPTION_SECTION ();
502 #ifdef ASM_OUTPUT_SECTION_NAME
503 named_section (NULL_TREE
, ".gcc_except_table", 0);
508 readonly_data_section ();
513 /* Create the rtl to represent a function, for a function definition.
514 DECL is a FUNCTION_DECL node which describes which function.
515 The rtl is stored into DECL. */
518 make_function_rtl (decl
)
521 char *name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
522 char *new_name
= name
;
524 /* Rename a nested function to avoid conflicts. */
525 if (decl_function_context (decl
) != 0
526 && DECL_INITIAL (decl
) != 0
527 && DECL_RTL (decl
) == 0)
531 name
= IDENTIFIER_POINTER (DECL_NAME (decl
));
532 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
533 name
= ggc_alloc_string (label
, -1);
538 /* When -fprefix-function-name is used, every function name is
539 prefixed. Even static functions are prefixed because they
540 could be declared latter. Note that a nested function name
542 if (flag_prefix_function_name
)
544 size_t name_len
= strlen (name
);
546 new_name
= ggc_alloc_string (NULL
, name_len
+ CHKR_PREFIX_SIZE
);
547 memcpy (new_name
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
);
548 memcpy (new_name
+ CHKR_PREFIX_SIZE
, name
, name_len
+ 1);
553 if (DECL_RTL (decl
) == 0)
556 = gen_rtx_MEM (DECL_MODE (decl
),
557 gen_rtx_SYMBOL_REF (Pmode
, name
));
559 /* Optionally set flags or add text to the name to record information
560 such as that it is a function name. If the name is changed, the macro
561 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
562 #ifdef ENCODE_SECTION_INFO
563 ENCODE_SECTION_INFO (decl
);
568 /* ??? Another way to do this would be to do what halfpic.c does
569 and maintain a hashed table of such critters. */
570 /* ??? Another way to do this would be to pass a flag bit to
571 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
572 /* Let the target reassign the RTL if it wants.
573 This is necessary, for example, when one machine specific
574 decl attribute overrides another. */
575 #ifdef REDO_SECTION_INFO_P
576 if (REDO_SECTION_INFO_P (decl
))
577 ENCODE_SECTION_INFO (decl
);
582 /* Given NAME, a putative register name, discard any customary prefixes. */
585 strip_reg_name (name
)
588 #ifdef REGISTER_PREFIX
589 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
590 name
+= strlen (REGISTER_PREFIX
);
592 if (name
[0] == '%' || name
[0] == '#')
597 /* Decode an `asm' spec for a declaration as a register name.
598 Return the register number, or -1 if nothing specified,
599 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
600 or -3 if ASMSPEC is `cc' and is not recognized,
601 or -4 if ASMSPEC is `memory' and is not recognized.
602 Accept an exact spelling or a decimal number.
603 Prefixes such as % are optional. */
606 decode_reg_name (asmspec
)
613 /* Get rid of confusing prefixes. */
614 asmspec
= strip_reg_name (asmspec
);
616 /* Allow a decimal number as a "register name". */
617 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
618 if (! (asmspec
[i
] >= '0' && asmspec
[i
] <= '9'))
620 if (asmspec
[0] != 0 && i
< 0)
623 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
629 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
631 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
634 #ifdef ADDITIONAL_REGISTER_NAMES
636 static struct { const char *name
; int number
; } table
[]
637 = ADDITIONAL_REGISTER_NAMES
;
639 for (i
= 0; i
< (int)(sizeof (table
) / sizeof (table
[0])); i
++)
640 if (! strcmp (asmspec
, table
[i
].name
))
641 return table
[i
].number
;
643 #endif /* ADDITIONAL_REGISTER_NAMES */
645 if (!strcmp (asmspec
, "memory"))
648 if (!strcmp (asmspec
, "cc"))
657 /* Create the DECL_RTL for a declaration for a static or external variable
658 or static or external function.
659 ASMSPEC, if not 0, is the string which the user specified
660 as the assembler symbol name.
661 TOP_LEVEL is nonzero if this is a file-scope variable.
663 This is never called for PARM_DECL nodes. */
666 make_decl_rtl (decl
, asmspec
, top_level
)
671 register char *name
= 0;
674 reg_number
= decode_reg_name (asmspec
);
676 if (DECL_ASSEMBLER_NAME (decl
) != NULL_TREE
)
677 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
679 if (reg_number
== -2)
681 /* ASMSPEC is given, and not the name of a register. */
682 size_t len
= strlen (asmspec
);
684 name
= ggc_alloc_string (NULL
, len
+ 1);
686 memcpy (&name
[1], asmspec
, len
+ 1);
689 /* For a duplicate declaration, we can be called twice on the
690 same DECL node. Don't discard the RTL already made. */
691 if (DECL_RTL (decl
) == 0)
693 /* First detect errors in declaring global registers. */
694 if (TREE_CODE (decl
) != FUNCTION_DECL
695 && DECL_REGISTER (decl
) && reg_number
== -1)
696 error_with_decl (decl
,
697 "register name not specified for `%s'");
698 else if (TREE_CODE (decl
) != FUNCTION_DECL
699 && DECL_REGISTER (decl
) && reg_number
< 0)
700 error_with_decl (decl
,
701 "invalid register name for `%s'");
702 else if ((reg_number
>= 0 || reg_number
== -3)
703 && (TREE_CODE (decl
) == FUNCTION_DECL
704 && ! DECL_REGISTER (decl
)))
705 error_with_decl (decl
,
706 "register name given for non-register variable `%s'");
707 else if (TREE_CODE (decl
) != FUNCTION_DECL
708 && DECL_REGISTER (decl
)
709 && TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
710 error_with_decl (decl
,
711 "data type of `%s' isn't suitable for a register");
712 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
)
713 && ! HARD_REGNO_MODE_OK (reg_number
,
714 TYPE_MODE (TREE_TYPE (decl
))))
715 error_with_decl (decl
,
716 "register number for `%s' isn't suitable for data type");
717 /* Now handle properly declared static register variables. */
718 else if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
722 if (DECL_INITIAL (decl
) != 0 && top_level
)
724 DECL_INITIAL (decl
) = 0;
725 error ("global register variable has initial value");
727 if (TREE_THIS_VOLATILE (decl
))
728 warning ("volatile register variables don't work as you might wish");
730 /* If the user specified one of the eliminables registers here,
731 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
732 confused with that register and be eliminated. Although this
733 usage is somewhat suspect, we nevertheless use the following
734 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
737 = gen_rtx_REG (DECL_MODE (decl
), FIRST_PSEUDO_REGISTER
);
738 REGNO (DECL_RTL (decl
)) = reg_number
;
739 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
743 /* Make this register global, so not usable for anything
745 #ifdef ASM_DECLARE_REGISTER_GLOBAL
746 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
748 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
750 globalize_reg (reg_number
+ --nregs
);
753 /* Specifying a section attribute on a variable forces it into a
754 non-.bss section, and thus it cannot be common. */
755 else if (TREE_CODE (decl
) == VAR_DECL
756 && DECL_SECTION_NAME (decl
) != NULL_TREE
757 && DECL_INITIAL (decl
) == NULL_TREE
758 && DECL_COMMON (decl
))
759 DECL_COMMON (decl
) = 0;
761 /* Now handle ordinary static variables and functions (in memory).
762 Also handle vars declared register invalidly. */
763 if (DECL_RTL (decl
) == 0)
765 /* Can't use just the variable's own name for a variable
766 whose scope is less than the whole file.
767 Concatenate a distinguishing number. */
768 if (!top_level
&& !TREE_PUBLIC (decl
) && asmspec
== 0)
772 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
773 name
= ggc_alloc_string (label
, -1);
780 /* When -fprefix-function-name is used, the functions
781 names are prefixed. Only nested function names are not
783 if (flag_prefix_function_name
&& TREE_CODE (decl
) == FUNCTION_DECL
)
785 size_t name_len
= strlen (name
);
788 new_name
= ggc_alloc_string (NULL
, name_len
+ CHKR_PREFIX_SIZE
);
789 memcpy (new_name
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
);
790 memcpy (new_name
+ CHKR_PREFIX_SIZE
, name
, name_len
+ 1);
794 DECL_RTL (decl
) = gen_rtx_MEM (DECL_MODE (decl
),
795 gen_rtx_SYMBOL_REF (Pmode
, name
));
796 MEM_ALIAS_SET (DECL_RTL (decl
)) = get_alias_set (decl
);
798 /* If this variable is to be treated as volatile, show its
799 tree node has side effects. If it has side effects, either
800 because of this test or from TREE_THIS_VOLATILE also
801 being set, show the MEM is volatile. */
802 if (flag_volatile_global
&& TREE_CODE (decl
) == VAR_DECL
803 && TREE_PUBLIC (decl
))
804 TREE_SIDE_EFFECTS (decl
) = 1;
805 else if (flag_volatile_static
&& TREE_CODE (decl
) == VAR_DECL
806 && (TREE_PUBLIC (decl
) || TREE_STATIC (decl
)))
807 TREE_SIDE_EFFECTS (decl
) = 1;
809 if (TREE_SIDE_EFFECTS (decl
))
810 MEM_VOLATILE_P (DECL_RTL (decl
)) = 1;
812 if (TREE_READONLY (decl
))
813 RTX_UNCHANGING_P (DECL_RTL (decl
)) = 1;
814 MEM_SET_IN_STRUCT_P (DECL_RTL (decl
),
815 AGGREGATE_TYPE_P (TREE_TYPE (decl
)));
817 /* Optionally set flags or add text to the name to record information
818 such as that it is a function name.
819 If the name is changed, the macro ASM_OUTPUT_LABELREF
820 will have to know how to strip this information. */
821 #ifdef ENCODE_SECTION_INFO
822 ENCODE_SECTION_INFO (decl
);
828 /* If the old RTL had the wrong mode, fix the mode. */
829 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
831 rtx rtl
= DECL_RTL (decl
);
832 PUT_MODE (rtl
, DECL_MODE (decl
));
835 /* ??? Another way to do this would be to do what halfpic.c does
836 and maintain a hashed table of such critters. */
837 /* ??? Another way to do this would be to pass a flag bit to
838 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
839 /* Let the target reassign the RTL if it wants.
840 This is necessary, for example, when one machine specific
841 decl attribute overrides another. */
842 #ifdef REDO_SECTION_INFO_P
843 if (REDO_SECTION_INFO_P (decl
))
844 ENCODE_SECTION_INFO (decl
);
849 /* Make the rtl for variable VAR be volatile.
850 Use this only for static variables. */
853 make_var_volatile (var
)
856 if (GET_CODE (DECL_RTL (var
)) != MEM
)
859 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
862 /* Output alignment directive to align for constant expression EXP. */
865 assemble_constant_align (exp
)
870 /* Align the location counter as required by EXP's data type. */
871 align
= TYPE_ALIGN (TREE_TYPE (exp
));
872 #ifdef CONSTANT_ALIGNMENT
873 align
= CONSTANT_ALIGNMENT (exp
, align
);
876 if (align
> BITS_PER_UNIT
)
877 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
880 /* Output a string of literal assembler code
881 for an `asm' keyword used between functions. */
884 assemble_asm (string
)
889 if (TREE_CODE (string
) == ADDR_EXPR
)
890 string
= TREE_OPERAND (string
, 0);
892 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
895 #if 0 /* This should no longer be needed, because
896 flag_gnu_linker should be 0 on these systems,
897 which should prevent any output
898 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
899 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
900 #ifndef ASM_OUTPUT_CONSTRUCTOR
901 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
903 #ifndef ASM_OUTPUT_DESTRUCTOR
904 #define ASM_OUTPUT_DESTRUCTOR(file, name)
909 /* Record an element in the table of global destructors.
910 How this is done depends on what sort of assembler and linker
913 NAME should be the name of a global function to be called
914 at exit time. This name is output using assemble_name. */
917 assemble_destructor (name
)
920 #ifdef ASM_OUTPUT_DESTRUCTOR
921 ASM_OUTPUT_DESTRUCTOR (asm_out_file
, name
);
925 /* Now tell GNU LD that this is part of the static destructor set. */
926 /* This code works for any machine provided you use GNU as/ld. */
927 fprintf (asm_out_file
, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
928 assemble_name (asm_out_file
, name
);
929 fputc ('\n', asm_out_file
);
934 /* Likewise for global constructors. */
937 assemble_constructor (name
)
940 #ifdef ASM_OUTPUT_CONSTRUCTOR
941 ASM_OUTPUT_CONSTRUCTOR (asm_out_file
, name
);
945 /* Now tell GNU LD that this is part of the static constructor set. */
946 /* This code works for any machine provided you use GNU as/ld. */
947 fprintf (asm_out_file
, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
948 assemble_name (asm_out_file
, name
);
949 fputc ('\n', asm_out_file
);
954 /* Likewise for entries we want to record for garbage collection.
955 Garbage collection is still under development. */
958 assemble_gc_entry (name
)
961 #ifdef ASM_OUTPUT_GC_ENTRY
962 ASM_OUTPUT_GC_ENTRY (asm_out_file
, name
);
966 /* Now tell GNU LD that this is part of the static constructor set. */
967 fprintf (asm_out_file
, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP
);
968 assemble_name (asm_out_file
, name
);
969 fputc ('\n', asm_out_file
);
974 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
975 a non-zero value if the constant pool should be output before the
976 start of the function, or a zero value if the pool should output
977 after the end of the function. The default is to put it before the
980 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
981 #define CONSTANT_POOL_BEFORE_FUNCTION 1
984 /* Output assembler code for the constant pool of a function and associated
985 with defining the name of the function. DECL describes the function.
986 NAME is the function's name. For the constant pool, we use the current
987 constant pool data. */
990 assemble_start_function (decl
, fnname
)
996 /* The following code does not need preprocessing in the assembler. */
1000 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1001 output_constant_pool (fnname
, decl
);
1003 #ifdef ASM_OUTPUT_SECTION_NAME
1004 /* If the function is to be put in its own section and it's not in a section
1005 already, indicate so. */
1006 if ((flag_function_sections
1007 && DECL_SECTION_NAME (decl
) == NULL_TREE
)
1008 || UNIQUE_SECTION_P (decl
))
1009 UNIQUE_SECTION (decl
, 0);
1012 function_section (decl
);
1014 /* Tell assembler to move to target machine's alignment for functions. */
1015 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1017 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1019 /* Handle a user-specified function alignment.
1020 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1021 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1022 if (align_functions_log
> align
)
1024 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1025 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1026 align_functions_log
, align_functions
-1);
1028 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1032 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1033 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1036 #ifdef SDB_DEBUGGING_INFO
1037 /* Output SDB definition of the function. */
1038 if (write_symbols
== SDB_DEBUG
)
1039 sdbout_mark_begin_function ();
1042 #ifdef DBX_DEBUGGING_INFO
1043 /* Output DBX definition of the function. */
1044 if (write_symbols
== DBX_DEBUG
)
1045 dbxout_begin_function (decl
);
1048 /* Make function name accessible from other files, if appropriate. */
1050 if (TREE_PUBLIC (decl
))
1052 if (! first_global_object_name
)
1057 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
1058 name
= &first_global_object_name
;
1060 name
= &weak_global_object_name
;
1062 STRIP_NAME_ENCODING (p
, fnname
);
1063 *name
= permalloc (strlen (p
) + 1);
1067 #ifdef ASM_WEAKEN_LABEL
1068 if (DECL_WEAK (decl
))
1070 ASM_WEAKEN_LABEL (asm_out_file
, fnname
);
1071 /* Remove this function from the pending weak list so that
1072 we do not emit multiple .weak directives for it. */
1073 remove_from_pending_weak_list
1074 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1078 ASM_GLOBALIZE_LABEL (asm_out_file
, fnname
);
1081 /* Do any machine/system dependent processing of the function name */
1082 #ifdef ASM_DECLARE_FUNCTION_NAME
1083 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1085 /* Standard thing is just output label for the function. */
1086 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1087 #endif /* ASM_DECLARE_FUNCTION_NAME */
1090 /* Output assembler code associated with defining the size of the
1091 function. DECL describes the function. NAME is the function's name. */
1094 assemble_end_function (decl
, fnname
)
1098 #ifdef ASM_DECLARE_FUNCTION_SIZE
1099 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1101 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1103 output_constant_pool (fnname
, decl
);
1104 function_section (decl
); /* need to switch back */
1107 /* Output any constants which should appear after the function. */
1108 output_after_function_constants ();
1111 /* Assemble code to leave SIZE bytes of zeros. */
1114 assemble_zeros (size
)
1117 /* Do no output if -fsyntax-only. */
1118 if (flag_syntax_only
)
1121 #ifdef ASM_NO_SKIP_IN_TEXT
1122 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1123 so we must output 0s explicitly in the text section. */
1124 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1128 for (i
= 0; i
< size
- 20; i
+= 20)
1131 fprintf (asm_out_file
,
1132 "%s 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP
);
1134 fprintf (asm_out_file
,
1135 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1141 fprintf (asm_out_file
, "%s 0", ASM_BYTE_OP
);
1143 fprintf (asm_out_file
, "\tbyte 0");
1146 for (; i
< size
; i
++)
1147 fprintf (asm_out_file
, ",0");
1148 fprintf (asm_out_file
, "\n");
1154 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1157 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1160 assemble_align (align
)
1163 if (align
> BITS_PER_UNIT
)
1164 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1167 /* Assemble a string constant with the specified C string as contents. */
1170 assemble_string (p
, size
)
1177 /* If the string is very long, split it up. */
1181 int thissize
= size
- pos
;
1182 if (thissize
> maximum
)
1185 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1193 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1194 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1195 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1197 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1198 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1199 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1201 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1202 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1206 #if defined ASM_OUTPUT_ALIGNED_BSS
1207 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1208 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1210 #if defined ASM_OUTPUT_BSS
1211 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1212 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1218 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1219 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1220 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1222 #if defined ASM_OUTPUT_ALIGNED_COMMON
1223 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1224 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1226 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1227 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1232 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1235 int size ATTRIBUTE_UNUSED
;
1236 int rounded ATTRIBUTE_UNUSED
;
1244 destination
= asm_dest_local
;
1246 if (TREE_PUBLIC (decl
))
1248 #if defined ASM_EMIT_BSS
1249 if (! DECL_COMMON (decl
))
1250 destination
= asm_dest_bss
;
1253 destination
= asm_dest_common
;
1256 if (flag_shared_data
)
1258 switch (destination
)
1260 #ifdef ASM_OUTPUT_SHARED_BSS
1262 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1265 #ifdef ASM_OUTPUT_SHARED_COMMON
1266 case asm_dest_common
:
1267 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1270 #ifdef ASM_OUTPUT_SHARED_LOCAL
1271 case asm_dest_local
:
1272 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1280 #ifdef ASM_OUTPUT_SECTION_NAME
1281 /* We already know that DECL_SECTION_NAME() == NULL. */
1282 if (flag_data_sections
!= 0 || UNIQUE_SECTION_P (decl
))
1283 UNIQUE_SECTION (decl
, NULL
);
1286 switch (destination
)
1290 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1293 case asm_dest_common
:
1294 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1296 case asm_dest_local
:
1297 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1306 /* Assemble everything that is needed for a variable or function declaration.
1307 Not used for automatic variables, and not used for function definitions.
1308 Should not be called for variables of incomplete structure type.
1310 TOP_LEVEL is nonzero if this variable has file scope.
1311 AT_END is nonzero if this is the special handling, at end of compilation,
1312 to define things that have had only tentative definitions.
1313 DONT_OUTPUT_DATA if nonzero means don't actually output the
1314 initial value (that will be done by the caller). */
1317 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1319 int top_level ATTRIBUTE_UNUSED
;
1320 int at_end ATTRIBUTE_UNUSED
;
1321 int dont_output_data
;
1323 register char *name
;
1325 tree size_tree
= NULL_TREE
;
1327 enum in_section saved_in_section
;
1329 last_assemble_variable_decl
= 0;
1331 if (GET_CODE (DECL_RTL (decl
)) == REG
)
1333 /* Do output symbol info for global register variables, but do nothing
1336 if (TREE_ASM_WRITTEN (decl
))
1338 TREE_ASM_WRITTEN (decl
) = 1;
1340 /* Do no output if -fsyntax-only. */
1341 if (flag_syntax_only
)
1344 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1345 /* File-scope global variables are output here. */
1346 if ((write_symbols
== DBX_DEBUG
|| write_symbols
== XCOFF_DEBUG
)
1348 dbxout_symbol (decl
, 0);
1350 #ifdef SDB_DEBUGGING_INFO
1351 if (write_symbols
== SDB_DEBUG
&& top_level
1352 /* Leave initialized global vars for end of compilation;
1353 see comment in compile_file. */
1354 && (TREE_PUBLIC (decl
) == 0 || DECL_INITIAL (decl
) == 0))
1355 sdbout_symbol (decl
, 0);
1358 /* Don't output any DWARF debugging information for variables here.
1359 In the case of local variables, the information for them is output
1360 when we do our recursive traversal of the tree representation for
1361 the entire containing function. In the case of file-scope variables,
1362 we output information for all of them at the very end of compilation
1363 while we are doing our final traversal of the chain of file-scope
1369 /* Normally no need to say anything here for external references,
1370 since assemble_external is called by the language-specific code
1371 when a declaration is first seen. */
1373 if (DECL_EXTERNAL (decl
))
1376 /* Output no assembler code for a function declaration.
1377 Only definitions of functions output anything. */
1379 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1382 /* If type was incomplete when the variable was declared,
1383 see if it is complete now. */
1385 if (DECL_SIZE (decl
) == 0)
1386 layout_decl (decl
, 0);
1388 /* Still incomplete => don't allocate it; treat the tentative defn
1389 (which is what it must have been) as an `extern' reference. */
1391 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1393 error_with_file_and_line (DECL_SOURCE_FILE (decl
),
1394 DECL_SOURCE_LINE (decl
),
1395 "storage size of `%s' isn't known",
1396 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1397 TREE_ASM_WRITTEN (decl
) = 1;
1401 /* The first declaration of a variable that comes through this function
1402 decides whether it is global (in C, has external linkage)
1403 or local (in C, has internal linkage). So do nothing more
1404 if this function has already run. */
1406 if (TREE_ASM_WRITTEN (decl
))
1409 TREE_ASM_WRITTEN (decl
) = 1;
1411 /* Do no output if -fsyntax-only. */
1412 if (flag_syntax_only
)
1417 if (! dont_output_data
)
1421 if (TREE_CODE (DECL_SIZE (decl
)) != INTEGER_CST
)
1424 /* This is better than explicit arithmetic, since it avoids overflow. */
1425 size_tree
= size_binop (CEIL_DIV_EXPR
,
1426 DECL_SIZE (decl
), size_int (BITS_PER_UNIT
));
1428 size
= TREE_INT_CST_LOW (size_tree
);
1429 if (TREE_INT_CST_HIGH (size_tree
) != 0
1430 || size
!= TREE_INT_CST_LOW (size_tree
))
1432 error_with_decl (decl
, "size of variable `%s' is too large");
1437 name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
1439 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1440 && ! first_global_object_name
1441 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1442 || DECL_INITIAL (decl
) == error_mark_node
))
1443 && ! DECL_WEAK (decl
)
1444 && ! DECL_ONE_ONLY (decl
))
1448 STRIP_NAME_ENCODING (p
, name
);
1449 first_global_object_name
= permalloc (strlen (p
) + 1);
1450 strcpy (first_global_object_name
, p
);
1453 /* Compute the alignment of this data. */
1455 align
= DECL_ALIGN (decl
);
1457 /* In the case for initialing an array whose length isn't specified,
1458 where we have not yet been able to do the layout,
1459 figure out the proper alignment now. */
1460 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1461 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1462 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1464 /* Some object file formats have a maximum alignment which they support.
1465 In particular, a.out format supports a maximum alignment of 4. */
1466 #ifndef MAX_OFILE_ALIGNMENT
1467 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1469 if (align
> MAX_OFILE_ALIGNMENT
)
1471 warning_with_decl (decl
,
1472 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1473 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1474 align
= MAX_OFILE_ALIGNMENT
;
1477 /* On some machines, it is good to increase alignment sometimes. */
1478 #ifdef DATA_ALIGNMENT
1479 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1481 #ifdef CONSTANT_ALIGNMENT
1482 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1483 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1486 /* Reset the alignment in case we have made it tighter, so we can benefit
1487 from it in get_pointer_alignment. */
1488 DECL_ALIGN (decl
) = align
;
1490 /* Handle uninitialized definitions. */
1492 if ((DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
)
1493 /* If the target can't output uninitialized but not common global data
1494 in .bss, then we have to use .data. */
1495 #if ! defined ASM_EMIT_BSS
1496 && DECL_COMMON (decl
)
1498 && DECL_SECTION_NAME (decl
) == NULL_TREE
1499 && ! dont_output_data
)
1501 int size
= TREE_INT_CST_LOW (size_tree
);
1504 /* Don't allocate zero bytes of common,
1505 since that means "undefined external" in the linker. */
1506 if (size
== 0) rounded
= 1;
1507 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1508 so that each uninitialized object starts on such a boundary. */
1509 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1510 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1511 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1513 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1514 if ((DECL_ALIGN (decl
) / BITS_PER_UNIT
) > (unsigned int) rounded
)
1516 (decl
, "requested alignment for %s is greater than implemented alignment of %d.",rounded
);
1519 #ifdef DBX_DEBUGGING_INFO
1520 /* File-scope global variables are output here. */
1521 if (write_symbols
== DBX_DEBUG
&& top_level
)
1522 dbxout_symbol (decl
, 0);
1524 #ifdef SDB_DEBUGGING_INFO
1525 if (write_symbols
== SDB_DEBUG
&& top_level
1526 /* Leave initialized global vars for end of compilation;
1527 see comment in compile_file. */
1528 && (TREE_PUBLIC (decl
) == 0 || DECL_INITIAL (decl
) == 0))
1529 sdbout_symbol (decl
, 0);
1532 /* Don't output any DWARF debugging information for variables here.
1533 In the case of local variables, the information for them is output
1534 when we do our recursive traversal of the tree representation for
1535 the entire containing function. In the case of file-scope variables,
1536 we output information for all of them at the very end of compilation
1537 while we are doing our final traversal of the chain of file-scope
1540 #if 0 /* ??? We should either delete this or add a comment describing what
1541 it was intended to do and why we shouldn't delete it. */
1542 if (flag_shared_data
)
1545 asm_emit_uninitialised (decl
, name
, size
, rounded
);
1550 /* Handle initialized definitions.
1551 Also handle uninitialized global definitions if -fno-common and the
1552 target doesn't support ASM_OUTPUT_BSS. */
1554 /* First make the assembler name(s) global if appropriate. */
1555 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1557 #ifdef ASM_WEAKEN_LABEL
1558 if (DECL_WEAK (decl
))
1560 ASM_WEAKEN_LABEL (asm_out_file
, name
);
1561 /* Remove this variable from the pending weak list so that
1562 we do not emit multiple .weak directives for it. */
1563 remove_from_pending_weak_list
1564 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1568 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1571 for (d
= equivalents
; d
; d
= TREE_CHAIN (d
))
1573 tree e
= TREE_VALUE (d
);
1574 if (TREE_PUBLIC (e
) && DECL_NAME (e
))
1575 ASM_GLOBALIZE_LABEL (asm_out_file
,
1576 XSTR (XEXP (DECL_RTL (e
), 0), 0));
1580 /* Output any data that we will need to use the address of. */
1581 if (DECL_INITIAL (decl
) == error_mark_node
)
1582 reloc
= contains_pointers_p (TREE_TYPE (decl
));
1583 else if (DECL_INITIAL (decl
))
1584 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1586 #ifdef ASM_OUTPUT_SECTION_NAME
1587 if ((flag_data_sections
!= 0 && DECL_SECTION_NAME (decl
) == NULL_TREE
)
1588 || UNIQUE_SECTION_P (decl
))
1589 UNIQUE_SECTION (decl
, reloc
);
1592 /* Switch to the appropriate section. */
1593 variable_section (decl
, reloc
);
1595 /* dbxout.c needs to know this. */
1596 if (in_text_section ())
1597 DECL_IN_TEXT_SECTION (decl
) = 1;
1599 /* Record current section so we can restore it if dbxout.c clobbers it. */
1600 saved_in_section
= in_section
;
1602 /* Output the dbx info now that we have chosen the section. */
1604 #ifdef DBX_DEBUGGING_INFO
1605 /* File-scope global variables are output here. */
1606 if (write_symbols
== DBX_DEBUG
&& top_level
)
1607 dbxout_symbol (decl
, 0);
1609 #ifdef SDB_DEBUGGING_INFO
1610 if (write_symbols
== SDB_DEBUG
&& top_level
1611 /* Leave initialized global vars for end of compilation;
1612 see comment in compile_file. */
1613 && (TREE_PUBLIC (decl
) == 0 || DECL_INITIAL (decl
) == 0))
1614 sdbout_symbol (decl
, 0);
1617 /* Don't output any DWARF debugging information for variables here.
1618 In the case of local variables, the information for them is output
1619 when we do our recursive traversal of the tree representation for
1620 the entire containing function. In the case of file-scope variables,
1621 we output information for all of them at the very end of compilation
1622 while we are doing our final traversal of the chain of file-scope
1625 /* If the debugging output changed sections, reselect the section
1626 that's supposed to be selected. */
1627 if (in_section
!= saved_in_section
)
1628 variable_section (decl
, reloc
);
1630 /* Output the alignment of this data. */
1631 if (align
> BITS_PER_UNIT
)
1632 ASM_OUTPUT_ALIGN (asm_out_file
,
1633 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1635 /* Do any machine/system dependent processing of the object. */
1636 #ifdef ASM_DECLARE_OBJECT_NAME
1637 last_assemble_variable_decl
= decl
;
1638 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1640 /* Standard thing is just output label for the object. */
1641 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1642 #endif /* ASM_DECLARE_OBJECT_NAME */
1644 if (!dont_output_data
)
1646 if (DECL_INITIAL (decl
))
1647 /* Output the actual data. */
1648 output_constant (DECL_INITIAL (decl
), TREE_INT_CST_LOW (size_tree
));
1650 /* Leave space for it. */
1651 assemble_zeros (TREE_INT_CST_LOW (size_tree
));
1655 #ifdef XCOFF_DEBUGGING_INFO
1656 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1657 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1658 and `aa' hasn't been output yet, the assembler generates a stab entry with
1659 a value of zero, in addition to creating an unnecessary external entry
1660 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1662 /* File-scope global variables are output here. */
1663 if (write_symbols
== XCOFF_DEBUG
&& top_level
)
1665 saved_in_section
= in_section
;
1667 dbxout_symbol (decl
, 0);
1669 if (in_section
!= saved_in_section
)
1670 variable_section (decl
, reloc
);
1673 /* There must be a statement after a label. */
1678 /* Return 1 if type TYPE contains any pointers. */
1681 contains_pointers_p (type
)
1684 switch (TREE_CODE (type
))
1687 case REFERENCE_TYPE
:
1688 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1689 so I'll play safe and return 1. */
1695 case QUAL_UNION_TYPE
:
1698 /* For a type that has fields, see if the fields have pointers. */
1699 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1700 if (TREE_CODE (fields
) == FIELD_DECL
1701 && contains_pointers_p (TREE_TYPE (fields
)))
1707 /* An array type contains pointers if its element type does. */
1708 return contains_pointers_p (TREE_TYPE (type
));
1715 /* Output something to declare an external symbol to the assembler.
1716 (Most assemblers don't need this, so we normally output nothing.)
1717 Do nothing if DECL is not external. */
1720 assemble_external (decl
)
1721 tree decl ATTRIBUTE_UNUSED
;
1723 #ifdef ASM_OUTPUT_EXTERNAL
1724 if (TREE_CODE_CLASS (TREE_CODE (decl
)) == 'd'
1725 && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1727 rtx rtl
= DECL_RTL (decl
);
1729 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1730 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1732 /* Some systems do require some output. */
1733 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1734 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1740 /* Similar, for calling a library function FUN. */
1743 assemble_external_libcall (fun
)
1744 rtx fun ATTRIBUTE_UNUSED
;
1746 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1747 /* Declare library function name external when first used, if nec. */
1748 if (! SYMBOL_REF_USED (fun
))
1750 SYMBOL_REF_USED (fun
) = 1;
1751 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1756 /* Declare the label NAME global. */
1759 assemble_global (name
)
1762 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1765 /* Assemble a label named NAME. */
1768 assemble_label (name
)
1771 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1774 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1775 If NAME starts with a *, the rest of NAME is output verbatim.
1776 Otherwise NAME is transformed in an implementation-defined way
1777 (usually by the addition of an underscore).
1778 Many macros in the tm file are defined to call this function. */
1781 assemble_name (file
, name
)
1785 const char *real_name
;
1788 STRIP_NAME_ENCODING (real_name
, name
);
1789 if (flag_prefix_function_name
1790 && ! bcmp (real_name
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
))
1791 real_name
= real_name
+ CHKR_PREFIX_SIZE
;
1793 id
= maybe_get_identifier (real_name
);
1795 TREE_SYMBOL_REFERENCED (id
) = 1;
1798 fputs (&name
[1], file
);
1800 ASM_OUTPUT_LABELREF (file
, name
);
1803 /* Allocate SIZE bytes writable static space with a gensym name
1804 and return an RTX to refer to its address. */
1807 assemble_static_space (size
)
1815 if (flag_shared_data
)
1819 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1821 namestring
= ggc_alloc_string (name
, -1);
1823 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1825 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1826 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1829 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1830 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1833 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1834 so that each uninitialized object starts on such a boundary. */
1835 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1836 int rounded ATTRIBUTE_UNUSED
1837 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1838 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1839 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1840 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1847 /* Assemble the static constant template for function entry trampolines.
1848 This is done at most once per compilation.
1849 Returns an RTX for the address of the template. */
1851 #ifdef TRAMPOLINE_TEMPLATE
1853 assemble_trampoline_template ()
1859 /* By default, put trampoline templates in read-only data section. */
1861 #ifdef TRAMPOLINE_SECTION
1862 TRAMPOLINE_SECTION ();
1864 readonly_data_section ();
1867 /* Write the assembler code to define one. */
1868 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1870 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1872 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LTRAMP", 0);
1873 TRAMPOLINE_TEMPLATE (asm_out_file
);
1875 /* Record the rtl to refer to it. */
1876 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1877 name
= ggc_alloc_string (label
, -1);
1878 return gen_rtx_SYMBOL_REF (Pmode
, name
);
1882 /* Assemble the integer constant X into an object of SIZE bytes.
1883 X must be either a CONST_INT or CONST_DOUBLE.
1885 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1886 non-zero, abort if we can't output the constant. */
1889 assemble_integer (x
, size
, force
)
1894 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1895 ASM_OUTPUT... macros. */
1899 #ifdef ASM_OUTPUT_CHAR
1901 ASM_OUTPUT_CHAR (asm_out_file
, x
);
1905 #ifdef ASM_OUTPUT_SHORT
1907 ASM_OUTPUT_SHORT (asm_out_file
, x
);
1911 #ifdef ASM_OUTPUT_INT
1913 ASM_OUTPUT_INT (asm_out_file
, x
);
1917 #ifdef ASM_OUTPUT_DOUBLE_INT
1919 ASM_OUTPUT_DOUBLE_INT (asm_out_file
, x
);
1923 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1925 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file
, x
);
1930 /* If we couldn't do it that way, there are two other possibilities: First,
1931 if the machine can output an explicit byte and this is a 1 byte constant,
1932 we can use ASM_OUTPUT_BYTE. */
1934 #ifdef ASM_OUTPUT_BYTE
1935 if (size
== 1 && GET_CODE (x
) == CONST_INT
)
1937 ASM_OUTPUT_BYTE (asm_out_file
, INTVAL (x
));
1942 /* Finally, if SIZE is larger than a single word, try to output the constant
1943 one word at a time. */
1945 if (size
> UNITS_PER_WORD
)
1948 enum machine_mode mode
1949 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1952 for (i
= 0; i
< size
/ UNITS_PER_WORD
; i
++)
1954 word
= operand_subword (x
, i
, 0, mode
);
1959 if (! assemble_integer (word
, UNITS_PER_WORD
, 0))
1963 if (i
== size
/ UNITS_PER_WORD
)
1965 /* If we output at least one word and then could not finish,
1966 there is no valid way to continue. */
1977 /* Assemble the floating-point constant D into an object of size MODE. */
1980 assemble_real (d
, mode
)
1982 enum machine_mode mode
;
1984 jmp_buf output_constant_handler
;
1986 if (setjmp (output_constant_handler
))
1988 error ("floating point trap outputting a constant");
1989 #ifdef REAL_IS_NOT_DOUBLE
1990 bzero ((char *) &d
, sizeof d
);
1997 set_float_handler (output_constant_handler
);
2001 #ifdef ASM_OUTPUT_BYTE_FLOAT
2003 ASM_OUTPUT_BYTE_FLOAT (asm_out_file
, d
);
2006 #ifdef ASM_OUTPUT_SHORT_FLOAT
2008 ASM_OUTPUT_SHORT_FLOAT (asm_out_file
, d
);
2011 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
2013 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file
, d
);
2016 #ifdef ASM_OUTPUT_FLOAT
2018 ASM_OUTPUT_FLOAT (asm_out_file
, d
);
2022 #ifdef ASM_OUTPUT_DOUBLE
2024 ASM_OUTPUT_DOUBLE (asm_out_file
, d
);
2028 #ifdef ASM_OUTPUT_LONG_DOUBLE
2031 ASM_OUTPUT_LONG_DOUBLE (asm_out_file
, d
);
2039 set_float_handler (NULL_PTR
);
2042 /* Here we combine duplicate floating constants to make
2043 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
2045 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2046 For an integer, I0 is the low-order word and I1 is the high-order word.
2047 For a real number, I0 is the word with the low address
2048 and I1 is the word with the high address. */
2051 immed_double_const (i0
, i1
, mode
)
2052 HOST_WIDE_INT i0
, i1
;
2053 enum machine_mode mode
;
2057 if (GET_MODE_CLASS (mode
) == MODE_INT
2058 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
2060 /* We clear out all bits that don't belong in MODE, unless they and our
2061 sign bit are all one. So we get either a reasonable negative value
2062 or a reasonable unsigned value for this mode. */
2063 int width
= GET_MODE_BITSIZE (mode
);
2064 if (width
< HOST_BITS_PER_WIDE_INT
2065 && ((i0
& ((HOST_WIDE_INT
) (-1) << (width
- 1)))
2066 != ((HOST_WIDE_INT
) (-1) << (width
- 1))))
2067 i0
&= ((HOST_WIDE_INT
) 1 << width
) - 1, i1
= 0;
2068 else if (width
== HOST_BITS_PER_WIDE_INT
2069 && ! (i1
== ~0 && i0
< 0))
2071 else if (width
> 2 * HOST_BITS_PER_WIDE_INT
)
2072 /* We cannot represent this value as a constant. */
2075 /* If this would be an entire word for the target, but is not for
2076 the host, then sign-extend on the host so that the number will look
2077 the same way on the host that it would on the target.
2079 For example, when building a 64 bit alpha hosted 32 bit sparc
2080 targeted compiler, then we want the 32 bit unsigned value -1 to be
2081 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2082 The later confuses the sparc backend. */
2084 if (BITS_PER_WORD
< HOST_BITS_PER_WIDE_INT
&& BITS_PER_WORD
== width
2085 && (i0
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
2086 i0
|= ((HOST_WIDE_INT
) (-1) << width
);
2088 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2090 ??? Strictly speaking, this is wrong if we create a CONST_INT
2091 for a large unsigned constant with the size of MODE being
2092 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2093 wider mode. In that case we will mis-interpret it as a negative
2096 Unfortunately, the only alternative is to make a CONST_DOUBLE
2097 for any constant in any mode if it is an unsigned constant larger
2098 than the maximum signed integer in an int on the host. However,
2099 doing this will break everyone that always expects to see a CONST_INT
2100 for SImode and smaller.
2102 We have always been making CONST_INTs in this case, so nothing new
2105 if (width
<= HOST_BITS_PER_WIDE_INT
)
2106 i1
= (i0
< 0) ? ~(HOST_WIDE_INT
) 0 : 0;
2108 /* If this integer fits in one word, return a CONST_INT. */
2109 if ((i1
== 0 && i0
>= 0)
2110 || (i1
== ~0 && i0
< 0))
2111 return GEN_INT (i0
);
2113 /* We use VOIDmode for integers. */
2117 /* Search the chain for an existing CONST_DOUBLE with the right value.
2118 If one is found, return it. */
2120 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2121 if (CONST_DOUBLE_LOW (r
) == i0
&& CONST_DOUBLE_HIGH (r
) == i1
2122 && GET_MODE (r
) == mode
)
2125 /* No; make a new one and add it to the chain.
2127 We may be called by an optimizer which may be discarding any memory
2128 allocated during its processing (such as combine and loop). However,
2129 we will be leaving this constant on the chain, so we cannot tolerate
2130 freed memory. So switch to saveable_obstack for this allocation
2131 and then switch back if we were in current_obstack. */
2133 push_obstacks_nochange ();
2134 rtl_in_saveable_obstack ();
2135 r
= gen_rtx_CONST_DOUBLE (mode
, NULL_RTX
, i0
, i1
);
2138 /* Don't touch const_double_chain if not inside any function. */
2139 if (current_function_decl
!= 0)
2141 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2142 const_double_chain
= r
;
2145 /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
2146 Actual use of mem-slot is only through force_const_mem. */
2148 CONST_DOUBLE_MEM (r
) = const0_rtx
;
2153 /* Return a CONST_DOUBLE for a specified `double' value
2154 and machine mode. */
2157 immed_real_const_1 (d
, mode
)
2159 enum machine_mode mode
;
2161 union real_extract u
;
2164 /* Get the desired `double' value as a sequence of ints
2165 since that is how they are stored in a CONST_DOUBLE. */
2169 /* Detect special cases. */
2171 if (REAL_VALUES_IDENTICAL (dconst0
, d
))
2172 return CONST0_RTX (mode
);
2173 /* Check for NaN first, because some ports (specifically the i386) do not
2174 emit correct ieee-fp code by default, and thus will generate a core
2175 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2176 does a floating point comparison. */
2177 else if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_EQUAL (dconst1
, d
))
2178 return CONST1_RTX (mode
);
2180 if (sizeof u
== sizeof (HOST_WIDE_INT
))
2181 return immed_double_const (u
.i
[0], 0, mode
);
2182 if (sizeof u
== 2 * sizeof (HOST_WIDE_INT
))
2183 return immed_double_const (u
.i
[0], u
.i
[1], mode
);
2185 /* The rest of this function handles the case where
2186 a float value requires more than 2 ints of space.
2187 It will be deleted as dead code on machines that don't need it. */
2189 /* Search the chain for an existing CONST_DOUBLE with the right value.
2190 If one is found, return it. */
2192 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2193 if (! bcmp ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
)
2194 && GET_MODE (r
) == mode
)
2197 /* No; make a new one and add it to the chain.
2199 We may be called by an optimizer which may be discarding any memory
2200 allocated during its processing (such as combine and loop). However,
2201 we will be leaving this constant on the chain, so we cannot tolerate
2202 freed memory. So switch to saveable_obstack for this allocation
2203 and then switch back if we were in current_obstack. */
2204 push_obstacks_nochange ();
2205 rtl_in_saveable_obstack ();
2206 r
= rtx_alloc (CONST_DOUBLE
);
2209 bcopy ((char *) &u
, (char *) &CONST_DOUBLE_LOW (r
), sizeof u
);
2211 /* Don't touch const_double_chain if not inside any function. */
2212 if (current_function_decl
!= 0)
2214 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2215 const_double_chain
= r
;
2218 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2219 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2220 is only through force_const_mem. */
2222 CONST_DOUBLE_MEM (r
) = const0_rtx
;
2227 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2228 which must be a REAL_CST tree node. */
2231 immed_real_const (exp
)
2234 return immed_real_const_1 (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)));
2237 /* At the end of a function, forget the memory-constants
2238 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2239 Also clear out real_constant_chain and clear out all the chain-pointers. */
2242 clear_const_double_mem ()
2244 register rtx r
, next
;
2246 for (r
= const_double_chain
; r
; r
= next
)
2248 next
= CONST_DOUBLE_CHAIN (r
);
2249 CONST_DOUBLE_CHAIN (r
) = 0;
2250 CONST_DOUBLE_MEM (r
) = cc0_rtx
;
2252 const_double_chain
= 0;
2255 /* Given an expression EXP with a constant value,
2256 reduce it to the sum of an assembler symbol and an integer.
2257 Store them both in the structure *VALUE.
2258 Abort if EXP does not reduce. */
2263 HOST_WIDE_INT offset
;
2267 decode_addr_const (exp
, value
)
2269 struct addr_const
*value
;
2271 register tree target
= TREE_OPERAND (exp
, 0);
2272 register int offset
= 0;
2277 if (TREE_CODE (target
) == COMPONENT_REF
2278 && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target
, 1)))
2281 offset
+= TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target
, 1))) / BITS_PER_UNIT
;
2282 target
= TREE_OPERAND (target
, 0);
2284 else if (TREE_CODE (target
) == ARRAY_REF
)
2286 if (TREE_CODE (TREE_OPERAND (target
, 1)) != INTEGER_CST
2287 || TREE_CODE (TYPE_SIZE (TREE_TYPE (target
))) != INTEGER_CST
)
2289 offset
+= ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target
)))
2290 * TREE_INT_CST_LOW (TREE_OPERAND (target
, 1)))
2292 target
= TREE_OPERAND (target
, 0);
2298 switch (TREE_CODE (target
))
2302 x
= DECL_RTL (target
);
2306 x
= gen_rtx_MEM (FUNCTION_MODE
,
2307 gen_rtx_LABEL_REF (VOIDmode
,
2308 label_rtx (TREE_OPERAND (exp
, 0))));
2316 x
= TREE_CST_RTL (target
);
2323 if (GET_CODE (x
) != MEM
)
2328 value
->offset
= offset
;
2331 /* Uniquize all constants that appear in memory.
2332 Each constant in memory thus far output is recorded
2333 in `const_hash_table' with a `struct constant_descriptor'
2334 that contains a polish representation of the value of
2337 We cannot store the trees in the hash table
2338 because the trees may be temporary. */
2340 struct constant_descriptor
2342 struct constant_descriptor
*next
;
2349 #define MAX_HASH_TABLE 1009
2350 static struct constant_descriptor
*const_hash_table
[MAX_HASH_TABLE
];
2352 /* Mark a const_hash_table descriptor for GC. */
2355 mark_const_hash_entry (ptr
)
2358 struct constant_descriptor
*desc
= * (struct constant_descriptor
**) ptr
;
2362 ggc_mark_string (desc
->label
);
2363 ggc_mark_rtx (desc
->rtl
);
2368 /* Compute a hash code for a constant expression. */
2375 register int len
, hi
, i
;
2376 register enum tree_code code
= TREE_CODE (exp
);
2378 /* Either set P and LEN to the address and len of something to hash and
2379 exit the switch or return a value. */
2384 p
= (char *) &TREE_INT_CST_LOW (exp
);
2385 len
= 2 * sizeof TREE_INT_CST_LOW (exp
);
2389 p
= (char *) &TREE_REAL_CST (exp
);
2390 len
= sizeof TREE_REAL_CST (exp
);
2394 p
= TREE_STRING_POINTER (exp
);
2395 len
= TREE_STRING_LENGTH (exp
);
2399 return (const_hash (TREE_REALPART (exp
)) * 5
2400 + const_hash (TREE_IMAGPART (exp
)));
2403 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2405 len
= int_size_in_bytes (TREE_TYPE (exp
));
2406 p
= (char *) alloca (len
);
2407 get_set_constructor_bytes (exp
, (unsigned char *) p
, len
);
2414 /* For record type, include the type in the hashing.
2415 We do not do so for array types
2416 because (1) the sizes of the elements are sufficient
2417 and (2) distinct array types can have the same constructor.
2418 Instead, we include the array size because the constructor could
2420 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2421 hi
= ((unsigned long) TREE_TYPE (exp
) & ((1 << HASHBITS
) - 1))
2424 hi
= ((5 + int_size_in_bytes (TREE_TYPE (exp
)))
2425 & ((1 << HASHBITS
) - 1)) % MAX_HASH_TABLE
;
2427 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2428 if (TREE_VALUE (link
))
2430 = (hi
* 603 + const_hash (TREE_VALUE (link
))) % MAX_HASH_TABLE
;
2437 struct addr_const value
;
2439 decode_addr_const (exp
, &value
);
2440 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2442 /* Don't hash the address of the SYMBOL_REF;
2443 only use the offset and the symbol name. */
2445 p
= XSTR (value
.base
, 0);
2446 for (i
= 0; p
[i
] != 0; i
++)
2447 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2449 else if (GET_CODE (value
.base
) == LABEL_REF
)
2450 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2454 hi
&= (1 << HASHBITS
) - 1;
2455 hi
%= MAX_HASH_TABLE
;
2461 return (const_hash (TREE_OPERAND (exp
, 0)) * 9
2462 + const_hash (TREE_OPERAND (exp
, 1)));
2466 case NON_LVALUE_EXPR
:
2467 return const_hash (TREE_OPERAND (exp
, 0)) * 7 + 2;
2473 /* Compute hashing function */
2475 for (i
= 0; i
< len
; i
++)
2476 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2478 hi
&= (1 << HASHBITS
) - 1;
2479 hi
%= MAX_HASH_TABLE
;
2483 /* Compare a constant expression EXP with a constant-descriptor DESC.
2484 Return 1 if DESC describes a constant with the same value as EXP. */
2487 compare_constant (exp
, desc
)
2489 struct constant_descriptor
*desc
;
2491 return 0 != compare_constant_1 (exp
, desc
->contents
);
2494 /* Compare constant expression EXP with a substring P of a constant descriptor.
2495 If they match, return a pointer to the end of the substring matched.
2496 If they do not match, return 0.
2498 Since descriptors are written in polish prefix notation,
2499 this function can be used recursively to test one operand of EXP
2500 against a subdescriptor, and if it succeeds it returns the
2501 address of the subdescriptor for the next operand. */
2504 compare_constant_1 (exp
, p
)
2508 register char *strp
;
2510 register enum tree_code code
= TREE_CODE (exp
);
2512 if (code
!= (enum tree_code
) *p
++)
2515 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2516 switch, or return the result of the comparison. */
2521 /* Integer constants are the same only if the same width of type. */
2522 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2525 strp
= (char *) &TREE_INT_CST_LOW (exp
);
2526 len
= 2 * sizeof TREE_INT_CST_LOW (exp
);
2530 /* Real constants are the same only if the same width of type. */
2531 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2534 strp
= (char *) &TREE_REAL_CST (exp
);
2535 len
= sizeof TREE_REAL_CST (exp
);
2539 if (flag_writable_strings
)
2542 if (*p
++ != TYPE_MODE (TREE_TYPE (exp
)))
2545 strp
= TREE_STRING_POINTER (exp
);
2546 len
= TREE_STRING_LENGTH (exp
);
2547 if (bcmp ((char *) &TREE_STRING_LENGTH (exp
), p
,
2548 sizeof TREE_STRING_LENGTH (exp
)))
2551 p
+= sizeof TREE_STRING_LENGTH (exp
);
2555 p
= compare_constant_1 (TREE_REALPART (exp
), p
);
2559 return compare_constant_1 (TREE_IMAGPART (exp
), p
);
2562 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2564 int xlen
= len
= int_size_in_bytes (TREE_TYPE (exp
));
2566 strp
= (char *) alloca (len
);
2567 get_set_constructor_bytes (exp
, (unsigned char *) strp
, len
);
2568 if (bcmp ((char *) &xlen
, p
, sizeof xlen
))
2577 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2579 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2580 int have_purpose
= 0;
2582 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2583 if (TREE_PURPOSE (link
))
2586 if (bcmp ((char *) &length
, p
, sizeof length
))
2591 /* For record constructors, insist that the types match.
2592 For arrays, just verify both constructors are for arrays.
2593 Then insist that either both or none have any TREE_PURPOSE
2595 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2596 type
= TREE_TYPE (exp
);
2600 if (bcmp ((char *) &type
, p
, sizeof type
))
2603 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2605 if (bcmp ((char *) &mode
, p
, sizeof mode
))
2613 if (bcmp ((char *) &have_purpose
, p
, sizeof have_purpose
))
2616 p
+= sizeof have_purpose
;
2618 /* For arrays, insist that the size in bytes match. */
2619 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2621 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2623 if (bcmp ((char *) &size
, p
, sizeof size
))
2629 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2631 if (TREE_VALUE (link
))
2633 if ((p
= compare_constant_1 (TREE_VALUE (link
), p
)) == 0)
2640 if (bcmp ((char *) &zero
, p
, sizeof zero
))
2646 if (TREE_PURPOSE (link
)
2647 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2649 if (bcmp ((char *) &TREE_PURPOSE (link
), p
,
2650 sizeof TREE_PURPOSE (link
)))
2653 p
+= sizeof TREE_PURPOSE (link
);
2655 else if (TREE_PURPOSE (link
))
2657 if ((p
= compare_constant_1 (TREE_PURPOSE (link
), p
)) == 0)
2660 else if (have_purpose
)
2664 if (bcmp ((char *) &zero
, p
, sizeof zero
))
2676 struct addr_const value
;
2678 decode_addr_const (exp
, &value
);
2679 strp
= (char *) &value
.offset
;
2680 len
= sizeof value
.offset
;
2681 /* Compare the offset. */
2683 if (*p
++ != *strp
++)
2686 /* Compare symbol name. */
2687 strp
= XSTR (value
.base
, 0);
2688 len
= strlen (strp
) + 1;
2695 p
= compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2699 return compare_constant_1 (TREE_OPERAND (exp
, 1), p
);
2703 case NON_LVALUE_EXPR
:
2704 return compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2710 /* Compare constant contents. */
2712 if (*p
++ != *strp
++)
2718 /* Construct a constant descriptor for the expression EXP.
2719 It is up to the caller to enter the descriptor in the hash table. */
2721 static struct constant_descriptor
*
2722 record_constant (exp
)
2725 struct constant_descriptor
*next
= 0;
2729 /* Make a struct constant_descriptor. The first three pointers will
2730 be filled in later. Here we just leave space for them. */
2732 obstack_grow (&permanent_obstack
, (char *) &next
, sizeof next
);
2733 obstack_grow (&permanent_obstack
, (char *) &label
, sizeof label
);
2734 obstack_grow (&permanent_obstack
, (char *) &rtl
, sizeof rtl
);
2735 record_constant_1 (exp
);
2736 return (struct constant_descriptor
*) obstack_finish (&permanent_obstack
);
2739 /* Add a description of constant expression EXP
2740 to the object growing in `permanent_obstack'.
2741 No need to return its address; the caller will get that
2742 from the obstack when the object is complete. */
2745 record_constant_1 (exp
)
2748 register char *strp
;
2750 register enum tree_code code
= TREE_CODE (exp
);
2752 obstack_1grow (&permanent_obstack
, (unsigned int) code
);
2757 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2758 strp
= (char *) &TREE_INT_CST_LOW (exp
);
2759 len
= 2 * sizeof TREE_INT_CST_LOW (exp
);
2763 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2764 strp
= (char *) &TREE_REAL_CST (exp
);
2765 len
= sizeof TREE_REAL_CST (exp
);
2769 if (flag_writable_strings
)
2772 obstack_1grow (&permanent_obstack
, TYPE_MODE (TREE_TYPE (exp
)));
2773 strp
= TREE_STRING_POINTER (exp
);
2774 len
= TREE_STRING_LENGTH (exp
);
2775 obstack_grow (&permanent_obstack
, (char *) &TREE_STRING_LENGTH (exp
),
2776 sizeof TREE_STRING_LENGTH (exp
));
2780 record_constant_1 (TREE_REALPART (exp
));
2781 record_constant_1 (TREE_IMAGPART (exp
));
2785 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2787 int nbytes
= int_size_in_bytes (TREE_TYPE (exp
));
2788 obstack_grow (&permanent_obstack
, &nbytes
, sizeof (nbytes
));
2789 obstack_blank (&permanent_obstack
, nbytes
);
2790 get_set_constructor_bytes
2791 (exp
, (unsigned char *) permanent_obstack
.next_free
-nbytes
,
2798 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2799 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2801 int have_purpose
= 0;
2803 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2804 if (TREE_PURPOSE (link
))
2807 obstack_grow (&permanent_obstack
, (char *) &length
, sizeof length
);
2809 /* For record constructors, insist that the types match.
2810 For arrays, just verify both constructors are for arrays
2811 of the same mode. Then insist that either both or none
2812 have any TREE_PURPOSE values. */
2813 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2814 type
= TREE_TYPE (exp
);
2818 obstack_grow (&permanent_obstack
, (char *) &type
, sizeof type
);
2819 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2820 obstack_grow (&permanent_obstack
, &mode
, sizeof mode
);
2822 obstack_grow (&permanent_obstack
, (char *) &have_purpose
,
2823 sizeof have_purpose
);
2825 /* For arrays, insist that the size in bytes match. */
2826 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2828 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2829 obstack_grow (&permanent_obstack
, (char *) &size
, sizeof size
);
2832 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2834 if (TREE_VALUE (link
))
2835 record_constant_1 (TREE_VALUE (link
));
2840 obstack_grow (&permanent_obstack
,
2841 (char *) &zero
, sizeof zero
);
2844 if (TREE_PURPOSE (link
)
2845 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2846 obstack_grow (&permanent_obstack
,
2847 (char *) &TREE_PURPOSE (link
),
2848 sizeof TREE_PURPOSE (link
));
2849 else if (TREE_PURPOSE (link
))
2850 record_constant_1 (TREE_PURPOSE (link
));
2851 else if (have_purpose
)
2855 obstack_grow (&permanent_obstack
,
2856 (char *) &zero
, sizeof zero
);
2864 struct addr_const value
;
2866 decode_addr_const (exp
, &value
);
2867 /* Record the offset. */
2868 obstack_grow (&permanent_obstack
,
2869 (char *) &value
.offset
, sizeof value
.offset
);
2870 /* Record the symbol name. */
2871 obstack_grow (&permanent_obstack
, XSTR (value
.base
, 0),
2872 strlen (XSTR (value
.base
, 0)) + 1);
2879 record_constant_1 (TREE_OPERAND (exp
, 0));
2880 record_constant_1 (TREE_OPERAND (exp
, 1));
2885 case NON_LVALUE_EXPR
:
2886 record_constant_1 (TREE_OPERAND (exp
, 0));
2893 /* Record constant contents. */
2894 obstack_grow (&permanent_obstack
, strp
, len
);
2897 /* Record a list of constant expressions that were passed to
2898 output_constant_def but that could not be output right away. */
2900 struct deferred_constant
2902 struct deferred_constant
*next
;
2908 static struct deferred_constant
*deferred_constants
;
2910 /* Another list of constants which should be output after the
2912 static struct deferred_constant
*after_function_constants
;
2914 /* Nonzero means defer output of addressed subconstants
2915 (i.e., those for which output_constant_def is called.) */
2916 static int defer_addressed_constants_flag
;
2918 /* Start deferring output of subconstants. */
2921 defer_addressed_constants ()
2923 defer_addressed_constants_flag
++;
2926 /* Stop deferring output of subconstants,
2927 and output now all those that have been deferred. */
2930 output_deferred_addressed_constants ()
2932 struct deferred_constant
*p
, *next
;
2934 defer_addressed_constants_flag
--;
2936 if (defer_addressed_constants_flag
> 0)
2939 for (p
= deferred_constants
; p
; p
= next
)
2941 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2946 deferred_constants
= 0;
2949 /* Output any constants which should appear after a function. */
2952 output_after_function_constants ()
2954 struct deferred_constant
*p
, *next
;
2956 for (p
= after_function_constants
; p
; p
= next
)
2958 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2963 after_function_constants
= 0;
2966 /* Make a copy of the whole tree structure for a constant.
2967 This handles the same types of nodes that compare_constant
2968 and record_constant handle. */
2974 switch (TREE_CODE (exp
))
2977 /* For ADDR_EXPR, we do not want to copy the decl whose address
2978 is requested. We do want to copy constants though. */
2979 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
2980 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2981 copy_constant (TREE_OPERAND (exp
, 0)));
2983 return copy_node (exp
);
2988 return copy_node (exp
);
2991 return build_complex (TREE_TYPE (exp
),
2992 copy_constant (TREE_REALPART (exp
)),
2993 copy_constant (TREE_IMAGPART (exp
)));
2997 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
2998 copy_constant (TREE_OPERAND (exp
, 0)),
2999 copy_constant (TREE_OPERAND (exp
, 1)));
3003 case NON_LVALUE_EXPR
:
3004 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
3005 copy_constant (TREE_OPERAND (exp
, 0)));
3009 tree copy
= copy_node (exp
);
3010 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
3013 CONSTRUCTOR_ELTS (copy
) = list
;
3014 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3015 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
3016 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
3017 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3018 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
3028 /* Return an rtx representing a reference to constant data in memory
3029 for the constant expression EXP.
3031 If assembler code for such a constant has already been output,
3032 return an rtx to refer to it.
3033 Otherwise, output such a constant in memory (or defer it for later)
3034 and generate an rtx for it.
3036 The TREE_CST_RTL of EXP is set up to point to that rtx.
3037 The const_hash_table records which constants already have label strings. */
3040 output_constant_def (exp
)
3044 register struct constant_descriptor
*desc
;
3049 if (TREE_CST_RTL (exp
))
3050 return TREE_CST_RTL (exp
);
3052 /* Make sure any other constants whose addresses appear in EXP
3053 are assigned label numbers. */
3055 reloc
= output_addressed_constants (exp
);
3057 /* Compute hash code of EXP. Search the descriptors for that hash code
3058 to see if any of them describes EXP. If yes, the descriptor records
3059 the label number already assigned. */
3061 hash
= const_hash (exp
) % MAX_HASH_TABLE
;
3063 for (desc
= const_hash_table
[hash
]; desc
; desc
= desc
->next
)
3064 if (compare_constant (exp
, desc
))
3069 /* No constant equal to EXP is known to have been output.
3070 Make a constant descriptor to enter EXP in the hash table.
3071 Assign the label number and record it in the descriptor for
3072 future calls to this function to find. */
3074 /* Create a string containing the label name, in LABEL. */
3075 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3077 desc
= record_constant (exp
);
3078 desc
->next
= const_hash_table
[hash
];
3079 desc
->label
= ggc_alloc_string (label
, -1);
3080 const_hash_table
[hash
] = desc
;
3082 /* We have a symbol name; construct the SYMBOL_REF and the MEM
3083 in the permanent obstack. We could also construct this in the
3084 obstack of EXP and put it into TREE_CST_RTL, but we have no way
3085 of knowing what obstack it is (e.g., it might be in a function
3086 obstack of a function we are nested inside). */
3088 push_obstacks_nochange ();
3089 end_temporary_allocation ();
3092 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
3093 gen_rtx_SYMBOL_REF (Pmode
, desc
->label
));
3095 RTX_UNCHANGING_P (desc
->rtl
) = 1;
3096 if (AGGREGATE_TYPE_P (TREE_TYPE (exp
)))
3097 MEM_SET_IN_STRUCT_P (desc
->rtl
, 1);
3104 TREE_CST_RTL (exp
) = desc
->rtl
;
3106 /* Optionally set flags or add text to the name to record information
3107 such as that it is a function name. If the name is changed, the macro
3108 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3109 #ifdef ENCODE_SECTION_INFO
3110 ENCODE_SECTION_INFO (exp
);
3113 /* If this is the first time we've seen this particular constant,
3114 output it (or defer its output for later). */
3117 int after_function
= 0;
3119 #ifdef CONSTANT_AFTER_FUNCTION_P
3120 if (current_function_decl
!= 0
3121 && CONSTANT_AFTER_FUNCTION_P (exp
))
3125 if (defer_addressed_constants_flag
|| after_function
)
3127 struct deferred_constant
*p
;
3128 p
= (struct deferred_constant
*) xmalloc (sizeof (struct deferred_constant
));
3130 push_obstacks_nochange ();
3131 suspend_momentary ();
3132 p
->exp
= copy_constant (exp
);
3135 p
->labelno
= const_labelno
++;
3138 p
->next
= after_function_constants
;
3139 after_function_constants
= p
;
3143 p
->next
= deferred_constants
;
3144 deferred_constants
= p
;
3149 /* Do no output if -fsyntax-only. */
3150 if (! flag_syntax_only
)
3151 output_constant_def_contents (exp
, reloc
, const_labelno
);
3156 return TREE_CST_RTL (exp
);
3159 /* Now output assembler code to define the label for EXP,
3160 and follow it with the data of EXP. */
3163 output_constant_def_contents (exp
, reloc
, labelno
)
3170 if (IN_NAMED_SECTION (exp
))
3171 named_section (exp
, NULL
, reloc
);
3174 /* First switch to text section, except for writable strings. */
3175 #ifdef SELECT_SECTION
3176 SELECT_SECTION (exp
, reloc
);
3178 if (((TREE_CODE (exp
) == STRING_CST
) && flag_writable_strings
)
3179 || (flag_pic
&& reloc
))
3182 readonly_data_section ();
3186 /* Align the location counter as required by EXP's data type. */
3187 align
= TYPE_ALIGN (TREE_TYPE (exp
));
3188 #ifdef CONSTANT_ALIGNMENT
3189 align
= CONSTANT_ALIGNMENT (exp
, align
);
3192 if (align
> BITS_PER_UNIT
)
3193 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3195 /* Output the label itself. */
3196 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", labelno
);
3198 /* Output the value of EXP. */
3199 output_constant (exp
,
3200 (TREE_CODE (exp
) == STRING_CST
3201 ? TREE_STRING_LENGTH (exp
)
3202 : int_size_in_bytes (TREE_TYPE (exp
))));
3206 /* Structure to represent sufficient information about a constant so that
3207 it can be output when the constant pool is output, so that function
3208 integration can be done, and to simplify handling on machines that reference
3209 constant pool as base+displacement. */
3211 struct pool_constant
3213 struct constant_descriptor
*desc
;
3214 struct pool_constant
*next
;
3215 enum machine_mode mode
;
3223 /* Structure used to maintain hash table mapping symbols used to their
3224 corresponding constants. */
3229 struct pool_constant
*pool
;
3230 struct pool_sym
*next
;
3233 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3234 The argument is XSTR (... , 0) */
3236 #define SYMHASH(LABEL) \
3237 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3239 /* Initialize constant pool hashing for a new function. */
3242 init_varasm_status (f
)
3245 struct varasm_status
*p
;
3246 p
= (struct varasm_status
*) xmalloc (sizeof (struct varasm_status
));
3248 p
->x_const_rtx_hash_table
3249 = ((struct constant_descriptor
**)
3250 xmalloc (MAX_RTX_HASH_TABLE
* sizeof (struct constant_descriptor
*)));
3251 p
->x_const_rtx_sym_hash_table
3252 = ((struct pool_sym
**)
3253 xmalloc (MAX_RTX_HASH_TABLE
* sizeof (struct pool_sym
*)));
3254 bzero ((char *) p
->x_const_rtx_hash_table
,
3255 MAX_RTX_HASH_TABLE
* sizeof (struct constant_descriptor
*));
3256 bzero ((char *) p
->x_const_rtx_sym_hash_table
,
3257 MAX_RTX_HASH_TABLE
* sizeof (struct pool_sym
*));
3259 p
->x_first_pool
= p
->x_last_pool
= 0;
3260 p
->x_pool_offset
= 0;
3261 p
->x_const_double_chain
= 0;
3264 /* Mark PC for GC. */
3267 mark_pool_constant (pc
)
3268 struct pool_constant
*pc
;
3272 ggc_mark_rtx (pc
->constant
);
3277 /* Mark PPS for GC. */
3280 mark_pool_sym_hash_table (pps
)
3281 struct pool_sym
**pps
;
3283 struct pool_sym
*ps
;
3286 for (i
= 0; i
< MAX_RTX_HASH_TABLE
; ++i
)
3287 for (ps
= pps
[i
]; ps
; ps
= ps
->next
)
3288 ggc_mark_string (ps
->label
);
3291 /* Mark P for GC. */
3294 mark_varasm_status (p
)
3295 struct varasm_status
*p
;
3300 mark_pool_constant (p
->x_first_pool
);
3301 mark_pool_sym_hash_table (p
->x_const_rtx_sym_hash_table
);
3302 ggc_mark_rtx (p
->x_const_double_chain
);
3305 /* Clear out all parts of the state in F that can safely be discarded
3306 after the function has been compiled, to let garbage collection
3307 reclaim the memory. */
3310 free_varasm_status (f
)
3313 struct varasm_status
*p
;
3316 free (p
->x_const_rtx_hash_table
);
3317 free (p
->x_const_rtx_sym_hash_table
);
3322 enum kind
{ RTX_DOUBLE
, RTX_INT
};
3326 #ifdef ONLY_INT_FIELDS
3327 unsigned int kind
: 16;
3328 unsigned int mode
: 16;
3330 enum kind kind
: 16;
3331 enum machine_mode mode
: 16;
3334 union real_extract du
;
3335 struct addr_const addr
;
3336 struct {HOST_WIDE_INT high
, low
;} di
;
3340 /* Express an rtx for a constant integer (perhaps symbolic)
3341 as the sum of a symbol or label plus an explicit integer.
3342 They are stored into VALUE. */
3345 decode_rtx_const (mode
, x
, value
)
3346 enum machine_mode mode
;
3348 struct rtx_const
*value
;
3350 /* Clear the whole structure, including any gaps. */
3353 int *p
= (int *) value
;
3354 int *end
= (int *) (value
+ 1);
3359 value
->kind
= RTX_INT
; /* Most usual kind. */
3362 switch (GET_CODE (x
))
3365 value
->kind
= RTX_DOUBLE
;
3366 if (GET_MODE (x
) != VOIDmode
)
3368 value
->mode
= GET_MODE (x
);
3369 bcopy ((char *) &CONST_DOUBLE_LOW (x
),
3370 (char *) &value
->un
.du
, sizeof value
->un
.du
);
3374 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
3375 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
3380 value
->un
.addr
.offset
= INTVAL (x
);
3386 value
->un
.addr
.base
= x
;
3391 if (GET_CODE (x
) == PLUS
)
3393 value
->un
.addr
.base
= XEXP (x
, 0);
3394 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3396 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
3398 else if (GET_CODE (x
) == MINUS
)
3400 value
->un
.addr
.base
= XEXP (x
, 0);
3401 if (GET_CODE (XEXP (x
, 1)) != CONST_INT
)
3403 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
3413 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0)
3414 switch (GET_CODE (value
->un
.addr
.base
))
3417 /* Use the string's address, not the SYMBOL_REF's address,
3418 for the sake of addresses of library routines. */
3419 value
->un
.addr
.base
= (rtx
) XSTR (value
->un
.addr
.base
, 0);
3423 /* For a LABEL_REF, compare labels. */
3424 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
3431 /* Given a MINUS expression, simplify it if both sides
3432 include the same symbol. */
3435 simplify_subtraction (x
)
3438 struct rtx_const val0
, val1
;
3440 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
3441 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
3443 if (val0
.un
.addr
.base
== val1
.un
.addr
.base
)
3444 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
3448 /* Compute a hash code for a constant RTL expression. */
3451 const_hash_rtx (mode
, x
)
3452 enum machine_mode mode
;
3458 struct rtx_const value
;
3459 decode_rtx_const (mode
, x
, &value
);
3461 /* Compute hashing function */
3463 for (i
= 0; i
< sizeof value
/ sizeof (int); i
++)
3464 hi
+= ((int *) &value
)[i
];
3466 hi
&= (1 << HASHBITS
) - 1;
3467 hi
%= MAX_RTX_HASH_TABLE
;
3471 /* Compare a constant rtl object X with a constant-descriptor DESC.
3472 Return 1 if DESC describes a constant with the same value as X. */
3475 compare_constant_rtx (mode
, x
, desc
)
3476 enum machine_mode mode
;
3478 struct constant_descriptor
*desc
;
3480 register int *p
= (int *) desc
->contents
;
3483 struct rtx_const value
;
3485 decode_rtx_const (mode
, x
, &value
);
3486 strp
= (int *) &value
;
3487 len
= sizeof value
/ sizeof (int);
3489 /* Compare constant contents. */
3491 if (*p
++ != *strp
++)
3497 /* Construct a constant descriptor for the rtl-expression X.
3498 It is up to the caller to enter the descriptor in the hash table. */
3500 static struct constant_descriptor
*
3501 record_constant_rtx (mode
, x
)
3502 enum machine_mode mode
;
3505 struct constant_descriptor
*ptr
;
3508 struct rtx_const value
;
3510 decode_rtx_const (mode
, x
, &value
);
3512 /* Put these things in the saveable obstack so we can ensure it won't
3513 be freed if we are called from combine or some other phase that discards
3514 memory allocated from function_obstack (current_obstack). */
3515 obstack_grow (saveable_obstack
, &ptr
, sizeof ptr
);
3516 obstack_grow (saveable_obstack
, &label
, sizeof label
);
3517 obstack_grow (saveable_obstack
, &rtl
, sizeof rtl
);
3519 /* Record constant contents. */
3520 obstack_grow (saveable_obstack
, &value
, sizeof value
);
3522 return (struct constant_descriptor
*) obstack_finish (saveable_obstack
);
3525 /* Given a constant rtx X, make (or find) a memory constant for its value
3526 and return a MEM rtx to refer to it in memory. */
3529 force_const_mem (mode
, x
)
3530 enum machine_mode mode
;
3534 register struct constant_descriptor
*desc
;
3539 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3540 (this will always be true for floating CONST_DOUBLEs that have been
3541 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3542 use the previous copy. Otherwise, make a new one. Note that in
3543 the unlikely event that this same CONST_DOUBLE is used in two different
3544 modes in an alternating fashion, we will allocate a lot of different
3545 memory locations, but this should be extremely rare. */
3547 if (GET_CODE (x
) == CONST_DOUBLE
3548 && GET_CODE (CONST_DOUBLE_MEM (x
)) == MEM
3549 && GET_MODE (CONST_DOUBLE_MEM (x
)) == mode
)
3550 return CONST_DOUBLE_MEM (x
);
3552 /* Compute hash code of X. Search the descriptors for that hash code
3553 to see if any of them describes X. If yes, the descriptor records
3554 the label number already assigned. */
3556 hash
= const_hash_rtx (mode
, x
);
3558 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3559 if (compare_constant_rtx (mode
, x
, desc
))
3561 found
= desc
->label
;
3567 register struct pool_constant
*pool
;
3568 register struct pool_sym
*sym
;
3571 /* No constant equal to X is known to have been output.
3572 Make a constant descriptor to enter X in the hash table.
3573 Assign the label number and record it in the descriptor for
3574 future calls to this function to find. */
3576 desc
= record_constant_rtx (mode
, x
);
3577 desc
->next
= const_rtx_hash_table
[hash
];
3578 const_rtx_hash_table
[hash
] = desc
;
3580 /* Align the location counter as required by EXP's data type. */
3581 align
= (mode
== VOIDmode
) ? UNITS_PER_WORD
: GET_MODE_SIZE (mode
);
3582 if (align
> BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
3583 align
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
3584 #ifdef CONSTANT_ALIGNMENT
3585 align
= CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode
, 0), x
),
3586 align
* BITS_PER_UNIT
) / BITS_PER_UNIT
;
3589 pool_offset
+= align
- 1;
3590 pool_offset
&= ~ (align
- 1);
3592 /* If RTL is not being placed into the saveable obstack, make a
3593 copy of X that is in the saveable obstack in case we are
3594 being called from combine or some other phase that discards
3595 memory it allocates. We used to only do this if it is a
3596 CONST; however, reload can allocate a CONST_INT when
3597 eliminating registers. */
3598 if (rtl_obstack
!= saveable_obstack
3599 && (GET_CODE (x
) == CONST
|| GET_CODE (x
) == CONST_INT
))
3601 push_obstacks_nochange ();
3602 rtl_in_saveable_obstack ();
3604 if (GET_CODE (x
) == CONST
)
3605 x
= gen_rtx_CONST (GET_MODE (x
),
3606 gen_rtx_PLUS (GET_MODE (x
),
3607 XEXP (XEXP (x
, 0), 0),
3608 XEXP (XEXP (x
, 0), 1)));
3610 x
= GEN_INT (INTVAL (x
));
3615 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3617 pool
= (struct pool_constant
*) savealloc (sizeof (struct pool_constant
));
3621 pool
->labelno
= const_labelno
;
3622 pool
->align
= align
;
3623 pool
->offset
= pool_offset
;
3630 last_pool
->next
= pool
;
3633 pool_offset
+= GET_MODE_SIZE (mode
);
3635 /* Create a string containing the label name, in LABEL. */
3636 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3640 desc
->label
= found
= ggc_alloc_string (label
, -1);
3642 /* Add label to symbol hash table. */
3643 hash
= SYMHASH (found
);
3644 sym
= (struct pool_sym
*) savealloc (sizeof (struct pool_sym
));
3647 sym
->next
= const_rtx_sym_hash_table
[hash
];
3648 const_rtx_sym_hash_table
[hash
] = sym
;
3651 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3653 def
= gen_rtx_MEM (mode
, gen_rtx_SYMBOL_REF (Pmode
, found
));
3655 RTX_UNCHANGING_P (def
) = 1;
3656 /* Mark the symbol_ref as belonging to this constants pool. */
3657 CONSTANT_POOL_ADDRESS_P (XEXP (def
, 0)) = 1;
3658 current_function_uses_const_pool
= 1;
3660 if (GET_CODE (x
) == CONST_DOUBLE
)
3662 if (CONST_DOUBLE_MEM (x
) == cc0_rtx
)
3664 CONST_DOUBLE_CHAIN (x
) = const_double_chain
;
3665 const_double_chain
= x
;
3667 CONST_DOUBLE_MEM (x
) = def
;
3673 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3674 the corresponding pool_constant structure. */
3676 static struct pool_constant
*
3677 find_pool_constant (f
, addr
)
3681 struct pool_sym
*sym
;
3682 char *label
= XSTR (addr
, 0);
3684 for (sym
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; sym
; sym
= sym
->next
)
3685 if (sym
->label
== label
)
3691 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3694 get_pool_constant (addr
)
3697 return (find_pool_constant (cfun
, addr
))->constant
;
3700 /* Likewise, but for the constant pool of a specific function. */
3703 get_pool_constant_for_function (f
, addr
)
3707 return (find_pool_constant (f
, addr
))->constant
;
3710 /* Similar, return the mode. */
3713 get_pool_mode (addr
)
3716 return (find_pool_constant (cfun
, addr
))->mode
;
3720 get_pool_mode_for_function (f
, addr
)
3724 return (find_pool_constant (f
, addr
))->mode
;
3727 /* Similar, return the offset in the constant pool. */
3730 get_pool_offset (addr
)
3733 return (find_pool_constant (cfun
, addr
))->offset
;
3736 /* Return the size of the constant pool. */
3744 /* Write all the constants in the constant pool. */
3747 output_constant_pool (fnname
, fndecl
)
3748 const char *fnname ATTRIBUTE_UNUSED
;
3749 tree fndecl ATTRIBUTE_UNUSED
;
3751 struct pool_constant
*pool
;
3753 union real_extract u
;
3755 /* It is possible for gcc to call force_const_mem and then to later
3756 discard the instructions which refer to the constant. In such a
3757 case we do not need to output the constant. */
3758 mark_constant_pool ();
3760 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3761 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3764 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3771 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3772 whose CODE_LABEL has been deleted. This can occur if a jump table
3773 is eliminated by optimization. If so, write a constant of zero
3774 instead. Note that this can also happen by turning the
3775 CODE_LABEL into a NOTE. */
3776 if (((GET_CODE (x
) == LABEL_REF
3777 && (INSN_DELETED_P (XEXP (x
, 0))
3778 || GET_CODE (XEXP (x
, 0)) == NOTE
)))
3779 || (GET_CODE (x
) == CONST
&& GET_CODE (XEXP (x
, 0)) == PLUS
3780 && GET_CODE (XEXP (XEXP (x
, 0), 0)) == LABEL_REF
3781 && (INSN_DELETED_P (XEXP (XEXP (XEXP (x
, 0), 0), 0))
3782 || GET_CODE (XEXP (XEXP (XEXP (x
, 0), 0), 0)) == NOTE
)))
3785 /* First switch to correct section. */
3786 #ifdef SELECT_RTX_SECTION
3787 SELECT_RTX_SECTION (pool
->mode
, x
);
3789 readonly_data_section ();
3792 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3793 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3794 pool
->align
, pool
->labelno
, done
);
3797 if (pool
->align
> 1)
3798 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (pool
->align
));
3800 /* Output the label. */
3801 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", pool
->labelno
);
3803 /* Output the value of the constant itself. */
3804 switch (GET_MODE_CLASS (pool
->mode
))
3807 if (GET_CODE (x
) != CONST_DOUBLE
)
3810 bcopy ((char *) &CONST_DOUBLE_LOW (x
), (char *) &u
, sizeof u
);
3811 assemble_real (u
.d
, pool
->mode
);
3815 case MODE_PARTIAL_INT
:
3816 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), 1);
3823 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3829 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3830 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3833 /* Done with this pool. */
3834 first_pool
= last_pool
= 0;
3837 /* Look through the instructions for this function, and mark all the
3838 entries in the constant pool which are actually being used. */
3841 mark_constant_pool ()
3844 struct pool_constant
*pool
;
3846 if (first_pool
== 0)
3849 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3852 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3853 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
3854 mark_constants (PATTERN (insn
));
3856 for (insn
= current_function_epilogue_delay_list
;
3858 insn
= XEXP (insn
, 1))
3859 if (GET_RTX_CLASS (GET_CODE (insn
)) == 'i')
3860 mark_constants (PATTERN (insn
));
3862 /* It's possible that the only reference to a symbol is in a symbol
3863 that's in the constant pool. This happens in Fortran under some
3864 situations. (When the constant contains the address of another
3865 constant, and only the first is used directly in an insn.)
3866 This is potentially suboptimal if there's ever a possibility of
3867 backwards (in pool order) 2'd level references. However, it's
3868 not clear that 2'd level references can happen. */
3869 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3871 struct pool_sym
*sym
;
3874 /* skip unmarked entries; no insn refers to them. */
3878 /* Skip everything except SYMBOL_REFs. */
3879 if (GET_CODE (pool
->constant
) != SYMBOL_REF
)
3881 label
= XSTR (pool
->constant
, 0);
3883 /* Be sure the symbol's value is marked. */
3884 for (sym
= const_rtx_sym_hash_table
[SYMHASH (label
)]; sym
;
3886 if (sym
->label
== label
)
3887 sym
->pool
->mark
= 1;
3888 /* If we didn't find it, there's something truly wrong here, but it
3889 will be announced by the assembler. */
3898 register const char *format_ptr
;
3903 if (GET_CODE (x
) == SYMBOL_REF
)
3905 if (CONSTANT_POOL_ADDRESS_P (x
))
3906 find_pool_constant (cfun
, x
)->mark
= 1;
3909 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3910 a MEM, but does not constitute a use of that MEM. */
3911 else if (GET_CODE (x
) == CONST_DOUBLE
)
3914 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3915 insns, not any notes that may be attached. We don't want to mark
3916 a constant just because it happens to appear in a REG_EQUIV note. */
3917 if (GET_RTX_CLASS (GET_CODE (x
)) == 'i')
3919 mark_constants (PATTERN (x
));
3923 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3925 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3927 switch (*format_ptr
++)
3930 mark_constants (XEXP (x
, i
));
3934 if (XVEC (x
, i
) != 0)
3938 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3939 mark_constants (XVECEXP (x
, i
, j
));
3958 /* Find all the constants whose addresses are referenced inside of EXP,
3959 and make sure assembler code with a label has been output for each one.
3960 Indicate whether an ADDR_EXPR has been encountered. */
3963 output_addressed_constants (exp
)
3968 switch (TREE_CODE (exp
))
3972 register tree constant
= TREE_OPERAND (exp
, 0);
3974 while (TREE_CODE (constant
) == COMPONENT_REF
)
3976 constant
= TREE_OPERAND (constant
, 0);
3979 if (TREE_CODE_CLASS (TREE_CODE (constant
)) == 'c'
3980 || TREE_CODE (constant
) == CONSTRUCTOR
)
3981 /* No need to do anything here
3982 for addresses of variables or functions. */
3983 output_constant_def (constant
);
3990 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3991 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
3996 case NON_LVALUE_EXPR
:
3997 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
4003 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
4004 if (TREE_VALUE (link
) != 0)
4005 reloc
|= output_addressed_constants (TREE_VALUE (link
));
4015 /* Return nonzero if VALUE is a valid constant-valued expression
4016 for use in initializing a static variable; one that can be an
4017 element of a "constant" initializer.
4019 Return null_pointer_node if the value is absolute;
4020 if it is relocatable, return the variable that determines the relocation.
4021 We assume that VALUE has been folded as much as possible;
4022 therefore, we do not need to check for such things as
4023 arithmetic-combinations of integers. */
4026 initializer_constant_valid_p (value
, endtype
)
4030 switch (TREE_CODE (value
))
4033 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
4034 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
4035 && TREE_CONSTANT (value
)
4036 && CONSTRUCTOR_ELTS (value
))
4038 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
4041 return TREE_STATIC (value
) ? null_pointer_node
: 0;
4047 return null_pointer_node
;
4050 return TREE_OPERAND (value
, 0);
4052 case NON_LVALUE_EXPR
:
4053 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4057 /* Allow conversions between pointer types. */
4058 if (POINTER_TYPE_P (TREE_TYPE (value
))
4059 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4060 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4062 /* Allow conversions between real types. */
4063 if (FLOAT_TYPE_P (TREE_TYPE (value
))
4064 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4065 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4067 /* Allow length-preserving conversions between integer types. */
4068 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4069 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4070 && (TYPE_PRECISION (TREE_TYPE (value
))
4071 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4072 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4074 /* Allow conversions between other integer types only if
4076 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4077 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4079 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4081 if (inner
== null_pointer_node
)
4082 return null_pointer_node
;
4086 /* Allow (int) &foo provided int is as wide as a pointer. */
4087 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4088 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4089 && (TYPE_PRECISION (TREE_TYPE (value
))
4090 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4091 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4094 /* Likewise conversions from int to pointers, but also allow
4095 conversions from 0. */
4096 if (POINTER_TYPE_P (TREE_TYPE (value
))
4097 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4099 if (integer_zerop (TREE_OPERAND (value
, 0)))
4100 return null_pointer_node
;
4101 else if (TYPE_PRECISION (TREE_TYPE (value
))
4102 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
4103 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4107 /* Allow conversions to union types if the value inside is okay. */
4108 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
4109 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4114 if (! INTEGRAL_TYPE_P (endtype
)
4115 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4117 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4119 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4121 /* If either term is absolute, use the other terms relocation. */
4122 if (valid0
== null_pointer_node
)
4124 if (valid1
== null_pointer_node
)
4130 if (! INTEGRAL_TYPE_P (endtype
)
4131 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4133 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4135 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4137 /* Win if second argument is absolute. */
4138 if (valid1
== null_pointer_node
)
4140 /* Win if both arguments have the same relocation.
4141 Then the value is absolute. */
4142 if (valid0
== valid1
&& valid0
!= 0)
4143 return null_pointer_node
;
4146 /* Support differences between labels. */
4147 if (INTEGRAL_TYPE_P (endtype
))
4150 op0
= TREE_OPERAND (value
, 0);
4151 op1
= TREE_OPERAND (value
, 1);
4155 if (TREE_CODE (op0
) == ADDR_EXPR
4156 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
4157 && TREE_CODE (op1
) == ADDR_EXPR
4158 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
4159 return null_pointer_node
;
4170 /* Output assembler code for constant EXP to FILE, with no label.
4171 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4172 Assumes output_addressed_constants has been done on EXP already.
4174 Generate exactly SIZE bytes of assembler data, padding at the end
4175 with zeros if necessary. SIZE must always be specified.
4177 SIZE is important for structure constructors,
4178 since trailing members may have been omitted from the constructor.
4179 It is also important for initialization of arrays from string constants
4180 since the full length of the string constant might not be wanted.
4181 It is also needed for initialization of unions, where the initializer's
4182 type is just one member, and that may not be as long as the union.
4184 There a case in which we would fail to output exactly SIZE bytes:
4185 for a structure constructor that wants to produce more than SIZE bytes.
4186 But such constructors will never be generated for any possible input. */
4189 output_constant (exp
, size
)
4193 register enum tree_code code
= TREE_CODE (TREE_TYPE (exp
));
4195 /* Some front-ends use constants other than the standard
4196 language-indepdent varieties, but which may still be output
4197 directly. Give the front-end a chance to convert EXP to a
4198 language-independent representation. */
4199 if (lang_expand_constant
)
4200 exp
= (*lang_expand_constant
) (exp
);
4202 if (size
== 0 || flag_syntax_only
)
4205 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4206 That way we get the constant (we hope) inside it. Also, strip off any
4207 NOP_EXPR that converts between two record, union, array, or set types. */
4208 while ((TREE_CODE (exp
) == NOP_EXPR
4209 && (TREE_TYPE (exp
) == TREE_TYPE (TREE_OPERAND (exp
, 0))
4210 || AGGREGATE_TYPE_P (TREE_TYPE (exp
))))
4211 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4212 exp
= TREE_OPERAND (exp
, 0);
4214 /* Allow a constructor with no elements for any data type.
4215 This means to fill the space with zeros. */
4216 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
4218 assemble_zeros (size
);
4229 case REFERENCE_TYPE
:
4230 /* ??? What about (int)((float)(int)&foo + 4) */
4231 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
4232 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4233 exp
= TREE_OPERAND (exp
, 0);
4235 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4236 EXPAND_INITIALIZER
),
4238 error ("initializer for integer value is too complicated");
4243 if (TREE_CODE (exp
) != REAL_CST
)
4244 error ("initializer for floating value is not a floating constant");
4246 assemble_real (TREE_REAL_CST (exp
),
4247 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0));
4252 output_constant (TREE_REALPART (exp
), size
/ 2);
4253 output_constant (TREE_IMAGPART (exp
), size
/ 2);
4254 size
-= (size
/ 2) * 2;
4258 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4260 output_constructor (exp
, size
);
4263 else if (TREE_CODE (exp
) == STRING_CST
)
4267 if (size
> TREE_STRING_LENGTH (exp
))
4269 excess
= size
- TREE_STRING_LENGTH (exp
);
4270 size
= TREE_STRING_LENGTH (exp
);
4273 assemble_string (TREE_STRING_POINTER (exp
), size
);
4282 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4283 output_constructor (exp
, size
);
4289 if (TREE_CODE (exp
) == INTEGER_CST
)
4290 assemble_integer (expand_expr (exp
, NULL_RTX
,
4291 VOIDmode
, EXPAND_INITIALIZER
),
4293 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
4295 unsigned char *buffer
= (unsigned char *) alloca (size
);
4296 if (get_set_constructor_bytes (exp
, buffer
, size
))
4298 assemble_string ((char *) buffer
, size
);
4301 error ("unknown set constructor type");
4309 assemble_zeros (size
);
4313 /* Subroutine of output_constant, used for CONSTRUCTORs
4314 (aggregate constants).
4315 Generate at least SIZE bytes, padding if necessary. */
4318 output_constructor (exp
, size
)
4322 register tree link
, field
= 0;
4323 HOST_WIDE_INT min_index
= 0;
4324 /* Number of bytes output or skipped so far.
4325 In other words, current position within the constructor. */
4326 int total_bytes
= 0;
4327 /* Non-zero means BYTE contains part of a byte, to be output. */
4328 int byte_buffer_in_use
= 0;
4329 register int byte
= 0;
4331 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4334 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
4335 field
= TYPE_FIELDS (TREE_TYPE (exp
));
4337 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
4338 && TYPE_DOMAIN (TREE_TYPE (exp
)) != 0)
4340 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp
))));
4342 /* As LINK goes through the elements of the constant,
4343 FIELD goes through the structure fields, if the constant is a structure.
4344 if the constant is a union, then we override this,
4345 by getting the field from the TREE_LIST element.
4346 But the constant could also be an array. Then FIELD is zero.
4348 There is always a maximum of one element in the chain LINK for unions
4349 (even if the initializer in a source program incorrectly contains
4351 for (link
= CONSTRUCTOR_ELTS (exp
);
4353 link
= TREE_CHAIN (link
),
4354 field
= field
? TREE_CHAIN (field
) : 0)
4356 tree val
= TREE_VALUE (link
);
4359 /* the element in a union constructor specifies the proper field. */
4361 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
4362 || TREE_CODE (TREE_TYPE (exp
)) == UNION_TYPE
)
4364 /* if available, use the type given by link */
4365 if (TREE_PURPOSE (link
) != 0)
4366 field
= TREE_PURPOSE (link
);
4369 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
4370 index
= TREE_PURPOSE (link
);
4372 /* Eliminate the marker that makes a cast not be an lvalue. */
4376 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4378 register int fieldsize
4379 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp
)));
4380 HOST_WIDE_INT lo_index
= TREE_INT_CST_LOW (TREE_OPERAND (index
, 0));
4381 HOST_WIDE_INT hi_index
= TREE_INT_CST_LOW (TREE_OPERAND (index
, 1));
4382 HOST_WIDE_INT index
;
4383 for (index
= lo_index
; index
<= hi_index
; index
++)
4385 /* Output the element's initial value. */
4387 assemble_zeros (fieldsize
);
4389 output_constant (val
, fieldsize
);
4391 /* Count its size. */
4392 total_bytes
+= fieldsize
;
4395 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4397 /* An element that is not a bit-field. */
4399 register int fieldsize
;
4400 /* Since this structure is static,
4401 we know the positions are constant. */
4402 int bitpos
= (field
? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
))
4406 bitpos
= (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val
)))
4408 * (TREE_INT_CST_LOW (index
) - min_index
));
4410 /* Output any buffered-up bit-fields preceding this element. */
4411 if (byte_buffer_in_use
)
4413 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4415 byte_buffer_in_use
= 0;
4418 /* Advance to offset of this element.
4419 Note no alignment needed in an array, since that is guaranteed
4420 if each element has the proper size. */
4421 if ((field
!= 0 || index
!= 0) && bitpos
!= total_bytes
)
4423 assemble_zeros (bitpos
- total_bytes
);
4424 total_bytes
= bitpos
;
4427 /* Determine size this element should occupy. */
4430 if (TREE_CODE (DECL_SIZE (field
)) != INTEGER_CST
)
4432 if (TREE_INT_CST_LOW (DECL_SIZE (field
)) > 100000)
4434 /* This avoids overflow trouble. */
4435 tree size_tree
= size_binop (CEIL_DIV_EXPR
,
4437 size_int (BITS_PER_UNIT
));
4438 fieldsize
= TREE_INT_CST_LOW (size_tree
);
4442 fieldsize
= TREE_INT_CST_LOW (DECL_SIZE (field
));
4443 fieldsize
= (fieldsize
+ BITS_PER_UNIT
- 1) / BITS_PER_UNIT
;
4447 fieldsize
= int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp
)));
4449 /* Output the element's initial value. */
4451 assemble_zeros (fieldsize
);
4453 output_constant (val
, fieldsize
);
4455 /* Count its size. */
4456 total_bytes
+= fieldsize
;
4458 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4459 error ("invalid initial value for member `%s'",
4460 IDENTIFIER_POINTER (DECL_NAME (field
)));
4463 /* Element that is a bit-field. */
4465 int next_offset
= TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
));
4467 = (next_offset
+ TREE_INT_CST_LOW (DECL_SIZE (field
)));
4470 val
= integer_zero_node
;
4472 /* If this field does not start in this (or, next) byte,
4474 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4476 /* Output remnant of any bit field in previous bytes. */
4477 if (byte_buffer_in_use
)
4479 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4481 byte_buffer_in_use
= 0;
4484 /* If still not at proper byte, advance to there. */
4485 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4487 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4488 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4492 if (! byte_buffer_in_use
)
4495 /* We must split the element into pieces that fall within
4496 separate bytes, and combine each byte with previous or
4497 following bit-fields. */
4499 /* next_offset is the offset n fbits from the beginning of
4500 the structure to the next bit of this element to be processed.
4501 end_offset is the offset of the first bit past the end of
4503 while (next_offset
< end_offset
)
4507 HOST_WIDE_INT value
;
4508 int next_byte
= next_offset
/ BITS_PER_UNIT
;
4509 int next_bit
= next_offset
% BITS_PER_UNIT
;
4511 /* Advance from byte to byte
4512 within this element when necessary. */
4513 while (next_byte
!= total_bytes
)
4515 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4520 /* Number of bits we can process at once
4521 (all part of the same byte). */
4522 this_time
= MIN (end_offset
- next_offset
,
4523 BITS_PER_UNIT
- next_bit
);
4524 if (BYTES_BIG_ENDIAN
)
4526 /* On big-endian machine, take the most significant bits
4527 first (of the bits that are significant)
4528 and put them into bytes from the most significant end. */
4529 shift
= end_offset
- next_offset
- this_time
;
4530 /* Don't try to take a bunch of bits that cross
4531 the word boundary in the INTEGER_CST. We can
4532 only select bits from the LOW or HIGH part
4534 if (shift
< HOST_BITS_PER_WIDE_INT
4535 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4537 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4538 shift
= HOST_BITS_PER_WIDE_INT
;
4541 /* Now get the bits from the appropriate constant word. */
4542 if (shift
< HOST_BITS_PER_WIDE_INT
)
4544 value
= TREE_INT_CST_LOW (val
);
4546 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4548 value
= TREE_INT_CST_HIGH (val
);
4549 shift
-= HOST_BITS_PER_WIDE_INT
;
4553 /* Get the result. This works only when:
4554 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4555 byte
|= (((value
>> shift
)
4556 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4557 << (BITS_PER_UNIT
- this_time
- next_bit
));
4561 /* On little-endian machines,
4562 take first the least significant bits of the value
4563 and pack them starting at the least significant
4564 bits of the bytes. */
4565 shift
= (next_offset
4566 - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field
)));
4567 /* Don't try to take a bunch of bits that cross
4568 the word boundary in the INTEGER_CST. We can
4569 only select bits from the LOW or HIGH part
4571 if (shift
< HOST_BITS_PER_WIDE_INT
4572 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4574 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4577 /* Now get the bits from the appropriate constant word. */
4578 if (shift
< HOST_BITS_PER_WIDE_INT
)
4579 value
= TREE_INT_CST_LOW (val
);
4580 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4582 value
= TREE_INT_CST_HIGH (val
);
4583 shift
-= HOST_BITS_PER_WIDE_INT
;
4587 /* Get the result. This works only when:
4588 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4589 byte
|= (((value
>> shift
)
4590 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4593 next_offset
+= this_time
;
4594 byte_buffer_in_use
= 1;
4598 if (byte_buffer_in_use
)
4600 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4603 if (total_bytes
< size
)
4604 assemble_zeros (size
- total_bytes
);
4607 #ifdef HANDLE_PRAGMA_WEAK
4608 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4609 associatd with NAME. */
4612 add_weak (name
, value
)
4616 struct weak_syms
*weak
;
4618 weak
= (struct weak_syms
*) permalloc (sizeof (struct weak_syms
));
4623 weak
->next
= weak_decls
;
4625 weak
->value
= value
;
4630 #endif /* HANDLE_PRAGMA_WEAK */
4632 /* Declare DECL to be a weak symbol. */
4638 if (! TREE_PUBLIC (decl
))
4639 error_with_decl (decl
, "weak declaration of `%s' must be public");
4640 else if (TREE_ASM_WRITTEN (decl
))
4641 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4642 else if (SUPPORTS_WEAK
)
4643 DECL_WEAK (decl
) = 1;
4644 #ifdef HANDLE_PRAGMA_WEAK
4645 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), NULL
);
4649 /* Emit any pending weak declarations. */
4651 #ifdef HANDLE_PRAGMA_WEAK
4652 struct weak_syms
* weak_decls
;
4658 #ifdef HANDLE_PRAGMA_WEAK
4659 if (HANDLE_PRAGMA_WEAK
)
4661 struct weak_syms
*t
;
4662 for (t
= weak_decls
; t
; t
= t
->next
)
4666 ASM_WEAKEN_LABEL (asm_out_file
, t
->name
);
4668 ASM_OUTPUT_DEF (asm_out_file
, t
->name
, t
->value
);
4675 /* Remove NAME from the pending list of weak symbols. This prevents
4676 the compiler from emitting multiple .weak directives which confuses
4678 #ifdef ASM_WEAKEN_LABEL
4680 remove_from_pending_weak_list (name
)
4681 char *name ATTRIBUTE_UNUSED
;
4683 #ifdef HANDLE_PRAGMA_WEAK
4684 if (HANDLE_PRAGMA_WEAK
)
4686 struct weak_syms
*t
;
4687 for (t
= weak_decls
; t
; t
= t
->next
)
4689 if (t
->name
&& strcmp (name
, t
->name
) == 0)
4698 assemble_alias (decl
, target
)
4699 tree decl
, target ATTRIBUTE_UNUSED
;
4703 make_decl_rtl (decl
, (char *) 0, 1);
4704 name
= XSTR (XEXP (DECL_RTL (decl
), 0), 0);
4706 #ifdef ASM_OUTPUT_DEF
4707 /* Make name accessible from other files, if appropriate. */
4709 if (TREE_PUBLIC (decl
))
4711 #ifdef ASM_WEAKEN_LABEL
4712 if (DECL_WEAK (decl
))
4714 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4715 /* Remove this function from the pending weak list so that
4716 we do not emit multiple .weak directives for it. */
4717 remove_from_pending_weak_list
4718 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4722 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
4725 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4726 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4728 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4730 TREE_ASM_WRITTEN (decl
) = 1;
4732 #ifdef ASM_OUTPUT_WEAK_ALIAS
4733 if (! DECL_WEAK (decl
))
4734 warning ("only weak aliases are supported in this configuration");
4736 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4737 TREE_ASM_WRITTEN (decl
) = 1;
4739 warning ("alias definitions not supported in this configuration; ignored");
4744 /* This determines whether or not we support link-once semantics. */
4745 #ifndef SUPPORTS_ONE_ONLY
4746 #ifdef MAKE_DECL_ONE_ONLY
4747 #define SUPPORTS_ONE_ONLY 1
4749 #define SUPPORTS_ONE_ONLY 0
4753 /* Returns 1 if the target configuration supports defining public symbols
4754 so that one of them will be chosen at link time instead of generating a
4755 multiply-defined symbol error, whether through the use of weak symbols or
4756 a target-specific mechanism for having duplicates discarded. */
4759 supports_one_only ()
4761 if (SUPPORTS_ONE_ONLY
)
4763 return SUPPORTS_WEAK
;
4766 /* Set up DECL as a public symbol that can be defined in multiple
4767 translation units without generating a linker error. */
4770 make_decl_one_only (decl
)
4773 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4776 TREE_PUBLIC (decl
) = 1;
4778 if (TREE_CODE (decl
) == VAR_DECL
4779 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4780 DECL_COMMON (decl
) = 1;
4781 else if (SUPPORTS_ONE_ONLY
)
4783 #ifdef MAKE_DECL_ONE_ONLY
4784 MAKE_DECL_ONE_ONLY (decl
);
4786 DECL_ONE_ONLY (decl
) = 1;
4788 else if (SUPPORTS_WEAK
)
4789 DECL_WEAK (decl
) = 1;
4797 ggc_add_root (const_hash_table
, MAX_HASH_TABLE
, sizeof const_hash_table
[0],
4798 mark_const_hash_entry
);
4799 ggc_add_string_root (&in_named_name
, 1);