* cfgloop.c (flow_loop_entry_edges_find): Fix typo.
[official-gcc.git] / gcc / varasm.c
blob419791d63630503064e110b1a8f3c3e23071429b
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
10 version.
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
15 for more details.
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
20 02111-1307, USA. */
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
30 #include "config.h"
31 #include "system.h"
32 #include "rtl.h"
33 #include "tree.h"
34 #include "flags.h"
35 #include "function.h"
36 #include "expr.h"
37 #include "hard-reg-set.h"
38 #include "regs.h"
39 #include "output.h"
40 #include "real.h"
41 #include "toplev.h"
42 #include "obstack.h"
43 #include "hashtab.h"
44 #include "c-pragma.h"
45 #include "ggc.h"
46 #include "langhooks.h"
47 #include "tm_p.h"
48 #include "debug.h"
49 #include "target.h"
51 #ifdef XCOFF_DEBUGGING_INFO
52 #include "xcoffout.h" /* Needed for external data
53 declarations for e.g. AIX 4.x. */
54 #endif
56 #ifndef TRAMPOLINE_ALIGNMENT
57 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
58 #endif
60 #ifndef ASM_STABS_OP
61 #define ASM_STABS_OP "\t.stabs\t"
62 #endif
64 /* The (assembler) name of the first globally-visible object output. */
65 const char *first_global_object_name;
66 const char *weak_global_object_name;
68 extern struct obstack permanent_obstack;
69 #define obstack_chunk_alloc xmalloc
71 struct addr_const;
72 struct constant_descriptor;
73 struct rtx_const;
74 struct pool_constant;
76 #define MAX_RTX_HASH_TABLE 61
78 struct varasm_status
80 /* Hash facility for making memory-constants
81 from constant rtl-expressions. It is used on RISC machines
82 where immediate integer arguments and constant addresses are restricted
83 so that such constants must be stored in memory.
85 This pool of constants is reinitialized for each function
86 so each function gets its own constants-pool that comes right before
87 it. */
88 struct constant_descriptor **x_const_rtx_hash_table;
89 struct pool_constant **x_const_rtx_sym_hash_table;
91 /* Pointers to first and last constant in pool. */
92 struct pool_constant *x_first_pool, *x_last_pool;
94 /* Current offset in constant pool (does not include any machine-specific
95 header). */
96 HOST_WIDE_INT x_pool_offset;
98 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
99 They are chained through the CONST_DOUBLE_CHAIN. */
100 rtx x_const_double_chain;
103 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
104 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
105 #define first_pool (cfun->varasm->x_first_pool)
106 #define last_pool (cfun->varasm->x_last_pool)
107 #define pool_offset (cfun->varasm->x_pool_offset)
108 #define const_double_chain (cfun->varasm->x_const_double_chain)
110 /* Number for making the label on the next
111 constant that is stored in memory. */
113 int const_labelno;
115 /* Number for making the label on the next
116 static variable internal to a function. */
118 int var_labelno;
120 /* Carry information from ASM_DECLARE_OBJECT_NAME
121 to ASM_FINISH_DECLARE_OBJECT. */
123 int size_directive_output;
125 /* The last decl for which assemble_variable was called,
126 if it did ASM_DECLARE_OBJECT_NAME.
127 If the last call to assemble_variable didn't do that,
128 this holds 0. */
130 tree last_assemble_variable_decl;
132 /* RTX_UNCHANGING_P in a MEM can mean it is stored into, for initialization.
133 So giving constant the alias set for the type will allow such
134 initializations to appear to conflict with the load of the constant. We
135 avoid this by giving all constants an alias set for just constants.
136 Since there will be no stores to that a alias set, nothing will ever
137 conflict with them. */
139 static HOST_WIDE_INT const_alias_set;
141 static const char *strip_reg_name PARAMS ((const char *));
142 static int contains_pointers_p PARAMS ((tree));
143 static void decode_addr_const PARAMS ((tree, struct addr_const *));
144 static int const_hash PARAMS ((tree));
145 static int compare_constant PARAMS ((tree,
146 struct constant_descriptor *));
147 static const unsigned char *compare_constant_1 PARAMS ((tree, const unsigned char *));
148 static struct constant_descriptor *record_constant PARAMS ((tree));
149 static void record_constant_1 PARAMS ((tree));
150 static tree copy_constant PARAMS ((tree));
151 static void output_constant_def_contents PARAMS ((tree, int, int));
152 static void decode_rtx_const PARAMS ((enum machine_mode, rtx,
153 struct rtx_const *));
154 static int const_hash_rtx PARAMS ((enum machine_mode, rtx));
155 static int compare_constant_rtx PARAMS ((enum machine_mode, rtx,
156 struct constant_descriptor *));
157 static struct constant_descriptor *record_constant_rtx PARAMS ((enum machine_mode,
158 rtx));
159 static struct pool_constant *find_pool_constant PARAMS ((struct function *, rtx));
160 static void mark_constant_pool PARAMS ((void));
161 static void mark_constants PARAMS ((rtx));
162 static int mark_constant PARAMS ((rtx *current_rtx, void *data));
163 static int output_addressed_constants PARAMS ((tree));
164 static void output_after_function_constants PARAMS ((void));
165 static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
166 static unsigned min_align PARAMS ((unsigned, unsigned));
167 static void output_constructor PARAMS ((tree, HOST_WIDE_INT,
168 unsigned int));
169 #ifdef ASM_WEAKEN_LABEL
170 static void remove_from_pending_weak_list PARAMS ((const char *));
171 #endif
172 static int in_named_entry_eq PARAMS ((const PTR, const PTR));
173 static hashval_t in_named_entry_hash PARAMS ((const PTR));
174 #ifdef ASM_OUTPUT_BSS
175 static void asm_output_bss PARAMS ((FILE *, tree, const char *, int, int));
176 #endif
177 #ifdef BSS_SECTION_ASM_OP
178 #ifdef ASM_OUTPUT_ALIGNED_BSS
179 static void asm_output_aligned_bss PARAMS ((FILE *, tree, const char *,
180 int, int));
181 #endif
182 #endif /* BSS_SECTION_ASM_OP */
183 static void mark_pool_constant PARAMS ((struct pool_constant *));
184 static void mark_const_hash_entry PARAMS ((void *));
185 static int mark_const_str_htab_1 PARAMS ((void **, void *));
186 static void mark_const_str_htab PARAMS ((void *));
187 static hashval_t const_str_htab_hash PARAMS ((const void *x));
188 static int const_str_htab_eq PARAMS ((const void *x, const void *y));
189 static void const_str_htab_del PARAMS ((void *));
190 static void asm_emit_uninitialised PARAMS ((tree, const char*, int, int));
191 static void resolve_unique_section PARAMS ((tree, int));
193 static enum in_section { no_section, in_text, in_data, in_named
194 #ifdef BSS_SECTION_ASM_OP
195 , in_bss
196 #endif
197 #ifdef CTORS_SECTION_ASM_OP
198 , in_ctors
199 #endif
200 #ifdef DTORS_SECTION_ASM_OP
201 , in_dtors
202 #endif
203 #ifdef EXTRA_SECTIONS
204 , EXTRA_SECTIONS
205 #endif
206 } in_section = no_section;
208 /* Return a non-zero value if DECL has a section attribute. */
209 #ifndef IN_NAMED_SECTION
210 #define IN_NAMED_SECTION(DECL) \
211 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
212 && DECL_SECTION_NAME (DECL) != NULL_TREE)
213 #endif
215 /* Text of section name when in_section == in_named. */
216 static const char *in_named_name;
218 /* Hash table of flags that have been used for a particular named section. */
220 struct in_named_entry
222 const char *name;
223 unsigned int flags;
224 bool declared;
227 static htab_t in_named_htab;
229 /* Define functions like text_section for any extra sections. */
230 #ifdef EXTRA_SECTION_FUNCTIONS
231 EXTRA_SECTION_FUNCTIONS
232 #endif
234 /* Tell assembler to switch to text section. */
236 void
237 text_section ()
239 if (in_section != in_text)
241 #ifdef TEXT_SECTION
242 TEXT_SECTION ();
243 #else
244 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
245 #endif
246 in_section = in_text;
250 /* Tell assembler to switch to data section. */
252 void
253 data_section ()
255 if (in_section != in_data)
257 if (flag_shared_data)
259 #ifdef SHARED_SECTION_ASM_OP
260 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
261 #else
262 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
263 #endif
265 else
266 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
268 in_section = in_data;
271 /* Tell assembler to ALWAYS switch to data section, in case
272 it's not sure where it is. */
274 void
275 force_data_section ()
277 in_section = no_section;
278 data_section ();
281 /* Tell assembler to switch to read-only data section. This is normally
282 the text section. */
284 void
285 readonly_data_section ()
287 #ifdef READONLY_DATA_SECTION
288 READONLY_DATA_SECTION (); /* Note this can call data_section. */
289 #else
290 text_section ();
291 #endif
294 /* Determine if we're in the text section. */
297 in_text_section ()
299 return in_section == in_text;
302 /* Determine if we're in the data section. */
305 in_data_section ()
307 return in_section == in_data;
310 /* Helper routines for maintaining in_named_htab. */
312 static int
313 in_named_entry_eq (p1, p2)
314 const PTR p1;
315 const PTR p2;
317 const struct in_named_entry *old = p1;
318 const char *new = p2;
320 return strcmp (old->name, new) == 0;
323 static hashval_t
324 in_named_entry_hash (p)
325 const PTR p;
327 const struct in_named_entry *old = p;
328 return htab_hash_string (old->name);
331 /* If SECTION has been seen before as a named section, return the flags
332 that were used. Otherwise, return 0. Note, that 0 is a perfectly valid
333 set of flags for a section to have, so 0 does not mean that the section
334 has not been seen. */
336 unsigned int
337 get_named_section_flags (section)
338 const char *section;
340 struct in_named_entry **slot;
342 slot = (struct in_named_entry**)
343 htab_find_slot_with_hash (in_named_htab, section,
344 htab_hash_string (section), NO_INSERT);
346 return slot ? (*slot)->flags : 0;
349 /* Returns true if the section has been declared before. Sets internal
350 flag on this section in in_named_hash so subsequent calls on this
351 section will return false. */
353 bool
354 named_section_first_declaration (name)
355 const char *name;
357 struct in_named_entry **slot;
359 slot = (struct in_named_entry**)
360 htab_find_slot_with_hash (in_named_htab, name,
361 htab_hash_string (name), NO_INSERT);
362 if (! (*slot)->declared)
364 (*slot)->declared = true;
365 return true;
367 else
369 return false;
374 /* Record FLAGS for SECTION. If SECTION was previously recorded with a
375 different set of flags, return false. */
377 bool
378 set_named_section_flags (section, flags)
379 const char *section;
380 unsigned int flags;
382 struct in_named_entry **slot, *entry;
384 slot = (struct in_named_entry**)
385 htab_find_slot_with_hash (in_named_htab, section,
386 htab_hash_string (section), INSERT);
387 entry = *slot;
389 if (!entry)
391 entry = (struct in_named_entry *) xmalloc (sizeof (*entry));
392 *slot = entry;
393 entry->name = ggc_strdup (section);
394 entry->flags = flags;
395 entry->declared = false;
397 else if (entry->flags != flags)
398 return false;
400 return true;
403 /* Tell assembler to change to section NAME with attributes FLAGS. */
405 void
406 named_section_flags (name, flags)
407 const char *name;
408 unsigned int flags;
410 if (in_section != in_named || strcmp (name, in_named_name) != 0)
412 if (! set_named_section_flags (name, flags))
413 abort ();
415 (* targetm.asm_out.named_section) (name, flags);
417 if (flags & SECTION_FORGET)
418 in_section = no_section;
419 else
421 in_named_name = ggc_strdup (name);
422 in_section = in_named;
427 /* Tell assembler to change to section NAME for DECL.
428 If DECL is NULL, just switch to section NAME.
429 If NAME is NULL, get the name from DECL.
430 If RELOC is 1, the initializer for DECL contains relocs. */
432 void
433 named_section (decl, name, reloc)
434 tree decl;
435 const char *name;
436 int reloc;
438 unsigned int flags;
440 if (decl != NULL_TREE && !DECL_P (decl))
441 abort ();
442 if (name == NULL)
443 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
445 flags = (* targetm.section_type_flags) (decl, name, reloc);
447 /* Sanity check user variables for flag changes. Non-user
448 section flag changes will abort in named_section_flags. */
449 if (decl && ! set_named_section_flags (name, flags))
451 error_with_decl (decl, "%s causes a section type conflict");
452 flags = get_named_section_flags (name);
455 named_section_flags (name, flags);
458 /* If required, set DECL_SECTION_NAME to a unique name. */
460 static void
461 resolve_unique_section (decl, reloc)
462 tree decl;
463 int reloc ATTRIBUTE_UNUSED;
465 if (DECL_SECTION_NAME (decl) == NULL_TREE
466 && (flag_function_sections
467 || (targetm.have_named_sections
468 && DECL_ONE_ONLY (decl))))
469 UNIQUE_SECTION (decl, reloc);
472 #ifdef BSS_SECTION_ASM_OP
474 /* Tell the assembler to switch to the bss section. */
476 void
477 bss_section ()
479 if (in_section != in_bss)
481 #ifdef SHARED_BSS_SECTION_ASM_OP
482 if (flag_shared_data)
483 fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
484 else
485 #endif
486 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
488 in_section = in_bss;
492 #ifdef ASM_OUTPUT_BSS
494 /* Utility function for ASM_OUTPUT_BSS for targets to use if
495 they don't support alignments in .bss.
496 ??? It is believed that this function will work in most cases so such
497 support is localized here. */
499 static void
500 asm_output_bss (file, decl, name, size, rounded)
501 FILE *file;
502 tree decl ATTRIBUTE_UNUSED;
503 const char *name;
504 int size ATTRIBUTE_UNUSED, rounded;
506 ASM_GLOBALIZE_LABEL (file, name);
507 bss_section ();
508 #ifdef ASM_DECLARE_OBJECT_NAME
509 last_assemble_variable_decl = decl;
510 ASM_DECLARE_OBJECT_NAME (file, name, decl);
511 #else
512 /* Standard thing is just output label for the object. */
513 ASM_OUTPUT_LABEL (file, name);
514 #endif /* ASM_DECLARE_OBJECT_NAME */
515 ASM_OUTPUT_SKIP (file, rounded);
518 #endif
520 #ifdef ASM_OUTPUT_ALIGNED_BSS
522 /* Utility function for targets to use in implementing
523 ASM_OUTPUT_ALIGNED_BSS.
524 ??? It is believed that this function will work in most cases so such
525 support is localized here. */
527 static void
528 asm_output_aligned_bss (file, decl, name, size, align)
529 FILE *file;
530 tree decl ATTRIBUTE_UNUSED;
531 const char *name;
532 int size, align;
534 ASM_GLOBALIZE_LABEL (file, name);
535 bss_section ();
536 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
537 #ifdef ASM_DECLARE_OBJECT_NAME
538 last_assemble_variable_decl = decl;
539 ASM_DECLARE_OBJECT_NAME (file, name, decl);
540 #else
541 /* Standard thing is just output label for the object. */
542 ASM_OUTPUT_LABEL (file, name);
543 #endif /* ASM_DECLARE_OBJECT_NAME */
544 ASM_OUTPUT_SKIP (file, size ? size : 1);
547 #endif
549 #endif /* BSS_SECTION_ASM_OP */
551 /* Switch to the section for function DECL.
553 If DECL is NULL_TREE, switch to the text section.
554 ??? It's not clear that we will ever be passed NULL_TREE, but it's
555 safer to handle it. */
557 void
558 function_section (decl)
559 tree decl;
561 if (decl != NULL_TREE
562 && DECL_SECTION_NAME (decl) != NULL_TREE)
563 named_section (decl, (char *) 0, 0);
564 else
565 text_section ();
568 /* Switch to section for variable DECL.
570 RELOC is the `reloc' argument to SELECT_SECTION. */
572 void
573 variable_section (decl, reloc)
574 tree decl;
575 int reloc;
577 if (IN_NAMED_SECTION (decl))
578 named_section (decl, NULL, reloc);
579 else
581 /* C++ can have const variables that get initialized from constructors,
582 and thus can not be in a readonly section. We prevent this by
583 verifying that the initial value is constant for objects put in a
584 readonly section.
586 error_mark_node is used by the C front end to indicate that the
587 initializer has not been seen yet. In this case, we assume that
588 the initializer must be constant.
590 C++ uses error_mark_node for variables that have complicated
591 initializers, but these variables go in BSS so we won't be called
592 for them. */
594 #ifdef SELECT_SECTION
595 SELECT_SECTION (decl, reloc, DECL_ALIGN (decl));
596 #else
597 if (DECL_READONLY_SECTION (decl, reloc))
598 readonly_data_section ();
599 else
600 data_section ();
601 #endif
605 /* Tell assembler to switch to the section for the exception handling
606 table. */
608 void
609 default_exception_section ()
611 if (targetm.have_named_sections)
612 named_section (NULL_TREE, ".gcc_except_table", 0);
613 else if (flag_pic)
614 data_section ();
615 else
616 readonly_data_section ();
619 /* Tell assembler to switch to the section for string merging. */
621 void
622 mergeable_string_section (decl, align, flags)
623 tree decl ATTRIBUTE_UNUSED;
624 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
625 unsigned int flags ATTRIBUTE_UNUSED;
627 #ifdef HAVE_GAS_SHF_MERGE
628 if (flag_merge_constants
629 && TREE_CODE (decl) == STRING_CST
630 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
631 && align <= 256
632 && TREE_STRING_LENGTH (decl) >= int_size_in_bytes (TREE_TYPE (decl)))
634 enum machine_mode mode;
635 unsigned int modesize;
636 const char *str;
637 int i, j, len, unit;
638 char name[30];
640 mode = TYPE_MODE (TREE_TYPE (TREE_TYPE (decl)));
641 modesize = GET_MODE_BITSIZE (mode);
642 if (modesize >= 8 && modesize <= 256
643 && (modesize & (modesize - 1)) == 0)
645 if (align < modesize)
646 align = modesize;
648 str = TREE_STRING_POINTER (decl);
649 len = TREE_STRING_LENGTH (decl);
650 unit = GET_MODE_SIZE (mode);
652 /* Check for embedded NUL characters. */
653 for (i = 0; i < len; i += unit)
655 for (j = 0; j < unit; j++)
656 if (str [i + j] != '\0')
657 break;
658 if (j == unit)
659 break;
661 if (i == len - unit)
663 sprintf (name, ".rodata.str%d.%d", modesize / 8,
664 (int) (align / 8));
665 flags |= (modesize / 8) | SECTION_MERGE | SECTION_STRINGS;
666 if (!i && modesize < align)
668 /* A "" string with requested alignment greater than
669 character size might cause a problem:
670 if some other string required even bigger
671 alignment than "", then linker might think the
672 "" is just part of padding after some other string
673 and not put it into the hash table initially.
674 But this means "" could have smaller alignment
675 than requested. */
676 #ifdef ASM_OUTPUT_SECTION_START
677 named_section_flags (name, flags);
678 ASM_OUTPUT_SECTION_START (asm_out_file);
679 #else
680 readonly_data_section ();
681 #endif
682 return;
685 named_section_flags (name, flags);
686 return;
690 #endif
691 readonly_data_section ();
694 /* Tell assembler to switch to the section for constant merging. */
696 void
697 mergeable_constant_section (mode, align, flags)
698 enum machine_mode mode ATTRIBUTE_UNUSED;
699 unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED;
700 unsigned int flags ATTRIBUTE_UNUSED;
702 #ifdef HAVE_GAS_SHF_MERGE
703 unsigned int modesize = GET_MODE_BITSIZE (mode);
705 if (flag_merge_constants
706 && mode != VOIDmode
707 && mode != BLKmode
708 && modesize <= align
709 && align >= 8
710 && align <= 256
711 && (align & (align - 1)) == 0)
713 char name[24];
715 sprintf (name, ".rodata.cst%d", (int) (align / 8));
716 flags |= (align / 8) | SECTION_MERGE;
717 named_section_flags (name, flags);
718 return;
720 #endif
721 readonly_data_section ();
724 /* Given NAME, a putative register name, discard any customary prefixes. */
726 static const char *
727 strip_reg_name (name)
728 const char *name;
730 #ifdef REGISTER_PREFIX
731 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
732 name += strlen (REGISTER_PREFIX);
733 #endif
734 if (name[0] == '%' || name[0] == '#')
735 name++;
736 return name;
739 /* Decode an `asm' spec for a declaration as a register name.
740 Return the register number, or -1 if nothing specified,
741 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
742 or -3 if ASMSPEC is `cc' and is not recognized,
743 or -4 if ASMSPEC is `memory' and is not recognized.
744 Accept an exact spelling or a decimal number.
745 Prefixes such as % are optional. */
748 decode_reg_name (asmspec)
749 const char *asmspec;
751 if (asmspec != 0)
753 int i;
755 /* Get rid of confusing prefixes. */
756 asmspec = strip_reg_name (asmspec);
758 /* Allow a decimal number as a "register name". */
759 for (i = strlen (asmspec) - 1; i >= 0; i--)
760 if (! ISDIGIT (asmspec[i]))
761 break;
762 if (asmspec[0] != 0 && i < 0)
764 i = atoi (asmspec);
765 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
766 return i;
767 else
768 return -2;
771 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
772 if (reg_names[i][0]
773 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
774 return i;
776 #ifdef ADDITIONAL_REGISTER_NAMES
778 static const struct { const char *const name; const int number; } table[]
779 = ADDITIONAL_REGISTER_NAMES;
781 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
782 if (! strcmp (asmspec, table[i].name))
783 return table[i].number;
785 #endif /* ADDITIONAL_REGISTER_NAMES */
787 if (!strcmp (asmspec, "memory"))
788 return -4;
790 if (!strcmp (asmspec, "cc"))
791 return -3;
793 return -2;
796 return -1;
799 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
800 have static storage duration. In other words, it should not be an
801 automatic variable, including PARM_DECLs.
803 There is, however, one exception: this function handles variables
804 explicitly placed in a particular register by the user.
806 ASMSPEC, if not 0, is the string which the user specified as the
807 assembler symbol name.
809 This is never called for PARM_DECL nodes. */
811 void
812 make_decl_rtl (decl, asmspec)
813 tree decl;
814 const char *asmspec;
816 int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
817 const char *name = 0;
818 const char *new_name = 0;
819 int reg_number;
820 rtx x;
822 /* Check that we are not being given an automatic variable. */
823 /* A weak alias has TREE_PUBLIC set but not the other bits. */
824 if (TREE_CODE (decl) == PARM_DECL
825 || TREE_CODE (decl) == RESULT_DECL
826 || (TREE_CODE (decl) == VAR_DECL
827 && !TREE_STATIC (decl)
828 && !TREE_PUBLIC (decl)
829 && !DECL_EXTERNAL (decl)
830 && !DECL_REGISTER (decl)))
831 abort ();
832 /* And that we were not given a type or a label. */
833 else if (TREE_CODE (decl) == TYPE_DECL
834 || TREE_CODE (decl) == LABEL_DECL)
835 abort ();
837 /* For a duplicate declaration, we can be called twice on the
838 same DECL node. Don't discard the RTL already made. */
839 if (DECL_RTL_SET_P (decl))
841 /* If the old RTL had the wrong mode, fix the mode. */
842 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
843 SET_DECL_RTL (decl, adjust_address_nv (DECL_RTL (decl),
844 DECL_MODE (decl), 0));
846 /* ??? Another way to do this would be to do what halfpic.c does
847 and maintain a hashed table of such critters. */
848 /* ??? Another way to do this would be to pass a flag bit to
849 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
850 /* Let the target reassign the RTL if it wants.
851 This is necessary, for example, when one machine specific
852 decl attribute overrides another. */
853 #ifdef REDO_SECTION_INFO_P
854 if (REDO_SECTION_INFO_P (decl))
855 ENCODE_SECTION_INFO (decl);
856 #endif
857 return;
860 new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
862 reg_number = decode_reg_name (asmspec);
863 if (reg_number == -2)
865 /* ASMSPEC is given, and not the name of a register. Mark the
866 name with a star so assemble_name won't munge it. */
867 char *starred = alloca (strlen (asmspec) + 2);
868 starred[0] = '*';
869 strcpy (starred + 1, asmspec);
870 new_name = starred;
873 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
875 /* First detect errors in declaring global registers. */
876 if (reg_number == -1)
877 error_with_decl (decl, "register name not specified for `%s'");
878 else if (reg_number < 0)
879 error_with_decl (decl, "invalid register name for `%s'");
880 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
881 error_with_decl (decl,
882 "data type of `%s' isn't suitable for a register");
883 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
884 error_with_decl (decl,
885 "register specified for `%s' isn't suitable for data type");
886 /* Now handle properly declared static register variables. */
887 else
889 int nregs;
891 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
893 DECL_INITIAL (decl) = 0;
894 error ("global register variable has initial value");
896 if (TREE_THIS_VOLATILE (decl))
897 warning ("volatile register variables don't work as you might wish");
899 /* If the user specified one of the eliminables registers here,
900 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
901 confused with that register and be eliminated. Although this
902 usage is somewhat suspect, we nevertheless use the following
903 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
905 SET_DECL_RTL (decl,
906 gen_rtx_REG (DECL_MODE (decl),
907 FIRST_PSEUDO_REGISTER));
908 REGNO (DECL_RTL (decl)) = reg_number;
909 REG_USERVAR_P (DECL_RTL (decl)) = 1;
911 if (TREE_STATIC (decl))
913 /* Make this register global, so not usable for anything
914 else. */
915 #ifdef ASM_DECLARE_REGISTER_GLOBAL
916 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
917 #endif
918 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
919 while (nregs > 0)
920 globalize_reg (reg_number + --nregs);
923 /* As a register variable, it has no section. */
924 return;
928 /* Now handle ordinary static variables and functions (in memory).
929 Also handle vars declared register invalidly. */
931 if (reg_number >= 0 || reg_number == -3)
932 error_with_decl (decl,
933 "register name given for non-register variable `%s'");
935 /* Specifying a section attribute on a variable forces it into a
936 non-.bss section, and thus it cannot be common. */
937 if (TREE_CODE (decl) == VAR_DECL
938 && DECL_SECTION_NAME (decl) != NULL_TREE
939 && DECL_INITIAL (decl) == NULL_TREE
940 && DECL_COMMON (decl))
941 DECL_COMMON (decl) = 0;
943 /* Can't use just the variable's own name for a variable
944 whose scope is less than the whole file, unless it's a member
945 of a local class (which will already be unambiguous).
946 Concatenate a distinguishing number. */
947 if (!top_level && !TREE_PUBLIC (decl)
948 && ! (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
949 && asmspec == 0
950 && name == IDENTIFIER_POINTER (DECL_NAME (decl)))
952 char *label;
954 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
955 var_labelno++;
956 new_name = label;
959 if (name != new_name)
961 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
962 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
965 /* If this variable is to be treated as volatile, show its
966 tree node has side effects. */
967 if ((flag_volatile_global && TREE_CODE (decl) == VAR_DECL
968 && TREE_PUBLIC (decl))
969 || ((flag_volatile_static && TREE_CODE (decl) == VAR_DECL
970 && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
971 TREE_SIDE_EFFECTS (decl) = 1;
973 x = gen_rtx_MEM (DECL_MODE (decl), gen_rtx_SYMBOL_REF (Pmode, name));
974 SYMBOL_REF_WEAK (XEXP (x, 0)) = DECL_WEAK (decl);
975 if (TREE_CODE (decl) != FUNCTION_DECL)
976 set_mem_attributes (x, decl, 1);
977 SET_DECL_RTL (decl, x);
979 /* Optionally set flags or add text to the name to record information
980 such as that it is a function name.
981 If the name is changed, the macro ASM_OUTPUT_LABELREF
982 will have to know how to strip this information. */
983 #ifdef ENCODE_SECTION_INFO
984 ENCODE_SECTION_INFO (decl);
985 #endif
988 /* Make the rtl for variable VAR be volatile.
989 Use this only for static variables. */
991 void
992 make_var_volatile (var)
993 tree var;
995 if (GET_CODE (DECL_RTL (var)) != MEM)
996 abort ();
998 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
1001 /* Output alignment directive to align for constant expression EXP. */
1003 void
1004 assemble_constant_align (exp)
1005 tree exp;
1007 int align;
1009 /* Align the location counter as required by EXP's data type. */
1010 align = TYPE_ALIGN (TREE_TYPE (exp));
1011 #ifdef CONSTANT_ALIGNMENT
1012 align = CONSTANT_ALIGNMENT (exp, align);
1013 #endif
1015 if (align > BITS_PER_UNIT)
1017 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1021 /* Output a string of literal assembler code
1022 for an `asm' keyword used between functions. */
1024 void
1025 assemble_asm (string)
1026 tree string;
1028 app_enable ();
1030 if (TREE_CODE (string) == ADDR_EXPR)
1031 string = TREE_OPERAND (string, 0);
1033 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
1036 /* Record an element in the table of global destructors. SYMBOL is
1037 a SYMBOL_REF of the function to be called; PRIORITY is a number
1038 between 0 and MAX_INIT_PRIORITY. */
1040 void
1041 default_stabs_asm_out_destructor (symbol, priority)
1042 rtx symbol;
1043 int priority ATTRIBUTE_UNUSED;
1045 /* Tell GNU LD that this is part of the static destructor set.
1046 This will work for any system that uses stabs, most usefully
1047 aout systems. */
1048 fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1049 assemble_name (asm_out_file, XSTR (symbol, 0));
1050 fputc ('\n', asm_out_file);
1053 void
1054 default_named_section_asm_out_destructor (symbol, priority)
1055 rtx symbol;
1056 int priority;
1058 const char *section = ".dtors";
1059 char buf[16];
1061 /* ??? This only works reliably with the GNU linker. */
1062 if (priority != DEFAULT_INIT_PRIORITY)
1064 sprintf (buf, ".dtors.%.5u",
1065 /* Invert the numbering so the linker puts us in the proper
1066 order; constructors are run from right to left, and the
1067 linker sorts in increasing order. */
1068 MAX_INIT_PRIORITY - priority);
1069 section = buf;
1072 named_section_flags (section, SECTION_WRITE);
1073 assemble_align (POINTER_SIZE);
1074 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1077 #ifdef DTORS_SECTION_ASM_OP
1078 void
1079 dtors_section ()
1081 if (in_section != in_dtors)
1083 in_section = in_dtors;
1084 fputs (DTORS_SECTION_ASM_OP, asm_out_file);
1085 fputc ('\n', asm_out_file);
1089 void
1090 default_dtor_section_asm_out_destructor (symbol, priority)
1091 rtx symbol;
1092 int priority ATTRIBUTE_UNUSED;
1094 dtors_section ();
1095 assemble_align (POINTER_SIZE);
1096 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1098 #endif
1100 /* Likewise for global constructors. */
1102 void
1103 default_stabs_asm_out_constructor (symbol, priority)
1104 rtx symbol;
1105 int priority ATTRIBUTE_UNUSED;
1107 /* Tell GNU LD that this is part of the static destructor set.
1108 This will work for any system that uses stabs, most usefully
1109 aout systems. */
1110 fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
1111 assemble_name (asm_out_file, XSTR (symbol, 0));
1112 fputc ('\n', asm_out_file);
1115 void
1116 default_named_section_asm_out_constructor (symbol, priority)
1117 rtx symbol;
1118 int priority;
1120 const char *section = ".ctors";
1121 char buf[16];
1123 /* ??? This only works reliably with the GNU linker. */
1124 if (priority != DEFAULT_INIT_PRIORITY)
1126 sprintf (buf, ".ctors.%.5u",
1127 /* Invert the numbering so the linker puts us in the proper
1128 order; constructors are run from right to left, and the
1129 linker sorts in increasing order. */
1130 MAX_INIT_PRIORITY - priority);
1131 section = buf;
1134 named_section_flags (section, SECTION_WRITE);
1135 assemble_align (POINTER_SIZE);
1136 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1139 #ifdef CTORS_SECTION_ASM_OP
1140 void
1141 ctors_section ()
1143 if (in_section != in_ctors)
1145 in_section = in_ctors;
1146 fputs (CTORS_SECTION_ASM_OP, asm_out_file);
1147 fputc ('\n', asm_out_file);
1151 void
1152 default_ctor_section_asm_out_constructor (symbol, priority)
1153 rtx symbol;
1154 int priority ATTRIBUTE_UNUSED;
1156 ctors_section ();
1157 assemble_align (POINTER_SIZE);
1158 assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
1160 #endif
1162 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
1163 a non-zero value if the constant pool should be output before the
1164 start of the function, or a zero value if the pool should output
1165 after the end of the function. The default is to put it before the
1166 start. */
1168 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
1169 #define CONSTANT_POOL_BEFORE_FUNCTION 1
1170 #endif
1172 /* Output assembler code for the constant pool of a function and associated
1173 with defining the name of the function. DECL describes the function.
1174 NAME is the function's name. For the constant pool, we use the current
1175 constant pool data. */
1177 void
1178 assemble_start_function (decl, fnname)
1179 tree decl;
1180 const char *fnname;
1182 int align;
1184 /* The following code does not need preprocessing in the assembler. */
1186 app_disable ();
1188 if (CONSTANT_POOL_BEFORE_FUNCTION)
1189 output_constant_pool (fnname, decl);
1191 resolve_unique_section (decl, 0);
1192 function_section (decl);
1194 /* Tell assembler to move to target machine's alignment for functions. */
1195 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1196 if (align > 0)
1198 ASM_OUTPUT_ALIGN (asm_out_file, align);
1201 /* Handle a user-specified function alignment.
1202 Note that we still need to align to FUNCTION_BOUNDARY, as above,
1203 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
1204 if (align_functions_log > align)
1206 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
1207 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
1208 align_functions_log, align_functions-1);
1209 #else
1210 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
1211 #endif
1214 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
1215 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
1216 #endif
1218 (*debug_hooks->begin_function) (decl);
1220 /* Make function name accessible from other files, if appropriate. */
1222 if (TREE_PUBLIC (decl))
1224 if (! first_global_object_name)
1226 const char *p;
1227 char *name;
1229 STRIP_NAME_ENCODING (p, fnname);
1230 name = permalloc (strlen (p) + 1);
1231 strcpy (name, p);
1233 if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1234 first_global_object_name = name;
1235 else
1236 weak_global_object_name = name;
1239 #ifdef ASM_WEAKEN_LABEL
1240 if (DECL_WEAK (decl))
1242 ASM_WEAKEN_LABEL (asm_out_file, fnname);
1243 /* Remove this function from the pending weak list so that
1244 we do not emit multiple .weak directives for it. */
1245 remove_from_pending_weak_list
1246 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1248 else
1249 #endif
1250 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
1253 /* Do any machine/system dependent processing of the function name */
1254 #ifdef ASM_DECLARE_FUNCTION_NAME
1255 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1256 #else
1257 /* Standard thing is just output label for the function. */
1258 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1259 #endif /* ASM_DECLARE_FUNCTION_NAME */
1262 /* Output assembler code associated with defining the size of the
1263 function. DECL describes the function. NAME is the function's name. */
1265 void
1266 assemble_end_function (decl, fnname)
1267 tree decl;
1268 const char *fnname;
1270 #ifdef ASM_DECLARE_FUNCTION_SIZE
1271 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1272 #endif
1273 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1275 output_constant_pool (fnname, decl);
1276 function_section (decl); /* need to switch back */
1279 /* Output any constants which should appear after the function. */
1280 output_after_function_constants ();
1283 /* Assemble code to leave SIZE bytes of zeros. */
1285 void
1286 assemble_zeros (size)
1287 int size;
1289 /* Do no output if -fsyntax-only. */
1290 if (flag_syntax_only)
1291 return;
1293 #ifdef ASM_NO_SKIP_IN_TEXT
1294 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1295 so we must output 0s explicitly in the text section. */
1296 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1298 int i;
1299 for (i = 0; i < size; i++)
1300 assemble_integer (const0_rtx, 1, BITS_PER_UNIT, 1);
1302 else
1303 #endif
1304 if (size > 0)
1305 ASM_OUTPUT_SKIP (asm_out_file, size);
1308 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1310 void
1311 assemble_align (align)
1312 int align;
1314 if (align > BITS_PER_UNIT)
1316 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1320 /* Assemble a string constant with the specified C string as contents. */
1322 void
1323 assemble_string (p, size)
1324 const char *p;
1325 int size;
1327 int pos = 0;
1328 int maximum = 2000;
1330 /* If the string is very long, split it up. */
1332 while (pos < size)
1334 int thissize = size - pos;
1335 if (thissize > maximum)
1336 thissize = maximum;
1338 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1340 pos += thissize;
1341 p += thissize;
1346 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1347 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1348 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1349 #else
1350 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1351 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1352 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1353 #else
1354 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1355 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1356 #endif
1357 #endif
1359 #if defined ASM_OUTPUT_ALIGNED_BSS
1360 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1361 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1362 #else
1363 #if defined ASM_OUTPUT_BSS
1364 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1365 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1366 #else
1367 #undef ASM_EMIT_BSS
1368 #endif
1369 #endif
1371 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1372 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1373 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1374 #else
1375 #if defined ASM_OUTPUT_ALIGNED_COMMON
1376 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1377 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1378 #else
1379 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1380 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1381 #endif
1382 #endif
1384 static void
1385 asm_emit_uninitialised (decl, name, size, rounded)
1386 tree decl;
1387 const char * name;
1388 int size ATTRIBUTE_UNUSED;
1389 int rounded ATTRIBUTE_UNUSED;
1391 enum
1393 asm_dest_common,
1394 asm_dest_bss,
1395 asm_dest_local
1397 destination = asm_dest_local;
1399 if (TREE_PUBLIC (decl))
1401 #if defined ASM_EMIT_BSS
1402 if (! DECL_COMMON (decl))
1403 destination = asm_dest_bss;
1404 else
1405 #endif
1406 destination = asm_dest_common;
1409 if (flag_shared_data)
1411 switch (destination)
1413 #ifdef ASM_OUTPUT_SHARED_BSS
1414 case asm_dest_bss:
1415 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1416 return;
1417 #endif
1418 #ifdef ASM_OUTPUT_SHARED_COMMON
1419 case asm_dest_common:
1420 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1421 return;
1422 #endif
1423 #ifdef ASM_OUTPUT_SHARED_LOCAL
1424 case asm_dest_local:
1425 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1426 return;
1427 #endif
1428 default:
1429 break;
1433 resolve_unique_section (decl, 0);
1435 switch (destination)
1437 #ifdef ASM_EMIT_BSS
1438 case asm_dest_bss:
1439 ASM_EMIT_BSS (decl, name, size, rounded);
1440 break;
1441 #endif
1442 case asm_dest_common:
1443 ASM_EMIT_COMMON (decl, name, size, rounded);
1444 break;
1445 case asm_dest_local:
1446 ASM_EMIT_LOCAL (decl, name, size, rounded);
1447 break;
1448 default:
1449 abort ();
1452 return;
1455 /* Assemble everything that is needed for a variable or function declaration.
1456 Not used for automatic variables, and not used for function definitions.
1457 Should not be called for variables of incomplete structure type.
1459 TOP_LEVEL is nonzero if this variable has file scope.
1460 AT_END is nonzero if this is the special handling, at end of compilation,
1461 to define things that have had only tentative definitions.
1462 DONT_OUTPUT_DATA if nonzero means don't actually output the
1463 initial value (that will be done by the caller). */
1465 void
1466 assemble_variable (decl, top_level, at_end, dont_output_data)
1467 tree decl;
1468 int top_level ATTRIBUTE_UNUSED;
1469 int at_end ATTRIBUTE_UNUSED;
1470 int dont_output_data;
1472 const char *name;
1473 unsigned int align;
1474 int reloc = 0;
1475 rtx decl_rtl;
1477 last_assemble_variable_decl = 0;
1479 /* Normally no need to say anything here for external references,
1480 since assemble_external is called by the language-specific code
1481 when a declaration is first seen. */
1483 if (DECL_EXTERNAL (decl))
1484 return;
1486 /* Output no assembler code for a function declaration.
1487 Only definitions of functions output anything. */
1489 if (TREE_CODE (decl) == FUNCTION_DECL)
1490 return;
1492 /* Do nothing for global register variables. */
1493 if (DECL_RTL_SET_P (decl) && GET_CODE (DECL_RTL (decl)) == REG)
1495 TREE_ASM_WRITTEN (decl) = 1;
1496 return;
1499 /* If type was incomplete when the variable was declared,
1500 see if it is complete now. */
1502 if (DECL_SIZE (decl) == 0)
1503 layout_decl (decl, 0);
1505 /* Still incomplete => don't allocate it; treat the tentative defn
1506 (which is what it must have been) as an `extern' reference. */
1508 if (!dont_output_data && DECL_SIZE (decl) == 0)
1510 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1511 DECL_SOURCE_LINE (decl),
1512 "storage size of `%s' isn't known",
1513 IDENTIFIER_POINTER (DECL_NAME (decl)));
1514 TREE_ASM_WRITTEN (decl) = 1;
1515 return;
1518 /* The first declaration of a variable that comes through this function
1519 decides whether it is global (in C, has external linkage)
1520 or local (in C, has internal linkage). So do nothing more
1521 if this function has already run. */
1523 if (TREE_ASM_WRITTEN (decl))
1524 return;
1526 /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN. */
1527 decl_rtl = DECL_RTL (decl);
1529 TREE_ASM_WRITTEN (decl) = 1;
1531 /* Do no output if -fsyntax-only. */
1532 if (flag_syntax_only)
1533 return;
1535 app_disable ();
1537 if (! dont_output_data
1538 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1540 error_with_decl (decl, "size of variable `%s' is too large");
1541 return;
1544 name = XSTR (XEXP (decl_rtl, 0), 0);
1545 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1546 && ! first_global_object_name
1547 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1548 || DECL_INITIAL (decl) == error_mark_node))
1549 && ! DECL_WEAK (decl)
1550 && ! DECL_ONE_ONLY (decl))
1552 const char *p;
1553 char *xname;
1555 STRIP_NAME_ENCODING (p, name);
1556 xname = permalloc (strlen (p) + 1);
1557 strcpy (xname, p);
1558 first_global_object_name = xname;
1561 /* Compute the alignment of this data. */
1563 align = DECL_ALIGN (decl);
1565 /* In the case for initialing an array whose length isn't specified,
1566 where we have not yet been able to do the layout,
1567 figure out the proper alignment now. */
1568 if (dont_output_data && DECL_SIZE (decl) == 0
1569 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1570 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1572 /* Some object file formats have a maximum alignment which they support.
1573 In particular, a.out format supports a maximum alignment of 4. */
1574 #ifndef MAX_OFILE_ALIGNMENT
1575 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1576 #endif
1577 if (align > MAX_OFILE_ALIGNMENT)
1579 warning_with_decl (decl,
1580 "alignment of `%s' is greater than maximum object file alignment. Using %d",
1581 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1582 align = MAX_OFILE_ALIGNMENT;
1585 /* On some machines, it is good to increase alignment sometimes. */
1586 if (! DECL_USER_ALIGN (decl))
1588 #ifdef DATA_ALIGNMENT
1589 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1590 #endif
1591 #ifdef CONSTANT_ALIGNMENT
1592 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1593 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1594 #endif
1597 /* Reset the alignment in case we have made it tighter, so we can benefit
1598 from it in get_pointer_alignment. */
1599 DECL_ALIGN (decl) = align;
1600 set_mem_align (decl_rtl, align);
1602 /* Handle uninitialized definitions. */
1604 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1605 /* If the target can't output uninitialized but not common global data
1606 in .bss, then we have to use .data. */
1607 #if ! defined ASM_EMIT_BSS
1608 && DECL_COMMON (decl)
1609 #endif
1610 && DECL_SECTION_NAME (decl) == NULL_TREE
1611 && ! dont_output_data)
1613 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1614 unsigned HOST_WIDE_INT rounded = size;
1616 /* Don't allocate zero bytes of common,
1617 since that means "undefined external" in the linker. */
1618 if (size == 0)
1619 rounded = 1;
1621 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1622 so that each uninitialized object starts on such a boundary. */
1623 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1624 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1625 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1627 /* Don't continue this line--convex cc version 4.1 would lose. */
1628 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1629 if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1630 warning_with_decl
1631 (decl, "requested alignment for %s is greater than implemented alignment of %d",rounded);
1632 #endif
1634 asm_emit_uninitialised (decl, name, size, rounded);
1636 return;
1639 /* Handle initialized definitions.
1640 Also handle uninitialized global definitions if -fno-common and the
1641 target doesn't support ASM_OUTPUT_BSS. */
1643 /* First make the assembler name(s) global if appropriate. */
1644 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1646 #ifdef ASM_WEAKEN_LABEL
1647 if (DECL_WEAK (decl))
1649 ASM_WEAKEN_LABEL (asm_out_file, name);
1650 /* Remove this variable from the pending weak list so that
1651 we do not emit multiple .weak directives for it. */
1652 remove_from_pending_weak_list
1653 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1655 else
1656 #endif
1657 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1660 /* Output any data that we will need to use the address of. */
1661 if (DECL_INITIAL (decl) == error_mark_node)
1662 reloc = contains_pointers_p (TREE_TYPE (decl)) ? 3 : 0;
1663 else if (DECL_INITIAL (decl))
1664 reloc = output_addressed_constants (DECL_INITIAL (decl));
1666 /* Switch to the appropriate section. */
1667 resolve_unique_section (decl, reloc);
1668 variable_section (decl, reloc);
1670 /* dbxout.c needs to know this. */
1671 if (in_text_section ())
1672 DECL_IN_TEXT_SECTION (decl) = 1;
1674 /* Output the alignment of this data. */
1675 if (align > BITS_PER_UNIT)
1677 ASM_OUTPUT_ALIGN (asm_out_file,
1678 floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1681 /* Do any machine/system dependent processing of the object. */
1682 #ifdef ASM_DECLARE_OBJECT_NAME
1683 last_assemble_variable_decl = decl;
1684 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1685 #else
1686 /* Standard thing is just output label for the object. */
1687 ASM_OUTPUT_LABEL (asm_out_file, name);
1688 #endif /* ASM_DECLARE_OBJECT_NAME */
1690 if (!dont_output_data)
1692 if (DECL_INITIAL (decl))
1693 /* Output the actual data. */
1694 output_constant (DECL_INITIAL (decl),
1695 tree_low_cst (DECL_SIZE_UNIT (decl), 1),
1696 align);
1697 else
1698 /* Leave space for it. */
1699 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1703 /* Return 1 if type TYPE contains any pointers. */
1705 static int
1706 contains_pointers_p (type)
1707 tree type;
1709 switch (TREE_CODE (type))
1711 case POINTER_TYPE:
1712 case REFERENCE_TYPE:
1713 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1714 so I'll play safe and return 1. */
1715 case OFFSET_TYPE:
1716 return 1;
1718 case RECORD_TYPE:
1719 case UNION_TYPE:
1720 case QUAL_UNION_TYPE:
1722 tree fields;
1723 /* For a type that has fields, see if the fields have pointers. */
1724 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1725 if (TREE_CODE (fields) == FIELD_DECL
1726 && contains_pointers_p (TREE_TYPE (fields)))
1727 return 1;
1728 return 0;
1731 case ARRAY_TYPE:
1732 /* An array type contains pointers if its element type does. */
1733 return contains_pointers_p (TREE_TYPE (type));
1735 default:
1736 return 0;
1740 /* Output something to declare an external symbol to the assembler.
1741 (Most assemblers don't need this, so we normally output nothing.)
1742 Do nothing if DECL is not external. */
1744 void
1745 assemble_external (decl)
1746 tree decl ATTRIBUTE_UNUSED;
1748 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1749 main body of this code is only rarely exercised. To provide some
1750 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1751 open. If it's not, we should not be calling this function. */
1752 if (!asm_out_file)
1753 abort ();
1755 #ifdef ASM_OUTPUT_EXTERNAL
1756 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1758 rtx rtl = DECL_RTL (decl);
1760 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1761 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1763 /* Some systems do require some output. */
1764 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1765 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1768 #endif
1771 /* Similar, for calling a library function FUN. */
1773 void
1774 assemble_external_libcall (fun)
1775 rtx fun ATTRIBUTE_UNUSED;
1777 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1778 /* Declare library function name external when first used, if nec. */
1779 if (! SYMBOL_REF_USED (fun))
1781 SYMBOL_REF_USED (fun) = 1;
1782 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1784 #endif
1787 /* Declare the label NAME global. */
1789 void
1790 assemble_global (name)
1791 const char *name ATTRIBUTE_UNUSED;
1793 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1796 /* Assemble a label named NAME. */
1798 void
1799 assemble_label (name)
1800 const char *name;
1802 ASM_OUTPUT_LABEL (asm_out_file, name);
1805 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1806 If NAME starts with a *, the rest of NAME is output verbatim.
1807 Otherwise NAME is transformed in an implementation-defined way
1808 (usually by the addition of an underscore).
1809 Many macros in the tm file are defined to call this function. */
1811 void
1812 assemble_name (file, name)
1813 FILE *file;
1814 const char *name;
1816 const char *real_name;
1817 tree id;
1819 STRIP_NAME_ENCODING (real_name, name);
1821 id = maybe_get_identifier (real_name);
1822 if (id)
1823 TREE_SYMBOL_REFERENCED (id) = 1;
1825 if (name[0] == '*')
1826 fputs (&name[1], file);
1827 else
1828 ASM_OUTPUT_LABELREF (file, name);
1831 /* Allocate SIZE bytes writable static space with a gensym name
1832 and return an RTX to refer to its address. */
1835 assemble_static_space (size)
1836 int size;
1838 char name[12];
1839 const char *namestring;
1840 rtx x;
1842 #if 0
1843 if (flag_shared_data)
1844 data_section ();
1845 #endif
1847 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1848 ++const_labelno;
1849 namestring = ggc_strdup (name);
1851 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1853 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1854 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1855 BIGGEST_ALIGNMENT);
1856 #else
1857 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1858 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1859 #else
1861 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1862 so that each uninitialized object starts on such a boundary. */
1863 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1864 int rounded ATTRIBUTE_UNUSED
1865 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1866 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1867 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1868 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1870 #endif
1871 #endif
1872 return x;
1875 /* Assemble the static constant template for function entry trampolines.
1876 This is done at most once per compilation.
1877 Returns an RTX for the address of the template. */
1879 #ifdef TRAMPOLINE_TEMPLATE
1881 assemble_trampoline_template ()
1883 char label[256];
1884 const char *name;
1885 int align;
1887 /* By default, put trampoline templates in read-only data section. */
1889 #ifdef TRAMPOLINE_SECTION
1890 TRAMPOLINE_SECTION ();
1891 #else
1892 readonly_data_section ();
1893 #endif
1895 /* Write the assembler code to define one. */
1896 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1897 if (align > 0)
1899 ASM_OUTPUT_ALIGN (asm_out_file, align);
1902 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1903 TRAMPOLINE_TEMPLATE (asm_out_file);
1905 /* Record the rtl to refer to it. */
1906 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1907 name = ggc_strdup (label);
1908 return gen_rtx_SYMBOL_REF (Pmode, name);
1910 #endif
1912 /* A and B are either alignments or offsets. Return the minimum alignment
1913 that may be assumed after adding the two together. */
1915 static inline unsigned
1916 min_align (a, b)
1917 unsigned int a, b;
1919 return (a | b) & -(a | b);
1922 /* Return the assembler directive for creating a given kind of integer
1923 object. SIZE is the number of bytes in the object and ALIGNED_P
1924 indicates whether it is known to be aligned. Return NULL if the
1925 assembly dialect has no such directive.
1927 The returned string should be printed at the start of a new line and
1928 be followed immediately by the object's initial value. */
1930 const char *
1931 integer_asm_op (size, aligned_p)
1932 int size;
1933 int aligned_p;
1935 struct asm_int_op *ops;
1937 if (aligned_p)
1938 ops = &targetm.asm_out.aligned_op;
1939 else
1940 ops = &targetm.asm_out.unaligned_op;
1942 switch (size)
1944 case 1:
1945 return targetm.asm_out.byte_op;
1946 case 2:
1947 return ops->hi;
1948 case 4:
1949 return ops->si;
1950 case 8:
1951 return ops->di;
1952 case 16:
1953 return ops->ti;
1954 default:
1955 return NULL;
1959 /* Use directive OP to assemble an integer object X. Print OP at the
1960 start of the line, followed immediately by the value of X. */
1962 void
1963 assemble_integer_with_op (op, x)
1964 const char *op;
1965 rtx x;
1967 fputs (op, asm_out_file);
1968 output_addr_const (asm_out_file, x);
1969 fputc ('\n', asm_out_file);
1972 /* The default implementation of the asm_out.integer target hook. */
1974 bool
1975 default_assemble_integer (x, size, aligned_p)
1976 rtx x ATTRIBUTE_UNUSED;
1977 unsigned int size ATTRIBUTE_UNUSED;
1978 int aligned_p ATTRIBUTE_UNUSED;
1980 const char *op = integer_asm_op (size, aligned_p);
1981 return op && (assemble_integer_with_op (op, x), true);
1984 /* Assemble the integer constant X into an object of SIZE bytes. ALIGN is
1985 the alignment of the integer in bits. Return 1 if we were able to output
1986 the constant, otherwise 0. If FORCE is non-zero, abort if we can't output
1987 the constant. */
1989 bool
1990 assemble_integer (x, size, align, force)
1991 rtx x;
1992 unsigned int size;
1993 unsigned int align;
1994 int force;
1996 int aligned_p;
1998 aligned_p = (align >= MIN (size * BITS_PER_UNIT, BIGGEST_ALIGNMENT));
2000 /* See if the target hook can handle this kind of object. */
2001 if ((*targetm.asm_out.integer) (x, size, aligned_p))
2002 return true;
2004 /* If the object is a multi-byte one, try splitting it up. Split
2005 it into words it if is multi-word, otherwise split it into bytes. */
2006 if (size > 1)
2008 enum machine_mode omode, imode;
2009 unsigned int subalign;
2010 unsigned int subsize, i;
2012 subsize = size > UNITS_PER_WORD? UNITS_PER_WORD : 1;
2013 subalign = MIN (align, subsize * BITS_PER_UNIT);
2014 omode = mode_for_size (subsize * BITS_PER_UNIT, MODE_INT, 0);
2015 imode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
2017 for (i = 0; i < size; i += subsize)
2019 rtx partial = simplify_subreg (omode, x, imode, i);
2020 if (!partial || !assemble_integer (partial, subsize, subalign, 0))
2021 break;
2023 if (i == size)
2024 return true;
2026 /* If we've printed some of it, but not all of it, there's no going
2027 back now. */
2028 if (i > 0)
2029 abort ();
2032 if (force)
2033 abort ();
2035 return false;
2038 void
2039 assemble_real (d, mode, align)
2040 REAL_VALUE_TYPE d;
2041 enum machine_mode mode;
2042 unsigned int align;
2044 long data[4];
2045 long l;
2046 unsigned int nalign = min_align (align, 32);
2048 switch (BITS_PER_UNIT)
2050 case 8:
2051 switch (mode)
2053 case SFmode:
2054 REAL_VALUE_TO_TARGET_SINGLE (d, l);
2055 assemble_integer (GEN_INT (l), 4, align, 1);
2056 break;
2057 case DFmode:
2058 REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2059 assemble_integer (GEN_INT (data[0]), 4, align, 1);
2060 assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2061 break;
2062 case XFmode:
2063 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2064 assemble_integer (GEN_INT (data[0]), 4, align, 1);
2065 assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2066 assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2067 break;
2068 case TFmode:
2069 REAL_VALUE_TO_TARGET_LONG_DOUBLE (d, data);
2070 assemble_integer (GEN_INT (data[0]), 4, align, 1);
2071 assemble_integer (GEN_INT (data[1]), 4, nalign, 1);
2072 assemble_integer (GEN_INT (data[2]), 4, nalign, 1);
2073 assemble_integer (GEN_INT (data[3]), 4, nalign, 1);
2074 break;
2075 default:
2076 abort ();
2078 break;
2080 case 16:
2081 switch (mode)
2083 case HFmode:
2084 REAL_VALUE_TO_TARGET_SINGLE (d, l);
2085 assemble_integer (GEN_INT (l), 2, align, 1);
2086 break;
2087 case TQFmode:
2088 REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2089 assemble_integer (GEN_INT (data[0]), 2, align, 1);
2090 assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2091 break;
2092 default:
2093 abort ();
2095 break;
2097 case 32:
2098 switch (mode)
2100 case QFmode:
2101 REAL_VALUE_TO_TARGET_SINGLE (d, l);
2102 assemble_integer (GEN_INT (l), 1, align, 1);
2103 break;
2104 case HFmode:
2105 REAL_VALUE_TO_TARGET_DOUBLE (d, data);
2106 assemble_integer (GEN_INT (data[0]), 1, align, 1);
2107 assemble_integer (GEN_INT (data[1]), 1, nalign, 1);
2108 break;
2109 default:
2110 abort ();
2112 break;
2114 default:
2115 abort ();
2119 /* Here we combine duplicate floating constants to make
2120 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
2122 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2123 For an integer, I0 is the low-order word and I1 is the high-order word.
2124 For a real number, I0 is the word with the low address
2125 and I1 is the word with the high address. */
2128 immed_double_const (i0, i1, mode)
2129 HOST_WIDE_INT i0, i1;
2130 enum machine_mode mode;
2132 rtx r;
2134 if (GET_MODE_CLASS (mode) == MODE_INT
2135 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2137 /* We clear out all bits that don't belong in MODE, unless they and our
2138 sign bit are all one. So we get either a reasonable negative value
2139 or a reasonable unsigned value for this mode. */
2140 int width = GET_MODE_BITSIZE (mode);
2141 if (width < HOST_BITS_PER_WIDE_INT
2142 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2143 != ((HOST_WIDE_INT) (-1) << (width - 1))))
2144 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2145 else if (width == HOST_BITS_PER_WIDE_INT
2146 && ! (i1 == ~0 && i0 < 0))
2147 i1 = 0;
2148 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2149 /* We cannot represent this value as a constant. */
2150 abort ();
2152 /* If this would be an entire word for the target, but is not for
2153 the host, then sign-extend on the host so that the number will look
2154 the same way on the host that it would on the target.
2156 For example, when building a 64 bit alpha hosted 32 bit sparc
2157 targeted compiler, then we want the 32 bit unsigned value -1 to be
2158 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2159 The later confuses the sparc backend. */
2161 if (width < HOST_BITS_PER_WIDE_INT
2162 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2163 i0 |= ((HOST_WIDE_INT) (-1) << width);
2165 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2167 ??? Strictly speaking, this is wrong if we create a CONST_INT
2168 for a large unsigned constant with the size of MODE being
2169 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2170 wider mode. In that case we will mis-interpret it as a negative
2171 number.
2173 Unfortunately, the only alternative is to make a CONST_DOUBLE
2174 for any constant in any mode if it is an unsigned constant larger
2175 than the maximum signed integer in an int on the host. However,
2176 doing this will break everyone that always expects to see a CONST_INT
2177 for SImode and smaller.
2179 We have always been making CONST_INTs in this case, so nothing new
2180 is being broken. */
2182 if (width <= HOST_BITS_PER_WIDE_INT)
2183 i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2185 /* If this integer fits in one word, return a CONST_INT. */
2186 if ((i1 == 0 && i0 >= 0)
2187 || (i1 == ~0 && i0 < 0))
2188 return GEN_INT (i0);
2190 /* We use VOIDmode for integers. */
2191 mode = VOIDmode;
2194 /* Search the chain for an existing CONST_DOUBLE with the right value.
2195 If one is found, return it. */
2196 if (cfun != 0)
2197 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2198 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2199 && GET_MODE (r) == mode)
2200 return r;
2202 /* No; make a new one and add it to the chain. */
2203 r = gen_rtx_CONST_DOUBLE (mode, i0, i1);
2205 /* Don't touch const_double_chain if not inside any function. */
2206 if (current_function_decl != 0)
2208 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2209 const_double_chain = r;
2212 return r;
2215 /* Return a CONST_DOUBLE for a specified `double' value
2216 and machine mode. */
2219 immed_real_const_1 (d, mode)
2220 REAL_VALUE_TYPE d;
2221 enum machine_mode mode;
2223 union real_extract u;
2224 rtx r;
2226 /* Get the desired `double' value as a sequence of ints
2227 since that is how they are stored in a CONST_DOUBLE. */
2229 u.d = d;
2231 /* Detect special cases. Check for NaN first, because some ports
2232 (specifically the i386) do not emit correct ieee-fp code by default, and
2233 thus will generate a core dump here if we pass a NaN to REAL_VALUES_EQUAL
2234 and if REAL_VALUES_EQUAL does a floating point comparison. */
2235 if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_IDENTICAL (dconst0, d))
2236 return CONST0_RTX (mode);
2237 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2238 return CONST1_RTX (mode);
2239 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst2, d))
2240 return CONST2_RTX (mode);
2242 if (sizeof u == sizeof (HOST_WIDE_INT))
2243 return immed_double_const (u.i[0], 0, mode);
2244 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2245 return immed_double_const (u.i[0], u.i[1], mode);
2247 /* The rest of this function handles the case where
2248 a float value requires more than 2 ints of space.
2249 It will be deleted as dead code on machines that don't need it. */
2251 /* Search the chain for an existing CONST_DOUBLE with the right value.
2252 If one is found, return it. */
2253 if (cfun != 0)
2254 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2255 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2256 && GET_MODE (r) == mode)
2257 return r;
2259 /* No; make a new one and add it to the chain.
2261 We may be called by an optimizer which may be discarding any memory
2262 allocated during its processing (such as combine and loop). However,
2263 we will be leaving this constant on the chain, so we cannot tolerate
2264 freed memory. */
2265 r = rtx_alloc (CONST_DOUBLE);
2266 PUT_MODE (r, mode);
2267 memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u);
2269 /* If we aren't inside a function, don't put r on the
2270 const_double_chain. */
2271 if (current_function_decl != 0)
2273 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2274 const_double_chain = r;
2276 else
2277 CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2279 return r;
2282 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2283 which must be a REAL_CST tree node. */
2286 immed_real_const (exp)
2287 tree exp;
2289 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2292 /* At the end of a function, forget the memory-constants
2293 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2294 Also clear out real_constant_chain and clear out all the chain-pointers. */
2296 void
2297 clear_const_double_mem ()
2299 rtx r, next;
2301 for (r = const_double_chain; r; r = next)
2303 next = CONST_DOUBLE_CHAIN (r);
2304 CONST_DOUBLE_CHAIN (r) = 0;
2306 const_double_chain = 0;
2309 /* Given an expression EXP with a constant value,
2310 reduce it to the sum of an assembler symbol and an integer.
2311 Store them both in the structure *VALUE.
2312 Abort if EXP does not reduce. */
2314 struct addr_const
2316 rtx base;
2317 HOST_WIDE_INT offset;
2320 static void
2321 decode_addr_const (exp, value)
2322 tree exp;
2323 struct addr_const *value;
2325 tree target = TREE_OPERAND (exp, 0);
2326 int offset = 0;
2327 rtx x;
2329 while (1)
2331 if (TREE_CODE (target) == COMPONENT_REF
2332 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2335 offset += int_byte_position (TREE_OPERAND (target, 1));
2336 target = TREE_OPERAND (target, 0);
2338 else if (TREE_CODE (target) == ARRAY_REF
2339 || TREE_CODE (target) == ARRAY_RANGE_REF)
2341 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2342 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2343 target = TREE_OPERAND (target, 0);
2345 else
2346 break;
2349 switch (TREE_CODE (target))
2351 case VAR_DECL:
2352 case FUNCTION_DECL:
2353 x = DECL_RTL (target);
2354 break;
2356 case LABEL_DECL:
2357 x = gen_rtx_MEM (FUNCTION_MODE,
2358 gen_rtx_LABEL_REF (VOIDmode,
2359 label_rtx (TREE_OPERAND (exp, 0))));
2360 break;
2362 case REAL_CST:
2363 case STRING_CST:
2364 case COMPLEX_CST:
2365 case CONSTRUCTOR:
2366 case INTEGER_CST:
2367 /* This constant should have been output already, but we can't simply
2368 use TREE_CST_RTL since INTEGER_CST doesn't have one. */
2369 x = output_constant_def (target, 1);
2370 break;
2372 default:
2373 abort ();
2376 if (GET_CODE (x) != MEM)
2377 abort ();
2378 x = XEXP (x, 0);
2380 value->base = x;
2381 value->offset = offset;
2384 enum kind { RTX_DOUBLE, RTX_INT };
2385 struct rtx_const
2387 ENUM_BITFIELD(kind) kind : 16;
2388 ENUM_BITFIELD(machine_mode) mode : 16;
2389 union {
2390 union real_extract du;
2391 struct addr_const addr;
2392 struct {HOST_WIDE_INT high, low;} di;
2393 } un;
2396 /* Uniquize all constants that appear in memory.
2397 Each constant in memory thus far output is recorded
2398 in `const_hash_table' with a `struct constant_descriptor'
2399 that contains a polish representation of the value of
2400 the constant.
2402 We cannot store the trees in the hash table
2403 because the trees may be temporary. */
2405 struct constant_descriptor
2407 struct constant_descriptor *next;
2408 const char *label;
2409 rtx rtl;
2410 /* Make sure the data is reasonably aligned. */
2411 union
2413 unsigned char contents[1];
2414 #ifdef HAVE_LONG_DOUBLE
2415 long double d;
2416 #else
2417 double d;
2418 #endif
2419 } u;
2422 #define HASHBITS 30
2423 #define MAX_HASH_TABLE 1009
2424 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2426 /* We maintain a hash table of STRING_CST values. Unless we are asked to force
2427 out a string constant, we defer output of the constants until we know
2428 they are actually used. This will be if something takes its address or if
2429 there is a usage of the string in the RTL of a function. */
2431 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2433 struct deferred_string
2435 const char *label;
2436 tree exp;
2437 int labelno;
2440 static htab_t const_str_htab;
2442 /* Mark a const_hash_table descriptor for GC. */
2444 static void
2445 mark_const_hash_entry (ptr)
2446 void *ptr;
2448 struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2450 while (desc)
2452 ggc_mark_rtx (desc->rtl);
2453 desc = desc->next;
2457 /* Mark the hash-table element X (which is really a pointer to an
2458 struct deferred_string *). */
2460 static int
2461 mark_const_str_htab_1 (x, data)
2462 void **x;
2463 void *data ATTRIBUTE_UNUSED;
2465 ggc_mark_tree (((struct deferred_string *) *x)->exp);
2466 return 1;
2469 /* Mark a const_str_htab for GC. */
2471 static void
2472 mark_const_str_htab (htab)
2473 void *htab;
2475 htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2478 /* Returns a hash code for X (which is a really a
2479 struct deferred_string *). */
2481 static hashval_t
2482 const_str_htab_hash (x)
2483 const void *x;
2485 return STRHASH (((const struct deferred_string *) x)->label);
2488 /* Returns non-zero if the value represented by X (which is really a
2489 struct deferred_string *) is the same as that given by Y
2490 (which is really a char *). */
2492 static int
2493 const_str_htab_eq (x, y)
2494 const void *x;
2495 const void *y;
2497 return (((const struct deferred_string *) x)->label == (const char *) y);
2500 /* Delete the hash table entry dfsp. */
2502 static void
2503 const_str_htab_del (dfsp)
2504 void *dfsp;
2506 free (dfsp);
2509 /* Compute a hash code for a constant expression. */
2511 static int
2512 const_hash (exp)
2513 tree exp;
2515 const char *p;
2516 int len, hi, i;
2517 enum tree_code code = TREE_CODE (exp);
2519 /* Either set P and LEN to the address and len of something to hash and
2520 exit the switch or return a value. */
2522 switch (code)
2524 case INTEGER_CST:
2525 p = (char *) &TREE_INT_CST (exp);
2526 len = sizeof TREE_INT_CST (exp);
2527 break;
2529 case REAL_CST:
2530 p = (char *) &TREE_REAL_CST (exp);
2531 len = sizeof TREE_REAL_CST (exp);
2532 break;
2534 case STRING_CST:
2535 p = TREE_STRING_POINTER (exp);
2536 len = TREE_STRING_LENGTH (exp);
2537 break;
2539 case COMPLEX_CST:
2540 return (const_hash (TREE_REALPART (exp)) * 5
2541 + const_hash (TREE_IMAGPART (exp)));
2543 case CONSTRUCTOR:
2544 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2546 char *tmp;
2548 len = int_size_in_bytes (TREE_TYPE (exp));
2549 tmp = (char *) alloca (len);
2550 get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2551 p = tmp;
2552 break;
2554 else
2556 tree link;
2558 /* For record type, include the type in the hashing.
2559 We do not do so for array types
2560 because (1) the sizes of the elements are sufficient
2561 and (2) distinct array types can have the same constructor.
2562 Instead, we include the array size because the constructor could
2563 be shorter. */
2564 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2565 hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2566 % MAX_HASH_TABLE;
2567 else
2568 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2569 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2571 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2572 if (TREE_VALUE (link))
2574 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2576 return hi;
2579 case ADDR_EXPR:
2581 struct addr_const value;
2583 decode_addr_const (exp, &value);
2584 if (GET_CODE (value.base) == SYMBOL_REF)
2586 /* Don't hash the address of the SYMBOL_REF;
2587 only use the offset and the symbol name. */
2588 hi = value.offset;
2589 p = XSTR (value.base, 0);
2590 for (i = 0; p[i] != 0; i++)
2591 hi = ((hi * 613) + (unsigned) (p[i]));
2593 else if (GET_CODE (value.base) == LABEL_REF)
2594 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2595 else
2596 abort();
2598 hi &= (1 << HASHBITS) - 1;
2599 hi %= MAX_HASH_TABLE;
2601 return hi;
2603 case PLUS_EXPR:
2604 case MINUS_EXPR:
2605 return (const_hash (TREE_OPERAND (exp, 0)) * 9
2606 + const_hash (TREE_OPERAND (exp, 1)));
2608 case NOP_EXPR:
2609 case CONVERT_EXPR:
2610 case NON_LVALUE_EXPR:
2611 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2613 default:
2614 /* A language specific constant. Just hash the code. */
2615 return (int) code % MAX_HASH_TABLE;
2618 /* Compute hashing function */
2619 hi = len;
2620 for (i = 0; i < len; i++)
2621 hi = ((hi * 613) + (unsigned) (p[i]));
2623 hi &= (1 << HASHBITS) - 1;
2624 hi %= MAX_HASH_TABLE;
2625 return hi;
2628 /* Compare a constant expression EXP with a constant-descriptor DESC.
2629 Return 1 if DESC describes a constant with the same value as EXP. */
2631 static int
2632 compare_constant (exp, desc)
2633 tree exp;
2634 struct constant_descriptor *desc;
2636 return 0 != compare_constant_1 (exp, desc->u.contents);
2639 /* Compare constant expression EXP with a substring P of a constant descriptor.
2640 If they match, return a pointer to the end of the substring matched.
2641 If they do not match, return 0.
2643 Since descriptors are written in polish prefix notation,
2644 this function can be used recursively to test one operand of EXP
2645 against a subdescriptor, and if it succeeds it returns the
2646 address of the subdescriptor for the next operand. */
2648 static const unsigned char *
2649 compare_constant_1 (exp, p)
2650 tree exp;
2651 const unsigned char *p;
2653 const unsigned char *strp;
2654 int len;
2655 enum tree_code code = TREE_CODE (exp);
2657 if (code != (enum tree_code) *p++)
2658 return 0;
2660 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2661 switch, or return the result of the comparison. */
2663 switch (code)
2665 case INTEGER_CST:
2666 /* Integer constants are the same only if the same width of type. */
2667 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2668 return 0;
2670 strp = (unsigned char *) &TREE_INT_CST (exp);
2671 len = sizeof TREE_INT_CST (exp);
2672 break;
2674 case REAL_CST:
2675 /* Real constants are the same only if the same width of type. */
2676 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2677 return 0;
2679 strp = (unsigned char *) &TREE_REAL_CST (exp);
2680 len = sizeof TREE_REAL_CST (exp);
2681 break;
2683 case STRING_CST:
2684 if (flag_writable_strings)
2685 return 0;
2687 if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2688 return 0;
2690 strp = (const unsigned char *)TREE_STRING_POINTER (exp);
2691 len = TREE_STRING_LENGTH (exp);
2692 if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2693 sizeof TREE_STRING_LENGTH (exp)))
2694 return 0;
2696 p += sizeof TREE_STRING_LENGTH (exp);
2697 break;
2699 case COMPLEX_CST:
2700 p = compare_constant_1 (TREE_REALPART (exp), p);
2701 if (p == 0)
2702 return 0;
2704 return compare_constant_1 (TREE_IMAGPART (exp), p);
2706 case CONSTRUCTOR:
2707 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2709 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2710 unsigned char *tmp = (unsigned char *) alloca (len);
2712 get_set_constructor_bytes (exp, tmp, len);
2713 strp = (unsigned char *) tmp;
2714 if (memcmp ((char *) &xlen, p, sizeof xlen))
2715 return 0;
2717 p += sizeof xlen;
2718 break;
2720 else
2722 tree link;
2723 int length = list_length (CONSTRUCTOR_ELTS (exp));
2724 tree type;
2725 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2726 int have_purpose = 0;
2728 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2729 if (TREE_PURPOSE (link))
2730 have_purpose = 1;
2732 if (memcmp ((char *) &length, p, sizeof length))
2733 return 0;
2735 p += sizeof length;
2737 /* For record constructors, insist that the types match.
2738 For arrays, just verify both constructors are for arrays.
2739 Then insist that either both or none have any TREE_PURPOSE
2740 values. */
2741 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2742 type = TREE_TYPE (exp);
2743 else
2744 type = 0;
2746 if (memcmp ((char *) &type, p, sizeof type))
2747 return 0;
2749 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2751 if (memcmp ((char *) &mode, p, sizeof mode))
2752 return 0;
2754 p += sizeof mode;
2757 p += sizeof type;
2759 if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2760 return 0;
2762 p += sizeof have_purpose;
2764 /* For arrays, insist that the size in bytes match. */
2765 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2767 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2769 if (memcmp ((char *) &size, p, sizeof size))
2770 return 0;
2772 p += sizeof size;
2775 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2777 if (TREE_VALUE (link))
2779 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2780 return 0;
2782 else
2784 tree zero = 0;
2786 if (memcmp ((char *) &zero, p, sizeof zero))
2787 return 0;
2789 p += sizeof zero;
2792 if (TREE_PURPOSE (link)
2793 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2795 if (memcmp ((char *) &TREE_PURPOSE (link), p,
2796 sizeof TREE_PURPOSE (link)))
2797 return 0;
2799 p += sizeof TREE_PURPOSE (link);
2801 else if (TREE_PURPOSE (link))
2803 if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2804 return 0;
2806 else if (have_purpose)
2808 int zero = 0;
2810 if (memcmp ((char *) &zero, p, sizeof zero))
2811 return 0;
2813 p += sizeof zero;
2817 return p;
2820 case ADDR_EXPR:
2822 struct addr_const value;
2824 decode_addr_const (exp, &value);
2825 strp = (unsigned char *) &value.offset;
2826 len = sizeof value.offset;
2827 /* Compare the offset. */
2828 while (--len >= 0)
2829 if (*p++ != *strp++)
2830 return 0;
2832 /* Compare symbol name. */
2833 strp = (const unsigned char *) XSTR (value.base, 0);
2834 len = strlen ((const char *) strp) + 1;
2836 break;
2838 case PLUS_EXPR:
2839 case MINUS_EXPR:
2840 case RANGE_EXPR:
2841 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2842 if (p == 0)
2843 return 0;
2845 return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2847 case NOP_EXPR:
2848 case CONVERT_EXPR:
2849 case NON_LVALUE_EXPR:
2850 return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2852 default:
2854 tree new = (*lang_hooks.expand_constant) (exp);
2856 if (new != exp)
2857 return compare_constant_1 (new, p);
2858 else
2859 return 0;
2863 /* Compare constant contents. */
2864 while (--len >= 0)
2865 if (*p++ != *strp++)
2866 return 0;
2868 return p;
2871 /* Construct a constant descriptor for the expression EXP.
2872 It is up to the caller to enter the descriptor in the hash table. */
2874 static struct constant_descriptor *
2875 record_constant (exp)
2876 tree exp;
2878 struct constant_descriptor *next = 0;
2879 char *label = 0;
2880 rtx rtl = 0;
2881 int pad;
2883 /* Make a struct constant_descriptor. The first three pointers will
2884 be filled in later. Here we just leave space for them. */
2886 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2887 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2888 obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2890 /* Align the descriptor for the data payload. */
2891 pad = (offsetof (struct constant_descriptor, u)
2892 - offsetof(struct constant_descriptor, rtl)
2893 - sizeof(next->rtl));
2894 if (pad > 0)
2895 obstack_blank (&permanent_obstack, pad);
2897 record_constant_1 (exp);
2898 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2901 /* Add a description of constant expression EXP
2902 to the object growing in `permanent_obstack'.
2903 No need to return its address; the caller will get that
2904 from the obstack when the object is complete. */
2906 static void
2907 record_constant_1 (exp)
2908 tree exp;
2910 const unsigned char *strp;
2911 int len;
2912 enum tree_code code = TREE_CODE (exp);
2914 obstack_1grow (&permanent_obstack, (unsigned int) code);
2916 switch (code)
2918 case INTEGER_CST:
2919 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2920 strp = (unsigned char *) &TREE_INT_CST (exp);
2921 len = sizeof TREE_INT_CST (exp);
2922 break;
2924 case REAL_CST:
2925 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2926 strp = (unsigned char *) &TREE_REAL_CST (exp);
2927 len = sizeof TREE_REAL_CST (exp);
2928 break;
2930 case STRING_CST:
2931 if (flag_writable_strings)
2932 return;
2934 obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2935 strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2936 len = TREE_STRING_LENGTH (exp);
2937 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2938 sizeof TREE_STRING_LENGTH (exp));
2939 break;
2941 case COMPLEX_CST:
2942 record_constant_1 (TREE_REALPART (exp));
2943 record_constant_1 (TREE_IMAGPART (exp));
2944 return;
2946 case CONSTRUCTOR:
2947 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2949 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2950 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2951 obstack_blank (&permanent_obstack, nbytes);
2952 get_set_constructor_bytes
2953 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2954 nbytes);
2955 return;
2957 else
2959 tree link;
2960 int length = list_length (CONSTRUCTOR_ELTS (exp));
2961 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2962 tree type;
2963 int have_purpose = 0;
2965 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2966 if (TREE_PURPOSE (link))
2967 have_purpose = 1;
2969 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2971 /* For record constructors, insist that the types match.
2972 For arrays, just verify both constructors are for arrays
2973 of the same mode. Then insist that either both or none
2974 have any TREE_PURPOSE values. */
2975 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2976 type = TREE_TYPE (exp);
2977 else
2978 type = 0;
2980 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2981 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2982 obstack_grow (&permanent_obstack, &mode, sizeof mode);
2984 obstack_grow (&permanent_obstack, (char *) &have_purpose,
2985 sizeof have_purpose);
2987 /* For arrays, insist that the size in bytes match. */
2988 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2990 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2991 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2994 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2996 if (TREE_VALUE (link))
2997 record_constant_1 (TREE_VALUE (link));
2998 else
3000 tree zero = 0;
3002 obstack_grow (&permanent_obstack,
3003 (char *) &zero, sizeof zero);
3006 if (TREE_PURPOSE (link)
3007 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
3008 obstack_grow (&permanent_obstack,
3009 (char *) &TREE_PURPOSE (link),
3010 sizeof TREE_PURPOSE (link));
3011 else if (TREE_PURPOSE (link))
3012 record_constant_1 (TREE_PURPOSE (link));
3013 else if (have_purpose)
3015 int zero = 0;
3017 obstack_grow (&permanent_obstack,
3018 (char *) &zero, sizeof zero);
3022 return;
3024 case ADDR_EXPR:
3026 struct addr_const value;
3028 decode_addr_const (exp, &value);
3029 /* Record the offset. */
3030 obstack_grow (&permanent_obstack,
3031 (char *) &value.offset, sizeof value.offset);
3033 switch (GET_CODE (value.base))
3035 case SYMBOL_REF:
3036 /* Record the symbol name. */
3037 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
3038 strlen (XSTR (value.base, 0)) + 1);
3039 break;
3040 case LABEL_REF:
3041 /* Record the address of the CODE_LABEL. It may not have
3042 been emitted yet, so it's UID may be zero. But pointer
3043 identity is good enough. */
3044 obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
3045 sizeof (rtx));
3046 break;
3047 default:
3048 abort ();
3051 return;
3053 case PLUS_EXPR:
3054 case MINUS_EXPR:
3055 case RANGE_EXPR:
3056 record_constant_1 (TREE_OPERAND (exp, 0));
3057 record_constant_1 (TREE_OPERAND (exp, 1));
3058 return;
3060 case NOP_EXPR:
3061 case CONVERT_EXPR:
3062 case NON_LVALUE_EXPR:
3063 record_constant_1 (TREE_OPERAND (exp, 0));
3064 return;
3066 default:
3068 tree new = (*lang_hooks.expand_constant) (exp);
3070 if (new != exp)
3071 record_constant_1 (new);
3072 return;
3076 /* Record constant contents. */
3077 obstack_grow (&permanent_obstack, strp, len);
3080 /* Record a list of constant expressions that were passed to
3081 output_constant_def but that could not be output right away. */
3083 struct deferred_constant
3085 struct deferred_constant *next;
3086 tree exp;
3087 int reloc;
3088 int labelno;
3091 static struct deferred_constant *deferred_constants;
3093 /* Another list of constants which should be output after the
3094 function. */
3095 static struct deferred_constant *after_function_constants;
3097 /* Nonzero means defer output of addressed subconstants
3098 (i.e., those for which output_constant_def is called.) */
3099 static int defer_addressed_constants_flag;
3101 /* Start deferring output of subconstants. */
3103 void
3104 defer_addressed_constants ()
3106 defer_addressed_constants_flag++;
3109 /* Stop deferring output of subconstants,
3110 and output now all those that have been deferred. */
3112 void
3113 output_deferred_addressed_constants ()
3115 struct deferred_constant *p, *next;
3117 defer_addressed_constants_flag--;
3119 if (defer_addressed_constants_flag > 0)
3120 return;
3122 for (p = deferred_constants; p; p = next)
3124 output_constant_def_contents (p->exp, p->reloc, p->labelno);
3125 next = p->next;
3126 free (p);
3129 deferred_constants = 0;
3132 /* Output any constants which should appear after a function. */
3134 static void
3135 output_after_function_constants ()
3137 struct deferred_constant *p, *next;
3139 for (p = after_function_constants; p; p = next)
3141 output_constant_def_contents (p->exp, p->reloc, p->labelno);
3142 next = p->next;
3143 free (p);
3146 after_function_constants = 0;
3149 /* Make a copy of the whole tree structure for a constant.
3150 This handles the same types of nodes that compare_constant
3151 and record_constant handle. */
3153 static tree
3154 copy_constant (exp)
3155 tree exp;
3157 switch (TREE_CODE (exp))
3159 case ADDR_EXPR:
3160 /* For ADDR_EXPR, we do not want to copy the decl whose address
3161 is requested. We do want to copy constants though. */
3162 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
3163 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3164 copy_constant (TREE_OPERAND (exp, 0)));
3165 else
3166 return copy_node (exp);
3168 case INTEGER_CST:
3169 case REAL_CST:
3170 case STRING_CST:
3171 return copy_node (exp);
3173 case COMPLEX_CST:
3174 return build_complex (TREE_TYPE (exp),
3175 copy_constant (TREE_REALPART (exp)),
3176 copy_constant (TREE_IMAGPART (exp)));
3178 case PLUS_EXPR:
3179 case MINUS_EXPR:
3180 return build (TREE_CODE (exp), TREE_TYPE (exp),
3181 copy_constant (TREE_OPERAND (exp, 0)),
3182 copy_constant (TREE_OPERAND (exp, 1)));
3184 case NOP_EXPR:
3185 case CONVERT_EXPR:
3186 case NON_LVALUE_EXPR:
3187 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3188 copy_constant (TREE_OPERAND (exp, 0)));
3190 case CONSTRUCTOR:
3192 tree copy = copy_node (exp);
3193 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3194 tree tail;
3196 CONSTRUCTOR_ELTS (copy) = list;
3197 for (tail = list; tail; tail = TREE_CHAIN (tail))
3198 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3199 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3200 for (tail = list; tail; tail = TREE_CHAIN (tail))
3201 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3203 return copy;
3206 default:
3207 abort ();
3211 /* Return an rtx representing a reference to constant data in memory
3212 for the constant expression EXP.
3214 If assembler code for such a constant has already been output,
3215 return an rtx to refer to it.
3216 Otherwise, output such a constant in memory (or defer it for later)
3217 and generate an rtx for it.
3219 If DEFER is non-zero, the output of string constants can be deferred
3220 and output only if referenced in the function after all optimizations.
3222 The TREE_CST_RTL of EXP is set up to point to that rtx.
3223 The const_hash_table records which constants already have label strings. */
3226 output_constant_def (exp, defer)
3227 tree exp;
3228 int defer;
3230 int hash;
3231 struct constant_descriptor *desc;
3232 struct deferred_string **defstr;
3233 char label[256];
3234 int reloc;
3235 int found = 1;
3236 int after_function = 0;
3237 int labelno = -1;
3238 rtx rtl;
3240 /* We can't just use the saved RTL if this is a defererred string constant
3241 and we are not to defer anymode. */
3242 if (TREE_CODE (exp) != INTEGER_CST && TREE_CST_RTL (exp)
3243 && (defer || !STRING_POOL_ADDRESS_P (XEXP (TREE_CST_RTL (exp), 0))))
3244 return TREE_CST_RTL (exp);
3246 /* Make sure any other constants whose addresses appear in EXP
3247 are assigned label numbers. */
3249 reloc = output_addressed_constants (exp);
3251 /* Compute hash code of EXP. Search the descriptors for that hash code
3252 to see if any of them describes EXP. If yes, the descriptor records
3253 the label number already assigned. */
3255 hash = const_hash (exp) % MAX_HASH_TABLE;
3257 for (desc = const_hash_table[hash]; desc; desc = desc->next)
3258 if (compare_constant (exp, desc))
3259 break;
3261 if (desc == 0)
3263 /* No constant equal to EXP is known to have been output.
3264 Make a constant descriptor to enter EXP in the hash table.
3265 Assign the label number and record it in the descriptor for
3266 future calls to this function to find. */
3268 /* Create a string containing the label name, in LABEL. */
3269 labelno = const_labelno++;
3270 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3272 desc = record_constant (exp);
3273 desc->next = const_hash_table[hash];
3274 desc->label = ggc_strdup (label);
3275 const_hash_table[hash] = desc;
3277 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3278 rtl = desc->rtl
3279 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3280 gen_rtx_SYMBOL_REF (Pmode, desc->label));
3282 set_mem_attributes (rtl, exp, 1);
3283 set_mem_alias_set (rtl, 0);
3284 set_mem_alias_set (rtl, const_alias_set);
3286 found = 0;
3288 else
3289 rtl = desc->rtl;
3291 if (TREE_CODE (exp) != INTEGER_CST)
3292 TREE_CST_RTL (exp) = rtl;
3294 /* Optionally set flags or add text to the name to record information
3295 such as that it is a function name. If the name is changed, the macro
3296 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3297 #ifdef ENCODE_SECTION_INFO
3298 /* A previously-processed constant would already have section info
3299 encoded in it. */
3300 if (! found)
3302 ENCODE_SECTION_INFO (exp);
3303 desc->rtl = rtl;
3304 desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3306 #endif
3308 #ifdef CONSTANT_AFTER_FUNCTION_P
3309 if (current_function_decl != 0
3310 && CONSTANT_AFTER_FUNCTION_P (exp))
3311 after_function = 1;
3312 #endif
3314 if (found
3315 && STRING_POOL_ADDRESS_P (XEXP (rtl, 0))
3316 && (!defer || defer_addressed_constants_flag || after_function))
3318 defstr = (struct deferred_string **)
3319 htab_find_slot_with_hash (const_str_htab, desc->label,
3320 STRHASH (desc->label), NO_INSERT);
3321 if (defstr)
3323 /* If the string is currently deferred but we need to output it now,
3324 remove it from deferred string hash table. */
3325 found = 0;
3326 labelno = (*defstr)->labelno;
3327 STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 0;
3328 htab_clear_slot (const_str_htab, (void **) defstr);
3332 /* If this is the first time we've seen this particular constant,
3333 output it (or defer its output for later). */
3334 if (! found)
3336 if (defer_addressed_constants_flag || after_function)
3338 struct deferred_constant *p
3339 = (struct deferred_constant *)
3340 xmalloc (sizeof (struct deferred_constant));
3342 p->exp = copy_constant (exp);
3343 p->reloc = reloc;
3344 p->labelno = labelno;
3345 if (after_function)
3347 p->next = after_function_constants;
3348 after_function_constants = p;
3350 else
3352 p->next = deferred_constants;
3353 deferred_constants = p;
3356 else
3358 /* Do no output if -fsyntax-only. */
3359 if (! flag_syntax_only)
3361 if (TREE_CODE (exp) != STRING_CST
3362 || !defer
3363 || flag_writable_strings
3364 || (defstr = (struct deferred_string **)
3365 htab_find_slot_with_hash (const_str_htab,
3366 desc->label,
3367 STRHASH (desc->label),
3368 INSERT)) == NULL)
3369 output_constant_def_contents (exp, reloc, labelno);
3370 else
3372 struct deferred_string *p;
3374 p = (struct deferred_string *)
3375 xmalloc (sizeof (struct deferred_string));
3377 p->exp = copy_constant (exp);
3378 p->label = desc->label;
3379 p->labelno = labelno;
3380 *defstr = p;
3381 STRING_POOL_ADDRESS_P (XEXP (rtl, 0)) = 1;
3387 return rtl;
3390 /* Now output assembler code to define the label for EXP,
3391 and follow it with the data of EXP. */
3393 static void
3394 output_constant_def_contents (exp, reloc, labelno)
3395 tree exp;
3396 int reloc;
3397 int labelno;
3399 int align;
3401 /* Align the location counter as required by EXP's data type. */
3402 align = TYPE_ALIGN (TREE_TYPE (exp));
3403 #ifdef CONSTANT_ALIGNMENT
3404 align = CONSTANT_ALIGNMENT (exp, align);
3405 #endif
3407 if (IN_NAMED_SECTION (exp))
3408 named_section (exp, NULL, reloc);
3409 else
3411 /* First switch to text section, except for writable strings. */
3412 #ifdef SELECT_SECTION
3413 SELECT_SECTION (exp, reloc, align);
3414 #else
3415 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3416 || (flag_pic && reloc))
3417 data_section ();
3418 else
3419 readonly_data_section ();
3420 #endif
3423 if (align > BITS_PER_UNIT)
3425 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3428 /* Output the label itself. */
3429 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3431 /* Output the value of EXP. */
3432 output_constant (exp,
3433 (TREE_CODE (exp) == STRING_CST
3434 ? MAX (TREE_STRING_LENGTH (exp),
3435 int_size_in_bytes (TREE_TYPE (exp)))
3436 : int_size_in_bytes (TREE_TYPE (exp))),
3437 align);
3441 /* Structure to represent sufficient information about a constant so that
3442 it can be output when the constant pool is output, so that function
3443 integration can be done, and to simplify handling on machines that reference
3444 constant pool as base+displacement. */
3446 struct pool_constant
3448 struct constant_descriptor *desc;
3449 struct pool_constant *next, *next_sym;
3450 rtx constant;
3451 enum machine_mode mode;
3452 int labelno;
3453 unsigned int align;
3454 HOST_WIDE_INT offset;
3455 int mark;
3458 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3459 The argument is XSTR (... , 0) */
3461 #define SYMHASH(LABEL) \
3462 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3464 /* Initialize constant pool hashing for a new function. */
3466 void
3467 init_varasm_status (f)
3468 struct function *f;
3470 struct varasm_status *p;
3471 p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3472 f->varasm = p;
3473 p->x_const_rtx_hash_table
3474 = ((struct constant_descriptor **)
3475 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3476 p->x_const_rtx_sym_hash_table
3477 = ((struct pool_constant **)
3478 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3480 p->x_first_pool = p->x_last_pool = 0;
3481 p->x_pool_offset = 0;
3482 p->x_const_double_chain = 0;
3485 /* Mark PC for GC. */
3487 static void
3488 mark_pool_constant (pc)
3489 struct pool_constant *pc;
3491 while (pc)
3493 ggc_mark (pc);
3494 ggc_mark_rtx (pc->constant);
3495 ggc_mark_rtx (pc->desc->rtl);
3496 pc = pc->next;
3500 /* Mark P for GC. */
3502 void
3503 mark_varasm_status (p)
3504 struct varasm_status *p;
3506 if (p == NULL)
3507 return;
3509 mark_pool_constant (p->x_first_pool);
3510 ggc_mark_rtx (p->x_const_double_chain);
3513 /* Clear out all parts of the state in F that can safely be discarded
3514 after the function has been compiled, to let garbage collection
3515 reclaim the memory. */
3517 void
3518 free_varasm_status (f)
3519 struct function *f;
3521 struct varasm_status *p;
3522 int i;
3524 p = f->varasm;
3526 /* Clear out the hash tables. */
3527 for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3529 struct constant_descriptor *cd;
3531 cd = p->x_const_rtx_hash_table[i];
3532 while (cd)
3534 struct constant_descriptor *next = cd->next;
3536 free (cd);
3537 cd = next;
3541 free (p->x_const_rtx_hash_table);
3542 free (p->x_const_rtx_sym_hash_table);
3543 free (p);
3545 f->varasm = NULL;
3549 /* Express an rtx for a constant integer (perhaps symbolic)
3550 as the sum of a symbol or label plus an explicit integer.
3551 They are stored into VALUE. */
3553 static void
3554 decode_rtx_const (mode, x, value)
3555 enum machine_mode mode;
3556 rtx x;
3557 struct rtx_const *value;
3559 /* Clear the whole structure, including any gaps. */
3560 memset (value, 0, sizeof (struct rtx_const));
3562 value->kind = RTX_INT; /* Most usual kind. */
3563 value->mode = mode;
3565 switch (GET_CODE (x))
3567 case CONST_DOUBLE:
3568 value->kind = RTX_DOUBLE;
3569 if (GET_MODE (x) != VOIDmode)
3571 value->mode = GET_MODE (x);
3572 memcpy ((char *) &value->un.du,
3573 (char *) &CONST_DOUBLE_LOW (x), sizeof value->un.du);
3575 else
3577 value->un.di.low = CONST_DOUBLE_LOW (x);
3578 value->un.di.high = CONST_DOUBLE_HIGH (x);
3580 break;
3582 case CONST_INT:
3583 value->un.addr.offset = INTVAL (x);
3584 break;
3586 case SYMBOL_REF:
3587 case LABEL_REF:
3588 case PC:
3589 value->un.addr.base = x;
3590 break;
3592 case CONST:
3593 x = XEXP (x, 0);
3594 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3596 value->un.addr.base = XEXP (x, 0);
3597 value->un.addr.offset = INTVAL (XEXP (x, 1));
3599 else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3601 value->un.addr.base = XEXP (x, 0);
3602 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3604 else
3606 value->un.addr.base = x;
3607 value->un.addr.offset = 0;
3609 break;
3611 default:
3612 abort ();
3615 if (value->kind == RTX_INT && value->un.addr.base != 0)
3616 switch (GET_CODE (value->un.addr.base))
3618 case SYMBOL_REF:
3619 /* Use the string's address, not the SYMBOL_REF's address,
3620 for the sake of addresses of library routines. */
3621 value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3622 break;
3624 case LABEL_REF:
3625 /* For a LABEL_REF, compare labels. */
3626 value->un.addr.base = XEXP (value->un.addr.base, 0);
3628 default:
3629 break;
3633 /* Given a MINUS expression, simplify it if both sides
3634 include the same symbol. */
3637 simplify_subtraction (x)
3638 rtx x;
3640 struct rtx_const val0, val1;
3642 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3643 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3645 if (val0.un.addr.base == val1.un.addr.base)
3646 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3647 return x;
3650 /* Compute a hash code for a constant RTL expression. */
3652 static int
3653 const_hash_rtx (mode, x)
3654 enum machine_mode mode;
3655 rtx x;
3657 int hi;
3658 size_t i;
3660 struct rtx_const value;
3661 decode_rtx_const (mode, x, &value);
3663 /* Compute hashing function */
3664 hi = 0;
3665 for (i = 0; i < sizeof value / sizeof (int); i++)
3666 hi += ((int *) &value)[i];
3668 hi &= (1 << HASHBITS) - 1;
3669 hi %= MAX_RTX_HASH_TABLE;
3670 return hi;
3673 /* Compare a constant rtl object X with a constant-descriptor DESC.
3674 Return 1 if DESC describes a constant with the same value as X. */
3676 static int
3677 compare_constant_rtx (mode, x, desc)
3678 enum machine_mode mode;
3679 rtx x;
3680 struct constant_descriptor *desc;
3682 int *p = (int *) desc->u.contents;
3683 int *strp;
3684 int len;
3685 struct rtx_const value;
3687 decode_rtx_const (mode, x, &value);
3688 strp = (int *) &value;
3689 len = sizeof value / sizeof (int);
3691 /* Compare constant contents. */
3692 while (--len >= 0)
3693 if (*p++ != *strp++)
3694 return 0;
3696 return 1;
3699 /* Construct a constant descriptor for the rtl-expression X.
3700 It is up to the caller to enter the descriptor in the hash table. */
3702 static struct constant_descriptor *
3703 record_constant_rtx (mode, x)
3704 enum machine_mode mode;
3705 rtx x;
3707 struct constant_descriptor *ptr;
3709 ptr = ((struct constant_descriptor *)
3710 xcalloc (1, (offsetof (struct constant_descriptor, u)
3711 + sizeof (struct rtx_const))));
3712 decode_rtx_const (mode, x, (struct rtx_const *) ptr->u.contents);
3714 return ptr;
3717 /* Given a constant rtx X, return a MEM for the location in memory at which
3718 this constant has been placed. Return 0 if it not has been placed yet. */
3721 mem_for_const_double (x)
3722 rtx x;
3724 enum machine_mode mode = GET_MODE (x);
3725 struct constant_descriptor *desc;
3727 for (desc = const_rtx_hash_table[const_hash_rtx (mode, x)]; desc;
3728 desc = desc->next)
3729 if (compare_constant_rtx (mode, x, desc))
3730 return desc->rtl;
3732 return 0;
3735 /* Given a constant rtx X, make (or find) a memory constant for its value
3736 and return a MEM rtx to refer to it in memory. */
3739 force_const_mem (mode, x)
3740 enum machine_mode mode;
3741 rtx x;
3743 int hash;
3744 struct constant_descriptor *desc;
3745 char label[256];
3746 rtx def;
3747 struct pool_constant *pool;
3748 unsigned int align;
3750 /* Compute hash code of X. Search the descriptors for that hash code
3751 to see if any of them describes X. If yes, we have an rtx to use. */
3752 hash = const_hash_rtx (mode, x);
3753 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3754 if (compare_constant_rtx (mode, x, desc))
3755 return desc->rtl;
3757 /* No constant equal to X is known to have been output.
3758 Make a constant descriptor to enter X in the hash table
3759 and make a MEM for it. */
3760 desc = record_constant_rtx (mode, x);
3761 desc->next = const_rtx_hash_table[hash];
3762 const_rtx_hash_table[hash] = desc;
3764 /* Align the location counter as required by EXP's data type. */
3765 align = GET_MODE_ALIGNMENT (mode == VOIDmode ? word_mode : mode);
3766 #ifdef CONSTANT_ALIGNMENT
3767 align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x), align);
3768 #endif
3770 pool_offset += (align / BITS_PER_UNIT) - 1;
3771 pool_offset &= ~ ((align / BITS_PER_UNIT) - 1);
3773 if (GET_CODE (x) == LABEL_REF)
3774 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3776 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3777 pool = (struct pool_constant *) ggc_alloc (sizeof (struct pool_constant));
3778 pool->desc = desc;
3779 pool->constant = x;
3780 pool->mode = mode;
3781 pool->labelno = const_labelno;
3782 pool->align = align;
3783 pool->offset = pool_offset;
3784 pool->mark = 1;
3785 pool->next = 0;
3787 if (last_pool == 0)
3788 first_pool = pool;
3789 else
3790 last_pool->next = pool;
3792 last_pool = pool;
3793 pool_offset += GET_MODE_SIZE (mode);
3795 /* Create a string containing the label name, in LABEL. */
3796 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3798 ++const_labelno;
3800 /* Construct the SYMBOL_REF and the MEM. */
3802 pool->desc->rtl = def
3803 = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (label)));
3804 set_mem_alias_set (def, const_alias_set);
3805 set_mem_attributes (def, type_for_mode (mode, 0), 1);
3806 RTX_UNCHANGING_P (def) = 1;
3808 /* Add label to symbol hash table. */
3809 hash = SYMHASH (XSTR (XEXP (def, 0), 0));
3810 pool->next_sym = const_rtx_sym_hash_table[hash];
3811 const_rtx_sym_hash_table[hash] = pool;
3813 /* Mark the symbol_ref as belonging to this constants pool. */
3814 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3815 current_function_uses_const_pool = 1;
3817 return def;
3820 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3821 the corresponding pool_constant structure. */
3823 static struct pool_constant *
3824 find_pool_constant (f, addr)
3825 struct function *f;
3826 rtx addr;
3828 struct pool_constant *pool;
3829 const char *label = XSTR (addr, 0);
3831 for (pool = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; pool;
3832 pool = pool->next_sym)
3833 if (XSTR (XEXP (pool->desc->rtl, 0), 0) == label)
3834 return pool;
3836 abort ();
3839 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3842 get_pool_constant (addr)
3843 rtx addr;
3845 return (find_pool_constant (cfun, addr))->constant;
3848 /* Likewise, but for the constant pool of a specific function. */
3851 get_pool_constant_for_function (f, addr)
3852 struct function *f;
3853 rtx addr;
3855 return (find_pool_constant (f, addr))->constant;
3858 /* Similar, return the mode. */
3860 enum machine_mode
3861 get_pool_mode (addr)
3862 rtx addr;
3864 return (find_pool_constant (cfun, addr))->mode;
3867 enum machine_mode
3868 get_pool_mode_for_function (f, addr)
3869 struct function *f;
3870 rtx addr;
3872 return (find_pool_constant (f, addr))->mode;
3875 /* Similar, return the offset in the constant pool. */
3878 get_pool_offset (addr)
3879 rtx addr;
3881 return (find_pool_constant (cfun, addr))->offset;
3884 /* Return the size of the constant pool. */
3887 get_pool_size ()
3889 return pool_offset;
3892 /* Write all the constants in the constant pool. */
3894 void
3895 output_constant_pool (fnname, fndecl)
3896 const char *fnname ATTRIBUTE_UNUSED;
3897 tree fndecl ATTRIBUTE_UNUSED;
3899 struct pool_constant *pool;
3900 rtx x;
3901 union real_extract u;
3903 /* It is possible for gcc to call force_const_mem and then to later
3904 discard the instructions which refer to the constant. In such a
3905 case we do not need to output the constant. */
3906 mark_constant_pool ();
3908 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3909 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3910 #endif
3912 for (pool = first_pool; pool; pool = pool->next)
3914 rtx tmp;
3916 x = pool->constant;
3918 if (! pool->mark)
3919 continue;
3921 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3922 whose CODE_LABEL has been deleted. This can occur if a jump table
3923 is eliminated by optimization. If so, write a constant of zero
3924 instead. Note that this can also happen by turning the
3925 CODE_LABEL into a NOTE. */
3926 /* ??? This seems completely and utterly wrong. Certainly it's
3927 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3928 functioning even with INSN_DELETED_P and friends. */
3930 tmp = x;
3931 switch (GET_CODE (x))
3933 case CONST:
3934 if (GET_CODE (XEXP (x, 0)) != PLUS
3935 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3936 break;
3937 tmp = XEXP (XEXP (x, 0), 0);
3938 /* FALLTHRU */
3940 case LABEL_REF:
3941 tmp = XEXP (x, 0);
3942 if (INSN_DELETED_P (tmp)
3943 || (GET_CODE (tmp) == NOTE
3944 && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3946 abort ();
3947 x = const0_rtx;
3949 break;
3951 default:
3952 break;
3955 /* First switch to correct section. */
3956 #ifdef SELECT_RTX_SECTION
3957 SELECT_RTX_SECTION (pool->mode, x, pool->align);
3958 #else
3959 readonly_data_section ();
3960 #endif
3962 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3963 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3964 pool->align, pool->labelno, done);
3965 #endif
3967 assemble_align (pool->align);
3969 /* Output the label. */
3970 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3972 /* Output the value of the constant itself. */
3973 switch (GET_MODE_CLASS (pool->mode))
3975 case MODE_FLOAT:
3976 if (GET_CODE (x) != CONST_DOUBLE)
3977 abort ();
3979 memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
3980 assemble_real (u.d, pool->mode, pool->align);
3981 break;
3983 case MODE_INT:
3984 case MODE_PARTIAL_INT:
3985 assemble_integer (x, GET_MODE_SIZE (pool->mode), pool->align, 1);
3986 break;
3988 default:
3989 abort ();
3992 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3993 done: ;
3994 #endif
3997 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3998 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3999 #endif
4001 /* Done with this pool. */
4002 first_pool = last_pool = 0;
4005 /* Look through the instructions for this function, and mark all the
4006 entries in the constant pool which are actually being used.
4007 Emit used deferred strings. */
4009 static void
4010 mark_constant_pool ()
4012 rtx insn;
4013 struct pool_constant *pool;
4015 if (first_pool == 0 && htab_elements (const_str_htab) == 0)
4016 return;
4018 for (pool = first_pool; pool; pool = pool->next)
4019 pool->mark = 0;
4021 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4022 if (INSN_P (insn))
4023 mark_constants (PATTERN (insn));
4025 for (insn = current_function_epilogue_delay_list;
4026 insn;
4027 insn = XEXP (insn, 1))
4028 if (INSN_P (insn))
4029 mark_constants (PATTERN (insn));
4032 /* Look through appropriate parts of X, marking all entries in the
4033 constant pool which are actually being used. Entries that are only
4034 referenced by other constants are also marked as used. Emit
4035 deferred strings that are used. */
4037 static void
4038 mark_constants (x)
4039 rtx x;
4041 int i;
4042 const char *format_ptr;
4044 if (x == 0)
4045 return;
4047 if (GET_CODE (x) == SYMBOL_REF)
4049 mark_constant (&x, NULL);
4050 return;
4053 /* Insns may appear inside a SEQUENCE. Only check the patterns of
4054 insns, not any notes that may be attached. We don't want to mark
4055 a constant just because it happens to appear in a REG_EQUIV note. */
4056 if (INSN_P (x))
4058 mark_constants (PATTERN (x));
4059 return;
4062 format_ptr = GET_RTX_FORMAT (GET_CODE (x));
4064 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
4066 switch (*format_ptr++)
4068 case 'e':
4069 mark_constants (XEXP (x, i));
4070 break;
4072 case 'E':
4073 if (XVEC (x, i) != 0)
4075 int j;
4077 for (j = 0; j < XVECLEN (x, i); j++)
4078 mark_constants (XVECEXP (x, i, j));
4080 break;
4082 case 'S':
4083 case 's':
4084 case '0':
4085 case 'i':
4086 case 'w':
4087 case 'n':
4088 case 'u':
4089 break;
4091 default:
4092 abort ();
4097 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
4098 to as used. Emit referenced deferred strings. This function can
4099 be used with for_each_rtx to mark all SYMBOL_REFs in an rtx. */
4101 static int
4102 mark_constant (current_rtx, data)
4103 rtx *current_rtx;
4104 void *data ATTRIBUTE_UNUSED;
4106 rtx x = *current_rtx;
4108 if (x == NULL_RTX)
4109 return 0;
4111 else if (GET_CODE (x) == SYMBOL_REF)
4113 if (CONSTANT_POOL_ADDRESS_P (x))
4115 struct pool_constant *pool = find_pool_constant (cfun, x);
4116 if (pool->mark == 0) {
4117 pool->mark = 1;
4118 for_each_rtx (&(pool->constant), &mark_constant, NULL);
4120 else
4121 return -1;
4123 else if (STRING_POOL_ADDRESS_P (x))
4125 struct deferred_string **defstr;
4127 defstr = (struct deferred_string **)
4128 htab_find_slot_with_hash (const_str_htab, XSTR (x, 0),
4129 STRHASH (XSTR (x, 0)), NO_INSERT);
4130 if (defstr)
4132 struct deferred_string *p = *defstr;
4134 STRING_POOL_ADDRESS_P (x) = 0;
4135 output_constant_def_contents (p->exp, 0, p->labelno);
4136 htab_clear_slot (const_str_htab, (void **) defstr);
4140 return 0;
4143 /* Find all the constants whose addresses are referenced inside of EXP,
4144 and make sure assembler code with a label has been output for each one.
4145 Indicate whether an ADDR_EXPR has been encountered. */
4147 static int
4148 output_addressed_constants (exp)
4149 tree exp;
4151 int reloc = 0;
4152 tree tem;
4154 /* Give the front-end a chance to convert VALUE to something that
4155 looks more like a constant to the back-end. */
4156 exp = (*lang_hooks.expand_constant) (exp);
4158 switch (TREE_CODE (exp))
4160 case ADDR_EXPR:
4161 /* Go inside any operations that get_inner_reference can handle and see
4162 if what's inside is a constant: no need to do anything here for
4163 addresses of variables or functions. */
4164 for (tem = TREE_OPERAND (exp, 0); handled_component_p (tem);
4165 tem = TREE_OPERAND (tem, 0))
4168 if (TREE_CODE_CLASS (TREE_CODE (tem)) == 'c'
4169 || TREE_CODE (tem) == CONSTRUCTOR)
4170 output_constant_def (tem, 0);
4172 if (TREE_PUBLIC (tem))
4173 reloc |= 2;
4174 else
4175 reloc |= 1;
4176 break;
4178 case PLUS_EXPR:
4179 case MINUS_EXPR:
4180 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4181 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
4182 break;
4184 case NOP_EXPR:
4185 case CONVERT_EXPR:
4186 case NON_LVALUE_EXPR:
4187 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4188 break;
4190 case CONSTRUCTOR:
4191 for (tem = CONSTRUCTOR_ELTS (exp); tem; tem = TREE_CHAIN (tem))
4192 if (TREE_VALUE (tem) != 0)
4193 reloc |= output_addressed_constants (TREE_VALUE (tem));
4195 break;
4197 default:
4198 break;
4200 return reloc;
4203 /* Return nonzero if VALUE is a valid constant-valued expression
4204 for use in initializing a static variable; one that can be an
4205 element of a "constant" initializer.
4207 Return null_pointer_node if the value is absolute;
4208 if it is relocatable, return the variable that determines the relocation.
4209 We assume that VALUE has been folded as much as possible;
4210 therefore, we do not need to check for such things as
4211 arithmetic-combinations of integers. */
4213 tree
4214 initializer_constant_valid_p (value, endtype)
4215 tree value;
4216 tree endtype;
4218 /* Give the front-end a chance to convert VALUE to something that
4219 looks more like a constant to the back-end. */
4220 value = (*lang_hooks.expand_constant) (value);
4222 switch (TREE_CODE (value))
4224 case CONSTRUCTOR:
4225 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4226 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4227 && TREE_CONSTANT (value)
4228 && CONSTRUCTOR_ELTS (value))
4229 return
4230 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4231 endtype);
4233 return TREE_STATIC (value) ? null_pointer_node : 0;
4235 case INTEGER_CST:
4236 case REAL_CST:
4237 case STRING_CST:
4238 case COMPLEX_CST:
4239 return null_pointer_node;
4241 case ADDR_EXPR:
4242 case FDESC_EXPR:
4243 return staticp (TREE_OPERAND (value, 0)) ? TREE_OPERAND (value, 0) : 0;
4245 case VIEW_CONVERT_EXPR:
4246 case NON_LVALUE_EXPR:
4247 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4249 case CONVERT_EXPR:
4250 case NOP_EXPR:
4251 /* Allow conversions between pointer types. */
4252 if (POINTER_TYPE_P (TREE_TYPE (value))
4253 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4254 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4256 /* Allow conversions between real types. */
4257 if (FLOAT_TYPE_P (TREE_TYPE (value))
4258 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4259 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4261 /* Allow length-preserving conversions between integer types. */
4262 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4263 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4264 && (TYPE_PRECISION (TREE_TYPE (value))
4265 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4266 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4268 /* Allow conversions between other integer types only if
4269 explicit value. */
4270 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4271 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4273 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4274 endtype);
4275 if (inner == null_pointer_node)
4276 return null_pointer_node;
4277 break;
4280 /* Allow (int) &foo provided int is as wide as a pointer. */
4281 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4282 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4283 && (TYPE_PRECISION (TREE_TYPE (value))
4284 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4285 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4286 endtype);
4288 /* Likewise conversions from int to pointers, but also allow
4289 conversions from 0. */
4290 if (POINTER_TYPE_P (TREE_TYPE (value))
4291 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4293 if (integer_zerop (TREE_OPERAND (value, 0)))
4294 return null_pointer_node;
4295 else if (TYPE_PRECISION (TREE_TYPE (value))
4296 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4297 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4298 endtype);
4301 /* Allow conversions to union types if the value inside is okay. */
4302 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4303 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4304 endtype);
4305 break;
4307 case PLUS_EXPR:
4308 if (! INTEGRAL_TYPE_P (endtype)
4309 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4311 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4312 endtype);
4313 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4314 endtype);
4315 /* If either term is absolute, use the other terms relocation. */
4316 if (valid0 == null_pointer_node)
4317 return valid1;
4318 if (valid1 == null_pointer_node)
4319 return valid0;
4321 break;
4323 case MINUS_EXPR:
4324 if (! INTEGRAL_TYPE_P (endtype)
4325 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4327 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4328 endtype);
4329 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4330 endtype);
4331 /* Win if second argument is absolute. */
4332 if (valid1 == null_pointer_node)
4333 return valid0;
4334 /* Win if both arguments have the same relocation.
4335 Then the value is absolute. */
4336 if (valid0 == valid1 && valid0 != 0)
4337 return null_pointer_node;
4339 /* Since GCC guarantees that string constants are unique in the
4340 generated code, a subtraction between two copies of the same
4341 constant string is absolute. */
4342 if (valid0 && TREE_CODE (valid0) == STRING_CST &&
4343 valid1 && TREE_CODE (valid1) == STRING_CST &&
4344 TREE_STRING_POINTER (valid0) == TREE_STRING_POINTER (valid1))
4345 return null_pointer_node;
4348 /* Support differences between labels. */
4349 if (INTEGRAL_TYPE_P (endtype))
4351 tree op0, op1;
4352 op0 = TREE_OPERAND (value, 0);
4353 op1 = TREE_OPERAND (value, 1);
4354 STRIP_NOPS (op0);
4355 STRIP_NOPS (op1);
4357 if (TREE_CODE (op0) == ADDR_EXPR
4358 && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
4359 && TREE_CODE (op1) == ADDR_EXPR
4360 && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
4361 return null_pointer_node;
4363 break;
4365 default:
4366 break;
4369 return 0;
4372 /* Output assembler code for constant EXP to FILE, with no label.
4373 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4374 Assumes output_addressed_constants has been done on EXP already.
4376 Generate exactly SIZE bytes of assembler data, padding at the end
4377 with zeros if necessary. SIZE must always be specified.
4379 SIZE is important for structure constructors,
4380 since trailing members may have been omitted from the constructor.
4381 It is also important for initialization of arrays from string constants
4382 since the full length of the string constant might not be wanted.
4383 It is also needed for initialization of unions, where the initializer's
4384 type is just one member, and that may not be as long as the union.
4386 There a case in which we would fail to output exactly SIZE bytes:
4387 for a structure constructor that wants to produce more than SIZE bytes.
4388 But such constructors will never be generated for any possible input.
4390 ALIGN is the alignment of the data in bits. */
4392 void
4393 output_constant (exp, size, align)
4394 tree exp;
4395 HOST_WIDE_INT size;
4396 unsigned int align;
4398 enum tree_code code;
4399 HOST_WIDE_INT thissize;
4401 /* Some front-ends use constants other than the standard language-indepdent
4402 varieties, but which may still be output directly. Give the front-end a
4403 chance to convert EXP to a language-independent representation. */
4404 exp = (*lang_hooks.expand_constant) (exp);
4406 if (size == 0 || flag_syntax_only)
4407 return;
4409 /* Eliminate any conversions since we'll be outputting the underlying
4410 constant. */
4411 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4412 || TREE_CODE (exp) == NON_LVALUE_EXPR
4413 || TREE_CODE (exp) == VIEW_CONVERT_EXPR)
4414 exp = TREE_OPERAND (exp, 0);
4416 code = TREE_CODE (TREE_TYPE (exp));
4417 thissize = int_size_in_bytes (TREE_TYPE (exp));
4419 /* Allow a constructor with no elements for any data type.
4420 This means to fill the space with zeros. */
4421 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
4423 assemble_zeros (size);
4424 return;
4427 if (TREE_CODE (exp) == FDESC_EXPR)
4429 #ifdef ASM_OUTPUT_FDESC
4430 HOST_WIDE_INT part = tree_low_cst (TREE_OPERAND (exp, 1), 0);
4431 tree decl = TREE_OPERAND (exp, 0);
4432 ASM_OUTPUT_FDESC (asm_out_file, decl, part);
4433 #else
4434 abort ();
4435 #endif
4436 return;
4439 /* Now output the underlying data. If we've handling the padding, return.
4440 Otherwise, break and ensure THISSIZE is the size written. */
4441 switch (code)
4443 case CHAR_TYPE:
4444 case BOOLEAN_TYPE:
4445 case INTEGER_TYPE:
4446 case ENUMERAL_TYPE:
4447 case POINTER_TYPE:
4448 case REFERENCE_TYPE:
4449 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4450 EXPAND_INITIALIZER),
4451 size, align, 0))
4452 error ("initializer for integer value is too complicated");
4453 break;
4455 case REAL_TYPE:
4456 if (TREE_CODE (exp) != REAL_CST)
4457 error ("initializer for floating value is not a floating constant");
4459 assemble_real (TREE_REAL_CST (exp),
4460 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0),
4461 align);
4462 break;
4464 case COMPLEX_TYPE:
4465 output_constant (TREE_REALPART (exp), thissize / 2, align);
4466 output_constant (TREE_IMAGPART (exp), thissize / 2,
4467 min_align (align, BITS_PER_UNIT * (thissize / 2)));
4468 break;
4470 case ARRAY_TYPE:
4471 if (TREE_CODE (exp) == CONSTRUCTOR)
4473 output_constructor (exp, size, align);
4474 return;
4476 else if (TREE_CODE (exp) == STRING_CST)
4478 thissize = MIN (TREE_STRING_LENGTH (exp), size);
4479 assemble_string (TREE_STRING_POINTER (exp), thissize);
4481 else
4482 abort ();
4483 break;
4485 case RECORD_TYPE:
4486 case UNION_TYPE:
4487 if (TREE_CODE (exp) == CONSTRUCTOR)
4488 output_constructor (exp, size, align);
4489 else
4490 abort ();
4491 return;
4493 case SET_TYPE:
4494 if (TREE_CODE (exp) == INTEGER_CST)
4495 assemble_integer (expand_expr (exp, NULL_RTX,
4496 VOIDmode, EXPAND_INITIALIZER),
4497 thissize, align, 1);
4498 else if (TREE_CODE (exp) == CONSTRUCTOR)
4500 unsigned char *buffer = (unsigned char *) alloca (thissize);
4501 if (get_set_constructor_bytes (exp, buffer, thissize))
4502 abort ();
4503 assemble_string ((char *) buffer, thissize);
4505 else
4506 error ("unknown set constructor type");
4507 return;
4509 case ERROR_MARK:
4510 return;
4512 default:
4513 abort ();
4516 size -= thissize;
4517 if (size > 0)
4518 assemble_zeros (size);
4522 /* Subroutine of output_constructor, used for computing the size of
4523 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4524 type with an unspecified upper bound. */
4526 static unsigned HOST_WIDE_INT
4527 array_size_for_constructor (val)
4528 tree val;
4530 tree max_index, i;
4532 /* This code used to attempt to handle string constants that are not
4533 arrays of single-bytes, but nothing else does, so there's no point in
4534 doing it here. */
4535 if (TREE_CODE (val) == STRING_CST)
4536 return TREE_STRING_LENGTH (val);
4538 max_index = NULL_TREE;
4539 for (i = CONSTRUCTOR_ELTS (val); i ; i = TREE_CHAIN (i))
4541 tree index = TREE_PURPOSE (i);
4543 if (TREE_CODE (index) == RANGE_EXPR)
4544 index = TREE_OPERAND (index, 1);
4545 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4546 max_index = index;
4549 if (max_index == NULL_TREE)
4550 return 0;
4552 /* Compute the total number of array elements. */
4553 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4554 convert (sizetype,
4555 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4556 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
4558 /* Multiply by the array element unit size to find number of bytes. */
4559 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4561 return tree_low_cst (i, 1);
4564 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4565 Generate at least SIZE bytes, padding if necessary. */
4567 static void
4568 output_constructor (exp, size, align)
4569 tree exp;
4570 HOST_WIDE_INT size;
4571 unsigned int align;
4573 tree type = TREE_TYPE (exp);
4574 tree link, field = 0;
4575 tree min_index = 0;
4576 /* Number of bytes output or skipped so far.
4577 In other words, current position within the constructor. */
4578 HOST_WIDE_INT total_bytes = 0;
4579 /* Non-zero means BYTE contains part of a byte, to be output. */
4580 int byte_buffer_in_use = 0;
4581 int byte = 0;
4583 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4584 abort ();
4586 if (TREE_CODE (type) == RECORD_TYPE)
4587 field = TYPE_FIELDS (type);
4589 if (TREE_CODE (type) == ARRAY_TYPE
4590 && TYPE_DOMAIN (type) != 0)
4591 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4593 /* As LINK goes through the elements of the constant,
4594 FIELD goes through the structure fields, if the constant is a structure.
4595 if the constant is a union, then we override this,
4596 by getting the field from the TREE_LIST element.
4597 But the constant could also be an array. Then FIELD is zero.
4599 There is always a maximum of one element in the chain LINK for unions
4600 (even if the initializer in a source program incorrectly contains
4601 more one). */
4602 for (link = CONSTRUCTOR_ELTS (exp);
4603 link;
4604 link = TREE_CHAIN (link),
4605 field = field ? TREE_CHAIN (field) : 0)
4607 tree val = TREE_VALUE (link);
4608 tree index = 0;
4610 /* The element in a union constructor specifies the proper field
4611 or index. */
4612 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4613 || TREE_CODE (type) == QUAL_UNION_TYPE)
4614 && TREE_PURPOSE (link) != 0)
4615 field = TREE_PURPOSE (link);
4617 else if (TREE_CODE (type) == ARRAY_TYPE)
4618 index = TREE_PURPOSE (link);
4620 /* Eliminate the marker that makes a cast not be an lvalue. */
4621 if (val != 0)
4622 STRIP_NOPS (val);
4624 if (index && TREE_CODE (index) == RANGE_EXPR)
4626 unsigned HOST_WIDE_INT fieldsize
4627 = int_size_in_bytes (TREE_TYPE (type));
4628 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4629 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4630 HOST_WIDE_INT index;
4631 unsigned int align2 = min_align (align, fieldsize * BITS_PER_UNIT);
4633 for (index = lo_index; index <= hi_index; index++)
4635 /* Output the element's initial value. */
4636 if (val == 0)
4637 assemble_zeros (fieldsize);
4638 else
4639 output_constant (val, fieldsize, align2);
4641 /* Count its size. */
4642 total_bytes += fieldsize;
4645 else if (field == 0 || !DECL_BIT_FIELD (field))
4647 /* An element that is not a bit-field. */
4649 unsigned HOST_WIDE_INT fieldsize;
4650 /* Since this structure is static,
4651 we know the positions are constant. */
4652 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4653 unsigned int align2;
4655 if (index != 0)
4656 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4657 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4659 /* Output any buffered-up bit-fields preceding this element. */
4660 if (byte_buffer_in_use)
4662 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4663 total_bytes++;
4664 byte_buffer_in_use = 0;
4667 /* Advance to offset of this element.
4668 Note no alignment needed in an array, since that is guaranteed
4669 if each element has the proper size. */
4670 if ((field != 0 || index != 0) && pos != total_bytes)
4672 assemble_zeros (pos - total_bytes);
4673 total_bytes = pos;
4676 /* Find the alignment of this element. */
4677 align2 = min_align (align, BITS_PER_UNIT * pos);
4679 /* Determine size this element should occupy. */
4680 if (field)
4682 fieldsize = 0;
4684 /* If this is an array with an unspecified upper bound,
4685 the initializer determines the size. */
4686 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4687 but we cannot do this until the deprecated support for
4688 initializing zero-length array members is removed. */
4689 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4690 && TYPE_DOMAIN (TREE_TYPE (field))
4691 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4693 fieldsize = array_size_for_constructor (val);
4694 /* Given a non-empty initialization, this field had
4695 better be last. */
4696 if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
4697 abort ();
4699 else if (DECL_SIZE_UNIT (field))
4701 /* ??? This can't be right. If the decl size overflows
4702 a host integer we will silently emit no data. */
4703 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4704 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4707 else
4708 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4710 /* Output the element's initial value. */
4711 if (val == 0)
4712 assemble_zeros (fieldsize);
4713 else
4714 output_constant (val, fieldsize, align2);
4716 /* Count its size. */
4717 total_bytes += fieldsize;
4719 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4720 error ("invalid initial value for member `%s'",
4721 IDENTIFIER_POINTER (DECL_NAME (field)));
4722 else
4724 /* Element that is a bit-field. */
4726 HOST_WIDE_INT next_offset = int_bit_position (field);
4727 HOST_WIDE_INT end_offset
4728 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4730 if (val == 0)
4731 val = integer_zero_node;
4733 /* If this field does not start in this (or, next) byte,
4734 skip some bytes. */
4735 if (next_offset / BITS_PER_UNIT != total_bytes)
4737 /* Output remnant of any bit field in previous bytes. */
4738 if (byte_buffer_in_use)
4740 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4741 total_bytes++;
4742 byte_buffer_in_use = 0;
4745 /* If still not at proper byte, advance to there. */
4746 if (next_offset / BITS_PER_UNIT != total_bytes)
4748 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4749 total_bytes = next_offset / BITS_PER_UNIT;
4753 if (! byte_buffer_in_use)
4754 byte = 0;
4756 /* We must split the element into pieces that fall within
4757 separate bytes, and combine each byte with previous or
4758 following bit-fields. */
4760 /* next_offset is the offset n fbits from the beginning of
4761 the structure to the next bit of this element to be processed.
4762 end_offset is the offset of the first bit past the end of
4763 this element. */
4764 while (next_offset < end_offset)
4766 int this_time;
4767 int shift;
4768 HOST_WIDE_INT value;
4769 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4770 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4772 /* Advance from byte to byte
4773 within this element when necessary. */
4774 while (next_byte != total_bytes)
4776 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4777 total_bytes++;
4778 byte = 0;
4781 /* Number of bits we can process at once
4782 (all part of the same byte). */
4783 this_time = MIN (end_offset - next_offset,
4784 BITS_PER_UNIT - next_bit);
4785 if (BYTES_BIG_ENDIAN)
4787 /* On big-endian machine, take the most significant bits
4788 first (of the bits that are significant)
4789 and put them into bytes from the most significant end. */
4790 shift = end_offset - next_offset - this_time;
4792 /* Don't try to take a bunch of bits that cross
4793 the word boundary in the INTEGER_CST. We can
4794 only select bits from the LOW or HIGH part
4795 not from both. */
4796 if (shift < HOST_BITS_PER_WIDE_INT
4797 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4799 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4800 shift = HOST_BITS_PER_WIDE_INT;
4803 /* Now get the bits from the appropriate constant word. */
4804 if (shift < HOST_BITS_PER_WIDE_INT)
4805 value = TREE_INT_CST_LOW (val);
4806 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4808 value = TREE_INT_CST_HIGH (val);
4809 shift -= HOST_BITS_PER_WIDE_INT;
4811 else
4812 abort ();
4814 /* Get the result. This works only when:
4815 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4816 byte |= (((value >> shift)
4817 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4818 << (BITS_PER_UNIT - this_time - next_bit));
4820 else
4822 /* On little-endian machines,
4823 take first the least significant bits of the value
4824 and pack them starting at the least significant
4825 bits of the bytes. */
4826 shift = next_offset - int_bit_position (field);
4828 /* Don't try to take a bunch of bits that cross
4829 the word boundary in the INTEGER_CST. We can
4830 only select bits from the LOW or HIGH part
4831 not from both. */
4832 if (shift < HOST_BITS_PER_WIDE_INT
4833 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4834 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4836 /* Now get the bits from the appropriate constant word. */
4837 if (shift < HOST_BITS_PER_WIDE_INT)
4838 value = TREE_INT_CST_LOW (val);
4839 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4841 value = TREE_INT_CST_HIGH (val);
4842 shift -= HOST_BITS_PER_WIDE_INT;
4844 else
4845 abort ();
4847 /* Get the result. This works only when:
4848 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4849 byte |= (((value >> shift)
4850 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4851 << next_bit);
4854 next_offset += this_time;
4855 byte_buffer_in_use = 1;
4860 if (byte_buffer_in_use)
4862 assemble_integer (GEN_INT (byte), 1, BITS_PER_UNIT, 1);
4863 total_bytes++;
4866 if (total_bytes < size)
4867 assemble_zeros (size - total_bytes);
4871 /* This structure contains any weak symbol declarations waiting
4872 to be emitted. */
4873 struct weak_syms
4875 struct weak_syms * next;
4876 const char * name;
4877 const char * value;
4880 static struct weak_syms * weak_decls;
4882 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4883 associated with NAME. */
4886 add_weak (name, value)
4887 const char *name;
4888 const char *value;
4890 struct weak_syms *weak;
4892 weak = (struct weak_syms *) xmalloc (sizeof (struct weak_syms));
4894 if (weak == NULL)
4895 return 0;
4897 weak->next = weak_decls;
4898 weak->name = name;
4899 weak->value = value;
4900 weak_decls = weak;
4902 return 1;
4905 /* Declare DECL to be a weak symbol. */
4907 void
4908 declare_weak (decl)
4909 tree decl;
4911 if (! TREE_PUBLIC (decl))
4912 error_with_decl (decl, "weak declaration of `%s' must be public");
4913 else if (TREE_ASM_WRITTEN (decl))
4914 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4915 else if (SUPPORTS_WEAK)
4916 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4917 else
4918 warning_with_decl (decl, "weak declaration of `%s' not supported");
4920 DECL_WEAK (decl) = 1;
4923 /* Emit any pending weak declarations. */
4925 void
4926 weak_finish ()
4928 if (SUPPORTS_WEAK)
4930 struct weak_syms *t;
4931 for (t = weak_decls; t; t = t->next)
4933 #ifdef ASM_OUTPUT_WEAK_ALIAS
4934 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, t->name, t->value);
4935 #else
4936 #ifdef ASM_WEAKEN_LABEL
4937 if (t->value)
4938 abort ();
4939 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4940 #endif
4941 #endif
4946 /* Remove NAME from the pending list of weak symbols. This prevents
4947 the compiler from emitting multiple .weak directives which confuses
4948 some assemblers. */
4949 #ifdef ASM_WEAKEN_LABEL
4950 static void
4951 remove_from_pending_weak_list (name)
4952 const char *name;
4954 struct weak_syms *t;
4955 struct weak_syms **p;
4957 for (p = &weak_decls; *p; )
4959 t = *p;
4960 if (strcmp (name, t->name) == 0)
4962 *p = t->next;
4963 free (t);
4965 else
4966 p = &(t->next);
4969 #endif /* ASM_WEAKEN_LABEL */
4971 /* Emit an assembler directive to make the symbol for DECL an alias to
4972 the symbol for TARGET. */
4974 void
4975 assemble_alias (decl, target)
4976 tree decl, target ATTRIBUTE_UNUSED;
4978 const char *name;
4980 /* We must force creation of DECL_RTL for debug info generation, even though
4981 we don't use it here. */
4982 make_decl_rtl (decl, NULL);
4984 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4986 #ifdef ASM_OUTPUT_DEF
4987 /* Make name accessible from other files, if appropriate. */
4989 if (TREE_PUBLIC (decl))
4991 #ifdef ASM_WEAKEN_LABEL
4992 if (DECL_WEAK (decl))
4994 ASM_WEAKEN_LABEL (asm_out_file, name);
4995 /* Remove this function from the pending weak list so that
4996 we do not emit multiple .weak directives for it. */
4997 remove_from_pending_weak_list
4998 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
5000 else
5001 #endif
5002 ASM_GLOBALIZE_LABEL (asm_out_file, name);
5005 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
5006 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
5007 #else
5008 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
5009 #endif
5010 TREE_ASM_WRITTEN (decl) = 1;
5011 #else
5012 #ifdef ASM_OUTPUT_WEAK_ALIAS
5013 if (! DECL_WEAK (decl))
5014 warning ("only weak aliases are supported in this configuration");
5016 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
5017 TREE_ASM_WRITTEN (decl) = 1;
5018 #else
5019 warning ("alias definitions not supported in this configuration; ignored");
5020 #endif
5021 #endif
5024 /* Returns 1 if the target configuration supports defining public symbols
5025 so that one of them will be chosen at link time instead of generating a
5026 multiply-defined symbol error, whether through the use of weak symbols or
5027 a target-specific mechanism for having duplicates discarded. */
5030 supports_one_only ()
5032 if (SUPPORTS_ONE_ONLY)
5033 return 1;
5034 return SUPPORTS_WEAK;
5037 /* Set up DECL as a public symbol that can be defined in multiple
5038 translation units without generating a linker error. */
5040 void
5041 make_decl_one_only (decl)
5042 tree decl;
5044 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
5045 abort ();
5047 TREE_PUBLIC (decl) = 1;
5049 if (TREE_CODE (decl) == VAR_DECL
5050 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
5051 DECL_COMMON (decl) = 1;
5052 else if (SUPPORTS_ONE_ONLY)
5054 #ifdef MAKE_DECL_ONE_ONLY
5055 MAKE_DECL_ONE_ONLY (decl);
5056 #endif
5057 DECL_ONE_ONLY (decl) = 1;
5059 else if (SUPPORTS_WEAK)
5060 DECL_WEAK (decl) = 1;
5061 else
5062 abort ();
5065 void
5066 init_varasm_once ()
5068 const_str_htab = htab_create (128, const_str_htab_hash, const_str_htab_eq,
5069 const_str_htab_del);
5070 in_named_htab = htab_create (31, in_named_entry_hash,
5071 in_named_entry_eq, NULL);
5073 ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
5074 mark_const_hash_entry);
5075 ggc_add_root (&const_str_htab, 1, sizeof const_str_htab,
5076 mark_const_str_htab);
5078 const_alias_set = new_alias_set ();
5081 /* Select a set of attributes for section NAME based on the properties
5082 of DECL and whether or not RELOC indicates that DECL's initializer
5083 might contain runtime relocations.
5085 We make the section read-only and executable for a function decl,
5086 read-only for a const data decl, and writable for a non-const data decl. */
5088 unsigned int
5089 default_section_type_flags (decl, name, reloc)
5090 tree decl;
5091 const char *name;
5092 int reloc;
5094 unsigned int flags;
5096 if (decl && TREE_CODE (decl) == FUNCTION_DECL)
5097 flags = SECTION_CODE;
5098 else if (decl && DECL_READONLY_SECTION (decl, reloc))
5099 flags = 0;
5100 else
5101 flags = SECTION_WRITE;
5103 if (decl && DECL_ONE_ONLY (decl))
5104 flags |= SECTION_LINKONCE;
5106 if (strcmp (name, ".bss") == 0
5107 || strncmp (name, ".bss.", 5) == 0
5108 || strncmp (name, ".gnu.linkonce.b.", 16) == 0
5109 || strcmp (name, ".sbss") == 0
5110 || strncmp (name, ".sbss.", 6) == 0
5111 || strncmp (name, ".gnu.linkonce.sb.", 17) == 0)
5112 flags |= SECTION_BSS;
5114 return flags;
5117 /* Output assembly to switch to section NAME with attribute FLAGS.
5118 Four variants for common object file formats. */
5120 void
5121 default_no_named_section (name, flags)
5122 const char *name ATTRIBUTE_UNUSED;
5123 unsigned int flags ATTRIBUTE_UNUSED;
5125 /* Some object formats don't support named sections at all. The
5126 front-end should already have flagged this as an error. */
5127 abort ();
5130 void
5131 default_elf_asm_named_section (name, flags)
5132 const char *name;
5133 unsigned int flags;
5135 char flagchars[10], *f = flagchars;
5136 const char *type;
5138 if (! named_section_first_declaration (name))
5140 fprintf (asm_out_file, "\t.section\t%s\n", name);
5141 return;
5144 if (!(flags & SECTION_DEBUG))
5145 *f++ = 'a';
5146 if (flags & SECTION_WRITE)
5147 *f++ = 'w';
5148 if (flags & SECTION_CODE)
5149 *f++ = 'x';
5150 if (flags & SECTION_SMALL)
5151 *f++ = 's';
5152 if (flags & SECTION_MERGE)
5153 *f++ = 'M';
5154 if (flags & SECTION_STRINGS)
5155 *f++ = 'S';
5156 *f = '\0';
5158 if (flags & SECTION_BSS)
5159 type = "nobits";
5160 else
5161 type = "progbits";
5163 if (flags & SECTION_ENTSIZE)
5164 fprintf (asm_out_file, "\t.section\t%s,\"%s\",@%s,%d\n",
5165 name, flagchars, type, flags & SECTION_ENTSIZE);
5166 else
5167 fprintf (asm_out_file, "\t.section\t%s,\"%s\",@%s\n",
5168 name, flagchars, type);
5171 void
5172 default_coff_asm_named_section (name, flags)
5173 const char *name;
5174 unsigned int flags;
5176 char flagchars[8], *f = flagchars;
5178 if (flags & SECTION_WRITE)
5179 *f++ = 'w';
5180 if (flags & SECTION_CODE)
5181 *f++ = 'x';
5182 *f = '\0';
5184 fprintf (asm_out_file, "\t.section\t%s,\"%s\"\n", name, flagchars);
5187 void
5188 default_pe_asm_named_section (name, flags)
5189 const char *name;
5190 unsigned int flags;
5192 default_coff_asm_named_section (name, flags);
5194 if (flags & SECTION_LINKONCE)
5196 /* Functions may have been compiled at various levels of
5197 optimization so we can't use `same_size' here.
5198 Instead, have the linker pick one. */
5199 fprintf (asm_out_file, "\t.linkonce %s\n",
5200 (flags & SECTION_CODE ? "discard" : "same_size"));
5204 /* Used for vtable gc in GNU binutils. Record that the pointer at OFFSET
5205 from SYMBOL is used in all classes derived from SYMBOL. */
5207 void
5208 assemble_vtable_entry (symbol, offset)
5209 rtx symbol;
5210 HOST_WIDE_INT offset;
5212 fputs ("\t.vtable_entry ", asm_out_file);
5213 output_addr_const (asm_out_file, symbol);
5214 fputs (", ", asm_out_file);
5215 fprintf (asm_out_file, HOST_WIDE_INT_PRINT_DEC, offset);
5216 fputc ('\n', asm_out_file);
5219 /* Used for vtable gc in GNU binutils. Record the class hierarchy by noting
5220 that the vtable symbol CHILD is derived from the vtable symbol PARENT. */
5222 void
5223 assemble_vtable_inherit (child, parent)
5224 rtx child, parent;
5226 fputs ("\t.vtable_inherit ", asm_out_file);
5227 output_addr_const (asm_out_file, child);
5228 fputs (", ", asm_out_file);
5229 output_addr_const (asm_out_file, parent);
5230 fputc ('\n', asm_out_file);