1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 88, 89, 92-98, 1999 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* This file handles generation of all the assembler code
23 *except* the instructions of a function.
24 This includes declarations of variables and their initial values.
26 We also output the assembler code for constants stored in memory
27 and are responsible for combining constants with the same value. */
32 /* #include <stab.h> */
39 #include "hard-reg-set.h"
50 #ifdef XCOFF_DEBUGGING_INFO
54 #ifndef TRAMPOLINE_ALIGNMENT
55 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
59 #define ASM_STABS_OP ".stabs"
62 /* Define the prefix to use when check_memory_usage_flag is enable. */
63 #ifdef NO_DOLLAR_IN_LABEL
64 #ifdef NO_DOT_IN_LABEL
65 #define CHKR_PREFIX "chkr_prefix_"
66 #else /* !NO_DOT_IN_LABEL */
67 #define CHKR_PREFIX "chkr."
69 #else /* !NO_DOLLAR_IN_LABEL */
70 #define CHKR_PREFIX "chkr$"
72 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
74 /* File in which assembler code is being written. */
76 extern FILE *asm_out_file;
78 /* The (assembler) name of the first globally-visible object output. */
79 char *first_global_object_name;
80 char *weak_global_object_name;
82 extern struct obstack *current_obstack;
83 extern struct obstack *saveable_obstack;
84 extern struct obstack *rtl_obstack;
85 extern struct obstack permanent_obstack;
86 #define obstack_chunk_alloc xmalloc
88 /* Number for making the label on the next
89 constant that is stored in memory. */
93 /* Number for making the label on the next
94 static variable internal to a function. */
98 /* Carry information from ASM_DECLARE_OBJECT_NAME
99 to ASM_FINISH_DECLARE_OBJECT. */
101 int size_directive_output;
103 /* The last decl for which assemble_variable was called,
104 if it did ASM_DECLARE_OBJECT_NAME.
105 If the last call to assemble_variable didn't do that,
108 tree last_assemble_variable_decl;
110 /* Nonzero if at least one function definition has been seen. */
112 static int function_defined;
115 struct constant_descriptor;
117 struct pool_constant;
119 static const char *strip_reg_name PROTO((const char *));
120 static int contains_pointers_p PROTO((tree));
121 static void decode_addr_const PROTO((tree, struct addr_const *));
122 static int const_hash PROTO((tree));
123 static int compare_constant PROTO((tree,
124 struct constant_descriptor *));
125 static char *compare_constant_1 PROTO((tree, char *));
126 static struct constant_descriptor *record_constant PROTO((tree));
127 static void record_constant_1 PROTO((tree));
128 static tree copy_constant PROTO((tree));
129 static void output_constant_def_contents PROTO((tree, int, int));
130 static void decode_rtx_const PROTO((enum machine_mode, rtx,
131 struct rtx_const *));
132 static int const_hash_rtx PROTO((enum machine_mode, rtx));
133 static int compare_constant_rtx PROTO((enum machine_mode, rtx,
134 struct constant_descriptor *));
135 static struct constant_descriptor *record_constant_rtx PROTO((enum machine_mode,
137 static struct pool_constant *find_pool_constant PROTO((rtx));
138 static void mark_constant_pool PROTO((void));
139 static void mark_constants PROTO((rtx));
140 static int output_addressed_constants PROTO((tree));
141 static void output_after_function_constants PROTO((void));
142 static void output_constructor PROTO((tree, int));
143 static void remove_from_pending_weak_list PROTO ((char *));
144 #ifdef ASM_OUTPUT_BSS
145 static void asm_output_bss PROTO((FILE *, tree, char *, int, int));
147 #ifdef BSS_SECTION_ASM_OP
148 #ifdef ASM_OUTPUT_ALIGNED_BSS
149 static void asm_output_aligned_bss PROTO((FILE *, tree, char *, int, int));
151 #endif /* BSS_SECTION_ASM_OP */
153 static enum in_section { no_section, in_text, in_data, in_named
154 #ifdef BSS_SECTION_ASM_OP
157 #ifdef EH_FRAME_SECTION_ASM_OP
160 #ifdef EXTRA_SECTIONS
163 } in_section = no_section;
165 /* Return a non-zero value if DECL has a section attribute. */
166 #define IN_NAMED_SECTION(DECL) \
167 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
168 && DECL_SECTION_NAME (DECL) != NULL_TREE)
170 /* Text of section name when in_section == in_named. */
171 static char *in_named_name;
173 /* Define functions like text_section for any extra sections. */
174 #ifdef EXTRA_SECTION_FUNCTIONS
175 EXTRA_SECTION_FUNCTIONS
178 /* Tell assembler to switch to text section. */
183 if (in_section != in_text)
185 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
186 in_section = in_text;
190 /* Tell assembler to switch to data section. */
195 if (in_section != in_data)
197 if (flag_shared_data)
199 #ifdef SHARED_SECTION_ASM_OP
200 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
202 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
206 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
208 in_section = in_data;
211 /* Tell assembler to ALWAYS switch to data section, in case
212 it's not sure where it it. */
215 force_data_section ()
217 in_section = no_section;
221 /* Tell assembler to switch to read-only data section. This is normally
225 readonly_data_section ()
227 #ifdef READONLY_DATA_SECTION
228 READONLY_DATA_SECTION (); /* Note this can call data_section. */
234 /* Determine if we're in the text section. */
239 return in_section == in_text;
242 /* Determine if we're in the data section. */
247 return in_section == in_data;
250 /* Tell assembler to change to section NAME for DECL.
251 If DECL is NULL, just switch to section NAME.
252 If NAME is NULL, get the name from DECL.
253 If RELOC is 1, the initializer for DECL contains relocs. */
256 named_section (decl, name, reloc)
259 int reloc ATTRIBUTE_UNUSED;
261 if (decl != NULL_TREE
262 && TREE_CODE_CLASS (TREE_CODE (decl)) != 'd')
265 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
267 if (in_section != in_named || strcmp (name, in_named_name))
269 #ifdef ASM_OUTPUT_SECTION_NAME
270 ASM_OUTPUT_SECTION_NAME (asm_out_file, decl, name, reloc);
272 /* Section attributes are not supported if this macro isn't provided -
273 some host formats don't support them at all. The front-end should
274 already have flagged this as an error. */
278 in_named_name = obstack_alloc (&permanent_obstack, strlen (name) + 1);
279 strcpy (in_named_name, name);
280 in_section = in_named;
284 #ifdef ASM_OUTPUT_SECTION_NAME
285 #ifndef UNIQUE_SECTION
286 #define UNIQUE_SECTION(DECL,RELOC) \
289 char *name, *string; \
291 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (DECL)); \
292 /* Strip off any encoding in name. */ \
293 STRIP_NAME_ENCODING (name, name); \
295 len = strlen (name) + 1; \
296 string = alloca (len + 1); \
297 sprintf (string, ".%s", name); \
299 DECL_SECTION_NAME (DECL) = build_string (len, string); \
302 #ifndef UNIQUE_SECTION_P
303 #define UNIQUE_SECTION_P(DECL) 0
307 #ifdef BSS_SECTION_ASM_OP
309 /* Tell the assembler to switch to the bss section. */
314 if (in_section != in_bss)
316 #ifdef SHARED_BSS_SECTION_ASM_OP
317 if (flag_shared_data)
318 fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
321 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
327 #ifdef ASM_OUTPUT_BSS
329 /* Utility function for ASM_OUTPUT_BSS for targets to use if
330 they don't support alignments in .bss.
331 ??? It is believed that this function will work in most cases so such
332 support is localized here. */
335 asm_output_bss (file, decl, name, size, rounded)
341 ASM_GLOBALIZE_LABEL (file, name);
343 #ifdef ASM_DECLARE_OBJECT_NAME
344 last_assemble_variable_decl = decl;
345 ASM_DECLARE_OBJECT_NAME (file, name, decl);
347 /* Standard thing is just output label for the object. */
348 ASM_OUTPUT_LABEL (file, name);
349 #endif /* ASM_DECLARE_OBJECT_NAME */
350 ASM_OUTPUT_SKIP (file, rounded);
355 #ifdef ASM_OUTPUT_ALIGNED_BSS
357 /* Utility function for targets to use in implementing
358 ASM_OUTPUT_ALIGNED_BSS.
359 ??? It is believed that this function will work in most cases so such
360 support is localized here. */
363 asm_output_aligned_bss (file, decl, name, size, align)
369 ASM_GLOBALIZE_LABEL (file, name);
371 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
372 #ifdef ASM_DECLARE_OBJECT_NAME
373 last_assemble_variable_decl = decl;
374 ASM_DECLARE_OBJECT_NAME (file, name, decl);
376 /* Standard thing is just output label for the object. */
377 ASM_OUTPUT_LABEL (file, name);
378 #endif /* ASM_DECLARE_OBJECT_NAME */
379 ASM_OUTPUT_SKIP (file, size ? size : 1);
384 #endif /* BSS_SECTION_ASM_OP */
386 #ifdef EH_FRAME_SECTION_ASM_OP
390 if (in_section != in_eh_frame)
392 fprintf (asm_out_file, "%s\n", EH_FRAME_SECTION_ASM_OP);
393 in_section = in_eh_frame;
398 /* Switch to the section for function DECL.
400 If DECL is NULL_TREE, switch to the text section.
401 ??? It's not clear that we will ever be passed NULL_TREE, but it's
402 safer to handle it. */
405 function_section (decl)
408 if (decl != NULL_TREE
409 && DECL_SECTION_NAME (decl) != NULL_TREE)
410 named_section (decl, (char *) 0, 0);
415 /* Switch to section for variable DECL.
417 RELOC is the `reloc' argument to SELECT_SECTION. */
420 variable_section (decl, reloc)
424 if (IN_NAMED_SECTION (decl))
425 named_section (decl, NULL, reloc);
428 /* C++ can have const variables that get initialized from constructors,
429 and thus can not be in a readonly section. We prevent this by
430 verifying that the initial value is constant for objects put in a
433 error_mark_node is used by the C front end to indicate that the
434 initializer has not been seen yet. In this case, we assume that
435 the initializer must be constant.
437 C++ uses error_mark_node for variables that have complicated
438 initializers, but these variables go in BSS so we won't be called
441 #ifdef SELECT_SECTION
442 SELECT_SECTION (decl, reloc);
444 if (DECL_READONLY_SECTION (decl, reloc))
445 readonly_data_section ();
452 /* Tell assembler to switch to the section for the exception handling
458 #if defined (EXCEPTION_SECTION)
459 EXCEPTION_SECTION ();
461 #ifdef ASM_OUTPUT_SECTION_NAME
462 named_section (NULL_TREE, ".gcc_except_table", 0);
467 readonly_data_section ();
472 /* Create the rtl to represent a function, for a function definition.
473 DECL is a FUNCTION_DECL node which describes which function.
474 The rtl is stored into DECL. */
477 make_function_rtl (decl)
480 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
481 char *new_name = name;
483 /* Rename a nested function to avoid conflicts. */
484 if (decl_function_context (decl) != 0
485 && DECL_INITIAL (decl) != 0
486 && DECL_RTL (decl) == 0)
490 name = IDENTIFIER_POINTER (DECL_NAME (decl));
491 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
492 name = obstack_copy0 (saveable_obstack, label, strlen (label));
497 /* When -fprefix-function-name is used, every function name is
498 prefixed. Even static functions are prefixed because they
499 could be declared latter. Note that a nested function name
501 if (flag_prefix_function_name)
503 new_name = (char *) alloca (strlen (name) + CHKR_PREFIX_SIZE + 1);
504 strcpy (new_name, CHKR_PREFIX);
505 strcpy (new_name + CHKR_PREFIX_SIZE, name);
506 name = obstack_copy0 (saveable_obstack, new_name, strlen (new_name));
510 if (DECL_RTL (decl) == 0)
513 = gen_rtx_MEM (DECL_MODE (decl),
514 gen_rtx_SYMBOL_REF (Pmode, name));
516 /* Optionally set flags or add text to the name to record information
517 such as that it is a function name. If the name is changed, the macro
518 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
519 #ifdef ENCODE_SECTION_INFO
520 ENCODE_SECTION_INFO (decl);
525 /* ??? Another way to do this would be to do what halfpic.c does
526 and maintain a hashed table of such critters. */
527 /* ??? Another way to do this would be to pass a flag bit to
528 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
529 /* Let the target reassign the RTL if it wants.
530 This is necessary, for example, when one machine specific
531 decl attribute overrides another. */
532 #ifdef REDO_SECTION_INFO_P
533 if (REDO_SECTION_INFO_P (decl))
534 ENCODE_SECTION_INFO (decl);
538 /* Record at least one function has been defined. */
539 function_defined = 1;
542 /* Given NAME, a putative register name, discard any customary prefixes. */
545 strip_reg_name (name)
548 #ifdef REGISTER_PREFIX
549 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
550 name += strlen (REGISTER_PREFIX);
552 if (name[0] == '%' || name[0] == '#')
557 /* Decode an `asm' spec for a declaration as a register name.
558 Return the register number, or -1 if nothing specified,
559 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
560 or -3 if ASMSPEC is `cc' and is not recognized,
561 or -4 if ASMSPEC is `memory' and is not recognized.
562 Accept an exact spelling or a decimal number.
563 Prefixes such as % are optional. */
566 decode_reg_name (asmspec)
573 /* Get rid of confusing prefixes. */
574 asmspec = strip_reg_name (asmspec);
576 /* Allow a decimal number as a "register name". */
577 for (i = strlen (asmspec) - 1; i >= 0; i--)
578 if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
580 if (asmspec[0] != 0 && i < 0)
583 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
589 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
591 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
594 #ifdef ADDITIONAL_REGISTER_NAMES
596 static struct { const char *name; int number; } table[]
597 = ADDITIONAL_REGISTER_NAMES;
599 for (i = 0; i < (int)(sizeof (table) / sizeof (table[0])); i++)
600 if (! strcmp (asmspec, table[i].name))
601 return table[i].number;
603 #endif /* ADDITIONAL_REGISTER_NAMES */
605 if (!strcmp (asmspec, "memory"))
608 if (!strcmp (asmspec, "cc"))
617 /* Create the DECL_RTL for a declaration for a static or external variable
618 or static or external function.
619 ASMSPEC, if not 0, is the string which the user specified
620 as the assembler symbol name.
621 TOP_LEVEL is nonzero if this is a file-scope variable.
623 This is never called for PARM_DECL nodes. */
626 make_decl_rtl (decl, asmspec, top_level)
631 register char *name = 0;
634 reg_number = decode_reg_name (asmspec);
636 if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
637 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
639 if (reg_number == -2)
641 /* ASMSPEC is given, and not the name of a register. */
642 name = (char *) obstack_alloc (saveable_obstack,
643 strlen (asmspec) + 2);
645 strcpy (&name[1], asmspec);
648 /* For a duplicate declaration, we can be called twice on the
649 same DECL node. Don't discard the RTL already made. */
650 if (DECL_RTL (decl) == 0)
652 /* First detect errors in declaring global registers. */
653 if (TREE_CODE (decl) != FUNCTION_DECL
654 && DECL_REGISTER (decl) && reg_number == -1)
655 error_with_decl (decl,
656 "register name not specified for `%s'");
657 else if (TREE_CODE (decl) != FUNCTION_DECL
658 && DECL_REGISTER (decl) && reg_number < 0)
659 error_with_decl (decl,
660 "invalid register name for `%s'");
661 else if ((reg_number >= 0 || reg_number == -3)
662 && (TREE_CODE (decl) == FUNCTION_DECL
663 && ! DECL_REGISTER (decl)))
664 error_with_decl (decl,
665 "register name given for non-register variable `%s'");
666 else if (TREE_CODE (decl) != FUNCTION_DECL
667 && DECL_REGISTER (decl)
668 && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
669 error_with_decl (decl,
670 "data type of `%s' isn't suitable for a register");
671 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)
672 && ! HARD_REGNO_MODE_OK (reg_number,
673 TYPE_MODE (TREE_TYPE (decl))))
674 error_with_decl (decl,
675 "register number for `%s' isn't suitable for data type");
676 /* Now handle properly declared static register variables. */
677 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
681 if (DECL_INITIAL (decl) != 0 && top_level)
683 DECL_INITIAL (decl) = 0;
684 error ("global register variable has initial value");
686 if (fixed_regs[reg_number] == 0
687 && function_defined && top_level)
688 error ("global register variable follows a function definition");
689 if (TREE_THIS_VOLATILE (decl))
690 warning ("volatile register variables don't work as you might wish");
692 /* If the user specified one of the eliminables registers here,
693 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
694 confused with that register and be eliminated. Although this
695 usage is somewhat suspect, we nevertheless use the following
696 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
699 = gen_rtx_REG (DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
700 REGNO (DECL_RTL (decl)) = reg_number;
701 REG_USERVAR_P (DECL_RTL (decl)) = 1;
705 /* Make this register global, so not usable for anything
707 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
709 globalize_reg (reg_number + --nregs);
712 /* Specifying a section attribute on a variable forces it into a
713 non-.bss section, and thus it cannot be common. */
714 else if (TREE_CODE (decl) == VAR_DECL
715 && DECL_SECTION_NAME (decl) != NULL_TREE
716 && DECL_INITIAL (decl) == NULL_TREE
717 && DECL_COMMON (decl))
718 DECL_COMMON (decl) = 0;
720 /* Now handle ordinary static variables and functions (in memory).
721 Also handle vars declared register invalidly. */
722 if (DECL_RTL (decl) == 0)
724 /* Can't use just the variable's own name for a variable
725 whose scope is less than the whole file.
726 Concatenate a distinguishing number. */
727 if (!top_level && !TREE_PUBLIC (decl) && asmspec == 0)
731 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
732 name = obstack_copy0 (saveable_obstack, label, strlen (label));
739 /* When -fprefix-function-name is used, the functions
740 names are prefixed. Only nested function names are not
742 if (flag_prefix_function_name && TREE_CODE (decl) == FUNCTION_DECL)
745 new_name = (char *) alloca (strlen (name) + CHKR_PREFIX_SIZE
747 strcpy (new_name, CHKR_PREFIX);
748 strcpy (new_name + CHKR_PREFIX_SIZE, name);
749 name = obstack_copy0 (saveable_obstack,
750 new_name, strlen (new_name));
753 DECL_RTL (decl) = gen_rtx_MEM (DECL_MODE (decl),
754 gen_rtx_SYMBOL_REF (Pmode, name));
755 MEM_ALIAS_SET (DECL_RTL (decl)) = get_alias_set (decl);
757 /* If this variable is to be treated as volatile, show its
758 tree node has side effects. If it has side effects, either
759 because of this test or from TREE_THIS_VOLATILE also
760 being set, show the MEM is volatile. */
761 if (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
762 && TREE_PUBLIC (decl))
763 TREE_SIDE_EFFECTS (decl) = 1;
764 else if (flag_volatile_static && TREE_CODE (decl) == VAR_DECL
765 && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))
766 TREE_SIDE_EFFECTS (decl) = 1;
768 if (TREE_SIDE_EFFECTS (decl))
769 MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
771 if (TREE_READONLY (decl))
772 RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
773 MEM_SET_IN_STRUCT_P (DECL_RTL (decl),
774 AGGREGATE_TYPE_P (TREE_TYPE (decl)));
776 /* Optionally set flags or add text to the name to record information
777 such as that it is a function name.
778 If the name is changed, the macro ASM_OUTPUT_LABELREF
779 will have to know how to strip this information. */
780 #ifdef ENCODE_SECTION_INFO
781 ENCODE_SECTION_INFO (decl);
787 /* If the old RTL had the wrong mode, fix the mode. */
788 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
790 rtx rtl = DECL_RTL (decl);
791 PUT_MODE (rtl, DECL_MODE (decl));
794 /* ??? Another way to do this would be to do what halfpic.c does
795 and maintain a hashed table of such critters. */
796 /* ??? Another way to do this would be to pass a flag bit to
797 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
798 /* Let the target reassign the RTL if it wants.
799 This is necessary, for example, when one machine specific
800 decl attribute overrides another. */
801 #ifdef REDO_SECTION_INFO_P
802 if (REDO_SECTION_INFO_P (decl))
803 ENCODE_SECTION_INFO (decl);
808 /* Make the rtl for variable VAR be volatile.
809 Use this only for static variables. */
812 make_var_volatile (var)
815 if (GET_CODE (DECL_RTL (var)) != MEM)
818 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
821 /* Output alignment directive to align for constant expression EXP. */
824 assemble_constant_align (exp)
829 /* Align the location counter as required by EXP's data type. */
830 align = TYPE_ALIGN (TREE_TYPE (exp));
831 #ifdef CONSTANT_ALIGNMENT
832 align = CONSTANT_ALIGNMENT (exp, align);
835 if (align > BITS_PER_UNIT)
836 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
839 /* Output a string of literal assembler code
840 for an `asm' keyword used between functions. */
843 assemble_asm (string)
848 if (TREE_CODE (string) == ADDR_EXPR)
849 string = TREE_OPERAND (string, 0);
851 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
854 #if 0 /* This should no longer be needed, because
855 flag_gnu_linker should be 0 on these systems,
856 which should prevent any output
857 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
858 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
859 #ifndef ASM_OUTPUT_CONSTRUCTOR
860 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
862 #ifndef ASM_OUTPUT_DESTRUCTOR
863 #define ASM_OUTPUT_DESTRUCTOR(file, name)
868 /* Record an element in the table of global destructors.
869 How this is done depends on what sort of assembler and linker
872 NAME should be the name of a global function to be called
873 at exit time. This name is output using assemble_name. */
876 assemble_destructor (name)
879 #ifdef ASM_OUTPUT_DESTRUCTOR
880 ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
884 /* Now tell GNU LD that this is part of the static destructor set. */
885 /* This code works for any machine provided you use GNU as/ld. */
886 fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
887 assemble_name (asm_out_file, name);
888 fputc ('\n', asm_out_file);
893 /* Likewise for global constructors. */
896 assemble_constructor (name)
899 #ifdef ASM_OUTPUT_CONSTRUCTOR
900 ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
904 /* Now tell GNU LD that this is part of the static constructor set. */
905 /* This code works for any machine provided you use GNU as/ld. */
906 fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
907 assemble_name (asm_out_file, name);
908 fputc ('\n', asm_out_file);
913 /* Likewise for entries we want to record for garbage collection.
914 Garbage collection is still under development. */
917 assemble_gc_entry (name)
920 #ifdef ASM_OUTPUT_GC_ENTRY
921 ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
925 /* Now tell GNU LD that this is part of the static constructor set. */
926 fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
927 assemble_name (asm_out_file, name);
928 fputc ('\n', asm_out_file);
933 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
934 a non-zero value if the constant pool should be output before the
935 start of the function, or a zero value if the pool should output
936 after the end of the function. The default is to put it before the
939 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
940 #define CONSTANT_POOL_BEFORE_FUNCTION 1
943 /* Output assembler code for the constant pool of a function and associated
944 with defining the name of the function. DECL describes the function.
945 NAME is the function's name. For the constant pool, we use the current
946 constant pool data. */
949 assemble_start_function (decl, fnname)
955 /* The following code does not need preprocessing in the assembler. */
959 if (CONSTANT_POOL_BEFORE_FUNCTION)
960 output_constant_pool (fnname, decl);
962 #ifdef ASM_OUTPUT_SECTION_NAME
963 /* If the function is to be put in its own section and it's not in a section
964 already, indicate so. */
965 if ((flag_function_sections
966 && DECL_SECTION_NAME (decl) == NULL_TREE)
967 || UNIQUE_SECTION_P (decl))
968 UNIQUE_SECTION (decl, 0);
971 function_section (decl);
973 /* Tell assembler to move to target machine's alignment for functions. */
974 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
976 ASM_OUTPUT_ALIGN (asm_out_file, align);
978 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
979 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
982 #ifdef SDB_DEBUGGING_INFO
983 /* Output SDB definition of the function. */
984 if (write_symbols == SDB_DEBUG)
985 sdbout_mark_begin_function ();
988 #ifdef DBX_DEBUGGING_INFO
989 /* Output DBX definition of the function. */
990 if (write_symbols == DBX_DEBUG)
991 dbxout_begin_function (decl);
994 /* Make function name accessible from other files, if appropriate. */
996 if (TREE_PUBLIC (decl))
998 if (! first_global_object_name)
1003 if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
1004 name = &first_global_object_name;
1006 name = &weak_global_object_name;
1008 STRIP_NAME_ENCODING (p, fnname);
1009 *name = permalloc (strlen (p) + 1);
1013 #ifdef ASM_WEAKEN_LABEL
1014 if (DECL_WEAK (decl))
1016 ASM_WEAKEN_LABEL (asm_out_file, fnname);
1017 /* Remove this function from the pending weak list so that
1018 we do not emit multiple .weak directives for it. */
1019 remove_from_pending_weak_list
1020 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1024 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
1027 /* Do any machine/system dependent processing of the function name */
1028 #ifdef ASM_DECLARE_FUNCTION_NAME
1029 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1031 /* Standard thing is just output label for the function. */
1032 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1033 #endif /* ASM_DECLARE_FUNCTION_NAME */
1036 /* Output assembler code associated with defining the size of the
1037 function. DECL describes the function. NAME is the function's name. */
1040 assemble_end_function (decl, fnname)
1044 #ifdef ASM_DECLARE_FUNCTION_SIZE
1045 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1047 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1049 output_constant_pool (fnname, decl);
1050 function_section (decl); /* need to switch back */
1053 /* Output any constants which should appear after the function. */
1054 output_after_function_constants ();
1057 /* Assemble code to leave SIZE bytes of zeros. */
1060 assemble_zeros (size)
1063 /* Do no output if -fsyntax-only. */
1064 if (flag_syntax_only)
1067 #ifdef ASM_NO_SKIP_IN_TEXT
1068 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1069 so we must output 0s explicitly in the text section. */
1070 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1074 for (i = 0; i < size - 20; i += 20)
1077 fprintf (asm_out_file,
1078 "%s 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
1080 fprintf (asm_out_file,
1081 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1087 fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
1089 fprintf (asm_out_file, "\tbyte 0");
1092 for (; i < size; i++)
1093 fprintf (asm_out_file, ",0");
1094 fprintf (asm_out_file, "\n");
1100 ASM_OUTPUT_SKIP (asm_out_file, size);
1103 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1106 assemble_align (align)
1109 if (align > BITS_PER_UNIT)
1110 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1113 /* Assemble a string constant with the specified C string as contents. */
1116 assemble_string (p, size)
1123 /* If the string is very long, split it up. */
1127 int thissize = size - pos;
1128 if (thissize > maximum)
1131 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1139 /* Assemble everything that is needed for a variable or function declaration.
1140 Not used for automatic variables, and not used for function definitions.
1141 Should not be called for variables of incomplete structure type.
1143 TOP_LEVEL is nonzero if this variable has file scope.
1144 AT_END is nonzero if this is the special handling, at end of compilation,
1145 to define things that have had only tentative definitions.
1146 DONT_OUTPUT_DATA if nonzero means don't actually output the
1147 initial value (that will be done by the caller). */
1150 assemble_variable (decl, top_level, at_end, dont_output_data)
1152 int top_level ATTRIBUTE_UNUSED;
1154 int dont_output_data;
1156 register char *name;
1160 enum in_section saved_in_section;
1162 last_assemble_variable_decl = 0;
1164 if (GET_CODE (DECL_RTL (decl)) == REG)
1166 /* Do output symbol info for global register variables, but do nothing
1169 if (TREE_ASM_WRITTEN (decl))
1171 TREE_ASM_WRITTEN (decl) = 1;
1173 /* Do no output if -fsyntax-only. */
1174 if (flag_syntax_only)
1177 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1178 /* File-scope global variables are output here. */
1179 if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1181 dbxout_symbol (decl, 0);
1183 #ifdef SDB_DEBUGGING_INFO
1184 if (write_symbols == SDB_DEBUG && top_level
1185 /* Leave initialized global vars for end of compilation;
1186 see comment in compile_file. */
1187 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1188 sdbout_symbol (decl, 0);
1191 /* Don't output any DWARF debugging information for variables here.
1192 In the case of local variables, the information for them is output
1193 when we do our recursive traversal of the tree representation for
1194 the entire containing function. In the case of file-scope variables,
1195 we output information for all of them at the very end of compilation
1196 while we are doing our final traversal of the chain of file-scope
1202 /* Normally no need to say anything here for external references,
1203 since assemble_external is called by the language-specific code
1204 when a declaration is first seen. */
1206 if (DECL_EXTERNAL (decl))
1209 /* Output no assembler code for a function declaration.
1210 Only definitions of functions output anything. */
1212 if (TREE_CODE (decl) == FUNCTION_DECL)
1215 /* If type was incomplete when the variable was declared,
1216 see if it is complete now. */
1218 if (DECL_SIZE (decl) == 0)
1219 layout_decl (decl, 0);
1221 /* Still incomplete => don't allocate it; treat the tentative defn
1222 (which is what it must have been) as an `extern' reference. */
1224 if (!dont_output_data && DECL_SIZE (decl) == 0)
1226 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1227 DECL_SOURCE_LINE (decl),
1228 "storage size of `%s' isn't known",
1229 IDENTIFIER_POINTER (DECL_NAME (decl)));
1230 TREE_ASM_WRITTEN (decl) = 1;
1234 /* The first declaration of a variable that comes through this function
1235 decides whether it is global (in C, has external linkage)
1236 or local (in C, has internal linkage). So do nothing more
1237 if this function has already run. */
1239 if (TREE_ASM_WRITTEN (decl))
1242 TREE_ASM_WRITTEN (decl) = 1;
1244 /* Do no output if -fsyntax-only. */
1245 if (flag_syntax_only)
1250 if (! dont_output_data)
1254 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1257 /* This is better than explicit arithmetic, since it avoids overflow. */
1258 size_tree = size_binop (CEIL_DIV_EXPR,
1259 DECL_SIZE (decl), size_int (BITS_PER_UNIT));
1261 size = TREE_INT_CST_LOW (size_tree);
1262 if (TREE_INT_CST_HIGH (size_tree) != 0
1263 || size != TREE_INT_CST_LOW (size_tree))
1265 error_with_decl (decl, "size of variable `%s' is too large");
1270 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1272 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1273 && ! first_global_object_name
1274 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1275 || DECL_INITIAL (decl) == error_mark_node))
1276 && ! DECL_WEAK (decl)
1277 && ! DECL_ONE_ONLY (decl))
1281 STRIP_NAME_ENCODING (p, name);
1282 first_global_object_name = permalloc (strlen (p) + 1);
1283 strcpy (first_global_object_name, p);
1286 /* Compute the alignment of this data. */
1288 align = DECL_ALIGN (decl);
1290 /* In the case for initialing an array whose length isn't specified,
1291 where we have not yet been able to do the layout,
1292 figure out the proper alignment now. */
1293 if (dont_output_data && DECL_SIZE (decl) == 0
1294 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1295 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1297 /* Some object file formats have a maximum alignment which they support.
1298 In particular, a.out format supports a maximum alignment of 4. */
1299 #ifndef MAX_OFILE_ALIGNMENT
1300 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1302 if (align > MAX_OFILE_ALIGNMENT)
1304 warning_with_decl (decl,
1305 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1306 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1307 align = MAX_OFILE_ALIGNMENT;
1310 /* On some machines, it is good to increase alignment sometimes. */
1311 #ifdef DATA_ALIGNMENT
1312 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1314 #ifdef CONSTANT_ALIGNMENT
1315 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1316 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1319 /* Reset the alignment in case we have made it tighter, so we can benefit
1320 from it in get_pointer_alignment. */
1321 DECL_ALIGN (decl) = align;
1323 /* Handle uninitialized definitions. */
1325 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1326 /* If the target can't output uninitialized but not common global data
1327 in .bss, then we have to use .data. */
1328 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
1329 && DECL_COMMON (decl)
1331 && DECL_SECTION_NAME (decl) == 0
1332 && ! dont_output_data)
1334 int size = TREE_INT_CST_LOW (size_tree);
1337 /* Don't allocate zero bytes of common,
1338 since that means "undefined external" in the linker. */
1339 if (size == 0) rounded = 1;
1340 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1341 so that each uninitialized object starts on such a boundary. */
1342 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1343 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1344 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1346 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1347 if ( (DECL_ALIGN (decl) / BITS_PER_UNIT) > rounded)
1349 (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
1352 #ifdef DBX_DEBUGGING_INFO
1353 /* File-scope global variables are output here. */
1354 if (write_symbols == DBX_DEBUG && top_level)
1355 dbxout_symbol (decl, 0);
1357 #ifdef SDB_DEBUGGING_INFO
1358 if (write_symbols == SDB_DEBUG && top_level
1359 /* Leave initialized global vars for end of compilation;
1360 see comment in compile_file. */
1361 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1362 sdbout_symbol (decl, 0);
1365 /* Don't output any DWARF debugging information for variables here.
1366 In the case of local variables, the information for them is output
1367 when we do our recursive traversal of the tree representation for
1368 the entire containing function. In the case of file-scope variables,
1369 we output information for all of them at the very end of compilation
1370 while we are doing our final traversal of the chain of file-scope
1373 #if 0 /* ??? We should either delete this or add a comment describing what
1374 it was intended to do and why we shouldn't delete it. */
1375 if (flag_shared_data)
1379 if (TREE_PUBLIC (decl)
1380 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1381 && DECL_COMMON (decl)
1385 #ifdef ASM_OUTPUT_SHARED_COMMON
1386 if (flag_shared_data)
1387 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1391 #ifdef ASM_OUTPUT_ALIGNED_DECL_COMMON
1392 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size,
1395 #ifdef ASM_OUTPUT_ALIGNED_COMMON
1396 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
1399 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1404 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1405 else if (TREE_PUBLIC (decl))
1407 #ifdef ASM_OUTPUT_SHARED_BSS
1408 if (flag_shared_data)
1409 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1413 #ifdef ASM_OUTPUT_ALIGNED_BSS
1414 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size,
1417 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1421 #endif /* ASM_OUTPUT_BSS || ASM_OUTPUT_ALIGNED_BSS */
1424 #ifdef ASM_OUTPUT_SHARED_LOCAL
1425 if (flag_shared_data)
1426 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1430 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1431 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size,
1434 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1435 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
1438 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1446 /* Handle initialized definitions.
1447 Also handle uninitialized global definitions if -fno-common and the
1448 target doesn't support ASM_OUTPUT_BSS. */
1450 /* First make the assembler name(s) global if appropriate. */
1451 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1453 #ifdef ASM_WEAKEN_LABEL
1454 if (DECL_WEAK (decl))
1456 ASM_WEAKEN_LABEL (asm_out_file, name);
1457 /* Remove this variable from the pending weak list so that
1458 we do not emit multiple .weak directives for it. */
1459 remove_from_pending_weak_list
1460 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1464 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1467 for (d = equivalents; d; d = TREE_CHAIN (d))
1469 tree e = TREE_VALUE (d);
1470 if (TREE_PUBLIC (e) && DECL_NAME (e))
1471 ASM_GLOBALIZE_LABEL (asm_out_file,
1472 XSTR (XEXP (DECL_RTL (e), 0), 0));
1476 /* Output any data that we will need to use the address of. */
1477 if (DECL_INITIAL (decl) == error_mark_node)
1478 reloc = contains_pointers_p (TREE_TYPE (decl));
1479 else if (DECL_INITIAL (decl))
1480 reloc = output_addressed_constants (DECL_INITIAL (decl));
1482 #ifdef ASM_OUTPUT_SECTION_NAME
1483 if ((flag_data_sections != 0
1484 && DECL_SECTION_NAME (decl) == NULL_TREE)
1485 || UNIQUE_SECTION_P (decl))
1486 UNIQUE_SECTION (decl, reloc);
1489 /* Switch to the appropriate section. */
1490 variable_section (decl, reloc);
1492 /* dbxout.c needs to know this. */
1493 if (in_text_section ())
1494 DECL_IN_TEXT_SECTION (decl) = 1;
1496 /* Record current section so we can restore it if dbxout.c clobbers it. */
1497 saved_in_section = in_section;
1499 /* Output the dbx info now that we have chosen the section. */
1501 #ifdef DBX_DEBUGGING_INFO
1502 /* File-scope global variables are output here. */
1503 if (write_symbols == DBX_DEBUG && top_level)
1504 dbxout_symbol (decl, 0);
1506 #ifdef SDB_DEBUGGING_INFO
1507 if (write_symbols == SDB_DEBUG && top_level
1508 /* Leave initialized global vars for end of compilation;
1509 see comment in compile_file. */
1510 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1511 sdbout_symbol (decl, 0);
1514 /* Don't output any DWARF debugging information for variables here.
1515 In the case of local variables, the information for them is output
1516 when we do our recursive traversal of the tree representation for
1517 the entire containing function. In the case of file-scope variables,
1518 we output information for all of them at the very end of compilation
1519 while we are doing our final traversal of the chain of file-scope
1522 /* If the debugging output changed sections, reselect the section
1523 that's supposed to be selected. */
1524 if (in_section != saved_in_section)
1525 variable_section (decl, reloc);
1527 /* Output the alignment of this data. */
1528 if (align > BITS_PER_UNIT)
1529 ASM_OUTPUT_ALIGN (asm_out_file,
1530 floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1532 /* Do any machine/system dependent processing of the object. */
1533 #ifdef ASM_DECLARE_OBJECT_NAME
1534 last_assemble_variable_decl = decl;
1535 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1537 /* Standard thing is just output label for the object. */
1538 ASM_OUTPUT_LABEL (asm_out_file, name);
1539 #endif /* ASM_DECLARE_OBJECT_NAME */
1541 if (!dont_output_data)
1543 if (DECL_INITIAL (decl))
1544 /* Output the actual data. */
1545 output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
1547 /* Leave space for it. */
1548 assemble_zeros (TREE_INT_CST_LOW (size_tree));
1552 #ifdef XCOFF_DEBUGGING_INFO
1553 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1554 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1555 and `aa' hasn't been output yet, the assembler generates a stab entry with
1556 a value of zero, in addition to creating an unnecessary external entry
1557 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1559 /* File-scope global variables are output here. */
1560 if (write_symbols == XCOFF_DEBUG && top_level)
1562 saved_in_section = in_section;
1564 dbxout_symbol (decl, 0);
1566 if (in_section != saved_in_section)
1567 variable_section (decl, reloc);
1570 /* There must be a statement after a label. */
1575 /* Return 1 if type TYPE contains any pointers. */
1578 contains_pointers_p (type)
1581 switch (TREE_CODE (type))
1584 case REFERENCE_TYPE:
1585 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1586 so I'll play safe and return 1. */
1592 case QUAL_UNION_TYPE:
1595 /* For a type that has fields, see if the fields have pointers. */
1596 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1597 if (TREE_CODE (fields) == FIELD_DECL
1598 && contains_pointers_p (TREE_TYPE (fields)))
1604 /* An array type contains pointers if its element type does. */
1605 return contains_pointers_p (TREE_TYPE (type));
1612 /* Output something to declare an external symbol to the assembler.
1613 (Most assemblers don't need this, so we normally output nothing.)
1614 Do nothing if DECL is not external. */
1617 assemble_external (decl)
1618 tree decl ATTRIBUTE_UNUSED;
1620 #ifdef ASM_OUTPUT_EXTERNAL
1621 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1622 && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1624 rtx rtl = DECL_RTL (decl);
1626 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1627 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1629 /* Some systems do require some output. */
1630 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1631 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1637 /* Similar, for calling a library function FUN. */
1640 assemble_external_libcall (fun)
1641 rtx fun ATTRIBUTE_UNUSED;
1643 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1644 /* Declare library function name external when first used, if nec. */
1645 if (! SYMBOL_REF_USED (fun))
1647 SYMBOL_REF_USED (fun) = 1;
1648 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1653 /* Declare the label NAME global. */
1656 assemble_global (name)
1659 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1662 /* Assemble a label named NAME. */
1665 assemble_label (name)
1668 ASM_OUTPUT_LABEL (asm_out_file, name);
1671 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1672 If NAME starts with a *, the rest of NAME is output verbatim.
1673 Otherwise NAME is transformed in an implementation-defined way
1674 (usually by the addition of an underscore).
1675 Many macros in the tm file are defined to call this function. */
1678 assemble_name (file, name)
1685 STRIP_NAME_ENCODING (real_name, name);
1686 if (flag_prefix_function_name
1687 && ! bcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
1688 real_name = real_name + CHKR_PREFIX_SIZE;
1690 id = maybe_get_identifier (real_name);
1692 TREE_SYMBOL_REFERENCED (id) = 1;
1695 fputs (&name[1], file);
1697 ASM_OUTPUT_LABELREF (file, name);
1700 /* Allocate SIZE bytes writable static space with a gensym name
1701 and return an RTX to refer to its address. */
1704 assemble_static_space (size)
1712 if (flag_shared_data)
1716 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1719 namestring = (char *) obstack_alloc (saveable_obstack,
1721 strcpy (namestring, name);
1723 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1725 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1726 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1729 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1730 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1733 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1734 so that each uninitialized object starts on such a boundary. */
1735 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1736 int rounded ATTRIBUTE_UNUSED
1737 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1738 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1739 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1740 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1747 /* Assemble the static constant template for function entry trampolines.
1748 This is done at most once per compilation.
1749 Returns an RTX for the address of the template. */
1751 #ifdef TRAMPOLINE_TEMPLATE
1753 assemble_trampoline_template ()
1759 /* By default, put trampoline templates in read-only data section. */
1761 #ifdef TRAMPOLINE_SECTION
1762 TRAMPOLINE_SECTION ();
1764 readonly_data_section ();
1767 /* Write the assembler code to define one. */
1768 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1770 ASM_OUTPUT_ALIGN (asm_out_file, align);
1772 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1773 TRAMPOLINE_TEMPLATE (asm_out_file);
1775 /* Record the rtl to refer to it. */
1776 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1778 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1779 return gen_rtx_SYMBOL_REF (Pmode, name);
1783 /* Assemble the integer constant X into an object of SIZE bytes.
1784 X must be either a CONST_INT or CONST_DOUBLE.
1786 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1787 non-zero, abort if we can't output the constant. */
1790 assemble_integer (x, size, force)
1795 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1796 ASM_OUTPUT... macros. */
1800 #ifdef ASM_OUTPUT_CHAR
1802 ASM_OUTPUT_CHAR (asm_out_file, x);
1806 #ifdef ASM_OUTPUT_SHORT
1808 ASM_OUTPUT_SHORT (asm_out_file, x);
1812 #ifdef ASM_OUTPUT_INT
1814 ASM_OUTPUT_INT (asm_out_file, x);
1818 #ifdef ASM_OUTPUT_DOUBLE_INT
1820 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1824 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1826 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1831 /* If we couldn't do it that way, there are two other possibilities: First,
1832 if the machine can output an explicit byte and this is a 1 byte constant,
1833 we can use ASM_OUTPUT_BYTE. */
1835 #ifdef ASM_OUTPUT_BYTE
1836 if (size == 1 && GET_CODE (x) == CONST_INT)
1838 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1843 /* Finally, if SIZE is larger than a single word, try to output the constant
1844 one word at a time. */
1846 if (size > UNITS_PER_WORD)
1849 enum machine_mode mode
1850 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1853 for (i = 0; i < size / UNITS_PER_WORD; i++)
1855 word = operand_subword (x, i, 0, mode);
1860 if (! assemble_integer (word, UNITS_PER_WORD, 0))
1864 if (i == size / UNITS_PER_WORD)
1866 /* If we output at least one word and then could not finish,
1867 there is no valid way to continue. */
1878 /* Assemble the floating-point constant D into an object of size MODE. */
1881 assemble_real (d, mode)
1883 enum machine_mode mode;
1885 jmp_buf output_constant_handler;
1887 if (setjmp (output_constant_handler))
1889 error ("floating point trap outputting a constant");
1890 #ifdef REAL_IS_NOT_DOUBLE
1891 bzero ((char *) &d, sizeof d);
1898 set_float_handler (output_constant_handler);
1902 #ifdef ASM_OUTPUT_BYTE_FLOAT
1904 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1907 #ifdef ASM_OUTPUT_SHORT_FLOAT
1909 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1912 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1914 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
1917 #ifdef ASM_OUTPUT_FLOAT
1919 ASM_OUTPUT_FLOAT (asm_out_file, d);
1923 #ifdef ASM_OUTPUT_DOUBLE
1925 ASM_OUTPUT_DOUBLE (asm_out_file, d);
1929 #ifdef ASM_OUTPUT_LONG_DOUBLE
1932 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1940 set_float_handler (NULL_PTR);
1943 /* Here we combine duplicate floating constants to make
1944 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1946 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
1947 They are chained through the CONST_DOUBLE_CHAIN.
1948 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
1949 In that case, CONST_DOUBLE_MEM is either a MEM,
1950 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.
1952 (CONST_DOUBLE_MEM is used only for top-level functions.
1953 See force_const_mem for explanation.) */
1955 static rtx const_double_chain;
1957 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1958 For an integer, I0 is the low-order word and I1 is the high-order word.
1959 For a real number, I0 is the word with the low address
1960 and I1 is the word with the high address. */
1963 immed_double_const (i0, i1, mode)
1964 HOST_WIDE_INT i0, i1;
1965 enum machine_mode mode;
1969 if (GET_MODE_CLASS (mode) == MODE_INT
1970 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1972 /* We clear out all bits that don't belong in MODE, unless they and our
1973 sign bit are all one. So we get either a reasonable negative value
1974 or a reasonable unsigned value for this mode. */
1975 int width = GET_MODE_BITSIZE (mode);
1976 if (width < HOST_BITS_PER_WIDE_INT
1977 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
1978 != ((HOST_WIDE_INT) (-1) << (width - 1))))
1979 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
1980 else if (width == HOST_BITS_PER_WIDE_INT
1981 && ! (i1 == ~0 && i0 < 0))
1983 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
1984 /* We cannot represent this value as a constant. */
1987 /* If this would be an entire word for the target, but is not for
1988 the host, then sign-extend on the host so that the number will look
1989 the same way on the host that it would on the target.
1991 For example, when building a 64 bit alpha hosted 32 bit sparc
1992 targeted compiler, then we want the 32 bit unsigned value -1 to be
1993 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
1994 The later confuses the sparc backend. */
1996 if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
1997 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
1998 i0 |= ((HOST_WIDE_INT) (-1) << width);
2000 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2002 ??? Strictly speaking, this is wrong if we create a CONST_INT
2003 for a large unsigned constant with the size of MODE being
2004 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2005 wider mode. In that case we will mis-interpret it as a negative
2008 Unfortunately, the only alternative is to make a CONST_DOUBLE
2009 for any constant in any mode if it is an unsigned constant larger
2010 than the maximum signed integer in an int on the host. However,
2011 doing this will break everyone that always expects to see a CONST_INT
2012 for SImode and smaller.
2014 We have always been making CONST_INTs in this case, so nothing new
2017 if (width <= HOST_BITS_PER_WIDE_INT)
2018 i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2020 /* If this integer fits in one word, return a CONST_INT. */
2021 if ((i1 == 0 && i0 >= 0)
2022 || (i1 == ~0 && i0 < 0))
2023 return GEN_INT (i0);
2025 /* We use VOIDmode for integers. */
2029 /* Search the chain for an existing CONST_DOUBLE with the right value.
2030 If one is found, return it. */
2032 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2033 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2034 && GET_MODE (r) == mode)
2037 /* No; make a new one and add it to the chain.
2039 We may be called by an optimizer which may be discarding any memory
2040 allocated during its processing (such as combine and loop). However,
2041 we will be leaving this constant on the chain, so we cannot tolerate
2042 freed memory. So switch to saveable_obstack for this allocation
2043 and then switch back if we were in current_obstack. */
2045 push_obstacks_nochange ();
2046 rtl_in_saveable_obstack ();
2047 r = gen_rtx_CONST_DOUBLE (mode, NULL_RTX, i0, i1);
2050 /* Don't touch const_double_chain in nested function; see force_const_mem.
2051 Also, don't touch it if not inside any function. */
2052 if (outer_function_chain == 0 && current_function_decl != 0)
2054 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2055 const_double_chain = r;
2058 /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
2059 Actual use of mem-slot is only through force_const_mem. */
2061 CONST_DOUBLE_MEM (r) = const0_rtx;
2066 /* Return a CONST_DOUBLE for a specified `double' value
2067 and machine mode. */
2070 immed_real_const_1 (d, mode)
2072 enum machine_mode mode;
2074 union real_extract u;
2077 /* Get the desired `double' value as a sequence of ints
2078 since that is how they are stored in a CONST_DOUBLE. */
2082 /* Detect special cases. */
2084 if (REAL_VALUES_IDENTICAL (dconst0, d))
2085 return CONST0_RTX (mode);
2086 /* Check for NaN first, because some ports (specifically the i386) do not
2087 emit correct ieee-fp code by default, and thus will generate a core
2088 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2089 does a floating point comparison. */
2090 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2091 return CONST1_RTX (mode);
2093 if (sizeof u == sizeof (HOST_WIDE_INT))
2094 return immed_double_const (u.i[0], 0, mode);
2095 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2096 return immed_double_const (u.i[0], u.i[1], mode);
2098 /* The rest of this function handles the case where
2099 a float value requires more than 2 ints of space.
2100 It will be deleted as dead code on machines that don't need it. */
2102 /* Search the chain for an existing CONST_DOUBLE with the right value.
2103 If one is found, return it. */
2105 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2106 if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2107 && GET_MODE (r) == mode)
2110 /* No; make a new one and add it to the chain.
2112 We may be called by an optimizer which may be discarding any memory
2113 allocated during its processing (such as combine and loop). However,
2114 we will be leaving this constant on the chain, so we cannot tolerate
2115 freed memory. So switch to saveable_obstack for this allocation
2116 and then switch back if we were in current_obstack. */
2118 push_obstacks_nochange ();
2119 rtl_in_saveable_obstack ();
2120 r = rtx_alloc (CONST_DOUBLE);
2122 bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
2125 /* Don't touch const_double_chain in nested function; see force_const_mem.
2126 Also, don't touch it if not inside any function. */
2127 if (outer_function_chain == 0 && current_function_decl != 0)
2129 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2130 const_double_chain = r;
2133 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2134 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2135 is only through force_const_mem. */
2137 CONST_DOUBLE_MEM (r) = const0_rtx;
2142 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2143 which must be a REAL_CST tree node. */
2146 immed_real_const (exp)
2149 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2152 /* At the end of a function, forget the memory-constants
2153 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2154 Also clear out real_constant_chain and clear out all the chain-pointers. */
2157 clear_const_double_mem ()
2159 register rtx r, next;
2161 /* Don't touch CONST_DOUBLE_MEM for nested functions.
2162 See force_const_mem for explanation. */
2163 if (outer_function_chain != 0)
2166 for (r = const_double_chain; r; r = next)
2168 next = CONST_DOUBLE_CHAIN (r);
2169 CONST_DOUBLE_CHAIN (r) = 0;
2170 CONST_DOUBLE_MEM (r) = cc0_rtx;
2172 const_double_chain = 0;
2175 /* Given an expression EXP with a constant value,
2176 reduce it to the sum of an assembler symbol and an integer.
2177 Store them both in the structure *VALUE.
2178 Abort if EXP does not reduce. */
2183 HOST_WIDE_INT offset;
2187 decode_addr_const (exp, value)
2189 struct addr_const *value;
2191 register tree target = TREE_OPERAND (exp, 0);
2192 register int offset = 0;
2197 if (TREE_CODE (target) == COMPONENT_REF
2198 && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
2201 offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
2202 target = TREE_OPERAND (target, 0);
2204 else if (TREE_CODE (target) == ARRAY_REF)
2206 if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
2207 || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
2209 offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
2210 * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
2212 target = TREE_OPERAND (target, 0);
2218 switch (TREE_CODE (target))
2222 x = DECL_RTL (target);
2226 x = gen_rtx_MEM (FUNCTION_MODE,
2227 gen_rtx_LABEL_REF (VOIDmode,
2228 label_rtx (TREE_OPERAND (exp, 0))));
2236 x = TREE_CST_RTL (target);
2243 if (GET_CODE (x) != MEM)
2248 value->offset = offset;
2251 /* Uniquize all constants that appear in memory.
2252 Each constant in memory thus far output is recorded
2253 in `const_hash_table' with a `struct constant_descriptor'
2254 that contains a polish representation of the value of
2257 We cannot store the trees in the hash table
2258 because the trees may be temporary. */
2260 struct constant_descriptor
2262 struct constant_descriptor *next;
2268 #define MAX_HASH_TABLE 1009
2269 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2271 /* Compute a hash code for a constant expression. */
2278 register int len, hi, i;
2279 register enum tree_code code = TREE_CODE (exp);
2281 /* Either set P and LEN to the address and len of something to hash and
2282 exit the switch or return a value. */
2287 p = (char *) &TREE_INT_CST_LOW (exp);
2288 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2292 p = (char *) &TREE_REAL_CST (exp);
2293 len = sizeof TREE_REAL_CST (exp);
2297 p = TREE_STRING_POINTER (exp);
2298 len = TREE_STRING_LENGTH (exp);
2302 return (const_hash (TREE_REALPART (exp)) * 5
2303 + const_hash (TREE_IMAGPART (exp)));
2306 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2308 len = int_size_in_bytes (TREE_TYPE (exp));
2309 p = (char *) alloca (len);
2310 get_set_constructor_bytes (exp, (unsigned char *) p, len);
2317 /* For record type, include the type in the hashing.
2318 We do not do so for array types
2319 because (1) the sizes of the elements are sufficient
2320 and (2) distinct array types can have the same constructor.
2321 Instead, we include the array size because the constructor could
2323 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2324 hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2327 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2328 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2330 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2331 if (TREE_VALUE (link))
2333 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2340 struct addr_const value;
2342 decode_addr_const (exp, &value);
2343 if (GET_CODE (value.base) == SYMBOL_REF)
2345 /* Don't hash the address of the SYMBOL_REF;
2346 only use the offset and the symbol name. */
2348 p = XSTR (value.base, 0);
2349 for (i = 0; p[i] != 0; i++)
2350 hi = ((hi * 613) + (unsigned) (p[i]));
2352 else if (GET_CODE (value.base) == LABEL_REF)
2353 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2355 hi &= (1 << HASHBITS) - 1;
2356 hi %= MAX_HASH_TABLE;
2362 return (const_hash (TREE_OPERAND (exp, 0)) * 9
2363 + const_hash (TREE_OPERAND (exp, 1)));
2367 case NON_LVALUE_EXPR:
2368 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2374 /* Compute hashing function */
2376 for (i = 0; i < len; i++)
2377 hi = ((hi * 613) + (unsigned) (p[i]));
2379 hi &= (1 << HASHBITS) - 1;
2380 hi %= MAX_HASH_TABLE;
2384 /* Compare a constant expression EXP with a constant-descriptor DESC.
2385 Return 1 if DESC describes a constant with the same value as EXP. */
2388 compare_constant (exp, desc)
2390 struct constant_descriptor *desc;
2392 return 0 != compare_constant_1 (exp, desc->contents);
2395 /* Compare constant expression EXP with a substring P of a constant descriptor.
2396 If they match, return a pointer to the end of the substring matched.
2397 If they do not match, return 0.
2399 Since descriptors are written in polish prefix notation,
2400 this function can be used recursively to test one operand of EXP
2401 against a subdescriptor, and if it succeeds it returns the
2402 address of the subdescriptor for the next operand. */
2405 compare_constant_1 (exp, p)
2409 register char *strp;
2411 register enum tree_code code = TREE_CODE (exp);
2413 if (code != (enum tree_code) *p++)
2416 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2417 switch, or return the result of the comparison. */
2422 /* Integer constants are the same only if the same width of type. */
2423 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2426 strp = (char *) &TREE_INT_CST_LOW (exp);
2427 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2431 /* Real constants are the same only if the same width of type. */
2432 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2435 strp = (char *) &TREE_REAL_CST (exp);
2436 len = sizeof TREE_REAL_CST (exp);
2440 if (flag_writable_strings)
2443 if (*p++ != TYPE_MODE (TREE_TYPE (exp)))
2446 strp = TREE_STRING_POINTER (exp);
2447 len = TREE_STRING_LENGTH (exp);
2448 if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2449 sizeof TREE_STRING_LENGTH (exp)))
2452 p += sizeof TREE_STRING_LENGTH (exp);
2456 p = compare_constant_1 (TREE_REALPART (exp), p);
2460 return compare_constant_1 (TREE_IMAGPART (exp), p);
2463 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2465 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2467 strp = (char *) alloca (len);
2468 get_set_constructor_bytes (exp, (unsigned char *) strp, len);
2469 if (bcmp ((char *) &xlen, p, sizeof xlen))
2478 int length = list_length (CONSTRUCTOR_ELTS (exp));
2480 int have_purpose = 0;
2482 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2483 if (TREE_PURPOSE (link))
2486 if (bcmp ((char *) &length, p, sizeof length))
2491 /* For record constructors, insist that the types match.
2492 For arrays, just verify both constructors are for arrays.
2493 Then insist that either both or none have any TREE_PURPOSE
2495 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2496 type = TREE_TYPE (exp);
2500 if (bcmp ((char *) &type, p, sizeof type))
2505 if (bcmp ((char *) &have_purpose, p, sizeof have_purpose))
2508 p += sizeof have_purpose;
2510 /* For arrays, insist that the size in bytes match. */
2511 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2513 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2515 if (bcmp ((char *) &size, p, sizeof size))
2521 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2523 if (TREE_VALUE (link))
2525 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2532 if (bcmp ((char *) &zero, p, sizeof zero))
2538 if (TREE_PURPOSE (link)
2539 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2541 if (bcmp ((char *) &TREE_PURPOSE (link), p,
2542 sizeof TREE_PURPOSE (link)))
2545 p += sizeof TREE_PURPOSE (link);
2547 else if (TREE_PURPOSE (link))
2549 if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2552 else if (have_purpose)
2556 if (bcmp ((char *) &zero, p, sizeof zero))
2568 struct addr_const value;
2570 decode_addr_const (exp, &value);
2571 strp = (char *) &value.offset;
2572 len = sizeof value.offset;
2573 /* Compare the offset. */
2575 if (*p++ != *strp++)
2578 /* Compare symbol name. */
2579 strp = XSTR (value.base, 0);
2580 len = strlen (strp) + 1;
2587 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2591 return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2595 case NON_LVALUE_EXPR:
2596 return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2602 /* Compare constant contents. */
2604 if (*p++ != *strp++)
2610 /* Construct a constant descriptor for the expression EXP.
2611 It is up to the caller to enter the descriptor in the hash table. */
2613 static struct constant_descriptor *
2614 record_constant (exp)
2617 struct constant_descriptor *next = 0;
2620 /* Make a struct constant_descriptor. The first two pointers will
2621 be filled in later. Here we just leave space for them. */
2623 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2624 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2625 record_constant_1 (exp);
2626 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2629 /* Add a description of constant expression EXP
2630 to the object growing in `permanent_obstack'.
2631 No need to return its address; the caller will get that
2632 from the obstack when the object is complete. */
2635 record_constant_1 (exp)
2638 register char *strp;
2640 register enum tree_code code = TREE_CODE (exp);
2642 obstack_1grow (&permanent_obstack, (unsigned int) code);
2647 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2648 strp = (char *) &TREE_INT_CST_LOW (exp);
2649 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2653 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2654 strp = (char *) &TREE_REAL_CST (exp);
2655 len = sizeof TREE_REAL_CST (exp);
2659 if (flag_writable_strings)
2662 obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2663 strp = TREE_STRING_POINTER (exp);
2664 len = TREE_STRING_LENGTH (exp);
2665 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2666 sizeof TREE_STRING_LENGTH (exp));
2670 record_constant_1 (TREE_REALPART (exp));
2671 record_constant_1 (TREE_IMAGPART (exp));
2675 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2677 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2678 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2679 obstack_blank (&permanent_obstack, nbytes);
2680 get_set_constructor_bytes
2681 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2688 int length = list_length (CONSTRUCTOR_ELTS (exp));
2690 int have_purpose = 0;
2692 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2693 if (TREE_PURPOSE (link))
2696 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2698 /* For record constructors, insist that the types match.
2699 For arrays, just verify both constructors are for arrays.
2700 Then insist that either both or none have any TREE_PURPOSE
2702 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2703 type = TREE_TYPE (exp);
2706 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2707 obstack_grow (&permanent_obstack, (char *) &have_purpose,
2708 sizeof have_purpose);
2710 /* For arrays, insist that the size in bytes match. */
2711 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2713 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2714 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2717 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2719 if (TREE_VALUE (link))
2720 record_constant_1 (TREE_VALUE (link));
2725 obstack_grow (&permanent_obstack,
2726 (char *) &zero, sizeof zero);
2729 if (TREE_PURPOSE (link)
2730 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2731 obstack_grow (&permanent_obstack,
2732 (char *) &TREE_PURPOSE (link),
2733 sizeof TREE_PURPOSE (link));
2734 else if (TREE_PURPOSE (link))
2735 record_constant_1 (TREE_PURPOSE (link));
2736 else if (have_purpose)
2740 obstack_grow (&permanent_obstack,
2741 (char *) &zero, sizeof zero);
2749 struct addr_const value;
2751 decode_addr_const (exp, &value);
2752 /* Record the offset. */
2753 obstack_grow (&permanent_obstack,
2754 (char *) &value.offset, sizeof value.offset);
2755 /* Record the symbol name. */
2756 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2757 strlen (XSTR (value.base, 0)) + 1);
2764 record_constant_1 (TREE_OPERAND (exp, 0));
2765 record_constant_1 (TREE_OPERAND (exp, 1));
2770 case NON_LVALUE_EXPR:
2771 record_constant_1 (TREE_OPERAND (exp, 0));
2778 /* Record constant contents. */
2779 obstack_grow (&permanent_obstack, strp, len);
2782 /* Record a list of constant expressions that were passed to
2783 output_constant_def but that could not be output right away. */
2785 struct deferred_constant
2787 struct deferred_constant *next;
2793 static struct deferred_constant *deferred_constants;
2795 /* Another list of constants which should be output after the
2797 static struct deferred_constant *after_function_constants;
2799 /* Nonzero means defer output of addressed subconstants
2800 (i.e., those for which output_constant_def is called.) */
2801 static int defer_addressed_constants_flag;
2803 /* Start deferring output of subconstants. */
2806 defer_addressed_constants ()
2808 defer_addressed_constants_flag++;
2811 /* Stop deferring output of subconstants,
2812 and output now all those that have been deferred. */
2815 output_deferred_addressed_constants ()
2817 struct deferred_constant *p, *next;
2819 defer_addressed_constants_flag--;
2821 if (defer_addressed_constants_flag > 0)
2824 for (p = deferred_constants; p; p = next)
2826 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2831 deferred_constants = 0;
2834 /* Output any constants which should appear after a function. */
2837 output_after_function_constants ()
2839 struct deferred_constant *p, *next;
2841 for (p = after_function_constants; p; p = next)
2843 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2848 after_function_constants = 0;
2851 /* Make a copy of the whole tree structure for a constant.
2852 This handles the same types of nodes that compare_constant
2853 and record_constant handle. */
2859 switch (TREE_CODE (exp))
2862 /* For ADDR_EXPR, we do not want to copy the decl whose address
2863 is requested. We do want to copy constants though. */
2864 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
2865 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2866 copy_constant (TREE_OPERAND (exp, 0)));
2868 return copy_node (exp);
2873 return copy_node (exp);
2876 return build_complex (TREE_TYPE (exp),
2877 copy_constant (TREE_REALPART (exp)),
2878 copy_constant (TREE_IMAGPART (exp)));
2882 return build (TREE_CODE (exp), TREE_TYPE (exp),
2883 copy_constant (TREE_OPERAND (exp, 0)),
2884 copy_constant (TREE_OPERAND (exp, 1)));
2888 case NON_LVALUE_EXPR:
2889 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2890 copy_constant (TREE_OPERAND (exp, 0)));
2894 tree copy = copy_node (exp);
2895 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2898 CONSTRUCTOR_ELTS (copy) = list;
2899 for (tail = list; tail; tail = TREE_CHAIN (tail))
2900 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2901 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2902 for (tail = list; tail; tail = TREE_CHAIN (tail))
2903 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
2913 /* Return an rtx representing a reference to constant data in memory
2914 for the constant expression EXP.
2916 If assembler code for such a constant has already been output,
2917 return an rtx to refer to it.
2918 Otherwise, output such a constant in memory (or defer it for later)
2919 and generate an rtx for it.
2921 The TREE_CST_RTL of EXP is set up to point to that rtx.
2922 The const_hash_table records which constants already have label strings. */
2925 output_constant_def (exp)
2929 register struct constant_descriptor *desc;
2935 if (TREE_CST_RTL (exp))
2936 return TREE_CST_RTL (exp);
2938 /* Make sure any other constants whose addresses appear in EXP
2939 are assigned label numbers. */
2941 reloc = output_addressed_constants (exp);
2943 /* Compute hash code of EXP. Search the descriptors for that hash code
2944 to see if any of them describes EXP. If yes, the descriptor records
2945 the label number already assigned. */
2947 hash = const_hash (exp) % MAX_HASH_TABLE;
2949 for (desc = const_hash_table[hash]; desc; desc = desc->next)
2950 if (compare_constant (exp, desc))
2952 found = desc->label;
2958 /* No constant equal to EXP is known to have been output.
2959 Make a constant descriptor to enter EXP in the hash table.
2960 Assign the label number and record it in the descriptor for
2961 future calls to this function to find. */
2963 /* Create a string containing the label name, in LABEL. */
2964 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2966 desc = record_constant (exp);
2967 desc->next = const_hash_table[hash];
2969 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
2970 const_hash_table[hash] = desc;
2974 /* Create a string containing the label name, in LABEL. */
2975 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2978 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2980 push_obstacks_nochange ();
2981 if (TREE_PERMANENT (exp))
2982 end_temporary_allocation ();
2984 def = gen_rtx_SYMBOL_REF (Pmode, desc->label);
2987 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)), def);
2988 RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
2989 if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2990 MEM_SET_IN_STRUCT_P (TREE_CST_RTL (exp), 1);
2994 /* Optionally set flags or add text to the name to record information
2995 such as that it is a function name. If the name is changed, the macro
2996 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
2997 #ifdef ENCODE_SECTION_INFO
2998 ENCODE_SECTION_INFO (exp);
3001 /* If this is the first time we've seen this particular constant,
3002 output it (or defer its output for later). */
3005 int after_function = 0;
3007 #ifdef CONSTANT_AFTER_FUNCTION_P
3008 if (current_function_decl != 0
3009 && CONSTANT_AFTER_FUNCTION_P (exp))
3013 if (defer_addressed_constants_flag || after_function)
3015 struct deferred_constant *p;
3016 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
3018 push_obstacks_nochange ();
3019 suspend_momentary ();
3020 p->exp = copy_constant (exp);
3023 p->labelno = const_labelno++;
3026 p->next = after_function_constants;
3027 after_function_constants = p;
3031 p->next = deferred_constants;
3032 deferred_constants = p;
3037 /* Do no output if -fsyntax-only. */
3038 if (! flag_syntax_only)
3039 output_constant_def_contents (exp, reloc, const_labelno);
3044 return TREE_CST_RTL (exp);
3047 /* Now output assembler code to define the label for EXP,
3048 and follow it with the data of EXP. */
3051 output_constant_def_contents (exp, reloc, labelno)
3058 if (IN_NAMED_SECTION (exp))
3059 named_section (exp, NULL, reloc);
3062 /* First switch to text section, except for writable strings. */
3063 #ifdef SELECT_SECTION
3064 SELECT_SECTION (exp, reloc);
3066 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3067 || (flag_pic && reloc))
3070 readonly_data_section ();
3074 /* Align the location counter as required by EXP's data type. */
3075 align = TYPE_ALIGN (TREE_TYPE (exp));
3076 #ifdef CONSTANT_ALIGNMENT
3077 align = CONSTANT_ALIGNMENT (exp, align);
3080 if (align > BITS_PER_UNIT)
3081 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3083 /* Output the label itself. */
3084 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3086 /* Output the value of EXP. */
3087 output_constant (exp,
3088 (TREE_CODE (exp) == STRING_CST
3089 ? TREE_STRING_LENGTH (exp)
3090 : int_size_in_bytes (TREE_TYPE (exp))));
3094 /* Similar hash facility for making memory-constants
3095 from constant rtl-expressions. It is used on RISC machines
3096 where immediate integer arguments and constant addresses are restricted
3097 so that such constants must be stored in memory.
3099 This pool of constants is reinitialized for each function
3100 so each function gets its own constants-pool that comes right before it.
3102 All structures allocated here are discarded when functions are saved for
3103 inlining, so they do not need to be allocated permanently. */
3105 #define MAX_RTX_HASH_TABLE 61
3106 static struct constant_descriptor **const_rtx_hash_table;
3108 /* Structure to represent sufficient information about a constant so that
3109 it can be output when the constant pool is output, so that function
3110 integration can be done, and to simplify handling on machines that reference
3111 constant pool as base+displacement. */
3113 struct pool_constant
3115 struct constant_descriptor *desc;
3116 struct pool_constant *next;
3117 enum machine_mode mode;
3125 /* Pointers to first and last constant in pool. */
3127 static struct pool_constant *first_pool, *last_pool;
3129 /* Current offset in constant pool (does not include any machine-specific
3132 static int pool_offset;
3134 /* Structure used to maintain hash table mapping symbols used to their
3135 corresponding constants. */
3140 struct pool_constant *pool;
3141 struct pool_sym *next;
3144 static struct pool_sym **const_rtx_sym_hash_table;
3146 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3147 The argument is XSTR (... , 0) */
3149 #define SYMHASH(LABEL) \
3150 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3152 /* Initialize constant pool hashing for next function. */
3155 init_const_rtx_hash_table ()
3157 const_rtx_hash_table
3158 = ((struct constant_descriptor **)
3159 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
3160 const_rtx_sym_hash_table
3161 = ((struct pool_sym **)
3162 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
3163 bzero ((char *) const_rtx_hash_table,
3164 MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
3165 bzero ((char *) const_rtx_sym_hash_table,
3166 MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
3168 first_pool = last_pool = 0;
3172 /* Save and restore status for a nested function. */
3175 save_varasm_status (p, context)
3179 p->const_rtx_hash_table = const_rtx_hash_table;
3180 p->const_rtx_sym_hash_table = const_rtx_sym_hash_table;
3181 p->first_pool = first_pool;
3182 p->last_pool = last_pool;
3183 p->pool_offset = pool_offset;
3184 p->const_double_chain = const_double_chain;
3186 /* If we are pushing to toplevel, we can't reuse const_double_chain. */
3187 if (context == NULL_TREE)
3188 const_double_chain = 0;
3192 restore_varasm_status (p)
3195 const_rtx_hash_table = p->const_rtx_hash_table;
3196 const_rtx_sym_hash_table = p->const_rtx_sym_hash_table;
3197 first_pool = p->first_pool;
3198 last_pool = p->last_pool;
3199 pool_offset = p->pool_offset;
3200 const_double_chain = p->const_double_chain;
3203 enum kind { RTX_DOUBLE, RTX_INT };
3207 #ifdef ONLY_INT_FIELDS
3208 unsigned int kind : 16;
3209 unsigned int mode : 16;
3211 enum kind kind : 16;
3212 enum machine_mode mode : 16;
3215 union real_extract du;
3216 struct addr_const addr;
3217 struct {HOST_WIDE_INT high, low;} di;
3221 /* Express an rtx for a constant integer (perhaps symbolic)
3222 as the sum of a symbol or label plus an explicit integer.
3223 They are stored into VALUE. */
3226 decode_rtx_const (mode, x, value)
3227 enum machine_mode mode;
3229 struct rtx_const *value;
3231 /* Clear the whole structure, including any gaps. */
3234 int *p = (int *) value;
3235 int *end = (int *) (value + 1);
3240 value->kind = RTX_INT; /* Most usual kind. */
3243 switch (GET_CODE (x))
3246 value->kind = RTX_DOUBLE;
3247 if (GET_MODE (x) != VOIDmode)
3249 value->mode = GET_MODE (x);
3250 bcopy ((char *) &CONST_DOUBLE_LOW (x),
3251 (char *) &value->un.du, sizeof value->un.du);
3255 value->un.di.low = CONST_DOUBLE_LOW (x);
3256 value->un.di.high = CONST_DOUBLE_HIGH (x);
3261 value->un.addr.offset = INTVAL (x);
3267 value->un.addr.base = x;
3272 if (GET_CODE (x) == PLUS)
3274 value->un.addr.base = XEXP (x, 0);
3275 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3277 value->un.addr.offset = INTVAL (XEXP (x, 1));
3279 else if (GET_CODE (x) == MINUS)
3281 value->un.addr.base = XEXP (x, 0);
3282 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3284 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3294 if (value->kind == RTX_INT && value->un.addr.base != 0)
3295 switch (GET_CODE (value->un.addr.base))
3299 /* Use the string's address, not the SYMBOL_REF's address,
3300 for the sake of addresses of library routines.
3301 For a LABEL_REF, compare labels. */
3302 value->un.addr.base = XEXP (value->un.addr.base, 0);
3309 /* Given a MINUS expression, simplify it if both sides
3310 include the same symbol. */
3313 simplify_subtraction (x)
3316 struct rtx_const val0, val1;
3318 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3319 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3321 if (val0.un.addr.base == val1.un.addr.base)
3322 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3326 /* Compute a hash code for a constant RTL expression. */
3329 const_hash_rtx (mode, x)
3330 enum machine_mode mode;
3336 struct rtx_const value;
3337 decode_rtx_const (mode, x, &value);
3339 /* Compute hashing function */
3341 for (i = 0; i < sizeof value / sizeof (int); i++)
3342 hi += ((int *) &value)[i];
3344 hi &= (1 << HASHBITS) - 1;
3345 hi %= MAX_RTX_HASH_TABLE;
3349 /* Compare a constant rtl object X with a constant-descriptor DESC.
3350 Return 1 if DESC describes a constant with the same value as X. */
3353 compare_constant_rtx (mode, x, desc)
3354 enum machine_mode mode;
3356 struct constant_descriptor *desc;
3358 register int *p = (int *) desc->contents;
3361 struct rtx_const value;
3363 decode_rtx_const (mode, x, &value);
3364 strp = (int *) &value;
3365 len = sizeof value / sizeof (int);
3367 /* Compare constant contents. */
3369 if (*p++ != *strp++)
3375 /* Construct a constant descriptor for the rtl-expression X.
3376 It is up to the caller to enter the descriptor in the hash table. */
3378 static struct constant_descriptor *
3379 record_constant_rtx (mode, x)
3380 enum machine_mode mode;
3383 struct constant_descriptor *ptr;
3385 struct rtx_const value;
3387 decode_rtx_const (mode, x, &value);
3389 /* Put these things in the saveable obstack so we can ensure it won't
3390 be freed if we are called from combine or some other phase that discards
3391 memory allocated from function_obstack (current_obstack). */
3392 obstack_grow (saveable_obstack, &ptr, sizeof ptr);
3393 obstack_grow (saveable_obstack, &label, sizeof label);
3395 /* Record constant contents. */
3396 obstack_grow (saveable_obstack, &value, sizeof value);
3398 return (struct constant_descriptor *) obstack_finish (saveable_obstack);
3401 /* Given a constant rtx X, make (or find) a memory constant for its value
3402 and return a MEM rtx to refer to it in memory. */
3405 force_const_mem (mode, x)
3406 enum machine_mode mode;
3410 register struct constant_descriptor *desc;
3415 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3416 (this will always be true for floating CONST_DOUBLEs that have been
3417 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3418 use the previous copy. Otherwise, make a new one. Note that in
3419 the unlikely event that this same CONST_DOUBLE is used in two different
3420 modes in an alternating fashion, we will allocate a lot of different
3421 memory locations, but this should be extremely rare. */
3423 /* Don't use CONST_DOUBLE_MEM in a nested function.
3424 Nested functions have their own constant pools,
3425 so they can't share the same values in CONST_DOUBLE_MEM
3426 with the containing function. */
3427 if (outer_function_chain == 0)
3428 if (GET_CODE (x) == CONST_DOUBLE
3429 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3430 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3431 return CONST_DOUBLE_MEM (x);
3433 /* Compute hash code of X. Search the descriptors for that hash code
3434 to see if any of them describes X. If yes, the descriptor records
3435 the label number already assigned. */
3437 hash = const_hash_rtx (mode, x);
3439 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3440 if (compare_constant_rtx (mode, x, desc))
3442 found = desc->label;
3448 register struct pool_constant *pool;
3449 register struct pool_sym *sym;
3452 /* No constant equal to X is known to have been output.
3453 Make a constant descriptor to enter X in the hash table.
3454 Assign the label number and record it in the descriptor for
3455 future calls to this function to find. */
3457 desc = record_constant_rtx (mode, x);
3458 desc->next = const_rtx_hash_table[hash];
3459 const_rtx_hash_table[hash] = desc;
3461 /* Align the location counter as required by EXP's data type. */
3462 align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3463 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3464 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3465 #ifdef CONSTANT_ALIGNMENT
3466 align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x),
3467 align * BITS_PER_UNIT) / BITS_PER_UNIT;
3470 pool_offset += align - 1;
3471 pool_offset &= ~ (align - 1);
3473 /* If RTL is not being placed into the saveable obstack, make a
3474 copy of X that is in the saveable obstack in case we are
3475 being called from combine or some other phase that discards
3476 memory it allocates. We used to only do this if it is a
3477 CONST; however, reload can allocate a CONST_INT when
3478 eliminating registers. */
3479 if (rtl_obstack != saveable_obstack
3480 && (GET_CODE (x) == CONST || GET_CODE (x) == CONST_INT))
3482 push_obstacks_nochange ();
3483 rtl_in_saveable_obstack ();
3485 if (GET_CODE (x) == CONST)
3486 x = gen_rtx_CONST (GET_MODE (x),
3487 gen_rtx_PLUS (GET_MODE (x),
3488 XEXP (XEXP (x, 0), 0),
3489 XEXP (XEXP (x, 0), 1)));
3491 x = GEN_INT (INTVAL (x));
3496 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3498 pool = (struct pool_constant *) savealloc (sizeof (struct pool_constant));
3502 pool->labelno = const_labelno;
3503 pool->align = align;
3504 pool->offset = pool_offset;
3511 last_pool->next = pool;
3514 pool_offset += GET_MODE_SIZE (mode);
3516 /* Create a string containing the label name, in LABEL. */
3517 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3522 = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
3524 /* Add label to symbol hash table. */
3525 hash = SYMHASH (found);
3526 sym = (struct pool_sym *) savealloc (sizeof (struct pool_sym));
3529 sym->next = const_rtx_sym_hash_table[hash];
3530 const_rtx_sym_hash_table[hash] = sym;
3533 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3535 def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, found));
3537 RTX_UNCHANGING_P (def) = 1;
3538 /* Mark the symbol_ref as belonging to this constants pool. */
3539 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3540 current_function_uses_const_pool = 1;
3542 if (outer_function_chain == 0)
3543 if (GET_CODE (x) == CONST_DOUBLE)
3545 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3547 CONST_DOUBLE_CHAIN (x) = const_double_chain;
3548 const_double_chain = x;
3550 CONST_DOUBLE_MEM (x) = def;
3556 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3557 the corresponding pool_constant structure. */
3559 static struct pool_constant *
3560 find_pool_constant (addr)
3563 struct pool_sym *sym;
3564 char *label = XSTR (addr, 0);
3566 for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
3567 if (sym->label == label)
3573 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3576 get_pool_constant (addr)
3579 return (find_pool_constant (addr))->constant;
3582 /* Similar, return the mode. */
3585 get_pool_mode (addr)
3588 return (find_pool_constant (addr))->mode;
3591 /* Similar, return the offset in the constant pool. */
3594 get_pool_offset (addr)
3597 return (find_pool_constant (addr))->offset;
3600 /* Return the size of the constant pool. */
3608 /* Write all the constants in the constant pool. */
3611 output_constant_pool (fnname, fndecl)
3612 char *fnname ATTRIBUTE_UNUSED;
3613 tree fndecl ATTRIBUTE_UNUSED;
3615 struct pool_constant *pool;
3617 union real_extract u;
3619 /* It is possible for gcc to call force_const_mem and then to later
3620 discard the instructions which refer to the constant. In such a
3621 case we do not need to output the constant. */
3622 mark_constant_pool ();
3624 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3625 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3628 for (pool = first_pool; pool; pool = pool->next)
3635 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3636 whose CODE_LABEL has been deleted. This can occur if a jump table
3637 is eliminated by optimization. If so, write a constant of zero
3638 instead. Note that this can also happen by turning the
3639 CODE_LABEL into a NOTE. */
3640 if (((GET_CODE (x) == LABEL_REF
3641 && (INSN_DELETED_P (XEXP (x, 0))
3642 || GET_CODE (XEXP (x, 0)) == NOTE)))
3643 || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3644 && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3645 && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3646 || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3649 /* First switch to correct section. */
3650 #ifdef SELECT_RTX_SECTION
3651 SELECT_RTX_SECTION (pool->mode, x);
3653 readonly_data_section ();
3656 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3657 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3658 pool->align, pool->labelno, done);
3661 if (pool->align > 1)
3662 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (pool->align));
3664 /* Output the label. */
3665 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3667 /* Output the value of the constant itself. */
3668 switch (GET_MODE_CLASS (pool->mode))
3671 if (GET_CODE (x) != CONST_DOUBLE)
3674 bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
3675 assemble_real (u.d, pool->mode);
3679 case MODE_PARTIAL_INT:
3680 assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3687 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3693 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3694 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3697 /* Done with this pool. */
3698 first_pool = last_pool = 0;
3701 /* Look through the instructions for this function, and mark all the
3702 entries in the constant pool which are actually being used. */
3705 mark_constant_pool ()
3708 struct pool_constant *pool;
3710 if (first_pool == 0)
3713 for (pool = first_pool; pool; pool = pool->next)
3716 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3717 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
3718 mark_constants (PATTERN (insn));
3720 for (insn = current_function_epilogue_delay_list;
3722 insn = XEXP (insn, 1))
3723 if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
3724 mark_constants (PATTERN (insn));
3726 /* It's possible that the only reference to a symbol is in a symbol
3727 that's in the constant pool. This happens in Fortran under some
3728 situations. (When the constant contains the address of another
3729 constant, and only the first is used directly in an insn.)
3730 This is potentially suboptimal if there's ever a possibility of
3731 backwards (in pool order) 2'd level references. However, it's
3732 not clear that 2'd level references can happen. */
3733 for (pool = first_pool; pool; pool = pool->next)
3735 struct pool_sym *sym;
3738 /* skip unmarked entries; no insn refers to them. */
3742 label = XSTR (pool->constant, 0);
3744 /* Be sure the symbol's value is marked. */
3745 for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym;
3747 if (sym->label == label)
3748 sym->pool->mark = 1;
3749 /* If we didn't find it, there's something truly wrong here, but it
3750 will be announced by the assembler. */
3759 register char *format_ptr;
3764 if (GET_CODE (x) == SYMBOL_REF)
3766 if (CONSTANT_POOL_ADDRESS_P (x))
3767 find_pool_constant (x)->mark = 1;
3770 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3771 a MEM, but does not constitute a use of that MEM. This is particularly
3772 important inside a nested function, because CONST_DOUBLE_MEM may be
3773 a reference to a MEM in the parent's constant pool. See the comment
3774 in force_const_mem. */
3775 else if (GET_CODE (x) == CONST_DOUBLE)
3778 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3779 insns, not any notes that may be attached. We don't want to mark
3780 a constant just because it happens to appear in a REG_EQUIV note. */
3781 if (GET_RTX_CLASS (GET_CODE (x)) == 'i')
3783 mark_constants (PATTERN (x));
3787 format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3789 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
3791 switch (*format_ptr++)
3794 mark_constants (XEXP (x, i));
3798 if (XVEC (x, i) != 0)
3802 for (j = 0; j < XVECLEN (x, i); j++)
3803 mark_constants (XVECEXP (x, i, j));
3822 /* Find all the constants whose addresses are referenced inside of EXP,
3823 and make sure assembler code with a label has been output for each one.
3824 Indicate whether an ADDR_EXPR has been encountered. */
3827 output_addressed_constants (exp)
3832 switch (TREE_CODE (exp))
3836 register tree constant = TREE_OPERAND (exp, 0);
3838 while (TREE_CODE (constant) == COMPONENT_REF)
3840 constant = TREE_OPERAND (constant, 0);
3843 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3844 || TREE_CODE (constant) == CONSTRUCTOR)
3845 /* No need to do anything here
3846 for addresses of variables or functions. */
3847 output_constant_def (constant);
3854 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3855 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3860 case NON_LVALUE_EXPR:
3861 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3867 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
3868 if (TREE_VALUE (link) != 0)
3869 reloc |= output_addressed_constants (TREE_VALUE (link));
3879 /* Output assembler code for constant EXP to FILE, with no label.
3880 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3881 Assumes output_addressed_constants has been done on EXP already.
3883 Generate exactly SIZE bytes of assembler data, padding at the end
3884 with zeros if necessary. SIZE must always be specified.
3886 SIZE is important for structure constructors,
3887 since trailing members may have been omitted from the constructor.
3888 It is also important for initialization of arrays from string constants
3889 since the full length of the string constant might not be wanted.
3890 It is also needed for initialization of unions, where the initializer's
3891 type is just one member, and that may not be as long as the union.
3893 There a case in which we would fail to output exactly SIZE bytes:
3894 for a structure constructor that wants to produce more than SIZE bytes.
3895 But such constructors will never be generated for any possible input. */
3898 output_constant (exp, size)
3902 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
3904 /* Some front-ends use constants other than the standard
3905 language-indepdent varieties, but which may still be output
3906 directly. Give the front-end a chance to convert EXP to a
3907 language-independent representation. */
3908 if (lang_expand_constant)
3909 exp = (*lang_expand_constant) (exp);
3911 if (size == 0 || flag_syntax_only)
3914 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
3915 That way we get the constant (we hope) inside it. Also, strip off any
3916 NOP_EXPR that converts between two record, union, array, or set types. */
3917 while ((TREE_CODE (exp) == NOP_EXPR
3918 && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
3919 || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
3920 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3921 exp = TREE_OPERAND (exp, 0);
3923 /* Allow a constructor with no elements for any data type.
3924 This means to fill the space with zeros. */
3925 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3927 assemble_zeros (size);
3938 case REFERENCE_TYPE:
3939 /* ??? What about (int)((float)(int)&foo + 4) */
3940 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3941 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3942 exp = TREE_OPERAND (exp, 0);
3944 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3945 EXPAND_INITIALIZER),
3947 error ("initializer for integer value is too complicated");
3952 if (TREE_CODE (exp) != REAL_CST)
3953 error ("initializer for floating value is not a floating constant");
3955 assemble_real (TREE_REAL_CST (exp),
3956 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
3961 output_constant (TREE_REALPART (exp), size / 2);
3962 output_constant (TREE_IMAGPART (exp), size / 2);
3963 size -= (size / 2) * 2;
3967 if (TREE_CODE (exp) == CONSTRUCTOR)
3969 output_constructor (exp, size);
3972 else if (TREE_CODE (exp) == STRING_CST)
3976 if (size > TREE_STRING_LENGTH (exp))
3978 excess = size - TREE_STRING_LENGTH (exp);
3979 size = TREE_STRING_LENGTH (exp);
3982 assemble_string (TREE_STRING_POINTER (exp), size);
3991 if (TREE_CODE (exp) == CONSTRUCTOR)
3992 output_constructor (exp, size);
3998 if (TREE_CODE (exp) == INTEGER_CST)
3999 assemble_integer (expand_expr (exp, NULL_RTX,
4000 VOIDmode, EXPAND_INITIALIZER),
4002 else if (TREE_CODE (exp) == CONSTRUCTOR)
4004 unsigned char *buffer = (unsigned char *) alloca (size);
4005 if (get_set_constructor_bytes (exp, buffer, size))
4007 assemble_string ((char *) buffer, size);
4010 error ("unknown set constructor type");
4018 assemble_zeros (size);
4022 /* Subroutine of output_constant, used for CONSTRUCTORs
4023 (aggregate constants).
4024 Generate at least SIZE bytes, padding if necessary. */
4027 output_constructor (exp, size)
4031 register tree link, field = 0;
4032 HOST_WIDE_INT min_index = 0;
4033 /* Number of bytes output or skipped so far.
4034 In other words, current position within the constructor. */
4035 int total_bytes = 0;
4036 /* Non-zero means BYTE contains part of a byte, to be output. */
4037 int byte_buffer_in_use = 0;
4040 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4043 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
4044 field = TYPE_FIELDS (TREE_TYPE (exp));
4046 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
4047 && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
4049 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
4051 /* As LINK goes through the elements of the constant,
4052 FIELD goes through the structure fields, if the constant is a structure.
4053 if the constant is a union, then we override this,
4054 by getting the field from the TREE_LIST element.
4055 But the constant could also be an array. Then FIELD is zero.
4057 There is always a maximum of one element in the chain LINK for unions
4058 (even if the initializer in a source program incorrectly contains
4060 for (link = CONSTRUCTOR_ELTS (exp);
4062 link = TREE_CHAIN (link),
4063 field = field ? TREE_CHAIN (field) : 0)
4065 tree val = TREE_VALUE (link);
4068 /* the element in a union constructor specifies the proper field. */
4070 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
4071 || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
4073 /* if available, use the type given by link */
4074 if (TREE_PURPOSE (link) != 0)
4075 field = TREE_PURPOSE (link);
4078 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
4079 index = TREE_PURPOSE (link);
4081 /* Eliminate the marker that makes a cast not be an lvalue. */
4085 if (index && TREE_CODE (index) == RANGE_EXPR)
4087 register int fieldsize
4088 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
4089 HOST_WIDE_INT lo_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 0));
4090 HOST_WIDE_INT hi_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 1));
4091 HOST_WIDE_INT index;
4092 for (index = lo_index; index <= hi_index; index++)
4094 /* Output the element's initial value. */
4096 assemble_zeros (fieldsize);
4098 output_constant (val, fieldsize);
4100 /* Count its size. */
4101 total_bytes += fieldsize;
4104 else if (field == 0 || !DECL_BIT_FIELD (field))
4106 /* An element that is not a bit-field. */
4108 register int fieldsize;
4109 /* Since this structure is static,
4110 we know the positions are constant. */
4111 int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
4115 bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
4117 * (TREE_INT_CST_LOW (index) - min_index));
4119 /* Output any buffered-up bit-fields preceding this element. */
4120 if (byte_buffer_in_use)
4122 ASM_OUTPUT_BYTE (asm_out_file, byte);
4124 byte_buffer_in_use = 0;
4127 /* Advance to offset of this element.
4128 Note no alignment needed in an array, since that is guaranteed
4129 if each element has the proper size. */
4130 if ((field != 0 || index != 0) && bitpos != total_bytes)
4132 assemble_zeros (bitpos - total_bytes);
4133 total_bytes = bitpos;
4136 /* Determine size this element should occupy. */
4139 if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
4141 if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
4143 /* This avoids overflow trouble. */
4144 tree size_tree = size_binop (CEIL_DIV_EXPR,
4146 size_int (BITS_PER_UNIT));
4147 fieldsize = TREE_INT_CST_LOW (size_tree);
4151 fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
4152 fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
4156 fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
4158 /* Output the element's initial value. */
4160 assemble_zeros (fieldsize);
4162 output_constant (val, fieldsize);
4164 /* Count its size. */
4165 total_bytes += fieldsize;
4167 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4168 error ("invalid initial value for member `%s'",
4169 IDENTIFIER_POINTER (DECL_NAME (field)));
4172 /* Element that is a bit-field. */
4174 int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
4176 = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
4179 val = integer_zero_node;
4181 /* If this field does not start in this (or, next) byte,
4183 if (next_offset / BITS_PER_UNIT != total_bytes)
4185 /* Output remnant of any bit field in previous bytes. */
4186 if (byte_buffer_in_use)
4188 ASM_OUTPUT_BYTE (asm_out_file, byte);
4190 byte_buffer_in_use = 0;
4193 /* If still not at proper byte, advance to there. */
4194 if (next_offset / BITS_PER_UNIT != total_bytes)
4196 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4197 total_bytes = next_offset / BITS_PER_UNIT;
4201 if (! byte_buffer_in_use)
4204 /* We must split the element into pieces that fall within
4205 separate bytes, and combine each byte with previous or
4206 following bit-fields. */
4208 /* next_offset is the offset n fbits from the beginning of
4209 the structure to the next bit of this element to be processed.
4210 end_offset is the offset of the first bit past the end of
4212 while (next_offset < end_offset)
4216 HOST_WIDE_INT value;
4217 int next_byte = next_offset / BITS_PER_UNIT;
4218 int next_bit = next_offset % BITS_PER_UNIT;
4220 /* Advance from byte to byte
4221 within this element when necessary. */
4222 while (next_byte != total_bytes)
4224 ASM_OUTPUT_BYTE (asm_out_file, byte);
4229 /* Number of bits we can process at once
4230 (all part of the same byte). */
4231 this_time = MIN (end_offset - next_offset,
4232 BITS_PER_UNIT - next_bit);
4233 if (BYTES_BIG_ENDIAN)
4235 /* On big-endian machine, take the most significant bits
4236 first (of the bits that are significant)
4237 and put them into bytes from the most significant end. */
4238 shift = end_offset - next_offset - this_time;
4239 /* Don't try to take a bunch of bits that cross
4240 the word boundary in the INTEGER_CST. */
4241 if (shift < HOST_BITS_PER_WIDE_INT
4242 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4244 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4245 shift = HOST_BITS_PER_WIDE_INT;
4248 /* Now get the bits from the appropriate constant word. */
4249 if (shift < HOST_BITS_PER_WIDE_INT)
4251 value = TREE_INT_CST_LOW (val);
4253 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4255 value = TREE_INT_CST_HIGH (val);
4256 shift -= HOST_BITS_PER_WIDE_INT;
4260 byte |= (((value >> shift)
4261 & (((HOST_WIDE_INT) 1 << this_time) - 1))
4262 << (BITS_PER_UNIT - this_time - next_bit));
4266 /* On little-endian machines,
4267 take first the least significant bits of the value
4268 and pack them starting at the least significant
4269 bits of the bytes. */
4270 shift = (next_offset
4271 - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
4272 /* Don't try to take a bunch of bits that cross
4273 the word boundary in the INTEGER_CST. */
4274 if (shift < HOST_BITS_PER_WIDE_INT
4275 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4277 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4278 shift = HOST_BITS_PER_WIDE_INT;
4281 /* Now get the bits from the appropriate constant word. */
4282 if (shift < HOST_BITS_PER_WIDE_INT)
4283 value = TREE_INT_CST_LOW (val);
4284 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4286 value = TREE_INT_CST_HIGH (val);
4287 shift -= HOST_BITS_PER_WIDE_INT;
4291 byte |= (((value >> shift)
4292 & (((HOST_WIDE_INT) 1 << this_time) - 1))
4295 next_offset += this_time;
4296 byte_buffer_in_use = 1;
4300 if (byte_buffer_in_use)
4302 ASM_OUTPUT_BYTE (asm_out_file, byte);
4305 if (total_bytes < size)
4306 assemble_zeros (size - total_bytes);
4309 #ifdef HANDLE_PRAGMA_WEAK
4310 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4311 associatd with NAME. */
4314 add_weak (name, value)
4318 struct weak_syms *weak;
4320 weak = (struct weak_syms *) permalloc (sizeof (struct weak_syms));
4325 weak->next = weak_decls;
4327 weak->value = value;
4332 #endif /* HANDLE_PRAGMA_WEAK */
4334 /* Declare DECL to be a weak symbol. */
4340 if (! TREE_PUBLIC (decl))
4341 error_with_decl (decl, "weak declaration of `%s' must be public");
4342 else if (TREE_ASM_WRITTEN (decl))
4343 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4344 else if (SUPPORTS_WEAK)
4345 DECL_WEAK (decl) = 1;
4346 #ifdef HANDLE_PRAGMA_WEAK
4347 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4351 /* Emit any pending weak declarations. */
4353 #ifdef HANDLE_PRAGMA_WEAK
4354 struct weak_syms * weak_decls;
4360 #ifdef HANDLE_PRAGMA_WEAK
4361 if (HANDLE_PRAGMA_WEAK)
4363 struct weak_syms *t;
4364 for (t = weak_decls; t; t = t->next)
4368 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4370 ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4377 /* Remove NAME from the pending list of weak symbols. This prevents
4378 the compiler from emitting multiple .weak directives which confuses
4381 remove_from_pending_weak_list (name)
4384 #ifdef HANDLE_PRAGMA_WEAK
4385 if (HANDLE_PRAGMA_WEAK)
4387 struct weak_syms *t;
4388 for (t = weak_decls; t; t = t->next)
4390 if (t->name && strcmp (name, t->name) == 0)
4398 assemble_alias (decl, target)
4399 tree decl, target ATTRIBUTE_UNUSED;
4403 make_decl_rtl (decl, (char *) 0, 1);
4404 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4406 #ifdef ASM_OUTPUT_DEF
4407 /* Make name accessible from other files, if appropriate. */
4409 if (TREE_PUBLIC (decl))
4411 #ifdef ASM_WEAKEN_LABEL
4412 if (DECL_WEAK (decl))
4414 ASM_WEAKEN_LABEL (asm_out_file, name);
4415 /* Remove this function from the pending weak list so that
4416 we do not emit multiple .weak directives for it. */
4417 remove_from_pending_weak_list
4418 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4422 ASM_GLOBALIZE_LABEL (asm_out_file, name);
4425 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4426 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4428 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4430 TREE_ASM_WRITTEN (decl) = 1;
4432 #ifdef ASM_OUTPUT_WEAK_ALIAS
4433 if (! DECL_WEAK (decl))
4434 warning ("only weak aliases are supported in this configuration");
4436 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4437 TREE_ASM_WRITTEN (decl) = 1;
4439 warning ("alias definitions not supported in this configuration; ignored");
4444 /* This determines whether or not we support link-once semantics. */
4445 #ifndef SUPPORTS_ONE_ONLY
4446 #ifdef MAKE_DECL_ONE_ONLY
4447 #define SUPPORTS_ONE_ONLY 1
4449 #define SUPPORTS_ONE_ONLY 0
4453 /* Returns 1 if the target configuration supports defining public symbols
4454 so that one of them will be chosen at link time instead of generating a
4455 multiply-defined symbol error, whether through the use of weak symbols or
4456 a target-specific mechanism for having duplicates discarded. */
4459 supports_one_only ()
4461 if (SUPPORTS_ONE_ONLY)
4463 return SUPPORTS_WEAK;
4466 /* Set up DECL as a public symbol that can be defined in multiple
4467 translation units without generating a linker error. */
4470 make_decl_one_only (decl)
4473 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4476 TREE_PUBLIC (decl) = 1;
4478 if (TREE_CODE (decl) == VAR_DECL
4479 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4480 DECL_COMMON (decl) = 1;
4481 else if (SUPPORTS_ONE_ONLY)
4483 #ifdef MAKE_DECL_ONE_ONLY
4484 MAKE_DECL_ONE_ONLY (decl);
4486 DECL_ONE_ONLY (decl) = 1;
4488 else if (SUPPORTS_WEAK)
4489 DECL_WEAK (decl) = 1;