1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
37 #include "hard-reg-set.h"
50 #ifdef XCOFF_DEBUGGING_INFO
51 #include "xcoffout.h" /* Needed for external data
52 declarations for e.g. AIX 4.x. */
55 #ifndef TRAMPOLINE_ALIGNMENT
56 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
60 #define ASM_STABS_OP "\t.stabs\t"
63 /* Define the prefix to use when check_memory_usage_flag is enable. */
64 #define CHKR_PREFIX "_CHKR_"
65 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
67 /* The (assembler) name of the first globally-visible object output. */
68 const char *first_global_object_name
;
69 const char *weak_global_object_name
;
71 extern struct obstack permanent_obstack
;
72 #define obstack_chunk_alloc xmalloc
75 struct constant_descriptor
;
79 #define MAX_RTX_HASH_TABLE 61
83 /* Hash facility for making memory-constants
84 from constant rtl-expressions. It is used on RISC machines
85 where immediate integer arguments and constant addresses are restricted
86 so that such constants must be stored in memory.
88 This pool of constants is reinitialized for each function
89 so each function gets its own constants-pool that comes right before
91 struct constant_descriptor
**x_const_rtx_hash_table
;
92 struct pool_constant
**x_const_rtx_sym_hash_table
;
94 /* Pointers to first and last constant in pool. */
95 struct pool_constant
*x_first_pool
, *x_last_pool
;
97 /* Current offset in constant pool (does not include any machine-specific
101 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
102 They are chained through the CONST_DOUBLE_CHAIN.
103 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
104 In that case, CONST_DOUBLE_MEM is either a MEM,
105 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
106 rtx x_const_double_chain
;
109 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
110 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
111 #define first_pool (cfun->varasm->x_first_pool)
112 #define last_pool (cfun->varasm->x_last_pool)
113 #define pool_offset (cfun->varasm->x_pool_offset)
114 #define const_double_chain (cfun->varasm->x_const_double_chain)
116 /* Number for making the label on the next
117 constant that is stored in memory. */
121 /* Number for making the label on the next
122 static variable internal to a function. */
126 /* Carry information from ASM_DECLARE_OBJECT_NAME
127 to ASM_FINISH_DECLARE_OBJECT. */
129 int size_directive_output
;
131 /* The last decl for which assemble_variable was called,
132 if it did ASM_DECLARE_OBJECT_NAME.
133 If the last call to assemble_variable didn't do that,
136 tree last_assemble_variable_decl
;
138 static const char *strip_reg_name
PARAMS ((const char *));
139 static int contains_pointers_p
PARAMS ((tree
));
140 static void assemble_real_1
PARAMS ((PTR
));
141 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
142 static int const_hash
PARAMS ((tree
));
143 static int compare_constant
PARAMS ((tree
,
144 struct constant_descriptor
*));
145 static const unsigned char *compare_constant_1
PARAMS ((tree
, const unsigned char *));
146 static struct constant_descriptor
*record_constant
PARAMS ((tree
));
147 static void record_constant_1
PARAMS ((tree
));
148 static tree copy_constant
PARAMS ((tree
));
149 static void output_constant_def_contents
PARAMS ((tree
, int, int));
150 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
151 struct rtx_const
*));
152 static int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
153 static int compare_constant_rtx
PARAMS ((enum machine_mode
, rtx
,
154 struct constant_descriptor
*));
155 static struct constant_descriptor
*record_constant_rtx
PARAMS ((enum machine_mode
,
157 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
158 static void mark_constant_pool
PARAMS ((void));
159 static void mark_constants
PARAMS ((rtx
));
160 static int mark_constant
PARAMS ((rtx
*current_rtx
, void *data
));
161 static int output_addressed_constants
PARAMS ((tree
));
162 static void output_after_function_constants
PARAMS ((void));
163 static unsigned HOST_WIDE_INT array_size_for_constructor
PARAMS ((tree
));
164 static void output_constructor
PARAMS ((tree
, int));
165 #ifdef ASM_WEAKEN_LABEL
166 static void remove_from_pending_weak_list
PARAMS ((const char *));
168 static int in_named_entry_eq
PARAMS ((const PTR
, const PTR
));
169 static hashval_t in_named_entry_hash
PARAMS ((const PTR
));
170 #ifdef ASM_OUTPUT_BSS
171 static void asm_output_bss
PARAMS ((FILE *, tree
, const char *, int, int));
173 #ifdef BSS_SECTION_ASM_OP
174 #ifdef ASM_OUTPUT_ALIGNED_BSS
175 static void asm_output_aligned_bss
PARAMS ((FILE *, tree
, const char *,
178 #endif /* BSS_SECTION_ASM_OP */
179 static void mark_pool_constant
PARAMS ((struct pool_constant
*));
180 static void mark_const_hash_entry
PARAMS ((void *));
181 static int mark_const_str_htab_1
PARAMS ((void **, void *));
182 static void mark_const_str_htab
PARAMS ((void *));
183 static hashval_t const_str_htab_hash
PARAMS ((const void *x
));
184 static int const_str_htab_eq
PARAMS ((const void *x
, const void *y
));
185 static void const_str_htab_del
PARAMS ((void *));
186 static void asm_emit_uninitialised
PARAMS ((tree
, const char*, int, int));
187 static void resolve_unique_section
PARAMS ((tree
, int));
189 static enum in_section
{ no_section
, in_text
, in_data
, in_named
190 #ifdef BSS_SECTION_ASM_OP
193 #ifdef CTORS_SECTION_ASM_OP
196 #ifdef DTORS_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 const char *in_named_name
;
214 /* Hash table of flags that have been used for a particular named section. */
216 struct in_named_entry
222 static htab_t in_named_htab
;
224 /* Define functions like text_section for any extra sections. */
225 #ifdef EXTRA_SECTION_FUNCTIONS
226 EXTRA_SECTION_FUNCTIONS
229 /* Tell assembler to switch to text section. */
234 if (in_section
!= in_text
)
239 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
241 in_section
= in_text
;
245 /* Tell assembler to switch to data section. */
250 if (in_section
!= in_data
)
252 if (flag_shared_data
)
254 #ifdef SHARED_SECTION_ASM_OP
255 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
257 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
261 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
263 in_section
= in_data
;
266 /* Tell assembler to ALWAYS switch to data section, in case
267 it's not sure where it is. */
270 force_data_section ()
272 in_section
= no_section
;
276 /* Tell assembler to switch to read-only data section. This is normally
280 readonly_data_section ()
282 #ifdef READONLY_DATA_SECTION
283 READONLY_DATA_SECTION (); /* Note this can call data_section. */
289 /* Determine if we're in the text section. */
294 return in_section
== in_text
;
297 /* Determine if we're in the data section. */
302 return in_section
== in_data
;
305 /* Helper routines for maintaining in_named_htab. */
308 in_named_entry_eq (p1
, p2
)
312 const struct in_named_entry
*old
= p1
;
313 const char *new = p2
;
315 return strcmp (old
->name
, new) == 0;
319 in_named_entry_hash (p
)
322 const struct in_named_entry
*old
= p
;
323 return htab_hash_string (old
->name
);
326 /* If SECTION has been seen before as a named section, return the flags
327 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
328 set of flags for a section to have, so 0 does not mean that the section
329 has not been seen. */
332 get_named_section_flags (section
)
335 struct in_named_entry
**slot
;
337 slot
= (struct in_named_entry
**)
338 htab_find_slot_with_hash (in_named_htab
, section
,
339 htab_hash_string (section
), NO_INSERT
);
341 return slot
? (*slot
)->flags
: 0;
344 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
345 different set of flags, return false. */
348 set_named_section_flags (section
, flags
)
352 struct in_named_entry
**slot
, *entry
;
354 slot
= (struct in_named_entry
**)
355 htab_find_slot_with_hash (in_named_htab
, section
,
356 htab_hash_string (section
), INSERT
);
361 entry
= (struct in_named_entry
*) xmalloc (sizeof (*entry
));
363 entry
->name
= ggc_strdup (section
);
364 entry
->flags
= flags
;
366 else if (entry
->flags
!= flags
)
372 /* Tell assembler to change to section NAME with attributes FLAGS. */
375 named_section_flags (name
, flags
)
379 if (in_section
!= in_named
|| strcmp (name
, in_named_name
) != 0)
381 if (! set_named_section_flags (name
, flags
))
384 (* targetm
.asm_out
.named_section
) (name
, flags
);
386 if (flags
& SECTION_FORGET
)
387 in_section
= no_section
;
390 in_named_name
= ggc_strdup (name
);
391 in_section
= in_named
;
396 /* Tell assembler to change to section NAME for DECL.
397 If DECL is NULL, just switch to section NAME.
398 If NAME is NULL, get the name from DECL.
399 If RELOC is 1, the initializer for DECL contains relocs. */
402 named_section (decl
, name
, reloc
)
409 if (decl
!= NULL_TREE
&& !DECL_P (decl
))
412 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
414 flags
= (* targetm
.section_type_flags
) (decl
, name
, reloc
);
416 /* Sanity check user variables for flag changes. Non-user
417 section flag changes will abort in named_section_flags. */
418 if (decl
&& ! set_named_section_flags (name
, flags
))
420 error_with_decl (decl
, "%s causes a section type conflict");
421 flags
= get_named_section_flags (name
);
424 named_section_flags (name
, flags
);
427 /* If required, set DECL_SECTION_NAME to a unique name. */
430 resolve_unique_section (decl
, reloc
)
432 int reloc ATTRIBUTE_UNUSED
;
434 if (DECL_SECTION_NAME (decl
) == NULL_TREE
435 && (flag_function_sections
436 || (targetm
.have_named_sections
437 && DECL_ONE_ONLY (decl
))))
438 UNIQUE_SECTION (decl
, reloc
);
441 #ifdef BSS_SECTION_ASM_OP
443 /* Tell the assembler to switch to the bss section. */
448 if (in_section
!= in_bss
)
450 #ifdef SHARED_BSS_SECTION_ASM_OP
451 if (flag_shared_data
)
452 fprintf (asm_out_file
, "%s\n", SHARED_BSS_SECTION_ASM_OP
);
455 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
461 #ifdef ASM_OUTPUT_BSS
463 /* Utility function for ASM_OUTPUT_BSS for targets to use if
464 they don't support alignments in .bss.
465 ??? It is believed that this function will work in most cases so such
466 support is localized here. */
469 asm_output_bss (file
, decl
, name
, size
, rounded
)
471 tree decl ATTRIBUTE_UNUSED
;
473 int size ATTRIBUTE_UNUSED
, rounded
;
475 ASM_GLOBALIZE_LABEL (file
, name
);
477 #ifdef ASM_DECLARE_OBJECT_NAME
478 last_assemble_variable_decl
= decl
;
479 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
481 /* Standard thing is just output label for the object. */
482 ASM_OUTPUT_LABEL (file
, name
);
483 #endif /* ASM_DECLARE_OBJECT_NAME */
484 ASM_OUTPUT_SKIP (file
, rounded
);
489 #ifdef ASM_OUTPUT_ALIGNED_BSS
491 /* Utility function for targets to use in implementing
492 ASM_OUTPUT_ALIGNED_BSS.
493 ??? It is believed that this function will work in most cases so such
494 support is localized here. */
497 asm_output_aligned_bss (file
, decl
, name
, size
, align
)
503 ASM_GLOBALIZE_LABEL (file
, name
);
505 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
506 #ifdef ASM_DECLARE_OBJECT_NAME
507 last_assemble_variable_decl
= decl
;
508 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
510 /* Standard thing is just output label for the object. */
511 ASM_OUTPUT_LABEL (file
, name
);
512 #endif /* ASM_DECLARE_OBJECT_NAME */
513 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
518 #endif /* BSS_SECTION_ASM_OP */
520 /* Switch to the section for function DECL.
522 If DECL is NULL_TREE, switch to the text section.
523 ??? It's not clear that we will ever be passed NULL_TREE, but it's
524 safer to handle it. */
527 function_section (decl
)
530 if (decl
!= NULL_TREE
531 && DECL_SECTION_NAME (decl
) != NULL_TREE
)
532 named_section (decl
, (char *) 0, 0);
537 /* Switch to section for variable DECL.
539 RELOC is the `reloc' argument to SELECT_SECTION. */
542 variable_section (decl
, reloc
)
546 if (IN_NAMED_SECTION (decl
))
547 named_section (decl
, NULL
, reloc
);
550 /* C++ can have const variables that get initialized from constructors,
551 and thus can not be in a readonly section. We prevent this by
552 verifying that the initial value is constant for objects put in a
555 error_mark_node is used by the C front end to indicate that the
556 initializer has not been seen yet. In this case, we assume that
557 the initializer must be constant.
559 C++ uses error_mark_node for variables that have complicated
560 initializers, but these variables go in BSS so we won't be called
563 #ifdef SELECT_SECTION
564 SELECT_SECTION (decl
, reloc
);
566 if (DECL_READONLY_SECTION (decl
, reloc
))
567 readonly_data_section ();
574 /* Tell assembler to switch to the section for the exception handling
580 #if defined (EXCEPTION_SECTION)
581 EXCEPTION_SECTION ();
583 if (targetm
.have_named_sections
)
584 named_section (NULL_TREE
, ".gcc_except_table", 0);
588 readonly_data_section ();
592 /* Given NAME, a putative register name, discard any customary prefixes. */
595 strip_reg_name (name
)
598 #ifdef REGISTER_PREFIX
599 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
600 name
+= strlen (REGISTER_PREFIX
);
602 if (name
[0] == '%' || name
[0] == '#')
607 /* Decode an `asm' spec for a declaration as a register name.
608 Return the register number, or -1 if nothing specified,
609 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
610 or -3 if ASMSPEC is `cc' and is not recognized,
611 or -4 if ASMSPEC is `memory' and is not recognized.
612 Accept an exact spelling or a decimal number.
613 Prefixes such as % are optional. */
616 decode_reg_name (asmspec
)
623 /* Get rid of confusing prefixes. */
624 asmspec
= strip_reg_name (asmspec
);
626 /* Allow a decimal number as a "register name". */
627 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
628 if (! (asmspec
[i
] >= '0' && asmspec
[i
] <= '9'))
630 if (asmspec
[0] != 0 && i
< 0)
633 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
639 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
641 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
644 #ifdef ADDITIONAL_REGISTER_NAMES
646 static struct { const char *name
; int number
; } table
[]
647 = ADDITIONAL_REGISTER_NAMES
;
649 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
650 if (! strcmp (asmspec
, table
[i
].name
))
651 return table
[i
].number
;
653 #endif /* ADDITIONAL_REGISTER_NAMES */
655 if (!strcmp (asmspec
, "memory"))
658 if (!strcmp (asmspec
, "cc"))
667 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
668 have static storage duration. In other words, it should not be an
669 automatic variable, including PARM_DECLs.
671 There is, however, one exception: this function handles variables
672 explicitly placed in a particular register by the user.
674 ASMSPEC, if not 0, is the string which the user specified as the
675 assembler symbol name.
677 This is never called for PARM_DECL nodes. */
680 make_decl_rtl (decl
, asmspec
)
684 int top_level
= (DECL_CONTEXT (decl
) == NULL_TREE
);
685 const char *name
= 0;
686 const char *new_name
= 0;
690 /* Check that we are not being given an automatic variable. */
691 /* A weak alias has TREE_PUBLIC set but not the other bits. */
692 if (TREE_CODE (decl
) == PARM_DECL
693 || TREE_CODE (decl
) == RESULT_DECL
694 || (TREE_CODE (decl
) == VAR_DECL
695 && !TREE_STATIC (decl
)
696 && !TREE_PUBLIC (decl
)
697 && !DECL_EXTERNAL (decl
)
698 && !DECL_REGISTER (decl
)))
700 /* And that we were not given a type or a label. */
701 else if (TREE_CODE (decl
) == TYPE_DECL
702 || TREE_CODE (decl
) == LABEL_DECL
)
705 /* For a duplicate declaration, we can be called twice on the
706 same DECL node. Don't discard the RTL already made. */
707 if (DECL_RTL_SET_P (decl
))
709 /* If the old RTL had the wrong mode, fix the mode. */
710 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
712 rtx rtl
= DECL_RTL (decl
);
713 PUT_MODE (rtl
, DECL_MODE (decl
));
716 /* ??? Another way to do this would be to do what halfpic.c does
717 and maintain a hashed table of such critters. */
718 /* ??? Another way to do this would be to pass a flag bit to
719 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
720 /* Let the target reassign the RTL if it wants.
721 This is necessary, for example, when one machine specific
722 decl attribute overrides another. */
723 #ifdef REDO_SECTION_INFO_P
724 if (REDO_SECTION_INFO_P (decl
))
725 ENCODE_SECTION_INFO (decl
);
730 new_name
= name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
732 reg_number
= decode_reg_name (asmspec
);
733 if (reg_number
== -2)
735 /* ASMSPEC is given, and not the name of a register. Mark the
736 name with a star so assemble_name won't munge it. */
737 char *starred
= alloca (strlen (asmspec
) + 2);
739 strcpy (starred
+ 1, asmspec
);
743 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
745 /* First detect errors in declaring global registers. */
746 if (reg_number
== -1)
747 error_with_decl (decl
, "register name not specified for `%s'");
748 else if (reg_number
< 0)
749 error_with_decl (decl
, "invalid register name for `%s'");
750 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
751 error_with_decl (decl
,
752 "data type of `%s' isn't suitable for a register");
753 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
754 error_with_decl (decl
,
755 "register specified for `%s' isn't suitable for data type");
756 /* Now handle properly declared static register variables. */
761 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
763 DECL_INITIAL (decl
) = 0;
764 error ("global register variable has initial value");
766 if (TREE_THIS_VOLATILE (decl
))
767 warning ("volatile register variables don't work as you might wish");
769 /* If the user specified one of the eliminables registers here,
770 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
771 confused with that register and be eliminated. Although this
772 usage is somewhat suspect, we nevertheless use the following
773 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
776 gen_rtx_REG (DECL_MODE (decl
),
777 FIRST_PSEUDO_REGISTER
));
778 REGNO (DECL_RTL (decl
)) = reg_number
;
779 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
781 if (TREE_STATIC (decl
))
783 /* Make this register global, so not usable for anything
785 #ifdef ASM_DECLARE_REGISTER_GLOBAL
786 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
788 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
790 globalize_reg (reg_number
+ --nregs
);
793 /* As a register variable, it has no section. */
798 /* Now handle ordinary static variables and functions (in memory).
799 Also handle vars declared register invalidly. */
801 if (reg_number
>= 0 || reg_number
== -3)
802 error_with_decl (decl
,
803 "register name given for non-register variable `%s'");
805 /* Specifying a section attribute on a variable forces it into a
806 non-.bss section, and thus it cannot be common. */
807 if (TREE_CODE (decl
) == VAR_DECL
808 && DECL_SECTION_NAME (decl
) != NULL_TREE
809 && DECL_INITIAL (decl
) == NULL_TREE
810 && DECL_COMMON (decl
))
811 DECL_COMMON (decl
) = 0;
813 /* Can't use just the variable's own name for a variable
814 whose scope is less than the whole file, unless it's a member
815 of a local class (which will already be unambiguous).
816 Concatenate a distinguishing number. */
817 if (!top_level
&& !TREE_PUBLIC (decl
)
818 && ! (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
820 && name
== IDENTIFIER_POINTER (DECL_NAME (decl
)))
823 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
828 /* When -fprefix-function-name is used, the functions
829 names are prefixed. Only nested function names are not
831 else if (flag_prefix_function_name
&& TREE_CODE (decl
) == FUNCTION_DECL
)
833 size_t name_len
= IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
));
836 pname
= alloca (name_len
+ CHKR_PREFIX_SIZE
+ 1);
837 memcpy (pname
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
);
838 memcpy (pname
+ CHKR_PREFIX_SIZE
, name
, name_len
+ 1);
842 if (name
!= new_name
)
844 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (new_name
));
845 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
848 /* If this variable is to be treated as volatile, show its
849 tree node has side effects. */
850 if ((flag_volatile_global
&& TREE_CODE (decl
) == VAR_DECL
851 && TREE_PUBLIC (decl
))
852 || ((flag_volatile_static
&& TREE_CODE (decl
) == VAR_DECL
853 && (TREE_PUBLIC (decl
) || TREE_STATIC (decl
)))))
854 TREE_SIDE_EFFECTS (decl
) = 1;
856 x
= gen_rtx_MEM (DECL_MODE (decl
), gen_rtx_SYMBOL_REF (Pmode
, name
));
857 SYMBOL_REF_WEAK (XEXP (x
, 0)) = DECL_WEAK (decl
);
858 if (TREE_CODE (decl
) != FUNCTION_DECL
)
859 set_mem_attributes (x
, decl
, 1);
860 SET_DECL_RTL (decl
, x
);
862 /* Optionally set flags or add text to the name to record information
863 such as that it is a function name.
864 If the name is changed, the macro ASM_OUTPUT_LABELREF
865 will have to know how to strip this information. */
866 #ifdef ENCODE_SECTION_INFO
867 ENCODE_SECTION_INFO (decl
);
871 /* Make the rtl for variable VAR be volatile.
872 Use this only for static variables. */
875 make_var_volatile (var
)
878 if (GET_CODE (DECL_RTL (var
)) != MEM
)
881 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
884 /* Output alignment directive to align for constant expression EXP. */
887 assemble_constant_align (exp
)
892 /* Align the location counter as required by EXP's data type. */
893 align
= TYPE_ALIGN (TREE_TYPE (exp
));
894 #ifdef CONSTANT_ALIGNMENT
895 align
= CONSTANT_ALIGNMENT (exp
, align
);
898 if (align
> BITS_PER_UNIT
)
899 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
902 /* Output a string of literal assembler code
903 for an `asm' keyword used between functions. */
906 assemble_asm (string
)
911 if (TREE_CODE (string
) == ADDR_EXPR
)
912 string
= TREE_OPERAND (string
, 0);
914 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
917 /* Record an element in the table of global destructors. SYMBOL is
918 a SYMBOL_REF of the function to be called; PRIORITY is a number
919 between 0 and MAX_INIT_PRIORITY. */
922 default_stabs_asm_out_destructor (symbol
, priority
)
924 int priority ATTRIBUTE_UNUSED
;
926 /* Tell GNU LD that this is part of the static destructor set.
927 This will work for any system that uses stabs, most usefully
929 fprintf (asm_out_file
, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
930 assemble_name (asm_out_file
, XSTR (symbol
, 0));
931 fputc ('\n', asm_out_file
);
935 default_named_section_asm_out_destructor (symbol
, priority
)
939 const char *section
= ".dtors";
942 /* ??? This only works reliably with the GNU linker. */
943 if (priority
!= DEFAULT_INIT_PRIORITY
)
945 sprintf (buf
, ".dtors.%.5u",
946 /* Invert the numbering so the linker puts us in the proper
947 order; constructors are run from right to left, and the
948 linker sorts in increasing order. */
949 MAX_INIT_PRIORITY
- priority
);
953 named_section_flags (section
, SECTION_WRITE
);
954 assemble_align (POINTER_SIZE
);
955 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
958 #ifdef DTORS_SECTION_ASM_OP
962 if (in_section
!= in_dtors
)
964 in_section
= in_dtors
;
965 fputs (DTORS_SECTION_ASM_OP
, asm_out_file
);
966 fputc ('\n', asm_out_file
);
971 default_dtor_section_asm_out_destructor (symbol
, priority
)
973 int priority ATTRIBUTE_UNUSED
;
976 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
980 /* Likewise for global constructors. */
983 default_stabs_asm_out_constructor (symbol
, priority
)
985 int priority ATTRIBUTE_UNUSED
;
987 /* Tell GNU LD that this is part of the static destructor set.
988 This will work for any system that uses stabs, most usefully
990 fprintf (asm_out_file
, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
991 assemble_name (asm_out_file
, XSTR (symbol
, 0));
992 fputc ('\n', asm_out_file
);
996 default_named_section_asm_out_constructor (symbol
, priority
)
1000 const char *section
= ".ctors";
1003 /* ??? This only works reliably with the GNU linker. */
1004 if (priority
!= DEFAULT_INIT_PRIORITY
)
1006 sprintf (buf
, ".ctors.%.5u",
1007 /* Invert the numbering so the linker puts us in the proper
1008 order; constructors are run from right to left, and the
1009 linker sorts in increasing order. */
1010 MAX_INIT_PRIORITY
- priority
);
1014 named_section_flags (section
, SECTION_WRITE
);
1015 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
1018 #ifdef CTORS_SECTION_ASM_OP
1022 if (in_section
!= in_ctors
)
1024 in_section
= in_ctors
;
1025 fputs (CTORS_SECTION_ASM_OP
, asm_out_file
);
1026 fputc ('\n', asm_out_file
);
1031 default_ctor_section_asm_out_constructor (symbol
, priority
)
1033 int priority ATTRIBUTE_UNUSED
;
1036 assemble_integer (symbol
, POINTER_SIZE
/ BITS_PER_UNIT
, 1);
1040 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1041 a non-zero value if the constant pool should be output before the
1042 start of the function, or a zero value if the pool should output
1043 after the end of the function. The default is to put it before the
1046 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1047 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1050 /* Output assembler code for the constant pool of a function and associated
1051 with defining the name of the function. DECL describes the function.
1052 NAME is the function's name. For the constant pool, we use the current
1053 constant pool data. */
1056 assemble_start_function (decl
, fnname
)
1062 /* The following code does not need preprocessing in the assembler. */
1066 if (CONSTANT_POOL_BEFORE_FUNCTION
)
1067 output_constant_pool (fnname
, decl
);
1069 resolve_unique_section (decl
, 0);
1070 function_section (decl
);
1072 /* Tell assembler to move to target machine's alignment for functions. */
1073 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
1075 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1077 /* Handle a user-specified function alignment.
1078 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1079 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1080 if (align_functions_log
> align
)
1082 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1083 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
1084 align_functions_log
, align_functions
-1);
1086 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
1090 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1091 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
1094 (*debug_hooks
->begin_function
) (decl
);
1096 /* Make function name accessible from other files, if appropriate. */
1098 if (TREE_PUBLIC (decl
))
1100 if (! first_global_object_name
)
1105 STRIP_NAME_ENCODING (p
, fnname
);
1106 name
= permalloc (strlen (p
) + 1);
1109 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
1110 first_global_object_name
= name
;
1112 weak_global_object_name
= name
;
1115 #ifdef ASM_WEAKEN_LABEL
1116 if (DECL_WEAK (decl
))
1118 ASM_WEAKEN_LABEL (asm_out_file
, fnname
);
1119 /* Remove this function from the pending weak list so that
1120 we do not emit multiple .weak directives for it. */
1121 remove_from_pending_weak_list
1122 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1126 ASM_GLOBALIZE_LABEL (asm_out_file
, fnname
);
1129 /* Do any machine/system dependent processing of the function name */
1130 #ifdef ASM_DECLARE_FUNCTION_NAME
1131 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
1133 /* Standard thing is just output label for the function. */
1134 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
1135 #endif /* ASM_DECLARE_FUNCTION_NAME */
1138 /* Output assembler code associated with defining the size of the
1139 function. DECL describes the function. NAME is the function's name. */
1142 assemble_end_function (decl
, fnname
)
1146 #ifdef ASM_DECLARE_FUNCTION_SIZE
1147 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
1149 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
1151 output_constant_pool (fnname
, decl
);
1152 function_section (decl
); /* need to switch back */
1155 /* Output any constants which should appear after the function. */
1156 output_after_function_constants ();
1159 /* Assemble code to leave SIZE bytes of zeros. */
1162 assemble_zeros (size
)
1165 /* Do no output if -fsyntax-only. */
1166 if (flag_syntax_only
)
1169 #ifdef ASM_NO_SKIP_IN_TEXT
1170 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1171 so we must output 0s explicitly in the text section. */
1172 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1176 for (i
= 0; i
< size
- 20; i
+= 20)
1179 fprintf (asm_out_file
,
1180 "%s0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP
);
1182 fprintf (asm_out_file
,
1183 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1189 fprintf (asm_out_file
, "%s0", ASM_BYTE_OP
);
1191 fprintf (asm_out_file
, "\tbyte 0");
1194 for (; i
< size
; i
++)
1195 fprintf (asm_out_file
, ",0");
1196 fprintf (asm_out_file
, "\n");
1202 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1205 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1208 assemble_align (align
)
1211 if (align
> BITS_PER_UNIT
)
1212 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1215 /* Assemble a string constant with the specified C string as contents. */
1218 assemble_string (p
, size
)
1225 /* If the string is very long, split it up. */
1229 int thissize
= size
- pos
;
1230 if (thissize
> maximum
)
1233 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1241 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1242 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1243 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1245 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1246 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1247 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1249 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1250 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1254 #if defined ASM_OUTPUT_ALIGNED_BSS
1255 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1256 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1258 #if defined ASM_OUTPUT_BSS
1259 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1260 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1266 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1267 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1268 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1270 #if defined ASM_OUTPUT_ALIGNED_COMMON
1271 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1272 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1274 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1275 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1280 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1283 int size ATTRIBUTE_UNUSED
;
1284 int rounded ATTRIBUTE_UNUSED
;
1292 destination
= asm_dest_local
;
1294 if (TREE_PUBLIC (decl
))
1296 #if defined ASM_EMIT_BSS
1297 if (! DECL_COMMON (decl
))
1298 destination
= asm_dest_bss
;
1301 destination
= asm_dest_common
;
1304 if (flag_shared_data
)
1306 switch (destination
)
1308 #ifdef ASM_OUTPUT_SHARED_BSS
1310 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1313 #ifdef ASM_OUTPUT_SHARED_COMMON
1314 case asm_dest_common
:
1315 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1318 #ifdef ASM_OUTPUT_SHARED_LOCAL
1319 case asm_dest_local
:
1320 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1328 resolve_unique_section (decl
, 0);
1330 switch (destination
)
1334 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1337 case asm_dest_common
:
1338 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1340 case asm_dest_local
:
1341 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1350 /* Assemble everything that is needed for a variable or function declaration.
1351 Not used for automatic variables, and not used for function definitions.
1352 Should not be called for variables of incomplete structure type.
1354 TOP_LEVEL is nonzero if this variable has file scope.
1355 AT_END is nonzero if this is the special handling, at end of compilation,
1356 to define things that have had only tentative definitions.
1357 DONT_OUTPUT_DATA if nonzero means don't actually output the
1358 initial value (that will be done by the caller). */
1361 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1363 int top_level ATTRIBUTE_UNUSED
;
1364 int at_end ATTRIBUTE_UNUSED
;
1365 int dont_output_data
;
1367 register const char *name
;
1372 last_assemble_variable_decl
= 0;
1374 /* Normally no need to say anything here for external references,
1375 since assemble_external is called by the language-specific code
1376 when a declaration is first seen. */
1378 if (DECL_EXTERNAL (decl
))
1381 /* Output no assembler code for a function declaration.
1382 Only definitions of functions output anything. */
1384 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1387 /* Do nothing for global register variables. */
1388 if (DECL_RTL_SET_P (decl
) && GET_CODE (DECL_RTL (decl
)) == REG
)
1390 TREE_ASM_WRITTEN (decl
) = 1;
1394 /* If type was incomplete when the variable was declared,
1395 see if it is complete now. */
1397 if (DECL_SIZE (decl
) == 0)
1398 layout_decl (decl
, 0);
1400 /* Still incomplete => don't allocate it; treat the tentative defn
1401 (which is what it must have been) as an `extern' reference. */
1403 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1405 error_with_file_and_line (DECL_SOURCE_FILE (decl
),
1406 DECL_SOURCE_LINE (decl
),
1407 "storage size of `%s' isn't known",
1408 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1409 TREE_ASM_WRITTEN (decl
) = 1;
1413 /* The first declaration of a variable that comes through this function
1414 decides whether it is global (in C, has external linkage)
1415 or local (in C, has internal linkage). So do nothing more
1416 if this function has already run. */
1418 if (TREE_ASM_WRITTEN (decl
))
1421 /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN. */
1422 decl_rtl
= DECL_RTL (decl
);
1424 TREE_ASM_WRITTEN (decl
) = 1;
1426 /* Do no output if -fsyntax-only. */
1427 if (flag_syntax_only
)
1432 if (! dont_output_data
1433 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1435 error_with_decl (decl
, "size of variable `%s' is too large");
1439 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1440 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1441 && ! first_global_object_name
1442 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1443 || DECL_INITIAL (decl
) == error_mark_node
))
1444 && ! DECL_WEAK (decl
)
1445 && ! DECL_ONE_ONLY (decl
))
1450 STRIP_NAME_ENCODING (p
, name
);
1451 xname
= permalloc (strlen (p
) + 1);
1453 first_global_object_name
= xname
;
1456 /* Compute the alignment of this data. */
1458 align
= DECL_ALIGN (decl
);
1460 /* In the case for initialing an array whose length isn't specified,
1461 where we have not yet been able to do the layout,
1462 figure out the proper alignment now. */
1463 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1464 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1465 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1467 /* Some object file formats have a maximum alignment which they support.
1468 In particular, a.out format supports a maximum alignment of 4. */
1469 #ifndef MAX_OFILE_ALIGNMENT
1470 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1472 if (align
> MAX_OFILE_ALIGNMENT
)
1474 warning_with_decl (decl
,
1475 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1476 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1477 align
= MAX_OFILE_ALIGNMENT
;
1480 /* On some machines, it is good to increase alignment sometimes. */
1481 if (! DECL_USER_ALIGN (decl
))
1483 #ifdef DATA_ALIGNMENT
1484 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1486 #ifdef CONSTANT_ALIGNMENT
1487 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1488 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1492 /* Reset the alignment in case we have made it tighter, so we can benefit
1493 from it in get_pointer_alignment. */
1494 DECL_ALIGN (decl
) = align
;
1496 /* Handle uninitialized definitions. */
1498 if ((DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
)
1499 /* If the target can't output uninitialized but not common global data
1500 in .bss, then we have to use .data. */
1501 #if ! defined ASM_EMIT_BSS
1502 && DECL_COMMON (decl
)
1504 && DECL_SECTION_NAME (decl
) == NULL_TREE
1505 && ! dont_output_data
)
1507 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1508 unsigned HOST_WIDE_INT rounded
= size
;
1510 /* Don't allocate zero bytes of common,
1511 since that means "undefined external" in the linker. */
1515 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1516 so that each uninitialized object starts on such a boundary. */
1517 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1518 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1519 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1521 /* Don't continue this line--convex cc version 4.1 would lose. */
1522 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1523 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN (decl
) / BITS_PER_UNIT
> rounded
)
1525 (decl
, "requested alignment for %s is greater than implemented alignment of %d.",rounded
);
1528 asm_emit_uninitialised (decl
, name
, size
, rounded
);
1533 /* Handle initialized definitions.
1534 Also handle uninitialized global definitions if -fno-common and the
1535 target doesn't support ASM_OUTPUT_BSS. */
1537 /* First make the assembler name(s) global if appropriate. */
1538 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1540 #ifdef ASM_WEAKEN_LABEL
1541 if (DECL_WEAK (decl
))
1543 ASM_WEAKEN_LABEL (asm_out_file
, name
);
1544 /* Remove this variable from the pending weak list so that
1545 we do not emit multiple .weak directives for it. */
1546 remove_from_pending_weak_list
1547 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1551 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1554 /* Output any data that we will need to use the address of. */
1555 if (DECL_INITIAL (decl
) == error_mark_node
)
1556 reloc
= contains_pointers_p (TREE_TYPE (decl
));
1557 else if (DECL_INITIAL (decl
))
1558 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1560 /* Switch to the appropriate section. */
1561 resolve_unique_section (decl
, reloc
);
1562 variable_section (decl
, reloc
);
1564 /* dbxout.c needs to know this. */
1565 if (in_text_section ())
1566 DECL_IN_TEXT_SECTION (decl
) = 1;
1568 /* Output the alignment of this data. */
1569 if (align
> BITS_PER_UNIT
)
1570 ASM_OUTPUT_ALIGN (asm_out_file
,
1571 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1573 /* Do any machine/system dependent processing of the object. */
1574 #ifdef ASM_DECLARE_OBJECT_NAME
1575 last_assemble_variable_decl
= decl
;
1576 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1578 /* Standard thing is just output label for the object. */
1579 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1580 #endif /* ASM_DECLARE_OBJECT_NAME */
1582 if (!dont_output_data
)
1584 if (DECL_INITIAL (decl
))
1585 /* Output the actual data. */
1586 output_constant (DECL_INITIAL (decl
),
1587 tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1589 /* Leave space for it. */
1590 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1594 /* Return 1 if type TYPE contains any pointers. */
1597 contains_pointers_p (type
)
1600 switch (TREE_CODE (type
))
1603 case REFERENCE_TYPE
:
1604 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1605 so I'll play safe and return 1. */
1611 case QUAL_UNION_TYPE
:
1614 /* For a type that has fields, see if the fields have pointers. */
1615 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1616 if (TREE_CODE (fields
) == FIELD_DECL
1617 && contains_pointers_p (TREE_TYPE (fields
)))
1623 /* An array type contains pointers if its element type does. */
1624 return contains_pointers_p (TREE_TYPE (type
));
1631 /* Output something to declare an external symbol to the assembler.
1632 (Most assemblers don't need this, so we normally output nothing.)
1633 Do nothing if DECL is not external. */
1636 assemble_external (decl
)
1637 tree decl ATTRIBUTE_UNUSED
;
1639 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1640 main body of this code is only rarely exercised. To provide some
1641 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1642 open. If it's not, we should not be calling this function. */
1646 #ifdef ASM_OUTPUT_EXTERNAL
1647 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1649 rtx rtl
= DECL_RTL (decl
);
1651 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1652 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1654 /* Some systems do require some output. */
1655 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1656 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1662 /* Similar, for calling a library function FUN. */
1665 assemble_external_libcall (fun
)
1666 rtx fun ATTRIBUTE_UNUSED
;
1668 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1669 /* Declare library function name external when first used, if nec. */
1670 if (! SYMBOL_REF_USED (fun
))
1672 SYMBOL_REF_USED (fun
) = 1;
1673 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1678 /* Declare the label NAME global. */
1681 assemble_global (name
)
1684 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1687 /* Assemble a label named NAME. */
1690 assemble_label (name
)
1693 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1696 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1697 If NAME starts with a *, the rest of NAME is output verbatim.
1698 Otherwise NAME is transformed in an implementation-defined way
1699 (usually by the addition of an underscore).
1700 Many macros in the tm file are defined to call this function. */
1703 assemble_name (file
, name
)
1707 const char *real_name
;
1710 STRIP_NAME_ENCODING (real_name
, name
);
1711 if (flag_prefix_function_name
1712 && ! memcmp (real_name
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
))
1713 real_name
= real_name
+ CHKR_PREFIX_SIZE
;
1715 id
= maybe_get_identifier (real_name
);
1717 TREE_SYMBOL_REFERENCED (id
) = 1;
1720 fputs (&name
[1], file
);
1722 ASM_OUTPUT_LABELREF (file
, name
);
1725 /* Allocate SIZE bytes writable static space with a gensym name
1726 and return an RTX to refer to its address. */
1729 assemble_static_space (size
)
1733 const char *namestring
;
1737 if (flag_shared_data
)
1741 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1743 namestring
= ggc_strdup (name
);
1745 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1747 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1748 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1751 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1752 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1755 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1756 so that each uninitialized object starts on such a boundary. */
1757 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1758 int rounded ATTRIBUTE_UNUSED
1759 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1760 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1761 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1762 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1769 /* Assemble the static constant template for function entry trampolines.
1770 This is done at most once per compilation.
1771 Returns an RTX for the address of the template. */
1773 #ifdef TRAMPOLINE_TEMPLATE
1775 assemble_trampoline_template ()
1781 /* By default, put trampoline templates in read-only data section. */
1783 #ifdef TRAMPOLINE_SECTION
1784 TRAMPOLINE_SECTION ();
1786 readonly_data_section ();
1789 /* Write the assembler code to define one. */
1790 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1792 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1794 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LTRAMP", 0);
1795 TRAMPOLINE_TEMPLATE (asm_out_file
);
1797 /* Record the rtl to refer to it. */
1798 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1799 name
= ggc_strdup (label
);
1800 return gen_rtx_SYMBOL_REF (Pmode
, name
);
1804 /* Assemble the integer constant X into an object of SIZE bytes.
1805 X must be either a CONST_INT or CONST_DOUBLE.
1807 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1808 non-zero, abort if we can't output the constant. */
1811 assemble_integer (x
, size
, force
)
1816 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1817 ASM_OUTPUT... macros. */
1821 #ifdef ASM_OUTPUT_CHAR
1823 ASM_OUTPUT_CHAR (asm_out_file
, x
);
1827 #ifdef ASM_OUTPUT_SHORT
1829 ASM_OUTPUT_SHORT (asm_out_file
, x
);
1833 #ifdef ASM_OUTPUT_INT
1835 ASM_OUTPUT_INT (asm_out_file
, x
);
1839 #ifdef ASM_OUTPUT_DOUBLE_INT
1841 ASM_OUTPUT_DOUBLE_INT (asm_out_file
, x
);
1845 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1847 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file
, x
);
1852 /* If we couldn't do it that way, there are two other possibilities: First,
1853 if the machine can output an explicit byte and this is a 1 byte constant,
1854 we can use ASM_OUTPUT_BYTE. */
1856 #ifdef ASM_OUTPUT_BYTE
1857 if (size
== 1 && GET_CODE (x
) == CONST_INT
)
1859 ASM_OUTPUT_BYTE (asm_out_file
, INTVAL (x
));
1864 /* Finally, if SIZE is larger than a single word, try to output the constant
1865 one word at a time. */
1867 if (size
> UNITS_PER_WORD
)
1870 enum machine_mode mode
1871 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1874 for (i
= 0; i
< size
/ UNITS_PER_WORD
; i
++)
1876 word
= operand_subword (x
, i
, 0, mode
);
1881 if (! assemble_integer (word
, UNITS_PER_WORD
, 0))
1885 if (i
== size
/ UNITS_PER_WORD
)
1887 /* If we output at least one word and then could not finish,
1888 there is no valid way to continue. */
1899 /* Assemble the floating-point constant D into an object of size MODE. */
1900 struct assemble_real_args
1903 enum machine_mode mode
;
1910 struct assemble_real_args
*args
= (struct assemble_real_args
*) p
;
1911 REAL_VALUE_TYPE
*d
= args
->d
;
1912 enum machine_mode mode
= args
->mode
;
1916 #ifdef ASM_OUTPUT_BYTE_FLOAT
1918 ASM_OUTPUT_BYTE_FLOAT (asm_out_file
, *d
);
1921 #ifdef ASM_OUTPUT_SHORT_FLOAT
1923 ASM_OUTPUT_SHORT_FLOAT (asm_out_file
, *d
);
1926 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1928 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file
, *d
);
1931 #ifdef ASM_OUTPUT_FLOAT
1933 ASM_OUTPUT_FLOAT (asm_out_file
, *d
);
1937 #ifdef ASM_OUTPUT_DOUBLE
1939 ASM_OUTPUT_DOUBLE (asm_out_file
, *d
);
1943 #ifdef ASM_OUTPUT_LONG_DOUBLE
1946 ASM_OUTPUT_LONG_DOUBLE (asm_out_file
, *d
);
1956 assemble_real (d
, mode
)
1958 enum machine_mode mode
;
1960 struct assemble_real_args args
;
1964 if (do_float_handler (assemble_real_1
, (PTR
) &args
))
1967 internal_error ("floating point trap outputting a constant");
1970 /* Here we combine duplicate floating constants to make
1971 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1973 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1974 For an integer, I0 is the low-order word and I1 is the high-order word.
1975 For a real number, I0 is the word with the low address
1976 and I1 is the word with the high address. */
1979 immed_double_const (i0
, i1
, mode
)
1980 HOST_WIDE_INT i0
, i1
;
1981 enum machine_mode mode
;
1985 if (GET_MODE_CLASS (mode
) == MODE_INT
1986 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
1988 /* We clear out all bits that don't belong in MODE, unless they and our
1989 sign bit are all one. So we get either a reasonable negative value
1990 or a reasonable unsigned value for this mode. */
1991 int width
= GET_MODE_BITSIZE (mode
);
1992 if (width
< HOST_BITS_PER_WIDE_INT
1993 && ((i0
& ((HOST_WIDE_INT
) (-1) << (width
- 1)))
1994 != ((HOST_WIDE_INT
) (-1) << (width
- 1))))
1995 i0
&= ((HOST_WIDE_INT
) 1 << width
) - 1, i1
= 0;
1996 else if (width
== HOST_BITS_PER_WIDE_INT
1997 && ! (i1
== ~0 && i0
< 0))
1999 else if (width
> 2 * HOST_BITS_PER_WIDE_INT
)
2000 /* We cannot represent this value as a constant. */
2003 /* If this would be an entire word for the target, but is not for
2004 the host, then sign-extend on the host so that the number will look
2005 the same way on the host that it would on the target.
2007 For example, when building a 64 bit alpha hosted 32 bit sparc
2008 targeted compiler, then we want the 32 bit unsigned value -1 to be
2009 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2010 The later confuses the sparc backend. */
2012 if (width
< HOST_BITS_PER_WIDE_INT
2013 && (i0
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
2014 i0
|= ((HOST_WIDE_INT
) (-1) << width
);
2016 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2018 ??? Strictly speaking, this is wrong if we create a CONST_INT
2019 for a large unsigned constant with the size of MODE being
2020 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2021 wider mode. In that case we will mis-interpret it as a negative
2024 Unfortunately, the only alternative is to make a CONST_DOUBLE
2025 for any constant in any mode if it is an unsigned constant larger
2026 than the maximum signed integer in an int on the host. However,
2027 doing this will break everyone that always expects to see a CONST_INT
2028 for SImode and smaller.
2030 We have always been making CONST_INTs in this case, so nothing new
2033 if (width
<= HOST_BITS_PER_WIDE_INT
)
2034 i1
= (i0
< 0) ? ~(HOST_WIDE_INT
) 0 : 0;
2036 /* If this integer fits in one word, return a CONST_INT. */
2037 if ((i1
== 0 && i0
>= 0)
2038 || (i1
== ~0 && i0
< 0))
2039 return GEN_INT (i0
);
2041 /* We use VOIDmode for integers. */
2045 /* Search the chain for an existing CONST_DOUBLE with the right value.
2046 If one is found, return it. */
2048 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2049 if (CONST_DOUBLE_LOW (r
) == i0
&& CONST_DOUBLE_HIGH (r
) == i1
2050 && GET_MODE (r
) == mode
)
2053 /* No; make a new one and add it to the chain. */
2054 r
= gen_rtx_CONST_DOUBLE (mode
, const0_rtx
, i0
, i1
);
2056 /* Don't touch const_double_chain if not inside any function. */
2057 if (current_function_decl
!= 0)
2059 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2060 const_double_chain
= r
;
2066 /* Return a CONST_DOUBLE for a specified `double' value
2067 and machine mode. */
2070 immed_real_const_1 (d
, mode
)
2072 enum machine_mode mode
;
2074 union real_extract u
;
2077 /* Get the desired `double' value as a sequence of ints
2078 since that is how they are stored in a CONST_DOUBLE. */
2082 /* Detect special cases. */
2083 if (REAL_VALUES_IDENTICAL (dconst0
, d
))
2084 return CONST0_RTX (mode
);
2086 /* Check for NaN first, because some ports (specifically the i386) do not
2087 emit correct ieee-fp code by default, and thus will generate a core
2088 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2089 does a floating point comparison. */
2090 else if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_EQUAL (dconst1
, d
))
2091 return CONST1_RTX (mode
);
2093 if (sizeof u
== sizeof (HOST_WIDE_INT
))
2094 return immed_double_const (u
.i
[0], 0, mode
);
2095 if (sizeof u
== 2 * sizeof (HOST_WIDE_INT
))
2096 return immed_double_const (u
.i
[0], u
.i
[1], mode
);
2098 /* The rest of this function handles the case where
2099 a float value requires more than 2 ints of space.
2100 It will be deleted as dead code on machines that don't need it. */
2102 /* Search the chain for an existing CONST_DOUBLE with the right value.
2103 If one is found, return it. */
2105 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
2106 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
)
2107 && GET_MODE (r
) == mode
)
2110 /* No; make a new one and add it to the chain.
2112 We may be called by an optimizer which may be discarding any memory
2113 allocated during its processing (such as combine and loop). However,
2114 we will be leaving this constant on the chain, so we cannot tolerate
2116 r
= rtx_alloc (CONST_DOUBLE
);
2118 memcpy ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
);
2120 /* If we aren't inside a function, don't put r on the
2121 const_double_chain. */
2122 if (current_function_decl
!= 0)
2124 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
2125 const_double_chain
= r
;
2128 CONST_DOUBLE_CHAIN (r
) = NULL_RTX
;
2130 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2131 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2132 is only through force_const_mem. */
2134 CONST_DOUBLE_MEM (r
) = const0_rtx
;
2139 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2140 which must be a REAL_CST tree node. */
2143 immed_real_const (exp
)
2146 return immed_real_const_1 (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)));
2149 /* At the end of a function, forget the memory-constants
2150 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2151 Also clear out real_constant_chain and clear out all the chain-pointers. */
2154 clear_const_double_mem ()
2156 register rtx r
, next
;
2157 enum machine_mode mode
;
2160 for (r
= const_double_chain
; r
; r
= next
)
2162 next
= CONST_DOUBLE_CHAIN (r
);
2163 CONST_DOUBLE_CHAIN (r
) = 0;
2164 CONST_DOUBLE_MEM (r
) = cc0_rtx
;
2166 const_double_chain
= 0;
2168 for (i
= 0; i
<= 2; i
++)
2169 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
); mode
!= VOIDmode
;
2170 mode
= GET_MODE_WIDER_MODE (mode
))
2172 r
= const_tiny_rtx
[i
][(int) mode
];
2173 CONST_DOUBLE_CHAIN (r
) = 0;
2174 CONST_DOUBLE_MEM (r
) = cc0_rtx
;
2178 /* Given an expression EXP with a constant value,
2179 reduce it to the sum of an assembler symbol and an integer.
2180 Store them both in the structure *VALUE.
2181 Abort if EXP does not reduce. */
2186 HOST_WIDE_INT offset
;
2190 decode_addr_const (exp
, value
)
2192 struct addr_const
*value
;
2194 register tree target
= TREE_OPERAND (exp
, 0);
2195 register int offset
= 0;
2200 if (TREE_CODE (target
) == COMPONENT_REF
2201 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2204 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2205 target
= TREE_OPERAND (target
, 0);
2207 else if (TREE_CODE (target
) == ARRAY_REF
2208 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2210 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2211 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2212 target
= TREE_OPERAND (target
, 0);
2218 switch (TREE_CODE (target
))
2222 x
= DECL_RTL (target
);
2226 x
= gen_rtx_MEM (FUNCTION_MODE
,
2227 gen_rtx_LABEL_REF (VOIDmode
,
2228 label_rtx (TREE_OPERAND (exp
, 0))));
2236 x
= TREE_CST_RTL (target
);
2243 if (GET_CODE (x
) != MEM
)
2248 value
->offset
= offset
;
2251 enum kind
{ RTX_DOUBLE
, RTX_INT
};
2254 ENUM_BITFIELD(kind
) kind
: 16;
2255 ENUM_BITFIELD(machine_mode
) mode
: 16;
2257 union real_extract du
;
2258 struct addr_const addr
;
2259 struct {HOST_WIDE_INT high
, low
;} di
;
2263 /* Uniquize all constants that appear in memory.
2264 Each constant in memory thus far output is recorded
2265 in `const_hash_table' with a `struct constant_descriptor'
2266 that contains a polish representation of the value of
2269 We cannot store the trees in the hash table
2270 because the trees may be temporary. */
2272 struct constant_descriptor
2274 struct constant_descriptor
*next
;
2277 /* Make sure the data is reasonably aligned. */
2280 unsigned char contents
[1];
2281 #ifdef HAVE_LONG_DOUBLE
2290 #define MAX_HASH_TABLE 1009
2291 static struct constant_descriptor
*const_hash_table
[MAX_HASH_TABLE
];
2293 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2295 struct deferred_string
2302 static htab_t const_str_htab
;
2304 /* Mark a const_hash_table descriptor for GC. */
2307 mark_const_hash_entry (ptr
)
2310 struct constant_descriptor
*desc
= * (struct constant_descriptor
**) ptr
;
2314 ggc_mark_rtx (desc
->rtl
);
2319 /* Mark the hash-table element X (which is really a pointer to an
2320 struct deferred_string *). */
2323 mark_const_str_htab_1 (x
, data
)
2325 void *data ATTRIBUTE_UNUSED
;
2327 ggc_mark_tree (((struct deferred_string
*) *x
)->exp
);
2331 /* Mark a const_str_htab for GC. */
2334 mark_const_str_htab (htab
)
2337 htab_traverse (*((htab_t
*) htab
), mark_const_str_htab_1
, NULL
);
2340 /* Returns a hash code for X (which is a really a
2341 struct deferred_string *). */
2344 const_str_htab_hash (x
)
2347 return STRHASH (((const struct deferred_string
*) x
)->label
);
2350 /* Returns non-zero if the value represented by X (which is really a
2351 struct deferred_string *) is the same as that given by Y
2352 (which is really a char *). */
2355 const_str_htab_eq (x
, y
)
2359 return (((const struct deferred_string
*) x
)->label
== (const char *) y
);
2362 /* Delete the hash table entry dfsp. */
2365 const_str_htab_del (dfsp
)
2371 /* Compute a hash code for a constant expression. */
2377 register const char *p
;
2378 register int len
, hi
, i
;
2379 register enum tree_code code
= TREE_CODE (exp
);
2381 /* Either set P and LEN to the address and len of something to hash and
2382 exit the switch or return a value. */
2387 p
= (char *) &TREE_INT_CST (exp
);
2388 len
= sizeof TREE_INT_CST (exp
);
2392 p
= (char *) &TREE_REAL_CST (exp
);
2393 len
= sizeof TREE_REAL_CST (exp
);
2397 p
= TREE_STRING_POINTER (exp
);
2398 len
= TREE_STRING_LENGTH (exp
);
2402 return (const_hash (TREE_REALPART (exp
)) * 5
2403 + const_hash (TREE_IMAGPART (exp
)));
2406 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2410 len
= int_size_in_bytes (TREE_TYPE (exp
));
2411 tmp
= (char *) alloca (len
);
2412 get_set_constructor_bytes (exp
, (unsigned char *) tmp
, len
);
2420 /* For record type, include the type in the hashing.
2421 We do not do so for array types
2422 because (1) the sizes of the elements are sufficient
2423 and (2) distinct array types can have the same constructor.
2424 Instead, we include the array size because the constructor could
2426 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2427 hi
= ((unsigned long) TREE_TYPE (exp
) & ((1 << HASHBITS
) - 1))
2430 hi
= ((5 + int_size_in_bytes (TREE_TYPE (exp
)))
2431 & ((1 << HASHBITS
) - 1)) % MAX_HASH_TABLE
;
2433 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2434 if (TREE_VALUE (link
))
2436 = (hi
* 603 + const_hash (TREE_VALUE (link
))) % MAX_HASH_TABLE
;
2443 struct addr_const value
;
2445 decode_addr_const (exp
, &value
);
2446 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2448 /* Don't hash the address of the SYMBOL_REF;
2449 only use the offset and the symbol name. */
2451 p
= XSTR (value
.base
, 0);
2452 for (i
= 0; p
[i
] != 0; i
++)
2453 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2455 else if (GET_CODE (value
.base
) == LABEL_REF
)
2456 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2460 hi
&= (1 << HASHBITS
) - 1;
2461 hi
%= MAX_HASH_TABLE
;
2467 return (const_hash (TREE_OPERAND (exp
, 0)) * 9
2468 + const_hash (TREE_OPERAND (exp
, 1)));
2472 case NON_LVALUE_EXPR
:
2473 return const_hash (TREE_OPERAND (exp
, 0)) * 7 + 2;
2476 /* A language specific constant. Just hash the code. */
2477 return (int) code
% MAX_HASH_TABLE
;
2480 /* Compute hashing function */
2482 for (i
= 0; i
< len
; i
++)
2483 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2485 hi
&= (1 << HASHBITS
) - 1;
2486 hi
%= MAX_HASH_TABLE
;
2490 /* Compare a constant expression EXP with a constant-descriptor DESC.
2491 Return 1 if DESC describes a constant with the same value as EXP. */
2494 compare_constant (exp
, desc
)
2496 struct constant_descriptor
*desc
;
2498 return 0 != compare_constant_1 (exp
, desc
->u
.contents
);
2501 /* Compare constant expression EXP with a substring P of a constant descriptor.
2502 If they match, return a pointer to the end of the substring matched.
2503 If they do not match, return 0.
2505 Since descriptors are written in polish prefix notation,
2506 this function can be used recursively to test one operand of EXP
2507 against a subdescriptor, and if it succeeds it returns the
2508 address of the subdescriptor for the next operand. */
2510 static const unsigned char *
2511 compare_constant_1 (exp
, p
)
2513 const unsigned char *p
;
2515 register const unsigned char *strp
;
2517 register enum tree_code code
= TREE_CODE (exp
);
2519 if (code
!= (enum tree_code
) *p
++)
2522 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2523 switch, or return the result of the comparison. */
2528 /* Integer constants are the same only if the same width of type. */
2529 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2532 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2533 len
= sizeof TREE_INT_CST (exp
);
2537 /* Real constants are the same only if the same width of type. */
2538 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2541 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2542 len
= sizeof TREE_REAL_CST (exp
);
2546 if (flag_writable_strings
)
2549 if ((enum machine_mode
) *p
++ != TYPE_MODE (TREE_TYPE (exp
)))
2552 strp
= (const unsigned char *)TREE_STRING_POINTER (exp
);
2553 len
= TREE_STRING_LENGTH (exp
);
2554 if (memcmp ((char *) &TREE_STRING_LENGTH (exp
), p
,
2555 sizeof TREE_STRING_LENGTH (exp
)))
2558 p
+= sizeof TREE_STRING_LENGTH (exp
);
2562 p
= compare_constant_1 (TREE_REALPART (exp
), p
);
2566 return compare_constant_1 (TREE_IMAGPART (exp
), p
);
2569 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2571 int xlen
= len
= int_size_in_bytes (TREE_TYPE (exp
));
2572 unsigned char *tmp
= (unsigned char *) alloca (len
);
2574 get_set_constructor_bytes (exp
, tmp
, len
);
2575 strp
= (unsigned char *) tmp
;
2576 if (memcmp ((char *) &xlen
, p
, sizeof xlen
))
2585 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2587 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2588 int have_purpose
= 0;
2590 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2591 if (TREE_PURPOSE (link
))
2594 if (memcmp ((char *) &length
, p
, sizeof length
))
2599 /* For record constructors, insist that the types match.
2600 For arrays, just verify both constructors are for arrays.
2601 Then insist that either both or none have any TREE_PURPOSE
2603 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2604 type
= TREE_TYPE (exp
);
2608 if (memcmp ((char *) &type
, p
, sizeof type
))
2611 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2613 if (memcmp ((char *) &mode
, p
, sizeof mode
))
2621 if (memcmp ((char *) &have_purpose
, p
, sizeof have_purpose
))
2624 p
+= sizeof have_purpose
;
2626 /* For arrays, insist that the size in bytes match. */
2627 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2629 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2631 if (memcmp ((char *) &size
, p
, sizeof size
))
2637 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2639 if (TREE_VALUE (link
))
2641 if ((p
= compare_constant_1 (TREE_VALUE (link
), p
)) == 0)
2648 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2654 if (TREE_PURPOSE (link
)
2655 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2657 if (memcmp ((char *) &TREE_PURPOSE (link
), p
,
2658 sizeof TREE_PURPOSE (link
)))
2661 p
+= sizeof TREE_PURPOSE (link
);
2663 else if (TREE_PURPOSE (link
))
2665 if ((p
= compare_constant_1 (TREE_PURPOSE (link
), p
)) == 0)
2668 else if (have_purpose
)
2672 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2684 struct addr_const value
;
2686 decode_addr_const (exp
, &value
);
2687 strp
= (unsigned char *) &value
.offset
;
2688 len
= sizeof value
.offset
;
2689 /* Compare the offset. */
2691 if (*p
++ != *strp
++)
2694 /* Compare symbol name. */
2695 strp
= (const unsigned char *) XSTR (value
.base
, 0);
2696 len
= strlen ((const char *) strp
) + 1;
2703 p
= compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2707 return compare_constant_1 (TREE_OPERAND (exp
, 1), p
);
2711 case NON_LVALUE_EXPR
:
2712 return compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2715 if (lang_expand_constant
)
2717 exp
= (*lang_expand_constant
) (exp
);
2718 return compare_constant_1 (exp
, p
);
2723 /* Compare constant contents. */
2725 if (*p
++ != *strp
++)
2731 /* Construct a constant descriptor for the expression EXP.
2732 It is up to the caller to enter the descriptor in the hash table. */
2734 static struct constant_descriptor
*
2735 record_constant (exp
)
2738 struct constant_descriptor
*next
= 0;
2743 /* Make a struct constant_descriptor. The first three pointers will
2744 be filled in later. Here we just leave space for them. */
2746 obstack_grow (&permanent_obstack
, (char *) &next
, sizeof next
);
2747 obstack_grow (&permanent_obstack
, (char *) &label
, sizeof label
);
2748 obstack_grow (&permanent_obstack
, (char *) &rtl
, sizeof rtl
);
2750 /* Align the descriptor for the data payload. */
2751 pad
= (offsetof (struct constant_descriptor
, u
)
2752 - offsetof(struct constant_descriptor
, rtl
)
2753 - sizeof(next
->rtl
));
2755 obstack_blank (&permanent_obstack
, pad
);
2757 record_constant_1 (exp
);
2758 return (struct constant_descriptor
*) obstack_finish (&permanent_obstack
);
2761 /* Add a description of constant expression EXP
2762 to the object growing in `permanent_obstack'.
2763 No need to return its address; the caller will get that
2764 from the obstack when the object is complete. */
2767 record_constant_1 (exp
)
2770 register const unsigned char *strp
;
2772 register enum tree_code code
= TREE_CODE (exp
);
2774 obstack_1grow (&permanent_obstack
, (unsigned int) code
);
2779 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2780 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2781 len
= sizeof TREE_INT_CST (exp
);
2785 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2786 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2787 len
= sizeof TREE_REAL_CST (exp
);
2791 if (flag_writable_strings
)
2794 obstack_1grow (&permanent_obstack
, TYPE_MODE (TREE_TYPE (exp
)));
2795 strp
= (const unsigned char *) TREE_STRING_POINTER (exp
);
2796 len
= TREE_STRING_LENGTH (exp
);
2797 obstack_grow (&permanent_obstack
, (char *) &TREE_STRING_LENGTH (exp
),
2798 sizeof TREE_STRING_LENGTH (exp
));
2802 record_constant_1 (TREE_REALPART (exp
));
2803 record_constant_1 (TREE_IMAGPART (exp
));
2807 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2809 int nbytes
= int_size_in_bytes (TREE_TYPE (exp
));
2810 obstack_grow (&permanent_obstack
, &nbytes
, sizeof (nbytes
));
2811 obstack_blank (&permanent_obstack
, nbytes
);
2812 get_set_constructor_bytes
2813 (exp
, (unsigned char *) permanent_obstack
.next_free
-nbytes
,
2820 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2821 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2823 int have_purpose
= 0;
2825 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2826 if (TREE_PURPOSE (link
))
2829 obstack_grow (&permanent_obstack
, (char *) &length
, sizeof length
);
2831 /* For record constructors, insist that the types match.
2832 For arrays, just verify both constructors are for arrays
2833 of the same mode. Then insist that either both or none
2834 have any TREE_PURPOSE values. */
2835 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2836 type
= TREE_TYPE (exp
);
2840 obstack_grow (&permanent_obstack
, (char *) &type
, sizeof type
);
2841 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2842 obstack_grow (&permanent_obstack
, &mode
, sizeof mode
);
2844 obstack_grow (&permanent_obstack
, (char *) &have_purpose
,
2845 sizeof have_purpose
);
2847 /* For arrays, insist that the size in bytes match. */
2848 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2850 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2851 obstack_grow (&permanent_obstack
, (char *) &size
, sizeof size
);
2854 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2856 if (TREE_VALUE (link
))
2857 record_constant_1 (TREE_VALUE (link
));
2862 obstack_grow (&permanent_obstack
,
2863 (char *) &zero
, sizeof zero
);
2866 if (TREE_PURPOSE (link
)
2867 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2868 obstack_grow (&permanent_obstack
,
2869 (char *) &TREE_PURPOSE (link
),
2870 sizeof TREE_PURPOSE (link
));
2871 else if (TREE_PURPOSE (link
))
2872 record_constant_1 (TREE_PURPOSE (link
));
2873 else if (have_purpose
)
2877 obstack_grow (&permanent_obstack
,
2878 (char *) &zero
, sizeof zero
);
2886 struct addr_const value
;
2888 decode_addr_const (exp
, &value
);
2889 /* Record the offset. */
2890 obstack_grow (&permanent_obstack
,
2891 (char *) &value
.offset
, sizeof value
.offset
);
2893 switch (GET_CODE (value
.base
))
2896 /* Record the symbol name. */
2897 obstack_grow (&permanent_obstack
, XSTR (value
.base
, 0),
2898 strlen (XSTR (value
.base
, 0)) + 1);
2901 /* Record the address of the CODE_LABEL. It may not have
2902 been emitted yet, so it's UID may be zero. But pointer
2903 identity is good enough. */
2904 obstack_grow (&permanent_obstack
, &XEXP (value
.base
, 0),
2916 record_constant_1 (TREE_OPERAND (exp
, 0));
2917 record_constant_1 (TREE_OPERAND (exp
, 1));
2922 case NON_LVALUE_EXPR
:
2923 record_constant_1 (TREE_OPERAND (exp
, 0));
2927 if (lang_expand_constant
)
2929 exp
= (*lang_expand_constant
) (exp
);
2930 record_constant_1 (exp
);
2935 /* Record constant contents. */
2936 obstack_grow (&permanent_obstack
, strp
, len
);
2939 /* Record a list of constant expressions that were passed to
2940 output_constant_def but that could not be output right away. */
2942 struct deferred_constant
2944 struct deferred_constant
*next
;
2950 static struct deferred_constant
*deferred_constants
;
2952 /* Another list of constants which should be output after the
2954 static struct deferred_constant
*after_function_constants
;
2956 /* Nonzero means defer output of addressed subconstants
2957 (i.e., those for which output_constant_def is called.) */
2958 static int defer_addressed_constants_flag
;
2960 /* Start deferring output of subconstants. */
2963 defer_addressed_constants ()
2965 defer_addressed_constants_flag
++;
2968 /* Stop deferring output of subconstants,
2969 and output now all those that have been deferred. */
2972 output_deferred_addressed_constants ()
2974 struct deferred_constant
*p
, *next
;
2976 defer_addressed_constants_flag
--;
2978 if (defer_addressed_constants_flag
> 0)
2981 for (p
= deferred_constants
; p
; p
= next
)
2983 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2988 deferred_constants
= 0;
2991 /* Output any constants which should appear after a function. */
2994 output_after_function_constants ()
2996 struct deferred_constant
*p
, *next
;
2998 for (p
= after_function_constants
; p
; p
= next
)
3000 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
3005 after_function_constants
= 0;
3008 /* Make a copy of the whole tree structure for a constant.
3009 This handles the same types of nodes that compare_constant
3010 and record_constant handle. */
3016 switch (TREE_CODE (exp
))
3019 /* For ADDR_EXPR, we do not want to copy the decl whose address
3020 is requested. We do want to copy constants though. */
3021 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
3022 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
3023 copy_constant (TREE_OPERAND (exp
, 0)));
3025 return copy_node (exp
);
3030 return copy_node (exp
);
3033 return build_complex (TREE_TYPE (exp
),
3034 copy_constant (TREE_REALPART (exp
)),
3035 copy_constant (TREE_IMAGPART (exp
)));
3039 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
3040 copy_constant (TREE_OPERAND (exp
, 0)),
3041 copy_constant (TREE_OPERAND (exp
, 1)));
3045 case NON_LVALUE_EXPR
:
3046 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
3047 copy_constant (TREE_OPERAND (exp
, 0)));
3051 tree copy
= copy_node (exp
);
3052 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
3055 CONSTRUCTOR_ELTS (copy
) = list
;
3056 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3057 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
3058 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
3059 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
3060 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
3070 /* Return an rtx representing a reference to constant data in memory
3071 for the constant expression EXP.
3073 If assembler code for such a constant has already been output,
3074 return an rtx to refer to it.
3075 Otherwise, output such a constant in memory (or defer it for later)
3076 and generate an rtx for it.
3078 If DEFER is non-zero, the output of string constants can be deferred
3079 and output only if referenced in the function after all optimizations.
3081 The TREE_CST_RTL of EXP is set up to point to that rtx.
3082 The const_hash_table records which constants already have label strings. */
3085 output_constant_def (exp
, defer
)
3090 register struct constant_descriptor
*desc
;
3091 struct deferred_string
**defstr
;
3095 int after_function
= 0;
3098 if (TREE_CST_RTL (exp
))
3099 return TREE_CST_RTL (exp
);
3101 /* Make sure any other constants whose addresses appear in EXP
3102 are assigned label numbers. */
3104 reloc
= output_addressed_constants (exp
);
3106 /* Compute hash code of EXP. Search the descriptors for that hash code
3107 to see if any of them describes EXP. If yes, the descriptor records
3108 the label number already assigned. */
3110 hash
= const_hash (exp
) % MAX_HASH_TABLE
;
3112 for (desc
= const_hash_table
[hash
]; desc
; desc
= desc
->next
)
3113 if (compare_constant (exp
, desc
))
3118 /* No constant equal to EXP is known to have been output.
3119 Make a constant descriptor to enter EXP in the hash table.
3120 Assign the label number and record it in the descriptor for
3121 future calls to this function to find. */
3123 /* Create a string containing the label name, in LABEL. */
3124 labelno
= const_labelno
++;
3125 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
3127 desc
= record_constant (exp
);
3128 desc
->next
= const_hash_table
[hash
];
3129 desc
->label
= ggc_strdup (label
);
3130 const_hash_table
[hash
] = desc
;
3132 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3134 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
3135 gen_rtx_SYMBOL_REF (Pmode
, desc
->label
));
3137 set_mem_attributes (desc
->rtl
, exp
, 1);
3142 TREE_CST_RTL (exp
) = desc
->rtl
;
3144 /* Optionally set flags or add text to the name to record information
3145 such as that it is a function name. If the name is changed, the macro
3146 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3147 #ifdef ENCODE_SECTION_INFO
3148 /* A previously-processed constant would already have section info
3152 ENCODE_SECTION_INFO (exp
);
3153 desc
->rtl
= TREE_CST_RTL (exp
);
3154 desc
->label
= XSTR (XEXP (desc
->rtl
, 0), 0);
3158 #ifdef CONSTANT_AFTER_FUNCTION_P
3159 if (current_function_decl
!= 0
3160 && CONSTANT_AFTER_FUNCTION_P (exp
))
3165 && STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0))
3166 && (!defer
|| defer_addressed_constants_flag
|| after_function
))
3168 defstr
= (struct deferred_string
**)
3169 htab_find_slot_with_hash (const_str_htab
, desc
->label
,
3170 STRHASH (desc
->label
), NO_INSERT
);
3173 /* If the string is currently deferred but we need to output it now,
3174 remove it from deferred string hash table. */
3176 labelno
= (*defstr
)->labelno
;
3177 STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0)) = 0;
3178 htab_clear_slot (const_str_htab
, (void **) defstr
);
3182 /* If this is the first time we've seen this particular constant,
3183 output it (or defer its output for later). */
3186 if (defer_addressed_constants_flag
|| after_function
)
3188 struct deferred_constant
*p
;
3189 p
= (struct deferred_constant
*) xmalloc (sizeof (struct deferred_constant
));
3191 p
->exp
= copy_constant (exp
);
3193 p
->labelno
= labelno
;
3196 p
->next
= after_function_constants
;
3197 after_function_constants
= p
;
3201 p
->next
= deferred_constants
;
3202 deferred_constants
= p
;
3207 /* Do no output if -fsyntax-only. */
3208 if (! flag_syntax_only
)
3210 if (TREE_CODE (exp
) != STRING_CST
3212 || flag_writable_strings
3213 || (defstr
= (struct deferred_string
**)
3214 htab_find_slot_with_hash (const_str_htab
,
3216 STRHASH (desc
->label
),
3218 output_constant_def_contents (exp
, reloc
, labelno
);
3221 struct deferred_string
*p
;
3223 p
= (struct deferred_string
*)
3224 xmalloc (sizeof (struct deferred_string
));
3226 p
->exp
= copy_constant (exp
);
3227 p
->label
= desc
->label
;
3228 p
->labelno
= labelno
;
3230 STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0)) = 1;
3236 return TREE_CST_RTL (exp
);
3239 /* Now output assembler code to define the label for EXP,
3240 and follow it with the data of EXP. */
3243 output_constant_def_contents (exp
, reloc
, labelno
)
3250 if (IN_NAMED_SECTION (exp
))
3251 named_section (exp
, NULL
, reloc
);
3254 /* First switch to text section, except for writable strings. */
3255 #ifdef SELECT_SECTION
3256 SELECT_SECTION (exp
, reloc
);
3258 if (((TREE_CODE (exp
) == STRING_CST
) && flag_writable_strings
)
3259 || (flag_pic
&& reloc
))
3262 readonly_data_section ();
3266 /* Align the location counter as required by EXP's data type. */
3267 align
= TYPE_ALIGN (TREE_TYPE (exp
));
3268 #ifdef CONSTANT_ALIGNMENT
3269 align
= CONSTANT_ALIGNMENT (exp
, align
);
3272 if (align
> BITS_PER_UNIT
)
3273 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3275 /* Output the label itself. */
3276 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", labelno
);
3278 /* Output the value of EXP. */
3279 output_constant (exp
,
3280 (TREE_CODE (exp
) == STRING_CST
3281 ? MAX (TREE_STRING_LENGTH (exp
),
3282 int_size_in_bytes (TREE_TYPE (exp
)))
3283 : int_size_in_bytes (TREE_TYPE (exp
))));
3287 /* Structure to represent sufficient information about a constant so that
3288 it can be output when the constant pool is output, so that function
3289 integration can be done, and to simplify handling on machines that reference
3290 constant pool as base+displacement. */
3292 struct pool_constant
3294 struct constant_descriptor
*desc
;
3295 struct pool_constant
*next
, *next_sym
;
3298 enum machine_mode mode
;
3305 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3306 The argument is XSTR (... , 0) */
3308 #define SYMHASH(LABEL) \
3309 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3311 /* Initialize constant pool hashing for a new function. */
3314 init_varasm_status (f
)
3317 struct varasm_status
*p
;
3318 p
= (struct varasm_status
*) xmalloc (sizeof (struct varasm_status
));
3320 p
->x_const_rtx_hash_table
3321 = ((struct constant_descriptor
**)
3322 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct constant_descriptor
*)));
3323 p
->x_const_rtx_sym_hash_table
3324 = ((struct pool_constant
**)
3325 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct pool_constant
*)));
3327 p
->x_first_pool
= p
->x_last_pool
= 0;
3328 p
->x_pool_offset
= 0;
3329 p
->x_const_double_chain
= 0;
3332 /* Mark PC for GC. */
3335 mark_pool_constant (pc
)
3336 struct pool_constant
*pc
;
3341 ggc_mark_rtx (pc
->constant
);
3346 /* Mark P for GC. */
3349 mark_varasm_status (p
)
3350 struct varasm_status
*p
;
3355 mark_pool_constant (p
->x_first_pool
);
3356 ggc_mark_rtx (p
->x_const_double_chain
);
3359 /* Clear out all parts of the state in F that can safely be discarded
3360 after the function has been compiled, to let garbage collection
3361 reclaim the memory. */
3364 free_varasm_status (f
)
3367 struct varasm_status
*p
;
3372 /* Clear out the hash tables. */
3373 for (i
= 0; i
< MAX_RTX_HASH_TABLE
; ++i
)
3375 struct constant_descriptor
* cd
;
3377 cd
= p
->x_const_rtx_hash_table
[i
];
3379 struct constant_descriptor
* next
= cd
->next
;
3385 free (p
->x_const_rtx_hash_table
);
3386 free (p
->x_const_rtx_sym_hash_table
);
3392 /* Express an rtx for a constant integer (perhaps symbolic)
3393 as the sum of a symbol or label plus an explicit integer.
3394 They are stored into VALUE. */
3397 decode_rtx_const (mode
, x
, value
)
3398 enum machine_mode mode
;
3400 struct rtx_const
*value
;
3402 /* Clear the whole structure, including any gaps. */
3403 memset (value
, 0, sizeof (struct rtx_const
));
3405 value
->kind
= RTX_INT
; /* Most usual kind. */
3408 switch (GET_CODE (x
))
3411 value
->kind
= RTX_DOUBLE
;
3412 if (GET_MODE (x
) != VOIDmode
)
3414 value
->mode
= GET_MODE (x
);
3415 memcpy ((char *) &value
->un
.du
,
3416 (char *) &CONST_DOUBLE_LOW (x
), sizeof value
->un
.du
);
3420 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
3421 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
3426 value
->un
.addr
.offset
= INTVAL (x
);
3432 value
->un
.addr
.base
= x
;
3437 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3439 value
->un
.addr
.base
= XEXP (x
, 0);
3440 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
3442 else if (GET_CODE (x
) == MINUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3444 value
->un
.addr
.base
= XEXP (x
, 0);
3445 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
3449 value
->un
.addr
.base
= x
;
3450 value
->un
.addr
.offset
= 0;
3458 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0)
3459 switch (GET_CODE (value
->un
.addr
.base
))
3462 /* Use the string's address, not the SYMBOL_REF's address,
3463 for the sake of addresses of library routines. */
3464 value
->un
.addr
.base
= (rtx
) XSTR (value
->un
.addr
.base
, 0);
3468 /* For a LABEL_REF, compare labels. */
3469 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
3476 /* Given a MINUS expression, simplify it if both sides
3477 include the same symbol. */
3480 simplify_subtraction (x
)
3483 struct rtx_const val0
, val1
;
3485 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
3486 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
3488 if (val0
.un
.addr
.base
== val1
.un
.addr
.base
)
3489 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
3493 /* Compute a hash code for a constant RTL expression. */
3496 const_hash_rtx (mode
, x
)
3497 enum machine_mode mode
;
3503 struct rtx_const value
;
3504 decode_rtx_const (mode
, x
, &value
);
3506 /* Compute hashing function */
3508 for (i
= 0; i
< sizeof value
/ sizeof (int); i
++)
3509 hi
+= ((int *) &value
)[i
];
3511 hi
&= (1 << HASHBITS
) - 1;
3512 hi
%= MAX_RTX_HASH_TABLE
;
3516 /* Compare a constant rtl object X with a constant-descriptor DESC.
3517 Return 1 if DESC describes a constant with the same value as X. */
3520 compare_constant_rtx (mode
, x
, desc
)
3521 enum machine_mode mode
;
3523 struct constant_descriptor
*desc
;
3525 register int *p
= (int *) desc
->u
.contents
;
3528 struct rtx_const value
;
3530 decode_rtx_const (mode
, x
, &value
);
3531 strp
= (int *) &value
;
3532 len
= sizeof value
/ sizeof (int);
3534 /* Compare constant contents. */
3536 if (*p
++ != *strp
++)
3542 /* Construct a constant descriptor for the rtl-expression X.
3543 It is up to the caller to enter the descriptor in the hash table. */
3545 static struct constant_descriptor
*
3546 record_constant_rtx (mode
, x
)
3547 enum machine_mode mode
;
3550 struct constant_descriptor
*ptr
;
3552 ptr
= ((struct constant_descriptor
*)
3553 xcalloc (1, (offsetof (struct constant_descriptor
, u
)
3554 + sizeof (struct rtx_const
))));
3555 decode_rtx_const (mode
, x
, (struct rtx_const
*) ptr
->u
.contents
);
3560 /* Given a constant rtx X, make (or find) a memory constant for its value
3561 and return a MEM rtx to refer to it in memory. */
3564 force_const_mem (mode
, x
)
3565 enum machine_mode mode
;
3569 register struct constant_descriptor
*desc
;
3571 const char *found
= 0;
3574 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3575 (this will always be true for floating CONST_DOUBLEs that have been
3576 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3577 use the previous copy. Otherwise, make a new one. Note that in
3578 the unlikely event that this same CONST_DOUBLE is used in two different
3579 modes in an alternating fashion, we will allocate a lot of different
3580 memory locations, but this should be extremely rare. */
3582 if (GET_CODE (x
) == CONST_DOUBLE
3583 && GET_CODE (CONST_DOUBLE_MEM (x
)) == MEM
3584 && GET_MODE (CONST_DOUBLE_MEM (x
)) == mode
)
3585 return CONST_DOUBLE_MEM (x
);
3587 /* Compute hash code of X. Search the descriptors for that hash code
3588 to see if any of them describes X. If yes, the descriptor records
3589 the label number already assigned. */
3591 hash
= const_hash_rtx (mode
, x
);
3593 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3594 if (compare_constant_rtx (mode
, x
, desc
))
3596 found
= desc
->label
;
3602 register struct pool_constant
*pool
;
3605 /* No constant equal to X is known to have been output.
3606 Make a constant descriptor to enter X in the hash table.
3607 Assign the label number and record it in the descriptor for
3608 future calls to this function to find. */
3610 desc
= record_constant_rtx (mode
, x
);
3611 desc
->next
= const_rtx_hash_table
[hash
];
3612 const_rtx_hash_table
[hash
] = desc
;
3614 /* Align the location counter as required by EXP's data type. */
3615 align
= GET_MODE_ALIGNMENT (mode
== VOIDmode
? word_mode
: mode
);
3616 #ifdef CONSTANT_ALIGNMENT
3617 align
= CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode
, 0), x
),
3621 pool_offset
+= (align
/ BITS_PER_UNIT
) - 1;
3622 pool_offset
&= ~ ((align
/ BITS_PER_UNIT
) - 1);
3624 if (GET_CODE (x
) == LABEL_REF
)
3625 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3627 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3629 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3633 pool
->labelno
= const_labelno
;
3634 pool
->align
= align
;
3635 pool
->offset
= pool_offset
;
3642 last_pool
->next
= pool
;
3645 pool_offset
+= GET_MODE_SIZE (mode
);
3647 /* Create a string containing the label name, in LABEL. */
3648 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3652 desc
->label
= found
= ggc_strdup (label
);
3654 /* Add label to symbol hash table. */
3655 hash
= SYMHASH (found
);
3656 pool
->label
= found
;
3657 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3658 const_rtx_sym_hash_table
[hash
] = pool
;
3661 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3663 def
= gen_rtx_MEM (mode
, gen_rtx_SYMBOL_REF (Pmode
, found
));
3664 set_mem_attributes (def
, type_for_mode (mode
, 0), 1);
3665 RTX_UNCHANGING_P (def
) = 1;
3667 /* Mark the symbol_ref as belonging to this constants pool. */
3668 CONSTANT_POOL_ADDRESS_P (XEXP (def
, 0)) = 1;
3669 current_function_uses_const_pool
= 1;
3671 if (GET_CODE (x
) == CONST_DOUBLE
)
3673 if (CONST_DOUBLE_MEM (x
) == cc0_rtx
)
3675 CONST_DOUBLE_CHAIN (x
) = const_double_chain
;
3676 const_double_chain
= x
;
3678 CONST_DOUBLE_MEM (x
) = def
;
3684 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3685 the corresponding pool_constant structure. */
3687 static struct pool_constant
*
3688 find_pool_constant (f
, addr
)
3692 struct pool_constant
*pool
;
3693 const char *label
= XSTR (addr
, 0);
3695 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3696 pool
= pool
->next_sym
)
3697 if (pool
->label
== label
)
3703 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3706 get_pool_constant (addr
)
3709 return (find_pool_constant (cfun
, addr
))->constant
;
3712 /* Likewise, but for the constant pool of a specific function. */
3715 get_pool_constant_for_function (f
, addr
)
3719 return (find_pool_constant (f
, addr
))->constant
;
3722 /* Similar, return the mode. */
3725 get_pool_mode (addr
)
3728 return (find_pool_constant (cfun
, addr
))->mode
;
3732 get_pool_mode_for_function (f
, addr
)
3736 return (find_pool_constant (f
, addr
))->mode
;
3739 /* Similar, return the offset in the constant pool. */
3742 get_pool_offset (addr
)
3745 return (find_pool_constant (cfun
, addr
))->offset
;
3748 /* Return the size of the constant pool. */
3756 /* Write all the constants in the constant pool. */
3759 output_constant_pool (fnname
, fndecl
)
3760 const char *fnname ATTRIBUTE_UNUSED
;
3761 tree fndecl ATTRIBUTE_UNUSED
;
3763 struct pool_constant
*pool
;
3765 union real_extract u
;
3767 /* It is possible for gcc to call force_const_mem and then to later
3768 discard the instructions which refer to the constant. In such a
3769 case we do not need to output the constant. */
3770 mark_constant_pool ();
3772 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3773 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3776 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3785 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3786 whose CODE_LABEL has been deleted. This can occur if a jump table
3787 is eliminated by optimization. If so, write a constant of zero
3788 instead. Note that this can also happen by turning the
3789 CODE_LABEL into a NOTE. */
3790 /* ??? This seems completely and utterly wrong. Certainly it's
3791 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3792 functioning even with INSN_DELETED_P and friends. */
3795 switch (GET_CODE (x
))
3798 if (GET_CODE (XEXP (x
, 0)) != PLUS
3799 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3801 tmp
= XEXP (XEXP (x
, 0), 0);
3806 if (INSN_DELETED_P (tmp
)
3807 || (GET_CODE (tmp
) == NOTE
3808 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
3819 /* First switch to correct section. */
3820 #ifdef SELECT_RTX_SECTION
3821 SELECT_RTX_SECTION (pool
->mode
, x
);
3823 readonly_data_section ();
3826 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3827 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3828 pool
->align
, pool
->labelno
, done
);
3831 assemble_align (pool
->align
);
3833 /* Output the label. */
3834 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", pool
->labelno
);
3836 /* Output the value of the constant itself. */
3837 switch (GET_MODE_CLASS (pool
->mode
))
3840 if (GET_CODE (x
) != CONST_DOUBLE
)
3843 memcpy ((char *) &u
, (char *) &CONST_DOUBLE_LOW (x
), sizeof u
);
3844 assemble_real (u
.d
, pool
->mode
);
3848 case MODE_PARTIAL_INT
:
3849 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), 1);
3856 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3862 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3863 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3866 /* Done with this pool. */
3867 first_pool
= last_pool
= 0;
3870 /* Look through the instructions for this function, and mark all the
3871 entries in the constant pool which are actually being used.
3872 Emit used deferred strings. */
3875 mark_constant_pool ()
3878 struct pool_constant
*pool
;
3880 if (first_pool
== 0 && htab_elements (const_str_htab
) == 0)
3883 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3886 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3888 mark_constants (PATTERN (insn
));
3890 for (insn
= current_function_epilogue_delay_list
;
3892 insn
= XEXP (insn
, 1))
3894 mark_constants (PATTERN (insn
));
3897 /* Look through appropriate parts of X, marking all entries in the
3898 constant pool which are actually being used. Entries that are only
3899 referenced by other constants are also marked as used. Emit
3900 deferred strings that are used. */
3907 register const char *format_ptr
;
3912 if (GET_CODE (x
) == SYMBOL_REF
)
3914 mark_constant (&x
, NULL
);
3917 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3918 a MEM, but does not constitute a use of that MEM. */
3919 else if (GET_CODE (x
) == CONST_DOUBLE
)
3922 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3923 insns, not any notes that may be attached. We don't want to mark
3924 a constant just because it happens to appear in a REG_EQUIV note. */
3927 mark_constants (PATTERN (x
));
3931 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3933 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3935 switch (*format_ptr
++)
3938 mark_constants (XEXP (x
, i
));
3942 if (XVEC (x
, i
) != 0)
3946 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3947 mark_constants (XVECEXP (x
, i
, j
));
3966 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3967 to as used. Emit referenced deferred strings. This function can
3968 be used with for_each_rtx () to mark all SYMBOL_REFs in an rtx. */
3971 mark_constant (current_rtx
, data
)
3973 void *data ATTRIBUTE_UNUSED
;
3975 rtx x
= *current_rtx
;
3979 else if (GET_CODE(x
) == CONST_DOUBLE
)
3980 /* Never search inside a CONST_DOUBLE because CONST_DOUBLE_MEM may
3981 be a MEM but does not constitute a use of that MEM. */
3983 else if (GET_CODE (x
) == SYMBOL_REF
)
3985 if (CONSTANT_POOL_ADDRESS_P (x
))
3987 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
3988 if (pool
->mark
== 0) {
3990 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
3995 else if (STRING_POOL_ADDRESS_P (x
))
3997 struct deferred_string
**defstr
;
3999 defstr
= (struct deferred_string
**)
4000 htab_find_slot_with_hash (const_str_htab
, XSTR (x
, 0),
4001 STRHASH (XSTR (x
, 0)), NO_INSERT
);
4004 struct deferred_string
*p
= *defstr
;
4006 STRING_POOL_ADDRESS_P (x
) = 0;
4007 output_constant_def_contents (p
->exp
, 0, p
->labelno
);
4008 htab_clear_slot (const_str_htab
, (void **) defstr
);
4015 /* Find all the constants whose addresses are referenced inside of EXP,
4016 and make sure assembler code with a label has been output for each one.
4017 Indicate whether an ADDR_EXPR has been encountered. */
4020 output_addressed_constants (exp
)
4025 /* Give the front-end a chance to convert VALUE to something that
4026 looks more like a constant to the back-end. */
4027 if (lang_expand_constant
)
4028 exp
= (*lang_expand_constant
) (exp
);
4030 switch (TREE_CODE (exp
))
4034 register tree constant
= TREE_OPERAND (exp
, 0);
4036 while (TREE_CODE (constant
) == COMPONENT_REF
)
4038 constant
= TREE_OPERAND (constant
, 0);
4041 if (TREE_CODE_CLASS (TREE_CODE (constant
)) == 'c'
4042 || TREE_CODE (constant
) == CONSTRUCTOR
)
4043 /* No need to do anything here
4044 for addresses of variables or functions. */
4045 output_constant_def (constant
, 0);
4052 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
4053 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
4058 case NON_LVALUE_EXPR
:
4059 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
4065 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
4066 if (TREE_VALUE (link
) != 0)
4067 reloc
|= output_addressed_constants (TREE_VALUE (link
));
4077 /* Return nonzero if VALUE is a valid constant-valued expression
4078 for use in initializing a static variable; one that can be an
4079 element of a "constant" initializer.
4081 Return null_pointer_node if the value is absolute;
4082 if it is relocatable, return the variable that determines the relocation.
4083 We assume that VALUE has been folded as much as possible;
4084 therefore, we do not need to check for such things as
4085 arithmetic-combinations of integers. */
4088 initializer_constant_valid_p (value
, endtype
)
4092 /* Give the front-end a chance to convert VALUE to something that
4093 looks more like a constant to the back-end. */
4094 if (lang_expand_constant
)
4095 value
= (*lang_expand_constant
) (value
);
4097 switch (TREE_CODE (value
))
4100 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
4101 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
4102 && TREE_CONSTANT (value
)
4103 && CONSTRUCTOR_ELTS (value
))
4105 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
4108 return TREE_STATIC (value
) ? null_pointer_node
: 0;
4114 return null_pointer_node
;
4117 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
4119 case NON_LVALUE_EXPR
:
4120 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4124 /* Allow conversions between pointer types. */
4125 if (POINTER_TYPE_P (TREE_TYPE (value
))
4126 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4127 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4129 /* Allow conversions between real types. */
4130 if (FLOAT_TYPE_P (TREE_TYPE (value
))
4131 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4132 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4134 /* Allow length-preserving conversions between integer types. */
4135 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4136 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4137 && (TYPE_PRECISION (TREE_TYPE (value
))
4138 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4139 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
4141 /* Allow conversions between other integer types only if
4143 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4144 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4146 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4148 if (inner
== null_pointer_node
)
4149 return null_pointer_node
;
4153 /* Allow (int) &foo provided int is as wide as a pointer. */
4154 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
4155 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
4156 && (TYPE_PRECISION (TREE_TYPE (value
))
4157 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
4158 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4161 /* Likewise conversions from int to pointers, but also allow
4162 conversions from 0. */
4163 if (POINTER_TYPE_P (TREE_TYPE (value
))
4164 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4166 if (integer_zerop (TREE_OPERAND (value
, 0)))
4167 return null_pointer_node
;
4168 else if (TYPE_PRECISION (TREE_TYPE (value
))
4169 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
4170 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4174 /* Allow conversions to union types if the value inside is okay. */
4175 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
4176 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4181 if (! INTEGRAL_TYPE_P (endtype
)
4182 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4184 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4186 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4188 /* If either term is absolute, use the other terms relocation. */
4189 if (valid0
== null_pointer_node
)
4191 if (valid1
== null_pointer_node
)
4197 if (! INTEGRAL_TYPE_P (endtype
)
4198 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4200 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4202 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4204 /* Win if second argument is absolute. */
4205 if (valid1
== null_pointer_node
)
4207 /* Win if both arguments have the same relocation.
4208 Then the value is absolute. */
4209 if (valid0
== valid1
&& valid0
!= 0)
4210 return null_pointer_node
;
4212 /* Since GCC guarantees that string constants are unique in the
4213 generated code, a subtraction between two copies of the same
4214 constant string is absolute. */
4215 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
&&
4216 valid1
&& TREE_CODE (valid1
) == STRING_CST
&&
4217 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
4218 return null_pointer_node
;
4221 /* Support differences between labels. */
4222 if (INTEGRAL_TYPE_P (endtype
))
4225 op0
= TREE_OPERAND (value
, 0);
4226 op1
= TREE_OPERAND (value
, 1);
4230 if (TREE_CODE (op0
) == ADDR_EXPR
4231 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
4232 && TREE_CODE (op1
) == ADDR_EXPR
4233 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
4234 return null_pointer_node
;
4245 /* Output assembler code for constant EXP to FILE, with no label.
4246 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4247 Assumes output_addressed_constants has been done on EXP already.
4249 Generate exactly SIZE bytes of assembler data, padding at the end
4250 with zeros if necessary. SIZE must always be specified.
4252 SIZE is important for structure constructors,
4253 since trailing members may have been omitted from the constructor.
4254 It is also important for initialization of arrays from string constants
4255 since the full length of the string constant might not be wanted.
4256 It is also needed for initialization of unions, where the initializer's
4257 type is just one member, and that may not be as long as the union.
4259 There a case in which we would fail to output exactly SIZE bytes:
4260 for a structure constructor that wants to produce more than SIZE bytes.
4261 But such constructors will never be generated for any possible input. */
4264 output_constant (exp
, size
)
4268 register enum tree_code code
= TREE_CODE (TREE_TYPE (exp
));
4270 /* Some front-ends use constants other than the standard
4271 language-indepdent varieties, but which may still be output
4272 directly. Give the front-end a chance to convert EXP to a
4273 language-independent representation. */
4274 if (lang_expand_constant
)
4276 exp
= (*lang_expand_constant
) (exp
);
4277 code
= TREE_CODE (TREE_TYPE (exp
));
4280 if (size
== 0 || flag_syntax_only
)
4283 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4284 That way we get the constant (we hope) inside it. Also, strip off any
4285 NOP_EXPR that converts between two record, union, array, or set types
4286 or a CONVERT_EXPR that converts to a union TYPE. */
4287 while ((TREE_CODE (exp
) == NOP_EXPR
4288 && (TREE_TYPE (exp
) == TREE_TYPE (TREE_OPERAND (exp
, 0))
4289 || AGGREGATE_TYPE_P (TREE_TYPE (exp
))))
4290 || (TREE_CODE (exp
) == CONVERT_EXPR
4291 && code
== UNION_TYPE
)
4292 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4294 exp
= TREE_OPERAND (exp
, 0);
4295 code
= TREE_CODE (TREE_TYPE (exp
));
4298 /* Allow a constructor with no elements for any data type.
4299 This means to fill the space with zeros. */
4300 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
4302 assemble_zeros (size
);
4313 case REFERENCE_TYPE
:
4314 /* ??? What about (int)((float)(int)&foo + 4) */
4315 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
4316 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4317 exp
= TREE_OPERAND (exp
, 0);
4319 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4320 EXPAND_INITIALIZER
),
4322 error ("initializer for integer value is too complicated");
4327 if (TREE_CODE (exp
) != REAL_CST
)
4328 error ("initializer for floating value is not a floating constant");
4330 assemble_real (TREE_REAL_CST (exp
),
4331 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0));
4336 output_constant (TREE_REALPART (exp
), size
/ 2);
4337 output_constant (TREE_IMAGPART (exp
), size
/ 2);
4338 size
-= (size
/ 2) * 2;
4342 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4344 output_constructor (exp
, size
);
4347 else if (TREE_CODE (exp
) == STRING_CST
)
4351 if (size
> TREE_STRING_LENGTH (exp
))
4353 excess
= size
- TREE_STRING_LENGTH (exp
);
4354 size
= TREE_STRING_LENGTH (exp
);
4357 assemble_string (TREE_STRING_POINTER (exp
), size
);
4366 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4367 output_constructor (exp
, size
);
4373 if (TREE_CODE (exp
) == INTEGER_CST
)
4374 assemble_integer (expand_expr (exp
, NULL_RTX
,
4375 VOIDmode
, EXPAND_INITIALIZER
),
4377 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
4379 unsigned char *buffer
= (unsigned char *) alloca (size
);
4380 if (get_set_constructor_bytes (exp
, buffer
, size
))
4382 assemble_string ((char *) buffer
, size
);
4385 error ("unknown set constructor type");
4393 assemble_zeros (size
);
4397 /* Subroutine of output_constructor, used for computing the size of
4398 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4399 type with an unspecified upper bound. */
4401 static unsigned HOST_WIDE_INT
4402 array_size_for_constructor (val
)
4407 max_index
= NULL_TREE
;
4408 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
4410 tree index
= TREE_PURPOSE (i
);
4412 if (TREE_CODE (index
) == RANGE_EXPR
)
4413 index
= TREE_OPERAND (index
, 1);
4414 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4418 if (max_index
== NULL_TREE
)
4421 /* Compute the total number of array elements. */
4422 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
4424 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
4425 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
4427 /* Multiply by the array element unit size to find number of bytes. */
4428 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4430 return tree_low_cst (i
, 1);
4433 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4434 Generate at least SIZE bytes, padding if necessary. */
4437 output_constructor (exp
, size
)
4441 tree type
= TREE_TYPE (exp
);
4442 register tree link
, field
= 0;
4444 /* Number of bytes output or skipped so far.
4445 In other words, current position within the constructor. */
4446 HOST_WIDE_INT total_bytes
= 0;
4447 /* Non-zero means BYTE contains part of a byte, to be output. */
4448 int byte_buffer_in_use
= 0;
4449 register int byte
= 0;
4451 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4454 if (TREE_CODE (type
) == RECORD_TYPE
)
4455 field
= TYPE_FIELDS (type
);
4457 if (TREE_CODE (type
) == ARRAY_TYPE
4458 && TYPE_DOMAIN (type
) != 0)
4459 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4461 /* As LINK goes through the elements of the constant,
4462 FIELD goes through the structure fields, if the constant is a structure.
4463 if the constant is a union, then we override this,
4464 by getting the field from the TREE_LIST element.
4465 But the constant could also be an array. Then FIELD is zero.
4467 There is always a maximum of one element in the chain LINK for unions
4468 (even if the initializer in a source program incorrectly contains
4470 for (link
= CONSTRUCTOR_ELTS (exp
);
4472 link
= TREE_CHAIN (link
),
4473 field
= field
? TREE_CHAIN (field
) : 0)
4475 tree val
= TREE_VALUE (link
);
4478 /* The element in a union constructor specifies the proper field
4480 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4481 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4482 && TREE_PURPOSE (link
) != 0)
4483 field
= TREE_PURPOSE (link
);
4485 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4486 index
= TREE_PURPOSE (link
);
4488 /* Eliminate the marker that makes a cast not be an lvalue. */
4492 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4494 unsigned HOST_WIDE_INT fieldsize
4495 = int_size_in_bytes (TREE_TYPE (type
));
4496 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4497 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4498 HOST_WIDE_INT index
;
4500 for (index
= lo_index
; index
<= hi_index
; index
++)
4502 /* Output the element's initial value. */
4504 assemble_zeros (fieldsize
);
4506 output_constant (val
, fieldsize
);
4508 /* Count its size. */
4509 total_bytes
+= fieldsize
;
4512 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4514 /* An element that is not a bit-field. */
4516 unsigned HOST_WIDE_INT fieldsize
;
4517 /* Since this structure is static,
4518 we know the positions are constant. */
4519 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4522 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4523 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4525 /* Output any buffered-up bit-fields preceding this element. */
4526 if (byte_buffer_in_use
)
4528 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4530 byte_buffer_in_use
= 0;
4533 /* Advance to offset of this element.
4534 Note no alignment needed in an array, since that is guaranteed
4535 if each element has the proper size. */
4536 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4538 assemble_zeros (pos
- total_bytes
);
4542 else if (field
!= 0 && DECL_PACKED (field
))
4543 /* Some assemblers automaticallly align a datum according to its
4544 size if no align directive is specified. The datum, however,
4545 may be declared with 'packed' attribute, so we have to disable
4547 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
4549 /* Determine size this element should occupy. */
4554 /* If this is an array with an unspecified upper bound,
4555 the initializer determines the size. */
4556 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4557 but we cannot do this until the deprecated support for
4558 initializing zero-length array members is removed. */
4559 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4560 && TYPE_DOMAIN (TREE_TYPE (field
))
4561 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4563 fieldsize
= array_size_for_constructor (val
);
4564 /* Given a non-empty initialization, this field had
4566 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4569 else if (DECL_SIZE_UNIT (field
))
4571 /* ??? This can't be right. If the decl size overflows
4572 a host integer we will silently emit no data. */
4573 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4574 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4578 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4580 /* Output the element's initial value. */
4582 assemble_zeros (fieldsize
);
4584 output_constant (val
, fieldsize
);
4586 /* Count its size. */
4587 total_bytes
+= fieldsize
;
4589 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4590 error ("invalid initial value for member `%s'",
4591 IDENTIFIER_POINTER (DECL_NAME (field
)));
4594 /* Element that is a bit-field. */
4596 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4597 HOST_WIDE_INT end_offset
4598 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4601 val
= integer_zero_node
;
4603 /* If this field does not start in this (or, next) byte,
4605 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4607 /* Output remnant of any bit field in previous bytes. */
4608 if (byte_buffer_in_use
)
4610 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4612 byte_buffer_in_use
= 0;
4615 /* If still not at proper byte, advance to there. */
4616 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4618 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4619 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4623 if (! byte_buffer_in_use
)
4626 /* We must split the element into pieces that fall within
4627 separate bytes, and combine each byte with previous or
4628 following bit-fields. */
4630 /* next_offset is the offset n fbits from the beginning of
4631 the structure to the next bit of this element to be processed.
4632 end_offset is the offset of the first bit past the end of
4634 while (next_offset
< end_offset
)
4638 HOST_WIDE_INT value
;
4639 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4640 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4642 /* Advance from byte to byte
4643 within this element when necessary. */
4644 while (next_byte
!= total_bytes
)
4646 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4651 /* Number of bits we can process at once
4652 (all part of the same byte). */
4653 this_time
= MIN (end_offset
- next_offset
,
4654 BITS_PER_UNIT
- next_bit
);
4655 if (BYTES_BIG_ENDIAN
)
4657 /* On big-endian machine, take the most significant bits
4658 first (of the bits that are significant)
4659 and put them into bytes from the most significant end. */
4660 shift
= end_offset
- next_offset
- this_time
;
4662 /* Don't try to take a bunch of bits that cross
4663 the word boundary in the INTEGER_CST. We can
4664 only select bits from the LOW or HIGH part
4666 if (shift
< HOST_BITS_PER_WIDE_INT
4667 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4669 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4670 shift
= HOST_BITS_PER_WIDE_INT
;
4673 /* Now get the bits from the appropriate constant word. */
4674 if (shift
< HOST_BITS_PER_WIDE_INT
)
4675 value
= TREE_INT_CST_LOW (val
);
4676 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4678 value
= TREE_INT_CST_HIGH (val
);
4679 shift
-= HOST_BITS_PER_WIDE_INT
;
4684 /* Get the result. This works only when:
4685 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4686 byte
|= (((value
>> shift
)
4687 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4688 << (BITS_PER_UNIT
- this_time
- next_bit
));
4692 /* On little-endian machines,
4693 take first the least significant bits of the value
4694 and pack them starting at the least significant
4695 bits of the bytes. */
4696 shift
= next_offset
- int_bit_position (field
);
4698 /* Don't try to take a bunch of bits that cross
4699 the word boundary in the INTEGER_CST. We can
4700 only select bits from the LOW or HIGH part
4702 if (shift
< HOST_BITS_PER_WIDE_INT
4703 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4704 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4706 /* Now get the bits from the appropriate constant word. */
4707 if (shift
< HOST_BITS_PER_WIDE_INT
)
4708 value
= TREE_INT_CST_LOW (val
);
4709 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4711 value
= TREE_INT_CST_HIGH (val
);
4712 shift
-= HOST_BITS_PER_WIDE_INT
;
4717 /* Get the result. This works only when:
4718 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4719 byte
|= (((value
>> shift
)
4720 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4724 next_offset
+= this_time
;
4725 byte_buffer_in_use
= 1;
4730 if (byte_buffer_in_use
)
4732 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4736 if (total_bytes
< size
)
4737 assemble_zeros (size
- total_bytes
);
4740 #ifdef HANDLE_PRAGMA_WEAK
4741 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4742 associatd with NAME. */
4745 add_weak (name
, value
)
4749 struct weak_syms
*weak
;
4751 weak
= (struct weak_syms
*) permalloc (sizeof (struct weak_syms
));
4756 weak
->next
= weak_decls
;
4758 weak
->value
= value
;
4763 #endif /* HANDLE_PRAGMA_WEAK */
4765 /* Declare DECL to be a weak symbol. */
4771 if (! TREE_PUBLIC (decl
))
4772 error_with_decl (decl
, "weak declaration of `%s' must be public");
4773 else if (TREE_ASM_WRITTEN (decl
))
4774 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4775 else if (SUPPORTS_WEAK
)
4776 DECL_WEAK (decl
) = 1;
4777 #ifdef HANDLE_PRAGMA_WEAK
4778 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), NULL
);
4782 /* Emit any pending weak declarations. */
4784 #ifdef HANDLE_PRAGMA_WEAK
4785 struct weak_syms
* weak_decls
;
4791 #ifdef HANDLE_PRAGMA_WEAK
4792 if (HANDLE_PRAGMA_WEAK
)
4794 struct weak_syms
*t
;
4795 for (t
= weak_decls
; t
; t
= t
->next
)
4798 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, t
->name
, t
->value
);
4804 /* Remove NAME from the pending list of weak symbols. This prevents
4805 the compiler from emitting multiple .weak directives which confuses
4807 #ifdef ASM_WEAKEN_LABEL
4809 remove_from_pending_weak_list (name
)
4810 const char *name ATTRIBUTE_UNUSED
;
4812 #ifdef HANDLE_PRAGMA_WEAK
4813 if (HANDLE_PRAGMA_WEAK
)
4815 struct weak_syms
*t
;
4816 for (t
= weak_decls
; t
; t
= t
->next
)
4818 if (t
->name
&& strcmp (name
, t
->name
) == 0)
4827 assemble_alias (decl
, target
)
4828 tree decl
, target ATTRIBUTE_UNUSED
;
4832 /* We must force creation of DECL_RTL for debug info generation, even though
4833 we don't use it here. */
4834 make_decl_rtl (decl
, NULL
);
4836 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4838 #ifdef ASM_OUTPUT_DEF
4839 /* Make name accessible from other files, if appropriate. */
4841 if (TREE_PUBLIC (decl
))
4843 #ifdef ASM_WEAKEN_LABEL
4844 if (DECL_WEAK (decl
))
4846 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4847 /* Remove this function from the pending weak list so that
4848 we do not emit multiple .weak directives for it. */
4849 remove_from_pending_weak_list
4850 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4854 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
4857 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4858 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4860 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4862 TREE_ASM_WRITTEN (decl
) = 1;
4864 #ifdef ASM_OUTPUT_WEAK_ALIAS
4865 if (! DECL_WEAK (decl
))
4866 warning ("only weak aliases are supported in this configuration");
4868 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4869 TREE_ASM_WRITTEN (decl
) = 1;
4871 warning ("alias definitions not supported in this configuration; ignored");
4876 /* Returns 1 if the target configuration supports defining public symbols
4877 so that one of them will be chosen at link time instead of generating a
4878 multiply-defined symbol error, whether through the use of weak symbols or
4879 a target-specific mechanism for having duplicates discarded. */
4882 supports_one_only ()
4884 if (SUPPORTS_ONE_ONLY
)
4886 return SUPPORTS_WEAK
;
4889 /* Set up DECL as a public symbol that can be defined in multiple
4890 translation units without generating a linker error. */
4893 make_decl_one_only (decl
)
4896 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4899 TREE_PUBLIC (decl
) = 1;
4901 if (TREE_CODE (decl
) == VAR_DECL
4902 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4903 DECL_COMMON (decl
) = 1;
4904 else if (SUPPORTS_ONE_ONLY
)
4906 #ifdef MAKE_DECL_ONE_ONLY
4907 MAKE_DECL_ONE_ONLY (decl
);
4909 DECL_ONE_ONLY (decl
) = 1;
4911 else if (SUPPORTS_WEAK
)
4912 DECL_WEAK (decl
) = 1;
4920 const_str_htab
= htab_create (128, const_str_htab_hash
, const_str_htab_eq
,
4921 const_str_htab_del
);
4922 in_named_htab
= htab_create (31, in_named_entry_hash
,
4923 in_named_entry_eq
, NULL
);
4925 ggc_add_root (const_hash_table
, MAX_HASH_TABLE
, sizeof const_hash_table
[0],
4926 mark_const_hash_entry
);
4927 ggc_add_root (&const_str_htab
, 1, sizeof const_str_htab
,
4928 mark_const_str_htab
);
4931 /* Select a set of attributes for section NAME based on the properties
4932 of DECL and whether or not RELOC indicates that DECL's initializer
4933 might contain runtime relocations.
4935 We make the section read-only and executable for a function decl,
4936 read-only for a const data decl, and writable for a non-const data decl. */
4939 default_section_type_flags (decl
, name
, reloc
)
4946 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4947 flags
= SECTION_CODE
;
4948 else if (decl
&& DECL_READONLY_SECTION (decl
, reloc
))
4951 flags
= SECTION_WRITE
;
4953 if (decl
&& DECL_ONE_ONLY (decl
))
4954 flags
|= SECTION_LINKONCE
;
4956 if (strcmp (name
, ".bss") == 0
4957 || strncmp (name
, ".bss.", 5) == 0
4958 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4959 || strcmp (name
, ".sbss") == 0
4960 || strncmp (name
, ".sbss.", 6) == 0
4961 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
4962 flags
|= SECTION_BSS
;
4967 /* Output assembly to switch to section NAME with attribute FLAGS.
4968 Four variants for common object file formats. */
4971 default_no_named_section (name
, flags
)
4972 const char *name ATTRIBUTE_UNUSED
;
4973 unsigned int flags ATTRIBUTE_UNUSED
;
4975 /* Some object formats don't support named sections at all. The
4976 front-end should already have flagged this as an error. */
4981 default_elf_asm_named_section (name
, flags
)
4985 char flagchars
[8], *f
= flagchars
;
4988 if (!(flags
& SECTION_DEBUG
))
4990 if (flags
& SECTION_WRITE
)
4992 if (flags
& SECTION_CODE
)
4994 if (flags
& SECTION_SMALL
)
4998 if (flags
& SECTION_BSS
)
5003 fprintf (asm_out_file
, "\t.section\t%s,\"%s\",@%s\n",
5004 name
, flagchars
, type
);
5008 default_coff_asm_named_section (name
, flags
)
5012 char flagchars
[8], *f
= flagchars
;
5014 if (flags
& SECTION_WRITE
)
5016 if (flags
& SECTION_CODE
)
5020 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
5024 default_pe_asm_named_section (name
, flags
)
5028 default_coff_asm_named_section (name
, flags
);
5030 if (flags
& SECTION_LINKONCE
)
5032 /* Functions may have been compiled at various levels of
5033 optimization so we can't use `same_size' here.
5034 Instead, have the linker pick one. */
5035 fprintf (asm_out_file
, "\t.linkonce %s\n",
5036 (flags
& SECTION_CODE
? "discard" : "same_size"));