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 GCC.
7 GCC is free software; you can redistribute it and/or modify it under
8 the terms of the GNU General Public License as published by the Free
9 Software Foundation; either version 2, or (at your option) any later
12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
14 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
17 You should have received a copy of the GNU General Public License
18 along with GCC; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
37 #include "hard-reg-set.h"
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 unsigned min_align PARAMS ((unsigned, unsigned));
165 static void output_constructor PARAMS ((tree, int, unsigned));
166 static void remove_from_pending_weak_list PARAMS ((const char *));
167 static int in_named_entry_eq PARAMS ((const PTR, const PTR));
168 static hashval_t in_named_entry_hash PARAMS ((const PTR));
169 #ifdef ASM_OUTPUT_BSS
170 static void asm_output_bss PARAMS ((FILE *, tree, const char *, int, int));
172 #ifdef BSS_SECTION_ASM_OP
173 #ifdef ASM_OUTPUT_ALIGNED_BSS
174 static void asm_output_aligned_bss PARAMS ((FILE *, tree, const char *,
177 #endif /* BSS_SECTION_ASM_OP */
178 static void mark_pool_constant PARAMS ((struct pool_constant *));
179 static void mark_const_hash_entry PARAMS ((void *));
180 static int mark_const_str_htab_1 PARAMS ((void **, void *));
181 static void mark_const_str_htab PARAMS ((void *));
182 static hashval_t const_str_htab_hash PARAMS ((const void *x));
183 static int const_str_htab_eq PARAMS ((const void *x, const void *y));
184 static void const_str_htab_del PARAMS ((void *));
185 static void asm_emit_uninitialised PARAMS ((tree, const char*, int, int));
186 static void resolve_unique_section PARAMS ((tree, int));
188 static enum in_section { no_section, in_text, in_data, in_named
189 #ifdef BSS_SECTION_ASM_OP
192 #ifdef CTORS_SECTION_ASM_OP
195 #ifdef DTORS_SECTION_ASM_OP
198 #ifdef EXTRA_SECTIONS
201 } in_section = no_section;
203 /* Return a non-zero value if DECL has a section attribute. */
204 #ifndef IN_NAMED_SECTION
205 #define IN_NAMED_SECTION(DECL) \
206 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
207 && DECL_SECTION_NAME (DECL) != NULL_TREE)
210 /* Text of section name when in_section == in_named. */
211 static const char *in_named_name;
213 /* Hash table of flags that have been used for a particular named section. */
215 struct in_named_entry
221 static htab_t in_named_htab;
223 /* Define functions like text_section for any extra sections. */
224 #ifdef EXTRA_SECTION_FUNCTIONS
225 EXTRA_SECTION_FUNCTIONS
228 /* Tell assembler to switch to text section. */
233 if (in_section != in_text)
238 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
240 in_section = in_text;
244 /* Tell assembler to switch to data section. */
249 if (in_section != in_data)
251 if (flag_shared_data)
253 #ifdef SHARED_SECTION_ASM_OP
254 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
256 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
260 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
262 in_section = in_data;
265 /* Tell assembler to ALWAYS switch to data section, in case
266 it's not sure where it is. */
269 force_data_section ()
271 in_section = no_section;
275 /* Tell assembler to switch to read-only data section. This is normally
279 readonly_data_section ()
281 #ifdef READONLY_DATA_SECTION
282 READONLY_DATA_SECTION (); /* Note this can call data_section. */
288 /* Determine if we're in the text section. */
293 return in_section == in_text;
296 /* Determine if we're in the data section. */
301 return in_section == in_data;
304 /* Helper routines for maintaining in_named_htab. */
307 in_named_entry_eq (p1, p2)
311 const struct in_named_entry *old = p1;
312 const char *new = p2;
314 return strcmp (old->name, new) == 0;
318 in_named_entry_hash (p)
321 const struct in_named_entry *old = p;
322 return htab_hash_string (old->name);
325 /* If SECTION has been seen before as a named section, return the flags
326 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
327 set of flags for a section to have, so 0 does not mean that the section
328 has not been seen. */
331 get_named_section_flags (section)
334 struct in_named_entry **slot;
336 slot = (struct in_named_entry**)
337 htab_find_slot_with_hash (in_named_htab, section,
338 htab_hash_string (section), NO_INSERT);
340 return slot ? (*slot)->flags : 0;
343 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
344 different set of flags, return false. */
347 set_named_section_flags (section, flags)
351 struct in_named_entry **slot, *entry;
353 slot = (struct in_named_entry**)
354 htab_find_slot_with_hash (in_named_htab, section,
355 htab_hash_string (section), INSERT);
360 entry = (struct in_named_entry *) xmalloc (sizeof (*entry));
362 entry->name = ggc_strdup (section);
363 entry->flags = flags;
365 else if (entry->flags != flags)
371 /* Tell assembler to change to section NAME with attributes FLAGS. */
374 named_section_flags (name, flags)
378 if (in_section != in_named || strcmp (name, in_named_name) != 0)
380 if (! set_named_section_flags (name, flags))
383 (* targetm.asm_out.named_section) (name, flags);
385 if (flags & SECTION_FORGET)
386 in_section = no_section;
389 in_named_name = ggc_strdup (name);
390 in_section = in_named;
395 /* Tell assembler to change to section NAME for DECL.
396 If DECL is NULL, just switch to section NAME.
397 If NAME is NULL, get the name from DECL.
398 If RELOC is 1, the initializer for DECL contains relocs. */
401 named_section (decl, name, reloc)
408 if (decl != NULL_TREE && !DECL_P (decl))
411 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
413 flags = (* targetm.section_type_flags) (decl, name, reloc);
415 /* Sanity check user variables for flag changes. Non-user
416 section flag changes will abort in named_section_flags. */
417 if (decl && ! set_named_section_flags (name, flags))
419 error_with_decl (decl, "%s causes a section type conflict");
420 flags = get_named_section_flags (name);
423 named_section_flags (name, flags);
426 /* If required, set DECL_SECTION_NAME to a unique name. */
429 resolve_unique_section (decl, reloc)
431 int reloc ATTRIBUTE_UNUSED;
433 if (DECL_SECTION_NAME (decl) == NULL_TREE
434 && (flag_function_sections
435 || (targetm.have_named_sections
436 && DECL_ONE_ONLY (decl))))
437 UNIQUE_SECTION (decl, reloc);
440 #ifdef BSS_SECTION_ASM_OP
442 /* Tell the assembler to switch to the bss section. */
447 if (in_section != in_bss)
449 #ifdef SHARED_BSS_SECTION_ASM_OP
450 if (flag_shared_data)
451 fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
454 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
460 #ifdef ASM_OUTPUT_BSS
462 /* Utility function for ASM_OUTPUT_BSS for targets to use if
463 they don't support alignments in .bss.
464 ??? It is believed that this function will work in most cases so such
465 support is localized here. */
468 asm_output_bss (file, decl, name, size, rounded)
470 tree decl ATTRIBUTE_UNUSED;
472 int size ATTRIBUTE_UNUSED, rounded;
474 ASM_GLOBALIZE_LABEL (file, name);
476 #ifdef ASM_DECLARE_OBJECT_NAME
477 last_assemble_variable_decl = decl;
478 ASM_DECLARE_OBJECT_NAME (file, name, decl);
480 /* Standard thing is just output label for the object. */
481 ASM_OUTPUT_LABEL (file, name);
482 #endif /* ASM_DECLARE_OBJECT_NAME */
483 ASM_OUTPUT_SKIP (file, rounded);
488 #ifdef ASM_OUTPUT_ALIGNED_BSS
490 /* Utility function for targets to use in implementing
491 ASM_OUTPUT_ALIGNED_BSS.
492 ??? It is believed that this function will work in most cases so such
493 support is localized here. */
496 asm_output_aligned_bss (file, decl, name, size, align)
502 ASM_GLOBALIZE_LABEL (file, name);
504 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
505 #ifdef ASM_DECLARE_OBJECT_NAME
506 last_assemble_variable_decl = decl;
507 ASM_DECLARE_OBJECT_NAME (file, name, decl);
509 /* Standard thing is just output label for the object. */
510 ASM_OUTPUT_LABEL (file, name);
511 #endif /* ASM_DECLARE_OBJECT_NAME */
512 ASM_OUTPUT_SKIP (file, size ? size : 1);
517 #endif /* BSS_SECTION_ASM_OP */
519 /* Switch to the section for function DECL.
521 If DECL is NULL_TREE, switch to the text section.
522 ??? It's not clear that we will ever be passed NULL_TREE, but it's
523 safer to handle it. */
526 function_section (decl)
529 if (decl != NULL_TREE
530 && DECL_SECTION_NAME (decl) != NULL_TREE)
531 named_section (decl, (char *) 0, 0);
536 /* Switch to section for variable DECL.
538 RELOC is the `reloc' argument to SELECT_SECTION. */
541 variable_section (decl, reloc)
545 if (IN_NAMED_SECTION (decl))
546 named_section (decl, NULL, reloc);
549 /* C++ can have const variables that get initialized from constructors,
550 and thus can not be in a readonly section. We prevent this by
551 verifying that the initial value is constant for objects put in a
554 error_mark_node is used by the C front end to indicate that the
555 initializer has not been seen yet. In this case, we assume that
556 the initializer must be constant.
558 C++ uses error_mark_node for variables that have complicated
559 initializers, but these variables go in BSS so we won't be called
562 #ifdef SELECT_SECTION
563 SELECT_SECTION (decl, reloc);
565 if (DECL_READONLY_SECTION (decl, reloc))
566 readonly_data_section ();
573 /* Tell assembler to switch to the section for the exception handling
579 #if defined (EXCEPTION_SECTION)
580 EXCEPTION_SECTION ();
582 if (targetm.have_named_sections)
583 named_section (NULL_TREE, ".gcc_except_table", 0);
587 readonly_data_section ();
591 /* Given NAME, a putative register name, discard any customary prefixes. */
594 strip_reg_name (name)
597 #ifdef REGISTER_PREFIX
598 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
599 name += strlen (REGISTER_PREFIX);
601 if (name[0] == '%' || name[0] == '#')
606 /* Decode an `asm' spec for a declaration as a register name.
607 Return the register number, or -1 if nothing specified,
608 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
609 or -3 if ASMSPEC is `cc' and is not recognized,
610 or -4 if ASMSPEC is `memory' and is not recognized.
611 Accept an exact spelling or a decimal number.
612 Prefixes such as % are optional. */
615 decode_reg_name (asmspec)
622 /* Get rid of confusing prefixes. */
623 asmspec = strip_reg_name (asmspec);
625 /* Allow a decimal number as a "register name". */
626 for (i = strlen (asmspec) - 1; i >= 0; i--)
627 if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
629 if (asmspec[0] != 0 && i < 0)
632 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
638 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
640 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
643 #ifdef ADDITIONAL_REGISTER_NAMES
645 static struct { const char *name; int number; } table[]
646 = ADDITIONAL_REGISTER_NAMES;
648 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
649 if (! strcmp (asmspec, table[i].name))
650 return table[i].number;
652 #endif /* ADDITIONAL_REGISTER_NAMES */
654 if (!strcmp (asmspec, "memory"))
657 if (!strcmp (asmspec, "cc"))
666 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
667 have static storage duration. In other words, it should not be an
668 automatic variable, including PARM_DECLs.
670 There is, however, one exception: this function handles variables
671 explicitly placed in a particular register by the user.
673 ASMSPEC, if not 0, is the string which the user specified as the
674 assembler symbol name.
676 This is never called for PARM_DECL nodes. */
679 make_decl_rtl (decl, asmspec)
683 int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
684 const char *name = 0;
685 const char *new_name = 0;
689 /* Check that we are not being given an automatic variable. */
690 /* A weak alias has TREE_PUBLIC set but not the other bits. */
691 if (TREE_CODE (decl) == PARM_DECL
692 || TREE_CODE (decl) == RESULT_DECL
693 || (TREE_CODE (decl) == VAR_DECL
694 && !TREE_STATIC (decl)
695 && !TREE_PUBLIC (decl)
696 && !DECL_EXTERNAL (decl)
697 && !DECL_REGISTER (decl)))
699 /* And that we were not given a type or a label. */
700 else if (TREE_CODE (decl) == TYPE_DECL
701 || TREE_CODE (decl) == LABEL_DECL)
704 /* For a duplicate declaration, we can be called twice on the
705 same DECL node. Don't discard the RTL already made. */
706 if (DECL_RTL_SET_P (decl))
708 /* If the old RTL had the wrong mode, fix the mode. */
709 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
711 rtx rtl = DECL_RTL (decl);
712 PUT_MODE (rtl, DECL_MODE (decl));
715 /* ??? Another way to do this would be to do what halfpic.c does
716 and maintain a hashed table of such critters. */
717 /* ??? Another way to do this would be to pass a flag bit to
718 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
719 /* Let the target reassign the RTL if it wants.
720 This is necessary, for example, when one machine specific
721 decl attribute overrides another. */
722 #ifdef REDO_SECTION_INFO_P
723 if (REDO_SECTION_INFO_P (decl))
724 ENCODE_SECTION_INFO (decl);
729 new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
731 reg_number = decode_reg_name (asmspec);
732 if (reg_number == -2)
734 /* ASMSPEC is given, and not the name of a register. Mark the
735 name with a star so assemble_name won't munge it. */
736 char *starred = alloca (strlen (asmspec) + 2);
738 strcpy (starred + 1, asmspec);
742 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
744 /* First detect errors in declaring global registers. */
745 if (reg_number == -1)
746 error_with_decl (decl, "register name not specified for `%s'");
747 else if (reg_number < 0)
748 error_with_decl (decl, "invalid register name for `%s'");
749 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
750 error_with_decl (decl,
751 "data type of `%s' isn't suitable for a register");
752 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
753 error_with_decl (decl,
754 "register specified for `%s' isn't suitable for data type");
755 /* Now handle properly declared static register variables. */
760 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
762 DECL_INITIAL (decl) = 0;
763 error ("global register variable has initial value");
765 if (TREE_THIS_VOLATILE (decl))
766 warning ("volatile register variables don't work as you might wish");
768 /* If the user specified one of the eliminables registers here,
769 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
770 confused with that register and be eliminated. Although this
771 usage is somewhat suspect, we nevertheless use the following
772 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
775 gen_rtx_REG (DECL_MODE (decl),
776 FIRST_PSEUDO_REGISTER));
777 REGNO (DECL_RTL (decl)) = reg_number;
778 REG_USERVAR_P (DECL_RTL (decl)) = 1;
780 if (TREE_STATIC (decl))
782 /* Make this register global, so not usable for anything
784 #ifdef ASM_DECLARE_REGISTER_GLOBAL
785 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
787 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
789 globalize_reg (reg_number + --nregs);
792 /* As a register variable, it has no section. */
797 /* Now handle ordinary static variables and functions (in memory).
798 Also handle vars declared register invalidly. */
800 if (reg_number >= 0 || reg_number == -3)
801 error_with_decl (decl,
802 "register name given for non-register variable `%s'");
804 /* Specifying a section attribute on a variable forces it into a
805 non-.bss section, and thus it cannot be common. */
806 if (TREE_CODE (decl) == VAR_DECL
807 && DECL_SECTION_NAME (decl) != NULL_TREE
808 && DECL_INITIAL (decl) == NULL_TREE
809 && DECL_COMMON (decl))
810 DECL_COMMON (decl) = 0;
812 /* Can't use just the variable's own name for a variable
813 whose scope is less than the whole file, unless it's a member
814 of a local class (which will already be unambiguous).
815 Concatenate a distinguishing number. */
816 if (!top_level && !TREE_PUBLIC (decl)
817 && ! (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
819 && name == IDENTIFIER_POINTER (DECL_NAME (decl)))
822 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
827 /* When -fprefix-function-name is used, the functions
828 names are prefixed. Only nested function names are not
830 else if (flag_prefix_function_name && TREE_CODE (decl) == FUNCTION_DECL)
832 size_t name_len = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl));
835 pname = alloca (name_len + CHKR_PREFIX_SIZE + 1);
836 memcpy (pname, CHKR_PREFIX, CHKR_PREFIX_SIZE);
837 memcpy (pname + CHKR_PREFIX_SIZE, name, name_len + 1);
841 if (name != new_name)
843 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
844 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
847 /* If this variable is to be treated as volatile, show its
848 tree node has side effects. */
849 if ((flag_volatile_global && TREE_CODE (decl) == VAR_DECL
850 && TREE_PUBLIC (decl))
851 || ((flag_volatile_static && TREE_CODE (decl) == VAR_DECL
852 && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
853 TREE_SIDE_EFFECTS (decl) = 1;
855 x = gen_rtx_MEM (DECL_MODE (decl), gen_rtx_SYMBOL_REF (Pmode, name));
856 SYMBOL_REF_WEAK (XEXP (x, 0)) = DECL_WEAK (decl);
857 if (TREE_CODE (decl) != FUNCTION_DECL)
858 set_mem_attributes (x, decl, 1);
859 SET_DECL_RTL (decl, x);
861 /* Optionally set flags or add text to the name to record information
862 such as that it is a function name.
863 If the name is changed, the macro ASM_OUTPUT_LABELREF
864 will have to know how to strip this information. */
865 #ifdef ENCODE_SECTION_INFO
866 ENCODE_SECTION_INFO (decl);
870 /* Make the rtl for variable VAR be volatile.
871 Use this only for static variables. */
874 make_var_volatile (var)
877 if (GET_CODE (DECL_RTL (var)) != MEM)
880 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
883 /* Output alignment directive to align for constant expression EXP. */
886 assemble_constant_align (exp)
891 /* Align the location counter as required by EXP's data type. */
892 align = TYPE_ALIGN (TREE_TYPE (exp));
893 #ifdef CONSTANT_ALIGNMENT
894 align = CONSTANT_ALIGNMENT (exp, align);
897 if (align > BITS_PER_UNIT)
898 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
901 /* Output a string of literal assembler code
902 for an `asm' keyword used between functions. */
905 assemble_asm (string)
910 if (TREE_CODE (string) == ADDR_EXPR)
911 string = TREE_OPERAND (string, 0);
913 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
916 /* Record an element in the table of global destructors. SYMBOL is
917 a SYMBOL_REF of the function to be called; PRIORITY is a number
918 between 0 and MAX_INIT_PRIORITY. */
921 default_stabs_asm_out_destructor (symbol, priority)
923 int priority ATTRIBUTE_UNUSED;
925 /* Tell GNU LD that this is part of the static destructor set.
926 This will work for any system that uses stabs, most usefully
928 fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
929 assemble_name (asm_out_file, XSTR (symbol, 0));
930 fputc ('\n', asm_out_file);
934 default_named_section_asm_out_destructor (symbol, priority)
938 const char *section = ".dtors";
941 /* ??? This only works reliably with the GNU linker. */
942 if (priority != DEFAULT_INIT_PRIORITY)
944 sprintf (buf, ".dtors.%.5u",
945 /* Invert the numbering so the linker puts us in the proper
946 order; constructors are run from right to left, and the
947 linker sorts in increasing order. */
948 MAX_INIT_PRIORITY - priority);
952 named_section_flags (section, SECTION_WRITE);
953 assemble_align (POINTER_SIZE);
954 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
957 #ifdef DTORS_SECTION_ASM_OP
961 if (in_section != in_dtors)
963 in_section = in_dtors;
964 fputs (DTORS_SECTION_ASM_OP, asm_out_file);
965 fputc ('\n', asm_out_file);
970 default_dtor_section_asm_out_destructor (symbol, priority)
972 int priority ATTRIBUTE_UNUSED;
975 assemble_align (POINTER_SIZE);
976 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 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_align (POINTER_SIZE);
1016 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1019 #ifdef CTORS_SECTION_ASM_OP
1023 if (in_section != in_ctors)
1025 in_section = in_ctors;
1026 fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1027 fputc ('\n', asm_out_file);
1032 default_ctor_section_asm_out_constructor (symbol, priority)
1034 int priority ATTRIBUTE_UNUSED;
1037 assemble_align (POINTER_SIZE);
1038 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1042 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1043 a non-zero value if the constant pool should be output before the
1044 start of the function, or a zero value if the pool should output
1045 after the end of the function. The default is to put it before the
1048 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1049 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1052 /* Output assembler code for the constant pool of a function and associated
1053 with defining the name of the function. DECL describes the function.
1054 NAME is the function's name. For the constant pool, we use the current
1055 constant pool data. */
1058 assemble_start_function (decl, fnname)
1064 /* The following code does not need preprocessing in the assembler. */
1068 if (CONSTANT_POOL_BEFORE_FUNCTION)
1069 output_constant_pool (fnname, decl);
1071 resolve_unique_section (decl, 0);
1072 function_section (decl);
1074 /* Tell assembler to move to target machine's alignment for functions. */
1075 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1077 ASM_OUTPUT_ALIGN (asm_out_file, align);
1079 /* Handle a user-specified function alignment.
1080 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1081 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1082 if (align_functions_log > align)
1084 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1085 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1086 align_functions_log, align_functions-1);
1088 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1092 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1093 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1096 (*debug_hooks->begin_function) (decl);
1098 /* Make function name accessible from other files, if appropriate. */
1100 if (TREE_PUBLIC (decl))
1102 if (! first_global_object_name)
1107 STRIP_NAME_ENCODING (p, fnname);
1108 name = permalloc (strlen (p) + 1);
1111 if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1112 first_global_object_name = name;
1114 weak_global_object_name = name;
1117 #ifdef ASM_WEAKEN_LABEL
1118 if (DECL_WEAK (decl))
1120 ASM_WEAKEN_LABEL (asm_out_file, fnname);
1121 /* Remove this function from the pending weak list so that
1122 we do not emit multiple .weak directives for it. */
1123 remove_from_pending_weak_list
1124 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1128 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
1131 /* Do any machine/system dependent processing of the function name */
1132 #ifdef ASM_DECLARE_FUNCTION_NAME
1133 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1135 /* Standard thing is just output label for the function. */
1136 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1137 #endif /* ASM_DECLARE_FUNCTION_NAME */
1140 /* Output assembler code associated with defining the size of the
1141 function. DECL describes the function. NAME is the function's name. */
1144 assemble_end_function (decl, fnname)
1148 #ifdef ASM_DECLARE_FUNCTION_SIZE
1149 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1151 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1153 output_constant_pool (fnname, decl);
1154 function_section (decl); /* need to switch back */
1157 /* Output any constants which should appear after the function. */
1158 output_after_function_constants ();
1161 /* Assemble code to leave SIZE bytes of zeros. */
1164 assemble_zeros (size)
1167 /* Do no output if -fsyntax-only. */
1168 if (flag_syntax_only)
1171 #ifdef ASM_NO_SKIP_IN_TEXT
1172 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1173 so we must output 0s explicitly in the text section. */
1174 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1177 for (i = 0; i < size; i++)
1178 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1183 ASM_OUTPUT_SKIP (asm_out_file, size);
1186 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1189 assemble_align (align)
1192 if (align > BITS_PER_UNIT)
1193 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1196 /* Assemble a string constant with the specified C string as contents. */
1199 assemble_string (p, size)
1206 /* If the string is very long, split it up. */
1210 int thissize = size - pos;
1211 if (thissize > maximum)
1214 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1222 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1223 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1224 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1226 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1227 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1228 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1230 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1231 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1235 #if defined ASM_OUTPUT_ALIGNED_BSS
1236 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1237 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1239 #if defined ASM_OUTPUT_BSS
1240 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1241 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1247 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1248 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1249 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1251 #if defined ASM_OUTPUT_ALIGNED_COMMON
1252 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1253 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1255 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1256 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1261 asm_emit_uninitialised (decl, name, size, rounded)
1264 int size ATTRIBUTE_UNUSED;
1265 int rounded ATTRIBUTE_UNUSED;
1273 destination = asm_dest_local;
1275 if (TREE_PUBLIC (decl))
1277 #if defined ASM_EMIT_BSS
1278 if (! DECL_COMMON (decl))
1279 destination = asm_dest_bss;
1282 destination = asm_dest_common;
1285 if (flag_shared_data)
1287 switch (destination)
1289 #ifdef ASM_OUTPUT_SHARED_BSS
1291 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1294 #ifdef ASM_OUTPUT_SHARED_COMMON
1295 case asm_dest_common:
1296 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1299 #ifdef ASM_OUTPUT_SHARED_LOCAL
1300 case asm_dest_local:
1301 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1309 resolve_unique_section (decl, 0);
1311 switch (destination)
1315 ASM_EMIT_BSS (decl, name, size, rounded);
1318 case asm_dest_common:
1319 ASM_EMIT_COMMON (decl, name, size, rounded);
1321 case asm_dest_local:
1322 ASM_EMIT_LOCAL (decl, name, size, rounded);
1331 /* Assemble everything that is needed for a variable or function declaration.
1332 Not used for automatic variables, and not used for function definitions.
1333 Should not be called for variables of incomplete structure type.
1335 TOP_LEVEL is nonzero if this variable has file scope.
1336 AT_END is nonzero if this is the special handling, at end of compilation,
1337 to define things that have had only tentative definitions.
1338 DONT_OUTPUT_DATA if nonzero means don't actually output the
1339 initial value (that will be done by the caller). */
1342 assemble_variable (decl, top_level, at_end, dont_output_data)
1344 int top_level ATTRIBUTE_UNUSED;
1345 int at_end ATTRIBUTE_UNUSED;
1346 int dont_output_data;
1348 register const char *name;
1353 last_assemble_variable_decl = 0;
1355 /* Normally no need to say anything here for external references,
1356 since assemble_external is called by the language-specific code
1357 when a declaration is first seen. */
1359 if (DECL_EXTERNAL (decl))
1362 /* Output no assembler code for a function declaration.
1363 Only definitions of functions output anything. */
1365 if (TREE_CODE (decl) == FUNCTION_DECL)
1368 /* Do nothing for global register variables. */
1369 if (DECL_RTL_SET_P (decl) && GET_CODE (DECL_RTL (decl)) == REG)
1371 TREE_ASM_WRITTEN (decl) = 1;
1375 /* If type was incomplete when the variable was declared,
1376 see if it is complete now. */
1378 if (DECL_SIZE (decl) == 0)
1379 layout_decl (decl, 0);
1381 /* Still incomplete => don't allocate it; treat the tentative defn
1382 (which is what it must have been) as an `extern' reference. */
1384 if (!dont_output_data && DECL_SIZE (decl) == 0)
1386 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1387 DECL_SOURCE_LINE (decl),
1388 "storage size of `%s' isn't known",
1389 IDENTIFIER_POINTER (DECL_NAME (decl)));
1390 TREE_ASM_WRITTEN (decl) = 1;
1394 /* The first declaration of a variable that comes through this function
1395 decides whether it is global (in C, has external linkage)
1396 or local (in C, has internal linkage). So do nothing more
1397 if this function has already run. */
1399 if (TREE_ASM_WRITTEN (decl))
1402 /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN. */
1403 decl_rtl = DECL_RTL (decl);
1405 TREE_ASM_WRITTEN (decl) = 1;
1407 /* Do no output if -fsyntax-only. */
1408 if (flag_syntax_only)
1413 if (! dont_output_data
1414 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1416 error_with_decl (decl, "size of variable `%s' is too large");
1420 name = XSTR (XEXP (decl_rtl, 0), 0);
1421 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1422 && ! first_global_object_name
1423 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1424 || DECL_INITIAL (decl) == error_mark_node))
1425 && ! DECL_WEAK (decl)
1426 && ! DECL_ONE_ONLY (decl))
1431 STRIP_NAME_ENCODING (p, name);
1432 xname = permalloc (strlen (p) + 1);
1434 first_global_object_name = xname;
1437 /* Compute the alignment of this data. */
1439 align = DECL_ALIGN (decl);
1441 /* In the case for initialing an array whose length isn't specified,
1442 where we have not yet been able to do the layout,
1443 figure out the proper alignment now. */
1444 if (dont_output_data && DECL_SIZE (decl) == 0
1445 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1446 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1448 /* Some object file formats have a maximum alignment which they support.
1449 In particular, a.out format supports a maximum alignment of 4. */
1450 #ifndef MAX_OFILE_ALIGNMENT
1451 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1453 if (align > MAX_OFILE_ALIGNMENT)
1455 warning_with_decl (decl,
1456 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1457 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1458 align = MAX_OFILE_ALIGNMENT;
1461 /* On some machines, it is good to increase alignment sometimes. */
1462 if (! DECL_USER_ALIGN (decl))
1464 #ifdef DATA_ALIGNMENT
1465 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1467 #ifdef CONSTANT_ALIGNMENT
1468 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1469 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1473 /* Reset the alignment in case we have made it tighter, so we can benefit
1474 from it in get_pointer_alignment. */
1475 DECL_ALIGN (decl) = align;
1477 /* Handle uninitialized definitions. */
1479 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1480 /* If the target can't output uninitialized but not common global data
1481 in .bss, then we have to use .data. */
1482 #if ! defined ASM_EMIT_BSS
1483 && DECL_COMMON (decl)
1485 && DECL_SECTION_NAME (decl) == NULL_TREE
1486 && ! dont_output_data)
1488 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1489 unsigned HOST_WIDE_INT rounded = size;
1491 /* Don't allocate zero bytes of common,
1492 since that means "undefined external" in the linker. */
1496 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1497 so that each uninitialized object starts on such a boundary. */
1498 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1499 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1500 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1502 /* Don't continue this line--convex cc version 4.1 would lose. */
1503 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1504 if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1506 (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
1509 asm_emit_uninitialised (decl, name, size, rounded);
1514 /* Handle initialized definitions.
1515 Also handle uninitialized global definitions if -fno-common and the
1516 target doesn't support ASM_OUTPUT_BSS. */
1518 /* First make the assembler name(s) global if appropriate. */
1519 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1521 #ifdef ASM_WEAKEN_LABEL
1522 if (DECL_WEAK (decl))
1524 ASM_WEAKEN_LABEL (asm_out_file, name);
1525 /* Remove this variable from the pending weak list so that
1526 we do not emit multiple .weak directives for it. */
1527 remove_from_pending_weak_list
1528 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1532 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1535 /* Output any data that we will need to use the address of. */
1536 if (DECL_INITIAL (decl) == error_mark_node)
1537 reloc = contains_pointers_p (TREE_TYPE (decl));
1538 else if (DECL_INITIAL (decl))
1539 reloc = output_addressed_constants (DECL_INITIAL (decl));
1541 /* Switch to the appropriate section. */
1542 resolve_unique_section (decl, reloc);
1543 variable_section (decl, reloc);
1545 /* dbxout.c needs to know this. */
1546 if (in_text_section ())
1547 DECL_IN_TEXT_SECTION (decl) = 1;
1549 /* Output the alignment of this data. */
1550 if (align > BITS_PER_UNIT)
1551 ASM_OUTPUT_ALIGN (asm_out_file,
1552 floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1554 /* Do any machine/system dependent processing of the object. */
1555 #ifdef ASM_DECLARE_OBJECT_NAME
1556 last_assemble_variable_decl = decl;
1557 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1559 /* Standard thing is just output label for the object. */
1560 ASM_OUTPUT_LABEL (asm_out_file, name);
1561 #endif /* ASM_DECLARE_OBJECT_NAME */
1563 if (!dont_output_data)
1565 if (DECL_INITIAL (decl))
1566 /* Output the actual data. */
1567 output_constant (DECL_INITIAL (decl),
1568 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1571 /* Leave space for it. */
1572 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1576 /* Return 1 if type TYPE contains any pointers. */
1579 contains_pointers_p (type)
1582 switch (TREE_CODE (type))
1585 case REFERENCE_TYPE:
1586 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1587 so I'll play safe and return 1. */
1593 case QUAL_UNION_TYPE:
1596 /* For a type that has fields, see if the fields have pointers. */
1597 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1598 if (TREE_CODE (fields) == FIELD_DECL
1599 && contains_pointers_p (TREE_TYPE (fields)))
1605 /* An array type contains pointers if its element type does. */
1606 return contains_pointers_p (TREE_TYPE (type));
1613 /* Output something to declare an external symbol to the assembler.
1614 (Most assemblers don't need this, so we normally output nothing.)
1615 Do nothing if DECL is not external. */
1618 assemble_external (decl)
1619 tree decl ATTRIBUTE_UNUSED;
1621 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1622 main body of this code is only rarely exercised. To provide some
1623 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1624 open. If it's not, we should not be calling this function. */
1628 #ifdef ASM_OUTPUT_EXTERNAL
1629 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1631 rtx rtl = DECL_RTL (decl);
1633 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1634 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1636 /* Some systems do require some output. */
1637 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1638 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1644 /* Similar, for calling a library function FUN. */
1647 assemble_external_libcall (fun)
1648 rtx fun ATTRIBUTE_UNUSED;
1650 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1651 /* Declare library function name external when first used, if nec. */
1652 if (! SYMBOL_REF_USED (fun))
1654 SYMBOL_REF_USED (fun) = 1;
1655 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1660 /* Declare the label NAME global. */
1663 assemble_global (name)
1666 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1669 /* Assemble a label named NAME. */
1672 assemble_label (name)
1675 ASM_OUTPUT_LABEL (asm_out_file, name);
1678 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1679 If NAME starts with a *, the rest of NAME is output verbatim.
1680 Otherwise NAME is transformed in an implementation-defined way
1681 (usually by the addition of an underscore).
1682 Many macros in the tm file are defined to call this function. */
1685 assemble_name (file, name)
1689 const char *real_name;
1692 STRIP_NAME_ENCODING (real_name, name);
1693 if (flag_prefix_function_name
1694 && ! memcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
1695 real_name = real_name + CHKR_PREFIX_SIZE;
1697 id = maybe_get_identifier (real_name);
1699 TREE_SYMBOL_REFERENCED (id) = 1;
1702 fputs (&name[1], file);
1704 ASM_OUTPUT_LABELREF (file, name);
1707 /* Allocate SIZE bytes writable static space with a gensym name
1708 and return an RTX to refer to its address. */
1711 assemble_static_space (size)
1715 const char *namestring;
1719 if (flag_shared_data)
1723 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1725 namestring = ggc_strdup (name);
1727 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1729 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1730 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1733 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1734 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1737 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1738 so that each uninitialized object starts on such a boundary. */
1739 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1740 int rounded ATTRIBUTE_UNUSED
1741 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1742 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1743 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1744 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1751 /* Assemble the static constant template for function entry trampolines.
1752 This is done at most once per compilation.
1753 Returns an RTX for the address of the template. */
1755 #ifdef TRAMPOLINE_TEMPLATE
1757 assemble_trampoline_template ()
1763 /* By default, put trampoline templates in read-only data section. */
1765 #ifdef TRAMPOLINE_SECTION
1766 TRAMPOLINE_SECTION ();
1768 readonly_data_section ();
1771 /* Write the assembler code to define one. */
1772 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1774 ASM_OUTPUT_ALIGN (asm_out_file, align);
1776 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1777 TRAMPOLINE_TEMPLATE (asm_out_file);
1779 /* Record the rtl to refer to it. */
1780 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1781 name = ggc_strdup (label);
1782 return gen_rtx_SYMBOL_REF (Pmode, name);
1786 /* A and B are either alignments or offsets. Return the minimum alignment
1787 that may be assumed after adding the two together. */
1789 static inline unsigned
1793 return (a | b) & -(a | b);
1796 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
1797 the alignment of the integer in bits. Return 1 if we were able to output
1798 the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
1802 assemble_integer (x, size, align, force)
1808 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1809 ASM_OUTPUT... macros. */
1811 if (align >= size * BITS_PER_UNIT)
1814 #ifdef ASM_OUTPUT_CHAR
1816 ASM_OUTPUT_CHAR (asm_out_file, x);
1819 #ifdef ASM_OUTPUT_SHORT
1821 ASM_OUTPUT_SHORT (asm_out_file, x);
1824 #ifdef ASM_OUTPUT_INT
1826 ASM_OUTPUT_INT (asm_out_file, x);
1829 #ifdef ASM_OUTPUT_DOUBLE_INT
1831 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1834 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1836 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1842 const char *asm_op = NULL;
1844 /* ??? This isn't quite as flexible as the ASM_OUTPUT_INT type hooks.
1845 At present powerpc-eabi can't jump -mrelocatable hoops, so you can
1846 get assembler errors from symbolic references in packed structs. */
1849 #ifdef UNALIGNED_SHORT_ASM_OP
1851 asm_op = UNALIGNED_SHORT_ASM_OP;
1854 #ifdef UNALIGNED_INT_ASM_OP
1856 asm_op = UNALIGNED_INT_ASM_OP;
1859 #ifdef UNALIGNED_DOUBLE_INT_ASM_OP
1861 asm_op = UNALIGNED_DOUBLE_INT_ASM_OP;
1868 fputs (asm_op, asm_out_file);
1869 output_addr_const (asm_out_file, x);
1870 fputc ('\n', asm_out_file);
1875 /* If we couldn't do it that way, there are two other possibilities: First,
1876 if the machine can output an explicit byte and this is a 1 byte constant,
1877 we can use ASM_OUTPUT_BYTE. */
1879 #ifdef ASM_OUTPUT_BYTE
1880 if (size == 1 && GET_CODE (x) == CONST_INT)
1882 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1887 /* If SIZE is larger than a single word, try to output the constant
1888 one word at a time. */
1890 if (size > UNITS_PER_WORD)
1892 enum machine_mode mode
1893 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1894 unsigned align2 = min_align (align, BITS_PER_WORD);
1897 for (i = 0; i < size / UNITS_PER_WORD; i++)
1899 rtx word = operand_subword (x, i, 0, mode);
1902 if (! assemble_integer (word, UNITS_PER_WORD, align2, 0))
1906 if (i == size / UNITS_PER_WORD)
1908 /* If we output at least one word and then could not finish,
1909 there is no valid way to continue. */
1914 /* If unaligned, and this is a constant, emit it one byte at a time. */
1915 if (align < size * BITS_PER_UNIT)
1917 enum machine_mode omode, imode;
1920 omode = mode_for_size (BITS_PER_UNIT, MODE_INT, 0);
1921 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1923 for (i = 0; i < size; i++)
1925 rtx byte = simplify_subreg (omode, x, imode, i);
1928 if (! assemble_integer (byte, 1, BITS_PER_UNIT, 0))
1934 /* If we output at least one byte and then could not finish,
1935 there is no valid way to continue. */
1946 /* Assemble the floating-point constant D into an object of size MODE. */
1947 struct assemble_real_args
1950 enum machine_mode mode;
1957 struct assemble_real_args *args = (struct assemble_real_args *) p;
1958 REAL_VALUE_TYPE *d = args->d;
1959 enum machine_mode mode = args->mode;
1963 #ifdef ASM_OUTPUT_BYTE_FLOAT
1965 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, *d);
1968 #ifdef ASM_OUTPUT_SHORT_FLOAT
1970 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, *d);
1973 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1975 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, *d);
1978 #ifdef ASM_OUTPUT_FLOAT
1980 ASM_OUTPUT_FLOAT (asm_out_file, *d);
1984 #ifdef ASM_OUTPUT_DOUBLE
1986 ASM_OUTPUT_DOUBLE (asm_out_file, *d);
1990 #ifdef ASM_OUTPUT_LONG_DOUBLE
1993 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, *d);
2003 assemble_real (d, mode, align)
2005 enum machine_mode mode;
2008 struct assemble_real_args args;
2012 /* We cannot emit unaligned floating point constants. This is slightly
2013 complicated in that we don't know what "unaligned" means exactly. */
2014 #ifdef BIGGEST_FIELD_ALIGNMENT
2015 if (align >= BIGGEST_FIELD_ALIGNMENT)
2019 if (align < GET_MODE_ALIGNMENT (mode))
2022 if (do_float_handler (assemble_real_1, (PTR) &args))
2025 internal_error ("floating point trap outputting a constant");
2028 /* Here we combine duplicate floating constants to make
2029 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
2031 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2032 For an integer, I0 is the low-order word and I1 is the high-order word.
2033 For a real number, I0 is the word with the low address
2034 and I1 is the word with the high address. */
2037 immed_double_const (i0, i1, mode)
2038 HOST_WIDE_INT i0, i1;
2039 enum machine_mode mode;
2043 if (GET_MODE_CLASS (mode) == MODE_INT
2044 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2046 /* We clear out all bits that don't belong in MODE, unless they and our
2047 sign bit are all one. So we get either a reasonable negative value
2048 or a reasonable unsigned value for this mode. */
2049 int width = GET_MODE_BITSIZE (mode);
2050 if (width < HOST_BITS_PER_WIDE_INT
2051 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2052 != ((HOST_WIDE_INT) (-1) << (width - 1))))
2053 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2054 else if (width == HOST_BITS_PER_WIDE_INT
2055 && ! (i1 == ~0 && i0 < 0))
2057 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2058 /* We cannot represent this value as a constant. */
2061 /* If this would be an entire word for the target, but is not for
2062 the host, then sign-extend on the host so that the number will look
2063 the same way on the host that it would on the target.
2065 For example, when building a 64 bit alpha hosted 32 bit sparc
2066 targeted compiler, then we want the 32 bit unsigned value -1 to be
2067 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2068 The later confuses the sparc backend. */
2070 if (width < HOST_BITS_PER_WIDE_INT
2071 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2072 i0 |= ((HOST_WIDE_INT) (-1) << width);
2074 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2076 ??? Strictly speaking, this is wrong if we create a CONST_INT
2077 for a large unsigned constant with the size of MODE being
2078 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2079 wider mode. In that case we will mis-interpret it as a negative
2082 Unfortunately, the only alternative is to make a CONST_DOUBLE
2083 for any constant in any mode if it is an unsigned constant larger
2084 than the maximum signed integer in an int on the host. However,
2085 doing this will break everyone that always expects to see a CONST_INT
2086 for SImode and smaller.
2088 We have always been making CONST_INTs in this case, so nothing new
2091 if (width <= HOST_BITS_PER_WIDE_INT)
2092 i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2094 /* If this integer fits in one word, return a CONST_INT. */
2095 if ((i1 == 0 && i0 >= 0)
2096 || (i1 == ~0 && i0 < 0))
2097 return GEN_INT (i0);
2099 /* We use VOIDmode for integers. */
2103 /* Search the chain for an existing CONST_DOUBLE with the right value.
2104 If one is found, return it. */
2106 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2107 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2108 && GET_MODE (r) == mode)
2111 /* No; make a new one and add it to the chain. */
2112 r = gen_rtx_CONST_DOUBLE (mode, const0_rtx, i0, i1);
2114 /* Don't touch const_double_chain if not inside any function. */
2115 if (current_function_decl != 0)
2117 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2118 const_double_chain = r;
2124 /* Return a CONST_DOUBLE for a specified `double' value
2125 and machine mode. */
2128 immed_real_const_1 (d, mode)
2130 enum machine_mode mode;
2132 union real_extract u;
2135 /* Get the desired `double' value as a sequence of ints
2136 since that is how they are stored in a CONST_DOUBLE. */
2140 /* Detect special cases. */
2141 if (REAL_VALUES_IDENTICAL (dconst0, d))
2142 return CONST0_RTX (mode);
2144 /* Check for NaN first, because some ports (specifically the i386) do not
2145 emit correct ieee-fp code by default, and thus will generate a core
2146 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2147 does a floating point comparison. */
2148 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2149 return CONST1_RTX (mode);
2151 if (sizeof u == sizeof (HOST_WIDE_INT))
2152 return immed_double_const (u.i[0], 0, mode);
2153 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2154 return immed_double_const (u.i[0], u.i[1], mode);
2156 /* The rest of this function handles the case where
2157 a float value requires more than 2 ints of space.
2158 It will be deleted as dead code on machines that don't need it. */
2160 /* Search the chain for an existing CONST_DOUBLE with the right value.
2161 If one is found, return it. */
2163 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2164 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2165 && GET_MODE (r) == mode)
2168 /* No; make a new one and add it to the chain.
2170 We may be called by an optimizer which may be discarding any memory
2171 allocated during its processing (such as combine and loop). However,
2172 we will be leaving this constant on the chain, so we cannot tolerate
2174 r = rtx_alloc (CONST_DOUBLE);
2176 memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u);
2178 /* If we aren't inside a function, don't put r on the
2179 const_double_chain. */
2180 if (current_function_decl != 0)
2182 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2183 const_double_chain = r;
2186 CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2188 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2189 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2190 is only through force_const_mem. */
2192 CONST_DOUBLE_MEM (r) = const0_rtx;
2197 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2198 which must be a REAL_CST tree node. */
2201 immed_real_const (exp)
2204 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2207 /* At the end of a function, forget the memory-constants
2208 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2209 Also clear out real_constant_chain and clear out all the chain-pointers. */
2212 clear_const_double_mem ()
2214 register rtx r, next;
2215 enum machine_mode mode;
2218 for (r = const_double_chain; r; r = next)
2220 next = CONST_DOUBLE_CHAIN (r);
2221 CONST_DOUBLE_CHAIN (r) = 0;
2222 CONST_DOUBLE_MEM (r) = cc0_rtx;
2224 const_double_chain = 0;
2226 for (i = 0; i <= 2; i++)
2227 for (mode = GET_CLASS_NARROWEST_MODE (MODE_FLOAT); mode != VOIDmode;
2228 mode = GET_MODE_WIDER_MODE (mode))
2230 r = const_tiny_rtx[i][(int) mode];
2231 CONST_DOUBLE_CHAIN (r) = 0;
2232 CONST_DOUBLE_MEM (r) = cc0_rtx;
2236 /* Given an expression EXP with a constant value,
2237 reduce it to the sum of an assembler symbol and an integer.
2238 Store them both in the structure *VALUE.
2239 Abort if EXP does not reduce. */
2244 HOST_WIDE_INT offset;
2248 decode_addr_const (exp, value)
2250 struct addr_const *value;
2252 register tree target = TREE_OPERAND (exp, 0);
2253 register int offset = 0;
2258 if (TREE_CODE (target) == COMPONENT_REF
2259 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2262 offset += int_byte_position (TREE_OPERAND (target, 1));
2263 target = TREE_OPERAND (target, 0);
2265 else if (TREE_CODE (target) == ARRAY_REF
2266 || TREE_CODE (target) == ARRAY_RANGE_REF)
2268 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2269 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2270 target = TREE_OPERAND (target, 0);
2276 switch (TREE_CODE (target))
2280 x = DECL_RTL (target);
2284 x = gen_rtx_MEM (FUNCTION_MODE,
2285 gen_rtx_LABEL_REF (VOIDmode,
2286 label_rtx (TREE_OPERAND (exp, 0))));
2294 x = TREE_CST_RTL (target);
2301 if (GET_CODE (x) != MEM)
2306 value->offset = offset;
2309 enum kind { RTX_DOUBLE, RTX_INT };
2312 ENUM_BITFIELD(kind) kind : 16;
2313 ENUM_BITFIELD(machine_mode) mode : 16;
2315 union real_extract du;
2316 struct addr_const addr;
2317 struct {HOST_WIDE_INT high, low;} di;
2321 /* Uniquize all constants that appear in memory.
2322 Each constant in memory thus far output is recorded
2323 in `const_hash_table' with a `struct constant_descriptor'
2324 that contains a polish representation of the value of
2327 We cannot store the trees in the hash table
2328 because the trees may be temporary. */
2330 struct constant_descriptor
2332 struct constant_descriptor *next;
2335 /* Make sure the data is reasonably aligned. */
2338 unsigned char contents[1];
2339 #ifdef HAVE_LONG_DOUBLE
2348 #define MAX_HASH_TABLE 1009
2349 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2351 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2353 struct deferred_string
2360 static htab_t const_str_htab;
2362 /* Mark a const_hash_table descriptor for GC. */
2365 mark_const_hash_entry (ptr)
2368 struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2372 ggc_mark_rtx (desc->rtl);
2377 /* Mark the hash-table element X (which is really a pointer to an
2378 struct deferred_string *). */
2381 mark_const_str_htab_1 (x, data)
2383 void *data ATTRIBUTE_UNUSED;
2385 ggc_mark_tree (((struct deferred_string *) *x)->exp);
2389 /* Mark a const_str_htab for GC. */
2392 mark_const_str_htab (htab)
2395 htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2398 /* Returns a hash code for X (which is a really a
2399 struct deferred_string *). */
2402 const_str_htab_hash (x)
2405 return STRHASH (((const struct deferred_string *) x)->label);
2408 /* Returns non-zero if the value represented by X (which is really a
2409 struct deferred_string *) is the same as that given by Y
2410 (which is really a char *). */
2413 const_str_htab_eq (x, y)
2417 return (((const struct deferred_string *) x)->label == (const char *) y);
2420 /* Delete the hash table entry dfsp. */
2423 const_str_htab_del (dfsp)
2429 /* Compute a hash code for a constant expression. */
2435 register const char *p;
2436 register int len, hi, i;
2437 register enum tree_code code = TREE_CODE (exp);
2439 /* Either set P and LEN to the address and len of something to hash and
2440 exit the switch or return a value. */
2445 p = (char *) &TREE_INT_CST (exp);
2446 len = sizeof TREE_INT_CST (exp);
2450 p = (char *) &TREE_REAL_CST (exp);
2451 len = sizeof TREE_REAL_CST (exp);
2455 p = TREE_STRING_POINTER (exp);
2456 len = TREE_STRING_LENGTH (exp);
2460 return (const_hash (TREE_REALPART (exp)) * 5
2461 + const_hash (TREE_IMAGPART (exp)));
2464 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2468 len = int_size_in_bytes (TREE_TYPE (exp));
2469 tmp = (char *) alloca (len);
2470 get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2478 /* For record type, include the type in the hashing.
2479 We do not do so for array types
2480 because (1) the sizes of the elements are sufficient
2481 and (2) distinct array types can have the same constructor.
2482 Instead, we include the array size because the constructor could
2484 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2485 hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2488 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2489 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2491 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2492 if (TREE_VALUE (link))
2494 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2501 struct addr_const value;
2503 decode_addr_const (exp, &value);
2504 if (GET_CODE (value.base) == SYMBOL_REF)
2506 /* Don't hash the address of the SYMBOL_REF;
2507 only use the offset and the symbol name. */
2509 p = XSTR (value.base, 0);
2510 for (i = 0; p[i] != 0; i++)
2511 hi = ((hi * 613) + (unsigned) (p[i]));
2513 else if (GET_CODE (value.base) == LABEL_REF)
2514 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2518 hi &= (1 << HASHBITS) - 1;
2519 hi %= MAX_HASH_TABLE;
2525 return (const_hash (TREE_OPERAND (exp, 0)) * 9
2526 + const_hash (TREE_OPERAND (exp, 1)));
2530 case NON_LVALUE_EXPR:
2531 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2534 /* A language specific constant. Just hash the code. */
2535 return (int) code % MAX_HASH_TABLE;
2538 /* Compute hashing function */
2540 for (i = 0; i < len; i++)
2541 hi = ((hi * 613) + (unsigned) (p[i]));
2543 hi &= (1 << HASHBITS) - 1;
2544 hi %= MAX_HASH_TABLE;
2548 /* Compare a constant expression EXP with a constant-descriptor DESC.
2549 Return 1 if DESC describes a constant with the same value as EXP. */
2552 compare_constant (exp, desc)
2554 struct constant_descriptor *desc;
2556 return 0 != compare_constant_1 (exp, desc->u.contents);
2559 /* Compare constant expression EXP with a substring P of a constant descriptor.
2560 If they match, return a pointer to the end of the substring matched.
2561 If they do not match, return 0.
2563 Since descriptors are written in polish prefix notation,
2564 this function can be used recursively to test one operand of EXP
2565 against a subdescriptor, and if it succeeds it returns the
2566 address of the subdescriptor for the next operand. */
2568 static const unsigned char *
2569 compare_constant_1 (exp, p)
2571 const unsigned char *p;
2573 register const unsigned char *strp;
2575 register enum tree_code code = TREE_CODE (exp);
2577 if (code != (enum tree_code) *p++)
2580 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2581 switch, or return the result of the comparison. */
2586 /* Integer constants are the same only if the same width of type. */
2587 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2590 strp = (unsigned char *) &TREE_INT_CST (exp);
2591 len = sizeof TREE_INT_CST (exp);
2595 /* Real constants are the same only if the same width of type. */
2596 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2599 strp = (unsigned char *) &TREE_REAL_CST (exp);
2600 len = sizeof TREE_REAL_CST (exp);
2604 if (flag_writable_strings)
2607 if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2610 strp = (const unsigned char *)TREE_STRING_POINTER (exp);
2611 len = TREE_STRING_LENGTH (exp);
2612 if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2613 sizeof TREE_STRING_LENGTH (exp)))
2616 p += sizeof TREE_STRING_LENGTH (exp);
2620 p = compare_constant_1 (TREE_REALPART (exp), p);
2624 return compare_constant_1 (TREE_IMAGPART (exp), p);
2627 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2629 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2630 unsigned char *tmp = (unsigned char *) alloca (len);
2632 get_set_constructor_bytes (exp, tmp, len);
2633 strp = (unsigned char *) tmp;
2634 if (memcmp ((char *) &xlen, p, sizeof xlen))
2643 int length = list_length (CONSTRUCTOR_ELTS (exp));
2645 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2646 int have_purpose = 0;
2648 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2649 if (TREE_PURPOSE (link))
2652 if (memcmp ((char *) &length, p, sizeof length))
2657 /* For record constructors, insist that the types match.
2658 For arrays, just verify both constructors are for arrays.
2659 Then insist that either both or none have any TREE_PURPOSE
2661 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2662 type = TREE_TYPE (exp);
2666 if (memcmp ((char *) &type, p, sizeof type))
2669 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2671 if (memcmp ((char *) &mode, p, sizeof mode))
2679 if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2682 p += sizeof have_purpose;
2684 /* For arrays, insist that the size in bytes match. */
2685 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2687 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2689 if (memcmp ((char *) &size, p, sizeof size))
2695 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2697 if (TREE_VALUE (link))
2699 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2706 if (memcmp ((char *) &zero, p, sizeof zero))
2712 if (TREE_PURPOSE (link)
2713 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2715 if (memcmp ((char *) &TREE_PURPOSE (link), p,
2716 sizeof TREE_PURPOSE (link)))
2719 p += sizeof TREE_PURPOSE (link);
2721 else if (TREE_PURPOSE (link))
2723 if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2726 else if (have_purpose)
2730 if (memcmp ((char *) &zero, p, sizeof zero))
2742 struct addr_const value;
2744 decode_addr_const (exp, &value);
2745 strp = (unsigned char *) &value.offset;
2746 len = sizeof value.offset;
2747 /* Compare the offset. */
2749 if (*p++ != *strp++)
2752 /* Compare symbol name. */
2753 strp = (const unsigned char *) XSTR (value.base, 0);
2754 len = strlen ((const char *) strp) + 1;
2761 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2765 return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2769 case NON_LVALUE_EXPR:
2770 return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2773 if (lang_expand_constant)
2775 exp = (*lang_expand_constant) (exp);
2776 return compare_constant_1 (exp, p);
2781 /* Compare constant contents. */
2783 if (*p++ != *strp++)
2789 /* Construct a constant descriptor for the expression EXP.
2790 It is up to the caller to enter the descriptor in the hash table. */
2792 static struct constant_descriptor *
2793 record_constant (exp)
2796 struct constant_descriptor *next = 0;
2801 /* Make a struct constant_descriptor. The first three pointers will
2802 be filled in later. Here we just leave space for them. */
2804 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2805 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2806 obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2808 /* Align the descriptor for the data payload. */
2809 pad = (offsetof (struct constant_descriptor, u)
2810 - offsetof(struct constant_descriptor, rtl)
2811 - sizeof(next->rtl));
2813 obstack_blank (&permanent_obstack, pad);
2815 record_constant_1 (exp);
2816 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2819 /* Add a description of constant expression EXP
2820 to the object growing in `permanent_obstack'.
2821 No need to return its address; the caller will get that
2822 from the obstack when the object is complete. */
2825 record_constant_1 (exp)
2828 register const unsigned char *strp;
2830 register enum tree_code code = TREE_CODE (exp);
2832 obstack_1grow (&permanent_obstack, (unsigned int) code);
2837 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2838 strp = (unsigned char *) &TREE_INT_CST (exp);
2839 len = sizeof TREE_INT_CST (exp);
2843 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2844 strp = (unsigned char *) &TREE_REAL_CST (exp);
2845 len = sizeof TREE_REAL_CST (exp);
2849 if (flag_writable_strings)
2852 obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2853 strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2854 len = TREE_STRING_LENGTH (exp);
2855 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2856 sizeof TREE_STRING_LENGTH (exp));
2860 record_constant_1 (TREE_REALPART (exp));
2861 record_constant_1 (TREE_IMAGPART (exp));
2865 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2867 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2868 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2869 obstack_blank (&permanent_obstack, nbytes);
2870 get_set_constructor_bytes
2871 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2878 int length = list_length (CONSTRUCTOR_ELTS (exp));
2879 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2881 int have_purpose = 0;
2883 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2884 if (TREE_PURPOSE (link))
2887 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2889 /* For record constructors, insist that the types match.
2890 For arrays, just verify both constructors are for arrays
2891 of the same mode. Then insist that either both or none
2892 have any TREE_PURPOSE values. */
2893 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2894 type = TREE_TYPE (exp);
2898 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2899 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2900 obstack_grow (&permanent_obstack, &mode, sizeof mode);
2902 obstack_grow (&permanent_obstack, (char *) &have_purpose,
2903 sizeof have_purpose);
2905 /* For arrays, insist that the size in bytes match. */
2906 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2908 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2909 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2912 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2914 if (TREE_VALUE (link))
2915 record_constant_1 (TREE_VALUE (link));
2920 obstack_grow (&permanent_obstack,
2921 (char *) &zero, sizeof zero);
2924 if (TREE_PURPOSE (link)
2925 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2926 obstack_grow (&permanent_obstack,
2927 (char *) &TREE_PURPOSE (link),
2928 sizeof TREE_PURPOSE (link));
2929 else if (TREE_PURPOSE (link))
2930 record_constant_1 (TREE_PURPOSE (link));
2931 else if (have_purpose)
2935 obstack_grow (&permanent_obstack,
2936 (char *) &zero, sizeof zero);
2944 struct addr_const value;
2946 decode_addr_const (exp, &value);
2947 /* Record the offset. */
2948 obstack_grow (&permanent_obstack,
2949 (char *) &value.offset, sizeof value.offset);
2951 switch (GET_CODE (value.base))
2954 /* Record the symbol name. */
2955 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2956 strlen (XSTR (value.base, 0)) + 1);
2959 /* Record the address of the CODE_LABEL. It may not have
2960 been emitted yet, so it's UID may be zero. But pointer
2961 identity is good enough. */
2962 obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
2974 record_constant_1 (TREE_OPERAND (exp, 0));
2975 record_constant_1 (TREE_OPERAND (exp, 1));
2980 case NON_LVALUE_EXPR:
2981 record_constant_1 (TREE_OPERAND (exp, 0));
2985 if (lang_expand_constant)
2987 exp = (*lang_expand_constant) (exp);
2988 record_constant_1 (exp);
2993 /* Record constant contents. */
2994 obstack_grow (&permanent_obstack, strp, len);
2997 /* Record a list of constant expressions that were passed to
2998 output_constant_def but that could not be output right away. */
3000 struct deferred_constant
3002 struct deferred_constant *next;
3008 static struct deferred_constant *deferred_constants;
3010 /* Another list of constants which should be output after the
3012 static struct deferred_constant *after_function_constants;
3014 /* Nonzero means defer output of addressed subconstants
3015 (i.e., those for which output_constant_def is called.) */
3016 static int defer_addressed_constants_flag;
3018 /* Start deferring output of subconstants. */
3021 defer_addressed_constants ()
3023 defer_addressed_constants_flag++;
3026 /* Stop deferring output of subconstants,
3027 and output now all those that have been deferred. */
3030 output_deferred_addressed_constants ()
3032 struct deferred_constant *p, *next;
3034 defer_addressed_constants_flag--;
3036 if (defer_addressed_constants_flag > 0)
3039 for (p = deferred_constants; p; p = next)
3041 output_constant_def_contents (p->exp, p->reloc, p->labelno);
3046 deferred_constants = 0;
3049 /* Output any constants which should appear after a function. */
3052 output_after_function_constants ()
3054 struct deferred_constant *p, *next;
3056 for (p = after_function_constants; p; p = next)
3058 output_constant_def_contents (p->exp, p->reloc, p->labelno);
3063 after_function_constants = 0;
3066 /* Make a copy of the whole tree structure for a constant.
3067 This handles the same types of nodes that compare_constant
3068 and record_constant handle. */
3074 switch (TREE_CODE (exp))
3077 /* For ADDR_EXPR, we do not want to copy the decl whose address
3078 is requested. We do want to copy constants though. */
3079 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
3080 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3081 copy_constant (TREE_OPERAND (exp, 0)));
3083 return copy_node (exp);
3088 return copy_node (exp);
3091 return build_complex (TREE_TYPE (exp),
3092 copy_constant (TREE_REALPART (exp)),
3093 copy_constant (TREE_IMAGPART (exp)));
3097 return build (TREE_CODE (exp), TREE_TYPE (exp),
3098 copy_constant (TREE_OPERAND (exp, 0)),
3099 copy_constant (TREE_OPERAND (exp, 1)));
3103 case NON_LVALUE_EXPR:
3104 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3105 copy_constant (TREE_OPERAND (exp, 0)));
3109 tree copy = copy_node (exp);
3110 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3113 CONSTRUCTOR_ELTS (copy) = list;
3114 for (tail = list; tail; tail = TREE_CHAIN (tail))
3115 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3116 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3117 for (tail = list; tail; tail = TREE_CHAIN (tail))
3118 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3128 /* Return an rtx representing a reference to constant data in memory
3129 for the constant expression EXP.
3131 If assembler code for such a constant has already been output,
3132 return an rtx to refer to it.
3133 Otherwise, output such a constant in memory (or defer it for later)
3134 and generate an rtx for it.
3136 If DEFER is non-zero, the output of string constants can be deferred
3137 and output only if referenced in the function after all optimizations.
3139 The TREE_CST_RTL of EXP is set up to point to that rtx.
3140 The const_hash_table records which constants already have label strings. */
3143 output_constant_def (exp, defer)
3148 register struct constant_descriptor *desc;
3149 struct deferred_string **defstr;
3153 int after_function = 0;
3156 if (TREE_CST_RTL (exp))
3157 return TREE_CST_RTL (exp);
3159 /* Make sure any other constants whose addresses appear in EXP
3160 are assigned label numbers. */
3162 reloc = output_addressed_constants (exp);
3164 /* Compute hash code of EXP. Search the descriptors for that hash code
3165 to see if any of them describes EXP. If yes, the descriptor records
3166 the label number already assigned. */
3168 hash = const_hash (exp) % MAX_HASH_TABLE;
3170 for (desc = const_hash_table[hash]; desc; desc = desc->next)
3171 if (compare_constant (exp, desc))
3176 /* No constant equal to EXP is known to have been output.
3177 Make a constant descriptor to enter EXP in the hash table.
3178 Assign the label number and record it in the descriptor for
3179 future calls to this function to find. */
3181 /* Create a string containing the label name, in LABEL. */
3182 labelno = const_labelno++;
3183 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3185 desc = record_constant (exp);
3186 desc->next = const_hash_table[hash];
3187 desc->label = ggc_strdup (label);
3188 const_hash_table[hash] = desc;
3190 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3192 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3193 gen_rtx_SYMBOL_REF (Pmode, desc->label));
3195 set_mem_attributes (desc->rtl, exp, 1);
3200 TREE_CST_RTL (exp) = desc->rtl;
3202 /* Optionally set flags or add text to the name to record information
3203 such as that it is a function name. If the name is changed, the macro
3204 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3205 #ifdef ENCODE_SECTION_INFO
3206 /* A previously-processed constant would already have section info
3210 ENCODE_SECTION_INFO (exp);
3211 desc->rtl = TREE_CST_RTL (exp);
3212 desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3216 #ifdef CONSTANT_AFTER_FUNCTION_P
3217 if (current_function_decl != 0
3218 && CONSTANT_AFTER_FUNCTION_P (exp))
3223 && STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0))
3224 && (!defer || defer_addressed_constants_flag || after_function))
3226 defstr = (struct deferred_string **)
3227 htab_find_slot_with_hash (const_str_htab, desc->label,
3228 STRHASH (desc->label), NO_INSERT);
3231 /* If the string is currently deferred but we need to output it now,
3232 remove it from deferred string hash table. */
3234 labelno = (*defstr)->labelno;
3235 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 0;
3236 htab_clear_slot (const_str_htab, (void **) defstr);
3240 /* If this is the first time we've seen this particular constant,
3241 output it (or defer its output for later). */
3244 if (defer_addressed_constants_flag || after_function)
3246 struct deferred_constant *p;
3247 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
3249 p->exp = copy_constant (exp);
3251 p->labelno = labelno;
3254 p->next = after_function_constants;
3255 after_function_constants = p;
3259 p->next = deferred_constants;
3260 deferred_constants = p;
3265 /* Do no output if -fsyntax-only. */
3266 if (! flag_syntax_only)
3268 if (TREE_CODE (exp) != STRING_CST
3270 || flag_writable_strings
3271 || (defstr = (struct deferred_string **)
3272 htab_find_slot_with_hash (const_str_htab,
3274 STRHASH (desc->label),
3276 output_constant_def_contents (exp, reloc, labelno);
3279 struct deferred_string *p;
3281 p = (struct deferred_string *)
3282 xmalloc (sizeof (struct deferred_string));
3284 p->exp = copy_constant (exp);
3285 p->label = desc->label;
3286 p->labelno = labelno;
3288 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 1;
3294 return TREE_CST_RTL (exp);
3297 /* Now output assembler code to define the label for EXP,
3298 and follow it with the data of EXP. */
3301 output_constant_def_contents (exp, reloc, labelno)
3308 if (IN_NAMED_SECTION (exp))
3309 named_section (exp, NULL, reloc);
3312 /* First switch to text section, except for writable strings. */
3313 #ifdef SELECT_SECTION
3314 SELECT_SECTION (exp, reloc);
3316 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3317 || (flag_pic && reloc))
3320 readonly_data_section ();
3324 /* Align the location counter as required by EXP's data type. */
3325 align = TYPE_ALIGN (TREE_TYPE (exp));
3326 #ifdef CONSTANT_ALIGNMENT
3327 align = CONSTANT_ALIGNMENT (exp, align);
3330 if (align > BITS_PER_UNIT)
3331 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3333 /* Output the label itself. */
3334 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3336 /* Output the value of EXP. */
3337 output_constant (exp,
3338 (TREE_CODE (exp) == STRING_CST
3339 ? MAX (TREE_STRING_LENGTH (exp),
3340 int_size_in_bytes (TREE_TYPE (exp)))
3341 : int_size_in_bytes (TREE_TYPE (exp))),
3346 /* Structure to represent sufficient information about a constant so that
3347 it can be output when the constant pool is output, so that function
3348 integration can be done, and to simplify handling on machines that reference
3349 constant pool as base+displacement. */
3351 struct pool_constant
3353 struct constant_descriptor *desc;
3354 struct pool_constant *next, *next_sym;
3357 enum machine_mode mode;
3364 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3365 The argument is XSTR (... , 0) */
3367 #define SYMHASH(LABEL) \
3368 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3370 /* Initialize constant pool hashing for a new function. */
3373 init_varasm_status (f)
3376 struct varasm_status *p;
3377 p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3379 p->x_const_rtx_hash_table
3380 = ((struct constant_descriptor **)
3381 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3382 p->x_const_rtx_sym_hash_table
3383 = ((struct pool_constant **)
3384 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3386 p->x_first_pool = p->x_last_pool = 0;
3387 p->x_pool_offset = 0;
3388 p->x_const_double_chain = 0;
3391 /* Mark PC for GC. */
3394 mark_pool_constant (pc)
3395 struct pool_constant *pc;
3400 ggc_mark_rtx (pc->constant);
3405 /* Mark P for GC. */
3408 mark_varasm_status (p)
3409 struct varasm_status *p;
3414 mark_pool_constant (p->x_first_pool);
3415 ggc_mark_rtx (p->x_const_double_chain);
3418 /* Clear out all parts of the state in F that can safely be discarded
3419 after the function has been compiled, to let garbage collection
3420 reclaim the memory. */
3423 free_varasm_status (f)
3426 struct varasm_status *p;
3431 /* Clear out the hash tables. */
3432 for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3434 struct constant_descriptor* cd;
3436 cd = p->x_const_rtx_hash_table[i];
3438 struct constant_descriptor* next = cd->next;
3444 free (p->x_const_rtx_hash_table);
3445 free (p->x_const_rtx_sym_hash_table);
3451 /* Express an rtx for a constant integer (perhaps symbolic)
3452 as the sum of a symbol or label plus an explicit integer.
3453 They are stored into VALUE. */
3456 decode_rtx_const (mode, x, value)
3457 enum machine_mode mode;
3459 struct rtx_const *value;
3461 /* Clear the whole structure, including any gaps. */
3462 memset (value, 0, sizeof (struct rtx_const));
3464 value->kind = RTX_INT; /* Most usual kind. */
3467 switch (GET_CODE (x))
3470 value->kind = RTX_DOUBLE;
3471 if (GET_MODE (x) != VOIDmode)
3473 value->mode = GET_MODE (x);
3474 memcpy ((char *) &value->un.du,
3475 (char *) &CONST_DOUBLE_LOW (x), sizeof value->un.du);
3479 value->un.di.low = CONST_DOUBLE_LOW (x);
3480 value->un.di.high = CONST_DOUBLE_HIGH (x);
3485 value->un.addr.offset = INTVAL (x);
3491 value->un.addr.base = x;
3496 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3498 value->un.addr.base = XEXP (x, 0);
3499 value->un.addr.offset = INTVAL (XEXP (x, 1));
3501 else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3503 value->un.addr.base = XEXP (x, 0);
3504 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3508 value->un.addr.base = x;
3509 value->un.addr.offset = 0;
3517 if (value->kind == RTX_INT && value->un.addr.base != 0)
3518 switch (GET_CODE (value->un.addr.base))
3521 /* Use the string's address, not the SYMBOL_REF's address,
3522 for the sake of addresses of library routines. */
3523 value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3527 /* For a LABEL_REF, compare labels. */
3528 value->un.addr.base = XEXP (value->un.addr.base, 0);
3535 /* Given a MINUS expression, simplify it if both sides
3536 include the same symbol. */
3539 simplify_subtraction (x)
3542 struct rtx_const val0, val1;
3544 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3545 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3547 if (val0.un.addr.base == val1.un.addr.base)
3548 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3552 /* Compute a hash code for a constant RTL expression. */
3555 const_hash_rtx (mode, x)
3556 enum machine_mode mode;
3562 struct rtx_const value;
3563 decode_rtx_const (mode, x, &value);
3565 /* Compute hashing function */
3567 for (i = 0; i < sizeof value / sizeof (int); i++)
3568 hi += ((int *) &value)[i];
3570 hi &= (1 << HASHBITS) - 1;
3571 hi %= MAX_RTX_HASH_TABLE;
3575 /* Compare a constant rtl object X with a constant-descriptor DESC.
3576 Return 1 if DESC describes a constant with the same value as X. */
3579 compare_constant_rtx (mode, x, desc)
3580 enum machine_mode mode;
3582 struct constant_descriptor *desc;
3584 register int *p = (int *) desc->u.contents;
3587 struct rtx_const value;
3589 decode_rtx_const (mode, x, &value);
3590 strp = (int *) &value;
3591 len = sizeof value / sizeof (int);
3593 /* Compare constant contents. */
3595 if (*p++ != *strp++)
3601 /* Construct a constant descriptor for the rtl-expression X.
3602 It is up to the caller to enter the descriptor in the hash table. */
3604 static struct constant_descriptor *
3605 record_constant_rtx (mode, x)
3606 enum machine_mode mode;
3609 struct constant_descriptor *ptr;
3611 ptr = ((struct constant_descriptor *)
3612 xcalloc (1, (offsetof (struct constant_descriptor, u)
3613 + sizeof (struct rtx_const))));
3614 decode_rtx_const (mode, x, (struct rtx_const *) ptr->u.contents);
3619 /* Given a constant rtx X, make (or find) a memory constant for its value
3620 and return a MEM rtx to refer to it in memory. */
3623 force_const_mem (mode, x)
3624 enum machine_mode mode;
3628 register struct constant_descriptor *desc;
3630 const char *found = 0;
3633 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3634 (this will always be true for floating CONST_DOUBLEs that have been
3635 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3636 use the previous copy. Otherwise, make a new one. Note that in
3637 the unlikely event that this same CONST_DOUBLE is used in two different
3638 modes in an alternating fashion, we will allocate a lot of different
3639 memory locations, but this should be extremely rare. */
3641 if (GET_CODE (x) == CONST_DOUBLE
3642 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3643 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3644 return CONST_DOUBLE_MEM (x);
3646 /* Compute hash code of X. Search the descriptors for that hash code
3647 to see if any of them describes X. If yes, the descriptor records
3648 the label number already assigned. */
3650 hash = const_hash_rtx (mode, x);
3652 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3653 if (compare_constant_rtx (mode, x, desc))
3655 found = desc->label;
3661 register struct pool_constant *pool;
3664 /* No constant equal to X is known to have been output.
3665 Make a constant descriptor to enter X in the hash table.
3666 Assign the label number and record it in the descriptor for
3667 future calls to this function to find. */
3669 desc = record_constant_rtx (mode, x);
3670 desc->next = const_rtx_hash_table[hash];
3671 const_rtx_hash_table[hash] = desc;
3673 /* Align the location counter as required by EXP's data type. */
3674 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3675 #ifdef CONSTANT_ALIGNMENT
3676 align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x),
3680 pool_offset += (align / BITS_PER_UNIT) - 1;
3681 pool_offset &= ~ ((align / BITS_PER_UNIT) - 1);
3683 if (GET_CODE (x) == LABEL_REF)
3684 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3686 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3688 pool = (struct pool_constant *) ggc_alloc (sizeof (struct pool_constant));
3692 pool->labelno = const_labelno;
3693 pool->align = align;
3694 pool->offset = pool_offset;
3701 last_pool->next = pool;
3704 pool_offset += GET_MODE_SIZE (mode);
3706 /* Create a string containing the label name, in LABEL. */
3707 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3711 desc->label = found = ggc_strdup (label);
3713 /* Add label to symbol hash table. */
3714 hash = SYMHASH (found);
3715 pool->label = found;
3716 pool->next_sym = const_rtx_sym_hash_table[hash];
3717 const_rtx_sym_hash_table[hash] = pool;
3720 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3722 def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, found));
3723 set_mem_attributes (def, type_for_mode (mode, 0), 1);
3724 RTX_UNCHANGING_P (def) = 1;
3726 /* Mark the symbol_ref as belonging to this constants pool. */
3727 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3728 current_function_uses_const_pool = 1;
3730 if (GET_CODE (x) == CONST_DOUBLE)
3732 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3734 CONST_DOUBLE_CHAIN (x) = const_double_chain;
3735 const_double_chain = x;
3737 CONST_DOUBLE_MEM (x) = def;
3743 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3744 the corresponding pool_constant structure. */
3746 static struct pool_constant *
3747 find_pool_constant (f, addr)
3751 struct pool_constant *pool;
3752 const char *label = XSTR (addr, 0);
3754 for (pool = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; pool;
3755 pool = pool->next_sym)
3756 if (pool->label == label)
3762 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3765 get_pool_constant (addr)
3768 return (find_pool_constant (cfun, addr))->constant;
3771 /* Likewise, but for the constant pool of a specific function. */
3774 get_pool_constant_for_function (f, addr)
3778 return (find_pool_constant (f, addr))->constant;
3781 /* Similar, return the mode. */
3784 get_pool_mode (addr)
3787 return (find_pool_constant (cfun, addr))->mode;
3791 get_pool_mode_for_function (f, addr)
3795 return (find_pool_constant (f, addr))->mode;
3798 /* Similar, return the offset in the constant pool. */
3801 get_pool_offset (addr)
3804 return (find_pool_constant (cfun, addr))->offset;
3807 /* Return the size of the constant pool. */
3815 /* Write all the constants in the constant pool. */
3818 output_constant_pool (fnname, fndecl)
3819 const char *fnname ATTRIBUTE_UNUSED;
3820 tree fndecl ATTRIBUTE_UNUSED;
3822 struct pool_constant *pool;
3824 union real_extract u;
3826 /* It is possible for gcc to call force_const_mem and then to later
3827 discard the instructions which refer to the constant. In such a
3828 case we do not need to output the constant. */
3829 mark_constant_pool ();
3831 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3832 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3835 for (pool = first_pool; pool; pool = pool->next)
3844 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3845 whose CODE_LABEL has been deleted. This can occur if a jump table
3846 is eliminated by optimization. If so, write a constant of zero
3847 instead. Note that this can also happen by turning the
3848 CODE_LABEL into a NOTE. */
3849 /* ??? This seems completely and utterly wrong. Certainly it's
3850 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3851 functioning even with INSN_DELETED_P and friends. */
3854 switch (GET_CODE (x))
3857 if (GET_CODE (XEXP (x, 0)) != PLUS
3858 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3860 tmp = XEXP (XEXP (x, 0), 0);
3865 if (INSN_DELETED_P (tmp)
3866 || (GET_CODE (tmp) == NOTE
3867 && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3878 /* First switch to correct section. */
3879 #ifdef SELECT_RTX_SECTION
3880 SELECT_RTX_SECTION (pool->mode, x);
3882 readonly_data_section ();
3885 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3886 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3887 pool->align, pool->labelno, done);
3890 assemble_align (pool->align);
3892 /* Output the label. */
3893 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3895 /* Output the value of the constant itself. */
3896 switch (GET_MODE_CLASS (pool->mode))
3899 if (GET_CODE (x) != CONST_DOUBLE)
3902 memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
3903 assemble_real (u.d, pool->mode, pool->align);
3907 case MODE_PARTIAL_INT:
3908 assemble_integer (x, GET_MODE_SIZE (pool->mode), pool->align, 1);
3915 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3920 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3921 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3924 /* Done with this pool. */
3925 first_pool = last_pool = 0;
3928 /* Look through the instructions for this function, and mark all the
3929 entries in the constant pool which are actually being used.
3930 Emit used deferred strings. */
3933 mark_constant_pool ()
3936 struct pool_constant *pool;
3938 if (first_pool == 0 && htab_elements (const_str_htab) == 0)
3941 for (pool = first_pool; pool; pool = pool->next)
3944 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3946 mark_constants (PATTERN (insn));
3948 for (insn = current_function_epilogue_delay_list;
3950 insn = XEXP (insn, 1))
3952 mark_constants (PATTERN (insn));
3955 /* Look through appropriate parts of X, marking all entries in the
3956 constant pool which are actually being used. Entries that are only
3957 referenced by other constants are also marked as used. Emit
3958 deferred strings that are used. */
3965 register const char *format_ptr;
3970 if (GET_CODE (x) == SYMBOL_REF)
3972 mark_constant (&x, NULL);
3975 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3976 a MEM, but does not constitute a use of that MEM. */
3977 else if (GET_CODE (x) == CONST_DOUBLE)
3980 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3981 insns, not any notes that may be attached. We don't want to mark
3982 a constant just because it happens to appear in a REG_EQUIV note. */
3985 mark_constants (PATTERN (x));
3989 format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3991 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
3993 switch (*format_ptr++)
3996 mark_constants (XEXP (x, i));
4000 if (XVEC (x, i) != 0)
4004 for (j = 0; j < XVECLEN (x, i); j++)
4005 mark_constants (XVECEXP (x, i, j));
4024 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
4025 to as used. Emit referenced deferred strings. This function can
4026 be used with for_each_rtx () to mark all SYMBOL_REFs in an rtx. */
4029 mark_constant (current_rtx, data)
4031 void *data ATTRIBUTE_UNUSED;
4033 rtx x = *current_rtx;
4037 else if (GET_CODE(x) == CONST_DOUBLE)
4038 /* Never search inside a CONST_DOUBLE because CONST_DOUBLE_MEM may
4039 be a MEM but does not constitute a use of that MEM. */
4041 else if (GET_CODE (x) == SYMBOL_REF)
4043 if (CONSTANT_POOL_ADDRESS_P (x))
4045 struct pool_constant *pool = find_pool_constant (cfun, x);
4046 if (pool->mark == 0) {
4048 for_each_rtx (&(pool->constant), &mark_constant, NULL);
4053 else if (STRING_POOL_ADDRESS_P (x))
4055 struct deferred_string **defstr;
4057 defstr = (struct deferred_string **)
4058 htab_find_slot_with_hash (const_str_htab, XSTR (x, 0),
4059 STRHASH (XSTR (x, 0)), NO_INSERT);
4062 struct deferred_string *p = *defstr;
4064 STRING_POOL_ADDRESS_P (x) = 0;
4065 output_constant_def_contents (p->exp, 0, p->labelno);
4066 htab_clear_slot (const_str_htab, (void **) defstr);
4073 /* Find all the constants whose addresses are referenced inside of EXP,
4074 and make sure assembler code with a label has been output for each one.
4075 Indicate whether an ADDR_EXPR has been encountered. */
4078 output_addressed_constants (exp)
4083 /* Give the front-end a chance to convert VALUE to something that
4084 looks more like a constant to the back-end. */
4085 if (lang_expand_constant)
4086 exp = (*lang_expand_constant) (exp);
4088 switch (TREE_CODE (exp))
4092 register tree constant = TREE_OPERAND (exp, 0);
4094 while (TREE_CODE (constant) == COMPONENT_REF)
4096 constant = TREE_OPERAND (constant, 0);
4099 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
4100 || TREE_CODE (constant) == CONSTRUCTOR)
4101 /* No need to do anything here
4102 for addresses of variables or functions. */
4103 output_constant_def (constant, 0);
4110 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4111 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
4116 case NON_LVALUE_EXPR:
4117 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4123 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
4124 if (TREE_VALUE (link) != 0)
4125 reloc |= output_addressed_constants (TREE_VALUE (link));
4135 /* Return nonzero if VALUE is a valid constant-valued expression
4136 for use in initializing a static variable; one that can be an
4137 element of a "constant" initializer.
4139 Return null_pointer_node if the value is absolute;
4140 if it is relocatable, return the variable that determines the relocation.
4141 We assume that VALUE has been folded as much as possible;
4142 therefore, we do not need to check for such things as
4143 arithmetic-combinations of integers. */
4146 initializer_constant_valid_p (value, endtype)
4150 /* Give the front-end a chance to convert VALUE to something that
4151 looks more like a constant to the back-end. */
4152 if (lang_expand_constant)
4153 value = (*lang_expand_constant) (value);
4155 switch (TREE_CODE (value))
4158 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4159 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4160 && TREE_CONSTANT (value)
4161 && CONSTRUCTOR_ELTS (value))
4163 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4166 return TREE_STATIC (value) ? null_pointer_node : 0;
4172 return null_pointer_node;
4175 return staticp (TREE_OPERAND (value, 0)) ? TREE_OPERAND (value, 0) : 0;
4177 case NON_LVALUE_EXPR:
4178 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4182 /* Allow conversions between pointer types. */
4183 if (POINTER_TYPE_P (TREE_TYPE (value))
4184 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4185 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4187 /* Allow conversions between real types. */
4188 if (FLOAT_TYPE_P (TREE_TYPE (value))
4189 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4190 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4192 /* Allow length-preserving conversions between integer types. */
4193 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4194 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4195 && (TYPE_PRECISION (TREE_TYPE (value))
4196 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4197 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4199 /* Allow conversions between other integer types only if
4201 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4202 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4204 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4206 if (inner == null_pointer_node)
4207 return null_pointer_node;
4211 /* Allow (int) &foo provided int is as wide as a pointer. */
4212 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4213 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4214 && (TYPE_PRECISION (TREE_TYPE (value))
4215 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4216 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4219 /* Likewise conversions from int to pointers, but also allow
4220 conversions from 0. */
4221 if (POINTER_TYPE_P (TREE_TYPE (value))
4222 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4224 if (integer_zerop (TREE_OPERAND (value, 0)))
4225 return null_pointer_node;
4226 else if (TYPE_PRECISION (TREE_TYPE (value))
4227 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4228 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4232 /* Allow conversions to union types if the value inside is okay. */
4233 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4234 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4239 if (! INTEGRAL_TYPE_P (endtype)
4240 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4242 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4244 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4246 /* If either term is absolute, use the other terms relocation. */
4247 if (valid0 == null_pointer_node)
4249 if (valid1 == null_pointer_node)
4255 if (! INTEGRAL_TYPE_P (endtype)
4256 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4258 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4260 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4262 /* Win if second argument is absolute. */
4263 if (valid1 == null_pointer_node)
4265 /* Win if both arguments have the same relocation.
4266 Then the value is absolute. */
4267 if (valid0 == valid1 && valid0 != 0)
4268 return null_pointer_node;
4270 /* Since GCC guarantees that string constants are unique in the
4271 generated code, a subtraction between two copies of the same
4272 constant string is absolute. */
4273 if (valid0 && TREE_CODE (valid0) == STRING_CST &&
4274 valid1 && TREE_CODE (valid1) == STRING_CST &&
4275 TREE_STRING_POINTER (valid0) == TREE_STRING_POINTER (valid1))
4276 return null_pointer_node;
4279 /* Support differences between labels. */
4280 if (INTEGRAL_TYPE_P (endtype))
4283 op0 = TREE_OPERAND (value, 0);
4284 op1 = TREE_OPERAND (value, 1);
4288 if (TREE_CODE (op0) == ADDR_EXPR
4289 && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
4290 && TREE_CODE (op1) == ADDR_EXPR
4291 && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
4292 return null_pointer_node;
4303 /* Output assembler code for constant EXP to FILE, with no label.
4304 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4305 Assumes output_addressed_constants has been done on EXP already.
4307 Generate exactly SIZE bytes of assembler data, padding at the end
4308 with zeros if necessary. SIZE must always be specified.
4310 SIZE is important for structure constructors,
4311 since trailing members may have been omitted from the constructor.
4312 It is also important for initialization of arrays from string constants
4313 since the full length of the string constant might not be wanted.
4314 It is also needed for initialization of unions, where the initializer's
4315 type is just one member, and that may not be as long as the union.
4317 There a case in which we would fail to output exactly SIZE bytes:
4318 for a structure constructor that wants to produce more than SIZE bytes.
4319 But such constructors will never be generated for any possible input.
4321 ALIGN is the alignment of the data in bits. */
4324 output_constant (exp, size, align)
4329 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
4331 /* Some front-ends use constants other than the standard
4332 language-indepdent varieties, but which may still be output
4333 directly. Give the front-end a chance to convert EXP to a
4334 language-independent representation. */
4335 if (lang_expand_constant)
4337 exp = (*lang_expand_constant) (exp);
4338 code = TREE_CODE (TREE_TYPE (exp));
4341 if (size == 0 || flag_syntax_only)
4344 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4345 That way we get the constant (we hope) inside it. Also, strip off any
4346 NOP_EXPR that converts between two record, union, array, or set types
4347 or a CONVERT_EXPR that converts to a union TYPE. */
4348 while ((TREE_CODE (exp) == NOP_EXPR
4349 && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
4350 || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
4351 || (TREE_CODE (exp) == CONVERT_EXPR
4352 && code == UNION_TYPE)
4353 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4355 exp = TREE_OPERAND (exp, 0);
4356 code = TREE_CODE (TREE_TYPE (exp));
4359 /* Allow a constructor with no elements for any data type.
4360 This means to fill the space with zeros. */
4361 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
4363 assemble_zeros (size);
4374 case REFERENCE_TYPE:
4375 /* ??? What about (int)((float)(int)&foo + 4) */
4376 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4377 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4378 exp = TREE_OPERAND (exp, 0);
4380 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4381 EXPAND_INITIALIZER),
4383 error ("initializer for integer value is too complicated");
4388 if (TREE_CODE (exp) != REAL_CST)
4389 error ("initializer for floating value is not a floating constant");
4391 assemble_real (TREE_REAL_CST (exp),
4392 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0),
4398 output_constant (TREE_REALPART (exp), size / 2, align);
4399 output_constant (TREE_IMAGPART (exp), size / 2,
4400 min_align (align, BITS_PER_UNIT * (size / 2)));
4401 size -= (size / 2) * 2;
4405 if (TREE_CODE (exp) == CONSTRUCTOR)
4407 output_constructor (exp, size, align);
4410 else if (TREE_CODE (exp) == STRING_CST)
4414 if (size > TREE_STRING_LENGTH (exp))
4416 excess = size - TREE_STRING_LENGTH (exp);
4417 size = TREE_STRING_LENGTH (exp);
4420 assemble_string (TREE_STRING_POINTER (exp), size);
4429 if (TREE_CODE (exp) == CONSTRUCTOR)
4430 output_constructor (exp, size, align);
4436 if (TREE_CODE (exp) == INTEGER_CST)
4437 assemble_integer (expand_expr (exp, NULL_RTX,
4438 VOIDmode, EXPAND_INITIALIZER),
4440 else if (TREE_CODE (exp) == CONSTRUCTOR)
4442 unsigned char *buffer = (unsigned char *) alloca (size);
4443 if (get_set_constructor_bytes (exp, buffer, size))
4445 assemble_string ((char *) buffer, size);
4448 error ("unknown set constructor type");
4456 assemble_zeros (size);
4460 /* Subroutine of output_constructor, used for computing the size of
4461 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4462 type with an unspecified upper bound. */
4464 static unsigned HOST_WIDE_INT
4465 array_size_for_constructor (val)
4470 max_index = NULL_TREE;
4471 for (i = CONSTRUCTOR_ELTS (val); i ; i = TREE_CHAIN (i))
4473 tree index = TREE_PURPOSE (i);
4475 if (TREE_CODE (index) == RANGE_EXPR)
4476 index = TREE_OPERAND (index, 1);
4477 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4481 if (max_index == NULL_TREE)
4484 /* Compute the total number of array elements. */
4485 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4487 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4488 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
4490 /* Multiply by the array element unit size to find number of bytes. */
4491 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4493 return tree_low_cst (i, 1);
4496 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4497 Generate at least SIZE bytes, padding if necessary. */
4500 output_constructor (exp, size, align)
4505 tree type = TREE_TYPE (exp);
4506 register tree link, field = 0;
4508 /* Number of bytes output or skipped so far.
4509 In other words, current position within the constructor. */
4510 HOST_WIDE_INT total_bytes = 0;
4511 /* Non-zero means BYTE contains part of a byte, to be output. */
4512 int byte_buffer_in_use = 0;
4513 register int byte = 0;
4515 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4518 if (TREE_CODE (type) == RECORD_TYPE)
4519 field = TYPE_FIELDS (type);
4521 if (TREE_CODE (type) == ARRAY_TYPE
4522 && TYPE_DOMAIN (type) != 0)
4523 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4525 /* As LINK goes through the elements of the constant,
4526 FIELD goes through the structure fields, if the constant is a structure.
4527 if the constant is a union, then we override this,
4528 by getting the field from the TREE_LIST element.
4529 But the constant could also be an array. Then FIELD is zero.
4531 There is always a maximum of one element in the chain LINK for unions
4532 (even if the initializer in a source program incorrectly contains
4534 for (link = CONSTRUCTOR_ELTS (exp);
4536 link = TREE_CHAIN (link),
4537 field = field ? TREE_CHAIN (field) : 0)
4539 tree val = TREE_VALUE (link);
4542 /* The element in a union constructor specifies the proper field
4544 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4545 || TREE_CODE (type) == QUAL_UNION_TYPE)
4546 && TREE_PURPOSE (link) != 0)
4547 field = TREE_PURPOSE (link);
4549 else if (TREE_CODE (type) == ARRAY_TYPE)
4550 index = TREE_PURPOSE (link);
4552 /* Eliminate the marker that makes a cast not be an lvalue. */
4556 if (index && TREE_CODE (index) == RANGE_EXPR)
4558 unsigned HOST_WIDE_INT fieldsize
4559 = int_size_in_bytes (TREE_TYPE (type));
4560 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4561 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4562 HOST_WIDE_INT index;
4563 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4565 for (index = lo_index; index <= hi_index; index++)
4567 /* Output the element's initial value. */
4569 assemble_zeros (fieldsize);
4571 output_constant (val, fieldsize, align2);
4573 /* Count its size. */
4574 total_bytes += fieldsize;
4577 else if (field == 0 || !DECL_BIT_FIELD (field))
4579 /* An element that is not a bit-field. */
4581 unsigned HOST_WIDE_INT fieldsize;
4582 /* Since this structure is static,
4583 we know the positions are constant. */
4584 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4585 unsigned int align2;
4588 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4589 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4591 /* Output any buffered-up bit-fields preceding this element. */
4592 if (byte_buffer_in_use)
4594 ASM_OUTPUT_BYTE (asm_out_file, byte);
4596 byte_buffer_in_use = 0;
4599 /* Advance to offset of this element.
4600 Note no alignment needed in an array, since that is guaranteed
4601 if each element has the proper size. */
4602 if ((field != 0 || index != 0) && pos != total_bytes)
4604 assemble_zeros (pos - total_bytes);
4608 /* Find the alignment of this element. */
4609 align2 = min_align (align, BITS_PER_UNIT * pos);
4611 /* Determine size this element should occupy. */
4616 /* If this is an array with an unspecified upper bound,
4617 the initializer determines the size. */
4618 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4619 but we cannot do this until the deprecated support for
4620 initializing zero-length array members is removed. */
4621 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4622 && TYPE_DOMAIN (TREE_TYPE (field))
4623 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4625 fieldsize = array_size_for_constructor (val);
4626 /* Given a non-empty initialization, this field had
4628 if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
4631 else if (DECL_SIZE_UNIT (field))
4633 /* ??? This can't be right. If the decl size overflows
4634 a host integer we will silently emit no data. */
4635 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4636 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4640 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4642 /* Output the element's initial value. */
4644 assemble_zeros (fieldsize);
4646 output_constant (val, fieldsize, align2);
4648 /* Count its size. */
4649 total_bytes += fieldsize;
4651 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4652 error ("invalid initial value for member `%s'",
4653 IDENTIFIER_POINTER (DECL_NAME (field)));
4656 /* Element that is a bit-field. */
4658 HOST_WIDE_INT next_offset = int_bit_position (field);
4659 HOST_WIDE_INT end_offset
4660 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4663 val = integer_zero_node;
4665 /* If this field does not start in this (or, next) byte,
4667 if (next_offset / BITS_PER_UNIT != total_bytes)
4669 /* Output remnant of any bit field in previous bytes. */
4670 if (byte_buffer_in_use)
4672 ASM_OUTPUT_BYTE (asm_out_file, byte);
4674 byte_buffer_in_use = 0;
4677 /* If still not at proper byte, advance to there. */
4678 if (next_offset / BITS_PER_UNIT != total_bytes)
4680 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4681 total_bytes = next_offset / BITS_PER_UNIT;
4685 if (! byte_buffer_in_use)
4688 /* We must split the element into pieces that fall within
4689 separate bytes, and combine each byte with previous or
4690 following bit-fields. */
4692 /* next_offset is the offset n fbits from the beginning of
4693 the structure to the next bit of this element to be processed.
4694 end_offset is the offset of the first bit past the end of
4696 while (next_offset < end_offset)
4700 HOST_WIDE_INT value;
4701 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4702 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4704 /* Advance from byte to byte
4705 within this element when necessary. */
4706 while (next_byte != total_bytes)
4708 ASM_OUTPUT_BYTE (asm_out_file, byte);
4713 /* Number of bits we can process at once
4714 (all part of the same byte). */
4715 this_time = MIN (end_offset - next_offset,
4716 BITS_PER_UNIT - next_bit);
4717 if (BYTES_BIG_ENDIAN)
4719 /* On big-endian machine, take the most significant bits
4720 first (of the bits that are significant)
4721 and put them into bytes from the most significant end. */
4722 shift = end_offset - next_offset - this_time;
4724 /* Don't try to take a bunch of bits that cross
4725 the word boundary in the INTEGER_CST. We can
4726 only select bits from the LOW or HIGH part
4728 if (shift < HOST_BITS_PER_WIDE_INT
4729 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4731 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4732 shift = HOST_BITS_PER_WIDE_INT;
4735 /* Now get the bits from the appropriate constant word. */
4736 if (shift < HOST_BITS_PER_WIDE_INT)
4737 value = TREE_INT_CST_LOW (val);
4738 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4740 value = TREE_INT_CST_HIGH (val);
4741 shift -= HOST_BITS_PER_WIDE_INT;
4746 /* Get the result. This works only when:
4747 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4748 byte |= (((value >> shift)
4749 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4750 << (BITS_PER_UNIT - this_time - next_bit));
4754 /* On little-endian machines,
4755 take first the least significant bits of the value
4756 and pack them starting at the least significant
4757 bits of the bytes. */
4758 shift = next_offset - int_bit_position (field);
4760 /* Don't try to take a bunch of bits that cross
4761 the word boundary in the INTEGER_CST. We can
4762 only select bits from the LOW or HIGH part
4764 if (shift < HOST_BITS_PER_WIDE_INT
4765 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4766 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4768 /* Now get the bits from the appropriate constant word. */
4769 if (shift < HOST_BITS_PER_WIDE_INT)
4770 value = TREE_INT_CST_LOW (val);
4771 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4773 value = TREE_INT_CST_HIGH (val);
4774 shift -= HOST_BITS_PER_WIDE_INT;
4779 /* Get the result. This works only when:
4780 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4781 byte |= (((value >> shift)
4782 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4786 next_offset += this_time;
4787 byte_buffer_in_use = 1;
4792 if (byte_buffer_in_use)
4794 ASM_OUTPUT_BYTE (asm_out_file, byte);
4798 if (total_bytes < size)
4799 assemble_zeros (size - total_bytes);
4803 /* This structure contains any weak symbol declarations waiting
4807 struct weak_syms * next;
4812 static struct weak_syms * weak_decls;
4814 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4815 associated with NAME. */
4818 add_weak (name, value)
4822 struct weak_syms *weak;
4824 weak = (struct weak_syms *) xmalloc (sizeof (struct weak_syms));
4829 weak->next = weak_decls;
4831 weak->value = value;
4837 /* Declare DECL to be a weak symbol. */
4843 if (! TREE_PUBLIC (decl))
4844 error_with_decl (decl, "weak declaration of `%s' must be public");
4845 else if (TREE_ASM_WRITTEN (decl))
4846 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4847 else if (SUPPORTS_WEAK)
4848 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4850 warning_with_decl (decl, "weak declaration of `%s' not supported");
4852 DECL_WEAK (decl) = 1;
4855 /* Emit any pending weak declarations. */
4862 struct weak_syms *t;
4863 for (t = weak_decls; t; t = t->next)
4865 #ifdef ASM_OUTPUT_WEAK_ALIAS
4866 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, t->name, t->value);
4868 #ifdef ASM_WEAKEN_LABEL
4871 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4878 /* Remove NAME from the pending list of weak symbols. This prevents
4879 the compiler from emitting multiple .weak directives which confuses
4882 remove_from_pending_weak_list (name)
4885 struct weak_syms *t;
4886 struct weak_syms **p;
4888 for (p = &weak_decls; *p; )
4891 if (strcmp (name, t->name) == 0)
4901 /* Emit an assembler directive to make the symbol for DECL an alias to
4902 the symbol for TARGET. */
4905 assemble_alias (decl, target)
4906 tree decl, target ATTRIBUTE_UNUSED;
4910 /* We must force creation of DECL_RTL for debug info generation, even though
4911 we don't use it here. */
4912 make_decl_rtl (decl, NULL);
4914 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4916 #ifdef ASM_OUTPUT_DEF
4917 /* Make name accessible from other files, if appropriate. */
4919 if (TREE_PUBLIC (decl))
4921 #ifdef ASM_WEAKEN_LABEL
4922 if (DECL_WEAK (decl))
4924 ASM_WEAKEN_LABEL (asm_out_file, name);
4925 /* Remove this function from the pending weak list so that
4926 we do not emit multiple .weak directives for it. */
4927 remove_from_pending_weak_list
4928 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4932 ASM_GLOBALIZE_LABEL (asm_out_file, name);
4935 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4936 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4938 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4940 TREE_ASM_WRITTEN (decl) = 1;
4942 #ifdef ASM_OUTPUT_WEAK_ALIAS
4943 if (! DECL_WEAK (decl))
4944 warning ("only weak aliases are supported in this configuration");
4946 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4947 TREE_ASM_WRITTEN (decl) = 1;
4949 warning ("alias definitions not supported in this configuration; ignored");
4954 /* Returns 1 if the target configuration supports defining public symbols
4955 so that one of them will be chosen at link time instead of generating a
4956 multiply-defined symbol error, whether through the use of weak symbols or
4957 a target-specific mechanism for having duplicates discarded. */
4960 supports_one_only ()
4962 if (SUPPORTS_ONE_ONLY)
4964 return SUPPORTS_WEAK;
4967 /* Set up DECL as a public symbol that can be defined in multiple
4968 translation units without generating a linker error. */
4971 make_decl_one_only (decl)
4974 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4977 TREE_PUBLIC (decl) = 1;
4979 if (TREE_CODE (decl) == VAR_DECL
4980 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4981 DECL_COMMON (decl) = 1;
4982 else if (SUPPORTS_ONE_ONLY)
4984 #ifdef MAKE_DECL_ONE_ONLY
4985 MAKE_DECL_ONE_ONLY (decl);
4987 DECL_ONE_ONLY (decl) = 1;
4989 else if (SUPPORTS_WEAK)
4990 DECL_WEAK (decl) = 1;
4998 const_str_htab = htab_create (128, const_str_htab_hash, const_str_htab_eq,
4999 const_str_htab_del);
5000 in_named_htab = htab_create (31, in_named_entry_hash,
5001 in_named_entry_eq, NULL);
5003 ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
5004 mark_const_hash_entry);
5005 ggc_add_root (&const_str_htab, 1, sizeof const_str_htab,
5006 mark_const_str_htab);
5009 /* Select a set of attributes for section NAME based on the properties
5010 of DECL and whether or not RELOC indicates that DECL's initializer
5011 might contain runtime relocations.
5013 We make the section read-only and executable for a function decl,
5014 read-only for a const data decl, and writable for a non-const data decl. */
5017 default_section_type_flags (decl, name, reloc)
5024 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5025 flags = SECTION_CODE;
5026 else if (decl && DECL_READONLY_SECTION (decl, reloc))
5029 flags = SECTION_WRITE;
5031 if (decl && DECL_ONE_ONLY (decl))
5032 flags |= SECTION_LINKONCE;
5034 if (strcmp (name, ".bss") == 0
5035 || strncmp (name, ".bss.", 5) == 0
5036 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5037 || strcmp (name, ".sbss") == 0
5038 || strncmp (name, ".sbss.", 6) == 0
5039 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5040 flags |= SECTION_BSS;
5045 /* Output assembly to switch to section NAME with attribute FLAGS.
5046 Four variants for common object file formats. */
5049 default_no_named_section (name, flags)
5050 const char *name ATTRIBUTE_UNUSED;
5051 unsigned int flags ATTRIBUTE_UNUSED;
5053 /* Some object formats don't support named sections at all. The
5054 front-end should already have flagged this as an error. */
5059 default_elf_asm_named_section (name, flags)
5063 char flagchars[8], *f = flagchars;
5066 if (!(flags & SECTION_DEBUG))
5068 if (flags & SECTION_WRITE)
5070 if (flags & SECTION_CODE)
5072 if (flags & SECTION_SMALL)
5076 if (flags & SECTION_BSS)
5081 fprintf (asm_out_file, "\t.section\t%s,\"%s\",@%s\n",
5082 name, flagchars, type);
5086 default_coff_asm_named_section (name, flags)
5090 char flagchars[8], *f = flagchars;
5092 if (flags & SECTION_WRITE)
5094 if (flags & SECTION_CODE)
5098 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5102 default_pe_asm_named_section (name, flags)
5106 default_coff_asm_named_section (name, flags);
5108 if (flags & SECTION_LINKONCE)
5110 /* Functions may have been compiled at various levels of
5111 optimization so we can't use `same_size' here.
5112 Instead, have the linker pick one. */
5113 fprintf (asm_out_file, "\t.linkonce %s\n",
5114 (flags & SECTION_CODE ? "discard" : "same_size"));