1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 88, 89, 92-5, 1996 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. */
31 /* #include <stab.h> */
40 #include "hard-reg-set.h"
49 #ifdef XCOFF_DEBUGGING_INFO
56 #define ASM_STABS_OP ".stabs"
59 /* This macro gets just the user-specified name
60 out of the string in a SYMBOL_REF. On most machines,
61 we discard the * if any and that's all. */
62 #ifndef STRIP_NAME_ENCODING
63 #define STRIP_NAME_ENCODING(VAR,SYMBOL_NAME) \
64 (VAR) = ((SYMBOL_NAME) + ((SYMBOL_NAME)[0] == '*'))
67 /* File in which assembler code is being written. */
69 extern FILE *asm_out_file;
71 /* The (assembler) name of the first globally-visible object output. */
72 char *first_global_object_name;
74 extern struct obstack *current_obstack;
75 extern struct obstack *saveable_obstack;
76 extern struct obstack *rtl_obstack;
77 extern struct obstack permanent_obstack;
78 #define obstack_chunk_alloc xmalloc
80 /* Number for making the label on the next
81 constant that is stored in memory. */
85 /* Number for making the label on the next
86 static variable internal to a function. */
90 /* Carry information from ASM_DECLARE_OBJECT_NAME
91 to ASM_FINISH_DECLARE_OBJECT. */
93 int size_directive_output;
95 /* The last decl for which assemble_variable was called,
96 if it did ASM_DECLARE_OBJECT_NAME.
97 If the last call to assemble_variable didn't do that,
100 tree last_assemble_variable_decl;
103 #ifdef HANDLE_PRAGMA_WEAK
104 /* Any weak symbol declarations waiting to be emitted. */
108 struct weak_syms *next;
113 static struct weak_syms *weak_decls;
116 /* Nonzero if at least one function definition has been seen. */
118 static int function_defined;
121 struct constant_descriptor;
123 struct pool_constant;
125 static void bc_make_decl_rtl PROTO((tree, char *, int));
126 static char *strip_reg_name PROTO((char *));
127 static void bc_output_ascii PROTO((FILE *, char *, int));
128 static int contains_pointers_p PROTO((tree));
129 static void decode_addr_const PROTO((tree, struct addr_const *));
130 static int const_hash PROTO((tree));
131 static int compare_constant PROTO((tree,
132 struct constant_descriptor *));
133 static char *compare_constant_1 PROTO((tree, char *));
134 static struct constant_descriptor *record_constant PROTO((tree));
135 static void record_constant_1 PROTO((tree));
136 static tree copy_constant PROTO((tree));
137 static void output_constant_def_contents PROTO((tree, int, int));
138 static void decode_rtx_const PROTO((enum machine_mode, rtx,
139 struct rtx_const *));
140 static int const_hash_rtx PROTO((enum machine_mode, rtx));
141 static int compare_constant_rtx PROTO((enum machine_mode, rtx,
142 struct constant_descriptor *));
143 static struct constant_descriptor *record_constant_rtx PROTO((enum machine_mode,
145 static struct pool_constant *find_pool_constant PROTO((rtx));
146 static int output_addressed_constants PROTO((tree));
147 static void bc_assemble_integer PROTO((tree, int));
148 static void output_constructor PROTO((tree, int));
150 static enum in_section { no_section, in_text, in_data, in_named
151 #ifdef BSS_SECTION_ASM_OP
154 #ifdef EXTRA_SECTIONS
157 } in_section = no_section;
159 /* Return a non-zero value if DECL has a section attribute. */
160 #define IN_NAMED_SECTION(DECL) \
161 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
162 && DECL_SECTION_NAME (DECL) != NULL_TREE)
164 /* Text of section name when in_section == in_named. */
165 static char *in_named_name;
167 /* Define functions like text_section for any extra sections. */
168 #ifdef EXTRA_SECTION_FUNCTIONS
169 EXTRA_SECTION_FUNCTIONS
172 /* Tell assembler to switch to text section. */
177 if (in_section != in_text)
182 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
184 in_section = in_text;
188 /* Tell assembler to switch to data section. */
193 if (in_section != in_data)
199 if (flag_shared_data)
201 #ifdef SHARED_SECTION_ASM_OP
202 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
204 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
208 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
211 in_section = in_data;
215 /* Tell assembler to switch to read-only data section. This is normally
219 readonly_data_section ()
221 #ifdef READONLY_DATA_SECTION
222 READONLY_DATA_SECTION (); /* Note this can call data_section. */
228 /* Determine if we're in the text section. */
233 return in_section == in_text;
236 /* Determine if we're in the data section. */
241 return in_section == in_data;
244 /* Tell assembler to change to section NAME for DECL.
245 If DECL is NULL, just switch to section NAME.
246 If NAME is NULL, get the name from DECL. */
249 named_section (decl, name)
253 if (decl != NULL_TREE
254 && TREE_CODE_CLASS (TREE_CODE (decl)) != 'd')
257 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
259 if (in_section != in_named || strcmp (name, in_named_name))
261 in_named_name = obstack_alloc (&permanent_obstack, strlen (name) + 1);
262 strcpy (in_named_name, name);
263 in_section = in_named;
265 #ifdef ASM_OUTPUT_SECTION_NAME
266 ASM_OUTPUT_SECTION_NAME (asm_out_file, decl, name);
268 /* Section attributes are not supported if this macro isn't provided -
269 some host formats don't support them at all. The front-end should
270 already have flagged this as an error. */
276 #ifdef BSS_SECTION_ASM_OP
278 /* Tell the assembler to switch to the bss section. */
283 if (in_section != in_bss)
289 #ifdef SHARED_BSS_SECTION_ASM_OP
290 if (flag_shared_data)
291 fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
294 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
301 #ifdef ASM_OUTPUT_BSS
303 /* Utility function for ASM_OUTPUT_BSS for targets to use if
304 they don't support alignments in .bss.
305 ??? It is believed that this function will work in most cases so such
306 support is localized here. */
309 asm_output_bss (file, decl, name, size, rounded)
315 ASM_GLOBALIZE_LABEL (file, name);
317 #ifdef ASM_DECLARE_OBJECT_NAME
318 last_assemble_variable_decl = decl;
319 ASM_DECLARE_OBJECT_NAME (file, name, decl);
321 /* Standard thing is just output label for the object. */
322 ASM_OUTPUT_LABEL (file, name);
323 #endif /* ASM_DECLARE_OBJECT_NAME */
324 ASM_OUTPUT_SKIP (file, rounded);
329 #ifdef ASM_OUTPUT_ALIGNED_BSS
331 /* Utility function for targets to use in implementing
332 ASM_OUTPUT_ALIGNED_BSS.
333 ??? It is believed that this function will work in most cases so such
334 support is localized here. */
337 asm_output_aligned_bss (file, decl, name, size, align)
343 ASM_GLOBALIZE_LABEL (file, name);
345 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
346 #ifdef ASM_DECLARE_OBJECT_NAME
347 last_assemble_variable_decl = decl;
348 ASM_DECLARE_OBJECT_NAME (file, name, decl);
350 /* Standard thing is just output label for the object. */
351 ASM_OUTPUT_LABEL (file, name);
352 #endif /* ASM_DECLARE_OBJECT_NAME */
353 ASM_OUTPUT_SKIP (file, size ? size : 1);
358 #endif /* BSS_SECTION_ASM_OP */
360 /* Switch to the section for function DECL.
362 If DECL is NULL_TREE, switch to the text section.
363 ??? It's not clear that we will ever be passed NULL_TREE, but it's
364 safer to handle it. */
367 function_section (decl)
370 if (decl != NULL_TREE
371 && DECL_SECTION_NAME (decl) != NULL_TREE)
372 named_section (decl, (char *) 0);
377 /* Switch to section for variable DECL.
379 RELOC is the `reloc' argument to SELECT_SECTION. */
382 variable_section (decl, reloc)
386 if (IN_NAMED_SECTION (decl))
387 named_section (decl, NULL);
390 /* C++ can have const variables that get initialized from constructors,
391 and thus can not be in a readonly section. We prevent this by
392 verifying that the initial value is constant for objects put in a
395 error_mark_node is used by the C front end to indicate that the
396 initializer has not been seen yet. In this case, we assume that
397 the initializer must be constant.
399 C++ uses error_mark_node for variables that have complicated
400 initializers, but these variables go in BSS so we won't be called
403 #ifdef SELECT_SECTION
404 SELECT_SECTION (decl, reloc);
406 if (TREE_READONLY (decl)
407 && ! TREE_THIS_VOLATILE (decl)
408 && DECL_INITIAL (decl)
409 && (DECL_INITIAL (decl) == error_mark_node
410 || TREE_CONSTANT (DECL_INITIAL (decl)))
411 && ! (flag_pic && reloc))
412 readonly_data_section ();
419 /* Tell assembler to switch to the section for the exception handling
425 #ifdef ASM_OUTPUT_SECTION_NAME
426 named_section (NULL_TREE, ".gcc_except_table");
431 #if defined (EXCEPTION_SECTION)
432 EXCEPTION_SECTION ();
434 readonly_data_section ();
439 /* Create the rtl to represent a function, for a function definition.
440 DECL is a FUNCTION_DECL node which describes which function.
441 The rtl is stored into DECL. */
444 make_function_rtl (decl)
447 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
451 if (DECL_RTL (decl) == 0)
452 DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
454 /* Record that at least one function has been defined. */
455 function_defined = 1;
459 /* Rename a nested function to avoid conflicts. */
460 if (decl_function_context (decl) != 0
461 && DECL_INITIAL (decl) != 0
462 && DECL_RTL (decl) == 0)
466 name = IDENTIFIER_POINTER (DECL_NAME (decl));
467 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
468 name = obstack_copy0 (saveable_obstack, label, strlen (label));
472 if (DECL_RTL (decl) == 0)
475 = gen_rtx (MEM, DECL_MODE (decl),
476 gen_rtx (SYMBOL_REF, Pmode, name));
478 /* Optionally set flags or add text to the name to record information
479 such as that it is a function name. If the name is changed, the macro
480 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
481 #ifdef ENCODE_SECTION_INFO
482 ENCODE_SECTION_INFO (decl);
486 /* Record at least one function has been defined. */
487 function_defined = 1;
490 /* Create the DECL_RTL for a declaration for a static or external
491 variable or static or external function.
492 ASMSPEC, if not 0, is the string which the user specified
493 as the assembler symbol name.
494 TOP_LEVEL is nonzero if this is a file-scope variable.
495 This is never called for PARM_DECLs. */
498 bc_make_decl_rtl (decl, asmspec, top_level)
503 register char *name = TREE_STRING_POINTER (DECL_ASSEMBLER_NAME (decl));
505 if (DECL_RTL (decl) == 0)
507 /* Print an error message for register variables. */
508 if (DECL_REGISTER (decl))
509 error ("global register variables not supported in the interpreter");
511 /* Handle ordinary static variables and functions. */
512 if (DECL_RTL (decl) == 0)
514 /* Can't use just the variable's own name for a variable
515 whose scope is less than the whole file.
516 Concatenate a distinguishing number. */
517 if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
521 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
522 name = obstack_copy0 (saveable_obstack, label, strlen (label));
526 DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
531 /* Given NAME, a putative register name, discard any customary prefixes. */
534 strip_reg_name (name)
537 #ifdef REGISTER_PREFIX
538 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
539 name += strlen (REGISTER_PREFIX);
541 if (name[0] == '%' || name[0] == '#')
546 /* Decode an `asm' spec for a declaration as a register name.
547 Return the register number, or -1 if nothing specified,
548 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
549 or -3 if ASMSPEC is `cc' and is not recognized,
550 or -4 if ASMSPEC is `memory' and is not recognized.
551 Accept an exact spelling or a decimal number.
552 Prefixes such as % are optional. */
555 decode_reg_name (asmspec)
562 /* Get rid of confusing prefixes. */
563 asmspec = strip_reg_name (asmspec);
565 /* Allow a decimal number as a "register name". */
566 for (i = strlen (asmspec) - 1; i >= 0; i--)
567 if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
569 if (asmspec[0] != 0 && i < 0)
572 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
578 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
580 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
583 #ifdef ADDITIONAL_REGISTER_NAMES
585 static struct { char *name; int number; } table[]
586 = ADDITIONAL_REGISTER_NAMES;
588 for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
589 if (! strcmp (asmspec, table[i].name))
590 return table[i].number;
592 #endif /* ADDITIONAL_REGISTER_NAMES */
594 if (!strcmp (asmspec, "memory"))
597 if (!strcmp (asmspec, "cc"))
606 /* Create the DECL_RTL for a declaration for a static or external variable
607 or static or external function.
608 ASMSPEC, if not 0, is the string which the user specified
609 as the assembler symbol name.
610 TOP_LEVEL is nonzero if this is a file-scope variable.
612 This is never called for PARM_DECL nodes. */
615 make_decl_rtl (decl, asmspec, top_level)
620 register char *name = 0;
625 bc_make_decl_rtl (decl, asmspec, top_level);
629 reg_number = decode_reg_name (asmspec);
631 if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
632 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
634 if (reg_number == -2)
636 /* ASMSPEC is given, and not the name of a register. */
637 name = (char *) obstack_alloc (saveable_obstack,
638 strlen (asmspec) + 2);
640 strcpy (&name[1], asmspec);
643 /* For a duplicate declaration, we can be called twice on the
644 same DECL node. Don't discard the RTL already made. */
645 if (DECL_RTL (decl) == 0)
649 /* First detect errors in declaring global registers. */
650 if (TREE_CODE (decl) != FUNCTION_DECL
651 && DECL_REGISTER (decl) && reg_number == -1)
652 error_with_decl (decl,
653 "register name not specified for `%s'");
654 else if (TREE_CODE (decl) != FUNCTION_DECL
655 && DECL_REGISTER (decl) && reg_number < 0)
656 error_with_decl (decl,
657 "invalid register name for `%s'");
658 else if ((reg_number >= 0 || reg_number == -3)
659 && (TREE_CODE (decl) == FUNCTION_DECL
660 && ! DECL_REGISTER (decl)))
661 error_with_decl (decl,
662 "register name given for non-register variable `%s'");
663 else if (TREE_CODE (decl) != FUNCTION_DECL
664 && DECL_REGISTER (decl)
665 && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
666 error_with_decl (decl,
667 "data type of `%s' isn't suitable for a register");
668 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl)
669 && ! HARD_REGNO_MODE_OK (reg_number,
670 TYPE_MODE (TREE_TYPE (decl))))
671 error_with_decl (decl,
672 "register number for `%s' isn't suitable for data type");
673 /* Now handle properly declared static register variables. */
674 else if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
678 if (DECL_INITIAL (decl) != 0 && top_level)
680 DECL_INITIAL (decl) = 0;
681 error ("global register variable has initial value");
683 if (fixed_regs[reg_number] == 0
684 && function_defined && top_level)
685 error ("global register variable follows a function definition");
686 if (TREE_THIS_VOLATILE (decl))
687 warning ("volatile register variables don't work as you might wish");
689 /* If the user specified one of the eliminables registers here,
690 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
691 confused with that register and be eliminated. Although this
692 usage is somewhat suspect, we nevertheless use the following
693 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
696 = gen_rtx (REG, DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
697 REGNO (DECL_RTL (decl)) = reg_number;
698 REG_USERVAR_P (DECL_RTL (decl)) = 1;
702 /* Make this register global, so not usable for anything
704 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
706 globalize_reg (reg_number + --nregs);
709 /* Specifying a section attribute on an uninitialized variable does not
710 (and cannot) cause it to be put in the given section. The linker
711 can only put initialized objects in specific sections, everything
712 else goes in bss for the linker to sort out later (otherwise the
713 linker would give a duplicate definition error for each compilation
714 unit that behaved thusly). So warn the user. */
715 else if (TREE_CODE (decl) == VAR_DECL
716 && DECL_SECTION_NAME (decl) != NULL_TREE
717 && DECL_INITIAL (decl) == NULL_TREE
718 && DECL_COMMON (decl))
720 warning_with_decl (decl,
721 "section attribute ignored for uninitialized variable `%s'");
722 /* Remove the section name so subsequent declarations won't see it.
723 We are ignoring it, remember. */
724 DECL_SECTION_NAME (decl) = NULL_TREE;
727 /* Now handle ordinary static variables and functions (in memory).
728 Also handle vars declared register invalidly. */
729 if (DECL_RTL (decl) == 0)
731 /* Can't use just the variable's own name for a variable
732 whose scope is less than the whole file.
733 Concatenate a distinguishing number. */
734 if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
738 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
739 name = obstack_copy0 (saveable_obstack, label, strlen (label));
746 DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
747 gen_rtx (SYMBOL_REF, Pmode, name));
749 /* If this variable is to be treated as volatile, show its
750 tree node has side effects. If it has side effects, either
751 because of this test or from TREE_THIS_VOLATILE also
752 being set, show the MEM is volatile. */
753 if (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
754 && TREE_PUBLIC (decl))
755 TREE_SIDE_EFFECTS (decl) = 1;
756 if (TREE_SIDE_EFFECTS (decl))
757 MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
759 if (TREE_READONLY (decl))
760 RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
761 MEM_IN_STRUCT_P (DECL_RTL (decl))
762 = AGGREGATE_TYPE_P (TREE_TYPE (decl));
764 /* Optionally set flags or add text to the name to record information
765 such as that it is a function name.
766 If the name is changed, the macro ASM_OUTPUT_LABELREF
767 will have to know how to strip this information. */
768 #ifdef ENCODE_SECTION_INFO
769 ENCODE_SECTION_INFO (decl);
773 /* If the old RTL had the wrong mode, fix the mode. */
774 else if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
776 rtx rtl = DECL_RTL (decl);
777 PUT_MODE (rtl, DECL_MODE (decl));
781 /* Make the rtl for variable VAR be volatile.
782 Use this only for static variables. */
785 make_var_volatile (var)
788 if (GET_CODE (DECL_RTL (var)) != MEM)
791 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
794 /* Output alignment directive to align for constant expression EXP. */
797 assemble_constant_align (exp)
802 /* Align the location counter as required by EXP's data type. */
803 align = TYPE_ALIGN (TREE_TYPE (exp));
804 #ifdef CONSTANT_ALIGNMENT
805 align = CONSTANT_ALIGNMENT (exp, align);
808 if (align > BITS_PER_UNIT)
809 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
812 /* Output a string of literal assembler code
813 for an `asm' keyword used between functions. */
816 assemble_asm (string)
821 error ("asm statements not allowed in interpreter");
827 if (TREE_CODE (string) == ADDR_EXPR)
828 string = TREE_OPERAND (string, 0);
830 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
833 #if 0 /* This should no longer be needed, because
834 flag_gnu_linker should be 0 on these systems,
835 which should prevent any output
836 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
837 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
838 #ifndef ASM_OUTPUT_CONSTRUCTOR
839 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
841 #ifndef ASM_OUTPUT_DESTRUCTOR
842 #define ASM_OUTPUT_DESTRUCTOR(file, name)
847 /* Record an element in the table of global destructors.
848 How this is done depends on what sort of assembler and linker
851 NAME should be the name of a global function to be called
852 at exit time. This name is output using assemble_name. */
855 assemble_destructor (name)
858 #ifdef ASM_OUTPUT_DESTRUCTOR
859 ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
863 /* Now tell GNU LD that this is part of the static destructor set. */
864 /* This code works for any machine provided you use GNU as/ld. */
865 fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
866 assemble_name (asm_out_file, name);
867 fputc ('\n', asm_out_file);
872 /* Likewise for global constructors. */
875 assemble_constructor (name)
878 #ifdef ASM_OUTPUT_CONSTRUCTOR
879 ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
883 /* Now tell GNU LD that this is part of the static constructor set. */
884 /* This code works for any machine provided you use GNU as/ld. */
885 fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
886 assemble_name (asm_out_file, name);
887 fputc ('\n', asm_out_file);
892 /* Likewise for entries we want to record for garbage collection.
893 Garbage collection is still under development. */
896 assemble_gc_entry (name)
899 #ifdef ASM_OUTPUT_GC_ENTRY
900 ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
904 /* Now tell GNU LD that this is part of the static constructor set. */
905 fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
906 assemble_name (asm_out_file, name);
907 fputc ('\n', asm_out_file);
912 /* Output assembler code for the constant pool of a function and associated
913 with defining the name of the function. DECL describes the function.
914 NAME is the function's name. For the constant pool, we use the current
915 constant pool data. */
918 assemble_start_function (decl, fnname)
924 /* The following code does not need preprocessing in the assembler. */
928 output_constant_pool (fnname, decl);
930 #ifdef ASM_OUTPUT_SECTION_NAME
931 /* If the function is to be put in its own section and it's not in a section
932 already, indicate so. */
933 if (flag_function_sections
934 && DECL_SECTION_NAME (decl) == NULL_TREE)
936 #ifdef UNIQUE_SECTION
937 DECL_SECTION_NAME(decl) = UNIQUE_SECTION (decl);
939 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
940 /* Strip off any encoding in name. */
941 STRIP_NAME_ENCODING (name, name);
942 DECL_SECTION_NAME (decl) = build_string (strlen (name), name);
947 function_section (decl);
949 /* Tell assembler to move to target machine's alignment for functions. */
950 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
954 BC_OUTPUT_ALIGN (asm_out_file, align);
956 ASM_OUTPUT_ALIGN (asm_out_file, align);
959 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
960 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
963 #ifdef SDB_DEBUGGING_INFO
964 /* Output SDB definition of the function. */
965 if (write_symbols == SDB_DEBUG)
966 sdbout_mark_begin_function ();
969 #ifdef DBX_DEBUGGING_INFO
970 /* Output DBX definition of the function. */
971 if (write_symbols == DBX_DEBUG)
972 dbxout_begin_function (decl);
975 /* Make function name accessible from other files, if appropriate. */
977 if (TREE_PUBLIC (decl))
979 if (!first_global_object_name && ! DECL_WEAK (decl)
980 && ! DECL_ONE_ONLY (decl))
984 STRIP_NAME_ENCODING (p, fnname);
985 first_global_object_name = permalloc (strlen (p) + 1);
986 strcpy (first_global_object_name, p);
989 #ifdef ASM_WEAKEN_LABEL
990 if (DECL_WEAK (decl))
991 ASM_WEAKEN_LABEL (asm_out_file, fnname);
995 BC_GLOBALIZE_LABEL (asm_out_file, fnname);
997 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
1000 /* Do any machine/system dependent processing of the function name */
1001 if (output_bytecode)
1002 BC_OUTPUT_LABEL (asm_out_file, fnname);
1005 #ifdef ASM_DECLARE_FUNCTION_NAME
1006 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
1008 /* Standard thing is just output label for the function. */
1009 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1010 #endif /* ASM_DECLARE_FUNCTION_NAME */
1014 /* Output assembler code associated with defining the size of the
1015 function. DECL describes the function. NAME is the function's name. */
1018 assemble_end_function (decl, fnname)
1022 #ifdef ASM_DECLARE_FUNCTION_SIZE
1023 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1027 /* Assemble code to leave SIZE bytes of zeros. */
1030 assemble_zeros (size)
1033 if (output_bytecode)
1035 bc_emit_const_skip (size);
1039 #ifdef ASM_NO_SKIP_IN_TEXT
1040 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1041 so we must output 0s explicitly in the text section. */
1042 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1046 for (i = 0; i < size - 20; i += 20)
1049 fprintf (asm_out_file,
1050 "%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);
1052 fprintf (asm_out_file,
1053 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1059 fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
1061 fprintf (asm_out_file, "\tbyte 0");
1064 for (; i < size; i++)
1065 fprintf (asm_out_file, ",0");
1066 fprintf (asm_out_file, "\n");
1073 if (output_bytecode)
1074 BC_OUTPUT_SKIP (asm_out_file, size);
1076 ASM_OUTPUT_SKIP (asm_out_file, size);
1080 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1083 assemble_align (align)
1086 if (align > BITS_PER_UNIT)
1087 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1090 /* Assemble a string constant with the specified C string as contents. */
1093 assemble_string (p, size)
1101 if (output_bytecode)
1107 /* If the string is very long, split it up. */
1111 int thissize = size - pos;
1112 if (thissize > maximum)
1115 if (output_bytecode)
1116 bc_output_ascii (asm_out_file, p, thissize);
1119 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1128 bc_output_ascii (file, p, size)
1133 BC_OUTPUT_ASCII (file, p, size);
1136 /* Assemble everything that is needed for a variable or function declaration.
1137 Not used for automatic variables, and not used for function definitions.
1138 Should not be called for variables of incomplete structure type.
1140 TOP_LEVEL is nonzero if this variable has file scope.
1141 AT_END is nonzero if this is the special handling, at end of compilation,
1142 to define things that have had only tentative definitions.
1143 DONT_OUTPUT_DATA if nonzero means don't actually output the
1144 initial value (that will be done by the caller). */
1147 assemble_variable (decl, top_level, at_end, dont_output_data)
1151 int dont_output_data;
1153 register char *name;
1157 enum in_section saved_in_section;
1159 last_assemble_variable_decl = 0;
1161 if (output_bytecode)
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 if (!output_bytecode)
1175 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1176 /* File-scope global variables are output here. */
1177 if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1179 dbxout_symbol (decl, 0);
1181 #ifdef SDB_DEBUGGING_INFO
1182 if (write_symbols == SDB_DEBUG && top_level
1183 /* Leave initialized global vars for end of compilation;
1184 see comment in compile_file. */
1185 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1186 sdbout_symbol (decl, 0);
1190 /* Don't output any DWARF debugging information for variables here.
1191 In the case of local variables, the information for them is output
1192 when we do our recursive traversal of the tree representation for
1193 the entire containing function. In the case of file-scope variables,
1194 we output information for all of them at the very end of compilation
1195 while we are doing our final traversal of the chain of file-scope
1201 /* Normally no need to say anything here for external references,
1202 since assemble_external is called by the language-specific code
1203 when a declaration is first seen. */
1205 if (DECL_EXTERNAL (decl))
1208 /* Output no assembler code for a function declaration.
1209 Only definitions of functions output anything. */
1211 if (TREE_CODE (decl) == FUNCTION_DECL)
1214 /* If type was incomplete when the variable was declared,
1215 see if it is complete now. */
1217 if (DECL_SIZE (decl) == 0)
1218 layout_decl (decl, 0);
1220 /* Still incomplete => don't allocate it; treat the tentative defn
1221 (which is what it must have been) as an `extern' reference. */
1223 if (!dont_output_data && DECL_SIZE (decl) == 0)
1225 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1226 DECL_SOURCE_LINE (decl),
1227 "storage size of `%s' isn't known",
1228 IDENTIFIER_POINTER (DECL_NAME (decl)));
1229 TREE_ASM_WRITTEN (decl) = 1;
1233 /* The first declaration of a variable that comes through this function
1234 decides whether it is global (in C, has external linkage)
1235 or local (in C, has internal linkage). So do nothing more
1236 if this function has already run. */
1238 if (TREE_ASM_WRITTEN (decl))
1241 TREE_ASM_WRITTEN (decl) = 1;
1245 if (! dont_output_data)
1247 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
1250 /* This is better than explicit arithmetic, since it avoids overflow. */
1251 size_tree = size_binop (CEIL_DIV_EXPR,
1252 DECL_SIZE (decl), size_int (BITS_PER_UNIT));
1254 if (TREE_INT_CST_HIGH (size_tree) != 0)
1256 error_with_decl (decl, "size of variable `%s' is too large");
1261 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1263 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1264 && ! first_global_object_name
1265 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1266 || DECL_INITIAL (decl) == error_mark_node))
1267 && ! DECL_WEAK (decl)
1268 && ! DECL_ONE_ONLY (decl))
1272 STRIP_NAME_ENCODING (p, name);
1273 first_global_object_name = permalloc (strlen (p) + 1);
1274 strcpy (first_global_object_name, p);
1277 /* Handle uninitialized definitions. */
1279 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1280 /* If the target can't output uninitialized but not common global data
1281 in .bss, then we have to use .data. */
1282 #if ! defined (ASM_OUTPUT_BSS) && ! defined (ASM_OUTPUT_ALIGNED_BSS)
1283 && DECL_COMMON (decl)
1285 && ! dont_output_data)
1287 int size = TREE_INT_CST_LOW (size_tree);
1290 /* Don't allocate zero bytes of common,
1291 since that means "undefined external" in the linker. */
1292 if (size == 0) rounded = 1;
1293 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1294 so that each uninitialized object starts on such a boundary. */
1295 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1296 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1297 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1299 #ifdef DBX_DEBUGGING_INFO
1300 /* File-scope global variables are output here. */
1301 if (write_symbols == DBX_DEBUG && top_level)
1302 dbxout_symbol (decl, 0);
1304 #ifdef SDB_DEBUGGING_INFO
1305 if (write_symbols == SDB_DEBUG && top_level
1306 /* Leave initialized global vars for end of compilation;
1307 see comment in compile_file. */
1308 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1309 sdbout_symbol (decl, 0);
1312 /* Don't output any DWARF debugging information for variables here.
1313 In the case of local variables, the information for them is output
1314 when we do our recursive traversal of the tree representation for
1315 the entire containing function. In the case of file-scope variables,
1316 we output information for all of them at the very end of compilation
1317 while we are doing our final traversal of the chain of file-scope
1320 #if 0 /* ??? We should either delete this or add a comment describing what
1321 it was intended to do and why we shouldn't delete it. */
1322 if (flag_shared_data)
1326 if (TREE_PUBLIC (decl)
1327 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1328 && DECL_COMMON (decl)
1332 #ifdef ASM_OUTPUT_SHARED_COMMON
1333 if (flag_shared_data)
1334 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1337 if (output_bytecode)
1339 BC_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1343 #ifdef ASM_OUTPUT_ALIGNED_COMMON
1344 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
1347 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1351 #if defined (ASM_OUTPUT_BSS) || defined (ASM_OUTPUT_ALIGNED_BSS)
1352 else if (TREE_PUBLIC (decl))
1354 #ifdef ASM_OUTPUT_SHARED_BSS
1355 if (flag_shared_data)
1356 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1359 if (output_bytecode)
1361 BC_OUTPUT_BSS (asm_out_file, name, size, rounded);
1365 #ifdef ASM_OUTPUT_ALIGNED_BSS
1366 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size,
1369 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded);
1373 #endif /* ASM_OUTPUT_BSS || ASM_OUTPUT_ALIGNED_BSS */
1376 #ifdef ASM_OUTPUT_SHARED_LOCAL
1377 if (flag_shared_data)
1378 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1381 if (output_bytecode)
1383 BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1387 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1388 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
1391 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1398 /* Handle initialized definitions.
1399 Also handle uninitialized global definitions if -fno-common and the
1400 target doesn't support ASM_OUTPUT_BSS. */
1402 /* First make the assembler name(s) global if appropriate. */
1403 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1405 #ifdef ASM_WEAKEN_LABEL
1406 if (DECL_WEAK (decl))
1407 ASM_WEAKEN_LABEL (asm_out_file, name);
1410 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1413 for (d = equivalents; d; d = TREE_CHAIN (d))
1415 tree e = TREE_VALUE (d);
1416 if (TREE_PUBLIC (e) && DECL_NAME (e))
1417 ASM_GLOBALIZE_LABEL (asm_out_file,
1418 XSTR (XEXP (DECL_RTL (e), 0), 0));
1422 /* Output any data that we will need to use the address of. */
1423 if (DECL_INITIAL (decl) == error_mark_node)
1424 reloc = contains_pointers_p (TREE_TYPE (decl));
1425 else if (DECL_INITIAL (decl))
1426 reloc = output_addressed_constants (DECL_INITIAL (decl));
1428 /* Switch to the appropriate section. */
1429 variable_section (decl, reloc);
1431 /* dbxout.c needs to know this. */
1432 if (in_text_section ())
1433 DECL_IN_TEXT_SECTION (decl) = 1;
1435 /* Record current section so we can restore it if dbxout.c clobbers it. */
1436 saved_in_section = in_section;
1438 /* Output the dbx info now that we have chosen the section. */
1440 #ifdef DBX_DEBUGGING_INFO
1441 /* File-scope global variables are output here. */
1442 if (write_symbols == DBX_DEBUG && top_level)
1443 dbxout_symbol (decl, 0);
1445 #ifdef SDB_DEBUGGING_INFO
1446 if (write_symbols == SDB_DEBUG && top_level
1447 /* Leave initialized global vars for end of compilation;
1448 see comment in compile_file. */
1449 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1450 sdbout_symbol (decl, 0);
1453 /* Don't output any DWARF debugging information for variables here.
1454 In the case of local variables, the information for them is output
1455 when we do our recursive traversal of the tree representation for
1456 the entire containing function. In the case of file-scope variables,
1457 we output information for all of them at the very end of compilation
1458 while we are doing our final traversal of the chain of file-scope
1461 /* If the debugging output changed sections, reselect the section
1462 that's supposed to be selected. */
1463 if (in_section != saved_in_section)
1464 variable_section (decl, reloc);
1466 /* Compute and output the alignment of this data. */
1468 align = DECL_ALIGN (decl);
1469 /* In the case for initialing an array whose length isn't specified,
1470 where we have not yet been able to do the layout,
1471 figure out the proper alignment now. */
1472 if (dont_output_data && DECL_SIZE (decl) == 0
1473 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1474 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1476 /* Some object file formats have a maximum alignment which they support.
1477 In particular, a.out format supports a maximum alignment of 4. */
1478 #ifndef MAX_OFILE_ALIGNMENT
1479 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1481 if (align > MAX_OFILE_ALIGNMENT)
1483 warning_with_decl (decl,
1484 "alignment of `%s' is greater than maximum object file alignment");
1485 align = MAX_OFILE_ALIGNMENT;
1487 #ifdef DATA_ALIGNMENT
1488 /* On some machines, it is good to increase alignment sometimes. */
1489 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1491 #ifdef CONSTANT_ALIGNMENT
1492 if (DECL_INITIAL (decl))
1493 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1496 /* Reset the alignment in case we have made it tighter, so we can benefit
1497 from it in get_pointer_alignment. */
1498 DECL_ALIGN (decl) = align;
1500 if (align > BITS_PER_UNIT)
1502 if (output_bytecode)
1503 BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1505 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1508 /* Do any machine/system dependent processing of the object. */
1509 if (output_bytecode)
1510 BC_OUTPUT_LABEL (asm_out_file, name);
1513 #ifdef ASM_DECLARE_OBJECT_NAME
1514 last_assemble_variable_decl = decl;
1515 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1517 /* Standard thing is just output label for the object. */
1518 ASM_OUTPUT_LABEL (asm_out_file, name);
1519 #endif /* ASM_DECLARE_OBJECT_NAME */
1522 if (!dont_output_data)
1524 if (DECL_INITIAL (decl))
1525 /* Output the actual data. */
1526 output_constant (DECL_INITIAL (decl), TREE_INT_CST_LOW (size_tree));
1528 /* Leave space for it. */
1529 assemble_zeros (TREE_INT_CST_LOW (size_tree));
1533 #ifdef XCOFF_DEBUGGING_INFO
1534 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1535 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1536 and `aa' hasn't been output yet, the assembler generates a stab entry with
1537 a value of zero, in addition to creating an unnecessary external entry
1538 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1540 /* File-scope global variables are output here. */
1541 if (write_symbols == XCOFF_DEBUG && top_level)
1543 saved_in_section = in_section;
1545 dbxout_symbol (decl, 0);
1547 if (in_section != saved_in_section)
1548 variable_section (decl, reloc);
1551 /* There must be a statement after a label. */
1556 /* Return 1 if type TYPE contains any pointers. */
1559 contains_pointers_p (type)
1562 switch (TREE_CODE (type))
1565 case REFERENCE_TYPE:
1566 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1567 so I'll play safe and return 1. */
1573 case QUAL_UNION_TYPE:
1576 /* For a type that has fields, see if the fields have pointers. */
1577 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1578 if (TREE_CODE (fields) == FIELD_DECL
1579 && contains_pointers_p (TREE_TYPE (fields)))
1585 /* An array type contains pointers if its element type does. */
1586 return contains_pointers_p (TREE_TYPE (type));
1593 /* Output text storage for constructor CONSTR. */
1596 bc_output_constructor (constr, size)
1602 /* Must always be a literal; non-literal constructors are handled
1605 if (!TREE_CONSTANT (constr))
1612 for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++)
1616 BC_OUTPUT_ALIGN (asm_out_file, i);
1619 output_constant (constr, size);
1622 /* Create storage for constructor CONSTR. */
1625 bc_output_data_constructor (constr)
1630 /* Put in data section */
1634 for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1636 BC_OUTPUT_ALIGN (asm_out_file, i);
1638 /* The constructor is filled in at runtime. */
1639 BC_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (constr)));
1642 /* Output something to declare an external symbol to the assembler.
1643 (Most assemblers don't need this, so we normally output nothing.)
1644 Do nothing if DECL is not external. */
1647 assemble_external (decl)
1650 if (output_bytecode)
1653 #ifdef ASM_OUTPUT_EXTERNAL
1654 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1655 && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1657 rtx rtl = DECL_RTL (decl);
1659 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1660 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1662 /* Some systems do require some output. */
1663 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1664 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1670 /* Similar, for calling a library function FUN. */
1673 assemble_external_libcall (fun)
1676 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1677 if (!output_bytecode)
1679 /* Declare library function name external when first used, if nec. */
1680 if (! SYMBOL_REF_USED (fun))
1682 SYMBOL_REF_USED (fun) = 1;
1683 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1689 /* Declare the label NAME global. */
1692 assemble_global (name)
1695 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1698 /* Assemble a label named NAME. */
1701 assemble_label (name)
1704 if (output_bytecode)
1705 BC_OUTPUT_LABEL (asm_out_file, name);
1707 ASM_OUTPUT_LABEL (asm_out_file, name);
1710 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1711 If NAME starts with a *, the rest of NAME is output verbatim.
1712 Otherwise NAME is transformed in an implementation-defined way
1713 (usually by the addition of an underscore).
1714 Many macros in the tm file are defined to call this function. */
1717 assemble_name (file, name)
1722 int save_warn_id_clash = warn_id_clash;
1724 STRIP_NAME_ENCODING (real_name, name);
1726 /* Don't warn about an identifier name length clash on this name, since
1727 it can be a user symbol suffixed by a number. */
1729 TREE_SYMBOL_REFERENCED (get_identifier (real_name)) = 1;
1730 warn_id_clash = save_warn_id_clash;
1734 if (output_bytecode)
1735 bc_emit_labelref (name, 0);
1737 fputs (&name[1], file);
1741 if (output_bytecode)
1742 BC_OUTPUT_LABELREF (file, name);
1744 ASM_OUTPUT_LABELREF (file, name);
1748 /* Allocate SIZE bytes writable static space with a gensym name
1749 and return an RTX to refer to its address. */
1752 assemble_static_space (size)
1758 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1759 so that each uninitialized object starts on such a boundary. */
1760 int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1761 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1762 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1765 if (flag_shared_data)
1769 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1772 namestring = (char *) obstack_alloc (saveable_obstack,
1774 strcpy (namestring, name);
1776 if (output_bytecode)
1777 x = bc_gen_rtx (namestring, 0, (struct bc_label *) 0);
1779 x = gen_rtx (SYMBOL_REF, Pmode, namestring);
1781 if (output_bytecode)
1783 BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1787 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1788 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1790 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1796 /* Assemble the static constant template for function entry trampolines.
1797 This is done at most once per compilation.
1798 Returns an RTX for the address of the template. */
1800 #ifdef TRAMPOLINE_TEMPLATE
1802 assemble_trampoline_template ()
1808 /* Shouldn't get here */
1809 if (output_bytecode)
1812 /* By default, put trampoline templates in read-only data section. */
1814 #ifdef TRAMPOLINE_SECTION
1815 TRAMPOLINE_SECTION ();
1817 readonly_data_section ();
1820 /* Write the assembler code to define one. */
1821 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1823 ASM_OUTPUT_ALIGN (asm_out_file, align);
1825 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1826 TRAMPOLINE_TEMPLATE (asm_out_file);
1828 /* Record the rtl to refer to it. */
1829 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1831 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1832 return gen_rtx (SYMBOL_REF, Pmode, name);
1836 /* Assemble the integer constant X into an object of SIZE bytes.
1837 X must be either a CONST_INT or CONST_DOUBLE.
1839 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1840 non-zero, abort if we can't output the constant. */
1843 assemble_integer (x, size, force)
1848 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1849 ASM_OUTPUT... macros. */
1853 #ifdef ASM_OUTPUT_CHAR
1855 ASM_OUTPUT_CHAR (asm_out_file, x);
1859 #ifdef ASM_OUTPUT_SHORT
1861 ASM_OUTPUT_SHORT (asm_out_file, x);
1865 #ifdef ASM_OUTPUT_INT
1867 ASM_OUTPUT_INT (asm_out_file, x);
1871 #ifdef ASM_OUTPUT_DOUBLE_INT
1873 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1877 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1879 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1884 /* If we couldn't do it that way, there are two other possibilities: First,
1885 if the machine can output an explicit byte and this is a 1 byte constant,
1886 we can use ASM_OUTPUT_BYTE. */
1888 #ifdef ASM_OUTPUT_BYTE
1889 if (size == 1 && GET_CODE (x) == CONST_INT)
1891 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1896 /* Finally, if SIZE is larger than a single word, try to output the constant
1897 one word at a time. */
1899 if (size > UNITS_PER_WORD)
1902 enum machine_mode mode
1903 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1906 for (i = 0; i < size / UNITS_PER_WORD; i++)
1908 word = operand_subword (x, i, 0, mode);
1913 if (! assemble_integer (word, UNITS_PER_WORD, 0))
1917 if (i == size / UNITS_PER_WORD)
1919 /* If we output at least one word and then could not finish,
1920 there is no valid way to continue. */
1931 /* Assemble the floating-point constant D into an object of size MODE. */
1934 assemble_real (d, mode)
1936 enum machine_mode mode;
1938 jmp_buf output_constant_handler;
1940 if (setjmp (output_constant_handler))
1942 error ("floating point trap outputting a constant");
1943 #ifdef REAL_IS_NOT_DOUBLE
1944 bzero ((char *) &d, sizeof d);
1951 set_float_handler (output_constant_handler);
1955 #ifdef ASM_OUTPUT_BYTE_FLOAT
1957 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1960 #ifdef ASM_OUTPUT_SHORT_FLOAT
1962 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1965 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1967 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
1970 #ifdef ASM_OUTPUT_FLOAT
1972 ASM_OUTPUT_FLOAT (asm_out_file, d);
1976 #ifdef ASM_OUTPUT_DOUBLE
1978 ASM_OUTPUT_DOUBLE (asm_out_file, d);
1982 #ifdef ASM_OUTPUT_LONG_DOUBLE
1985 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1993 set_float_handler (NULL_PTR);
1996 /* Here we combine duplicate floating constants to make
1997 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1999 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
2000 They are chained through the CONST_DOUBLE_CHAIN.
2001 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
2002 In that case, CONST_DOUBLE_MEM is either a MEM,
2003 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.
2005 (CONST_DOUBLE_MEM is used only for top-level functions.
2006 See force_const_mem for explanation.) */
2008 static rtx const_double_chain;
2010 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
2011 For an integer, I0 is the low-order word and I1 is the high-order word.
2012 For a real number, I0 is the word with the low address
2013 and I1 is the word with the high address. */
2016 immed_double_const (i0, i1, mode)
2017 HOST_WIDE_INT i0, i1;
2018 enum machine_mode mode;
2021 int in_current_obstack;
2023 if (GET_MODE_CLASS (mode) == MODE_INT
2024 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
2026 /* We clear out all bits that don't belong in MODE, unless they and our
2027 sign bit are all one. So we get either a reasonable negative value
2028 or a reasonable unsigned value for this mode. */
2029 int width = GET_MODE_BITSIZE (mode);
2030 if (width < HOST_BITS_PER_WIDE_INT
2031 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
2032 != ((HOST_WIDE_INT) (-1) << (width - 1))))
2033 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
2034 else if (width == HOST_BITS_PER_WIDE_INT
2035 && ! (i1 == ~0 && i0 < 0))
2037 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
2038 /* We cannot represent this value as a constant. */
2041 /* If this would be an entire word for the target, but is not for
2042 the host, then sign-extend on the host so that the number will look
2043 the same way on the host that it would on the target.
2045 For example, when building a 64 bit alpha hosted 32 bit sparc
2046 targeted compiler, then we want the 32 bit unsigned value -1 to be
2047 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
2048 The later confuses the sparc backend. */
2050 if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
2051 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
2052 i0 |= ((HOST_WIDE_INT) (-1) << width);
2054 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2056 ??? Strictly speaking, this is wrong if we create a CONST_INT
2057 for a large unsigned constant with the size of MODE being
2058 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2059 wider mode. In that case we will mis-interpret it as a negative
2062 Unfortunately, the only alternative is to make a CONST_DOUBLE
2063 for any constant in any mode if it is an unsigned constant larger
2064 than the maximum signed integer in an int on the host. However,
2065 doing this will break everyone that always expects to see a CONST_INT
2066 for SImode and smaller.
2068 We have always been making CONST_INTs in this case, so nothing new
2071 if (width <= HOST_BITS_PER_WIDE_INT)
2072 i1 = (i0 < 0) ? ~0 : 0;
2074 /* If this integer fits in one word, return a CONST_INT. */
2075 if ((i1 == 0 && i0 >= 0)
2076 || (i1 == ~0 && i0 < 0))
2077 return GEN_INT (i0);
2079 /* We use VOIDmode for integers. */
2083 /* Search the chain for an existing CONST_DOUBLE with the right value.
2084 If one is found, return it. */
2086 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2087 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2088 && GET_MODE (r) == mode)
2091 /* No; make a new one and add it to the chain.
2093 We may be called by an optimizer which may be discarding any memory
2094 allocated during its processing (such as combine and loop). However,
2095 we will be leaving this constant on the chain, so we cannot tolerate
2096 freed memory. So switch to saveable_obstack for this allocation
2097 and then switch back if we were in current_obstack. */
2099 push_obstacks_nochange ();
2100 rtl_in_saveable_obstack ();
2101 r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
2104 /* Don't touch const_double_chain in nested function; see force_const_mem.
2105 Also, don't touch it if not inside any function. */
2106 if (outer_function_chain == 0 && current_function_decl != 0)
2108 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2109 const_double_chain = r;
2112 /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
2113 Actual use of mem-slot is only through force_const_mem. */
2115 CONST_DOUBLE_MEM (r) = const0_rtx;
2120 /* Return a CONST_DOUBLE for a specified `double' value
2121 and machine mode. */
2124 immed_real_const_1 (d, mode)
2126 enum machine_mode mode;
2128 union real_extract u;
2130 int in_current_obstack;
2132 /* Get the desired `double' value as a sequence of ints
2133 since that is how they are stored in a CONST_DOUBLE. */
2137 /* Detect special cases. */
2139 /* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero. */
2140 if (!bcmp ((char *) &dconst0, (char *) &d, sizeof d))
2141 return CONST0_RTX (mode);
2142 /* Check for NaN first, because some ports (specifically the i386) do not
2143 emit correct ieee-fp code by default, and thus will generate a core
2144 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2145 does a floating point comparison. */
2146 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2147 return CONST1_RTX (mode);
2149 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2150 return immed_double_const (u.i[0], u.i[1], mode);
2152 /* The rest of this function handles the case where
2153 a float value requires more than 2 ints of space.
2154 It will be deleted as dead code on machines that don't need it. */
2156 /* Search the chain for an existing CONST_DOUBLE with the right value.
2157 If one is found, return it. */
2159 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2160 if (! bcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2161 && GET_MODE (r) == mode)
2164 /* No; make a new one and add it to the chain.
2166 We may be called by an optimizer which may be discarding any memory
2167 allocated during its processing (such as combine and loop). However,
2168 we will be leaving this constant on the chain, so we cannot tolerate
2169 freed memory. So switch to saveable_obstack for this allocation
2170 and then switch back if we were in current_obstack. */
2172 push_obstacks_nochange ();
2173 rtl_in_saveable_obstack ();
2174 r = rtx_alloc (CONST_DOUBLE);
2176 bcopy ((char *) &u, (char *) &CONST_DOUBLE_LOW (r), sizeof u);
2179 /* Don't touch const_double_chain in nested function; see force_const_mem.
2180 Also, don't touch it if not inside any function. */
2181 if (outer_function_chain == 0 && current_function_decl != 0)
2183 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2184 const_double_chain = r;
2187 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2188 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2189 is only through force_const_mem. */
2191 CONST_DOUBLE_MEM (r) = const0_rtx;
2196 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2197 which must be a REAL_CST tree node. */
2200 immed_real_const (exp)
2203 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2206 /* At the end of a function, forget the memory-constants
2207 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2208 Also clear out real_constant_chain and clear out all the chain-pointers. */
2211 clear_const_double_mem ()
2213 register rtx r, next;
2215 /* Don't touch CONST_DOUBLE_MEM for nested functions.
2216 See force_const_mem for explanation. */
2217 if (outer_function_chain != 0)
2220 for (r = const_double_chain; r; r = next)
2222 next = CONST_DOUBLE_CHAIN (r);
2223 CONST_DOUBLE_CHAIN (r) = 0;
2224 CONST_DOUBLE_MEM (r) = cc0_rtx;
2226 const_double_chain = 0;
2229 /* Given an expression EXP with a constant value,
2230 reduce it to the sum of an assembler symbol and an integer.
2231 Store them both in the structure *VALUE.
2232 Abort if EXP does not reduce. */
2237 HOST_WIDE_INT offset;
2241 decode_addr_const (exp, value)
2243 struct addr_const *value;
2245 register tree target = TREE_OPERAND (exp, 0);
2246 register int offset = 0;
2251 if (TREE_CODE (target) == COMPONENT_REF
2252 && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
2255 offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
2256 target = TREE_OPERAND (target, 0);
2258 else if (TREE_CODE (target) == ARRAY_REF)
2260 if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
2261 || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
2263 offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
2264 * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
2266 target = TREE_OPERAND (target, 0);
2272 switch (TREE_CODE (target))
2276 x = DECL_RTL (target);
2280 if (output_bytecode)
2281 /* FIXME: this may not be correct, check it */
2282 x = bc_gen_rtx (TREE_STRING_POINTER (target), 0, (struct bc_label *) 0);
2284 x = gen_rtx (MEM, FUNCTION_MODE,
2285 gen_rtx (LABEL_REF, VOIDmode,
2286 label_rtx (TREE_OPERAND (exp, 0))));
2294 x = TREE_CST_RTL (target);
2301 if (!output_bytecode)
2303 if (GET_CODE (x) != MEM)
2309 value->offset = offset;
2312 /* Uniquize all constants that appear in memory.
2313 Each constant in memory thus far output is recorded
2314 in `const_hash_table' with a `struct constant_descriptor'
2315 that contains a polish representation of the value of
2318 We cannot store the trees in the hash table
2319 because the trees may be temporary. */
2321 struct constant_descriptor
2323 struct constant_descriptor *next;
2329 #define MAX_HASH_TABLE 1009
2330 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2332 /* Compute a hash code for a constant expression. */
2339 register int len, hi, i;
2340 register enum tree_code code = TREE_CODE (exp);
2342 if (code == INTEGER_CST)
2344 p = (char *) &TREE_INT_CST_LOW (exp);
2345 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2347 else if (code == REAL_CST)
2349 p = (char *) &TREE_REAL_CST (exp);
2350 len = sizeof TREE_REAL_CST (exp);
2352 else if (code == STRING_CST)
2353 p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
2354 else if (code == COMPLEX_CST)
2355 return const_hash (TREE_REALPART (exp)) * 5
2356 + const_hash (TREE_IMAGPART (exp));
2357 else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2359 len = int_size_in_bytes (TREE_TYPE (exp));
2360 p = (char *) alloca (len);
2361 get_set_constructor_bytes (exp, (unsigned char *) p, len);
2363 else if (code == CONSTRUCTOR)
2367 /* For record type, include the type in the hashing.
2368 We do not do so for array types
2369 because (1) the sizes of the elements are sufficient
2370 and (2) distinct array types can have the same constructor.
2371 Instead, we include the array size because the constructor could
2373 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2374 hi = ((HOST_WIDE_INT) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2377 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2378 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2380 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2381 if (TREE_VALUE (link))
2382 hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2386 else if (code == ADDR_EXPR)
2388 struct addr_const value;
2389 decode_addr_const (exp, &value);
2390 if (GET_CODE (value.base) == SYMBOL_REF)
2392 /* Don't hash the address of the SYMBOL_REF;
2393 only use the offset and the symbol name. */
2395 p = XSTR (value.base, 0);
2396 for (i = 0; p[i] != 0; i++)
2397 hi = ((hi * 613) + (unsigned) (p[i]));
2399 else if (GET_CODE (value.base) == LABEL_REF)
2400 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2402 hi &= (1 << HASHBITS) - 1;
2403 hi %= MAX_HASH_TABLE;
2406 else if (code == PLUS_EXPR || code == MINUS_EXPR)
2407 return const_hash (TREE_OPERAND (exp, 0)) * 9
2408 + const_hash (TREE_OPERAND (exp, 1));
2409 else if (code == NOP_EXPR || code == CONVERT_EXPR)
2410 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2412 /* Compute hashing function */
2414 for (i = 0; i < len; i++)
2415 hi = ((hi * 613) + (unsigned) (p[i]));
2417 hi &= (1 << HASHBITS) - 1;
2418 hi %= MAX_HASH_TABLE;
2422 /* Compare a constant expression EXP with a constant-descriptor DESC.
2423 Return 1 if DESC describes a constant with the same value as EXP. */
2426 compare_constant (exp, desc)
2428 struct constant_descriptor *desc;
2430 return 0 != compare_constant_1 (exp, desc->contents);
2433 /* Compare constant expression EXP with a substring P of a constant descriptor.
2434 If they match, return a pointer to the end of the substring matched.
2435 If they do not match, return 0.
2437 Since descriptors are written in polish prefix notation,
2438 this function can be used recursively to test one operand of EXP
2439 against a subdescriptor, and if it succeeds it returns the
2440 address of the subdescriptor for the next operand. */
2443 compare_constant_1 (exp, p)
2447 register char *strp;
2449 register enum tree_code code = TREE_CODE (exp);
2451 if (code != (enum tree_code) *p++)
2454 if (code == INTEGER_CST)
2456 /* Integer constants are the same only if the same width of type. */
2457 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2459 strp = (char *) &TREE_INT_CST_LOW (exp);
2460 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2462 else if (code == REAL_CST)
2464 /* Real constants are the same only if the same width of type. */
2465 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2467 strp = (char *) &TREE_REAL_CST (exp);
2468 len = sizeof TREE_REAL_CST (exp);
2470 else if (code == STRING_CST)
2472 if (flag_writable_strings)
2474 strp = TREE_STRING_POINTER (exp);
2475 len = TREE_STRING_LENGTH (exp);
2476 if (bcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2477 sizeof TREE_STRING_LENGTH (exp)))
2479 p += sizeof TREE_STRING_LENGTH (exp);
2481 else if (code == COMPLEX_CST)
2483 p = compare_constant_1 (TREE_REALPART (exp), p);
2484 if (p == 0) return 0;
2485 p = compare_constant_1 (TREE_IMAGPART (exp), p);
2488 else if (code == CONSTRUCTOR && TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2490 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2491 strp = (char *) alloca (len);
2492 get_set_constructor_bytes (exp, (unsigned char *) strp, len);
2493 if (bcmp ((char *) &xlen, p, sizeof xlen))
2497 else if (code == CONSTRUCTOR)
2500 int length = list_length (CONSTRUCTOR_ELTS (exp));
2503 if (bcmp ((char *) &length, p, sizeof length))
2507 /* For record constructors, insist that the types match.
2508 For arrays, just verify both constructors are for arrays. */
2509 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2510 type = TREE_TYPE (exp);
2513 if (bcmp ((char *) &type, p, sizeof type))
2517 /* For arrays, insist that the size in bytes match. */
2518 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2520 int size = int_size_in_bytes (TREE_TYPE (exp));
2521 if (bcmp ((char *) &size, p, sizeof size))
2526 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2528 if (TREE_VALUE (link))
2530 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2537 if (bcmp ((char *) &zero, p, sizeof zero))
2545 else if (code == ADDR_EXPR)
2547 struct addr_const value;
2548 decode_addr_const (exp, &value);
2549 strp = (char *) &value.offset;
2550 len = sizeof value.offset;
2551 /* Compare the offset. */
2553 if (*p++ != *strp++)
2555 /* Compare symbol name. */
2556 strp = XSTR (value.base, 0);
2557 len = strlen (strp) + 1;
2559 else if (code == PLUS_EXPR || code == MINUS_EXPR)
2561 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2562 if (p == 0) return 0;
2563 p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
2566 else if (code == NOP_EXPR || code == CONVERT_EXPR)
2568 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2572 /* Compare constant contents. */
2574 if (*p++ != *strp++)
2580 /* Construct a constant descriptor for the expression EXP.
2581 It is up to the caller to enter the descriptor in the hash table. */
2583 static struct constant_descriptor *
2584 record_constant (exp)
2587 struct constant_descriptor *next = 0;
2590 /* Make a struct constant_descriptor. The first two pointers will
2591 be filled in later. Here we just leave space for them. */
2593 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2594 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2595 record_constant_1 (exp);
2596 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2599 /* Add a description of constant expression EXP
2600 to the object growing in `permanent_obstack'.
2601 No need to return its address; the caller will get that
2602 from the obstack when the object is complete. */
2605 record_constant_1 (exp)
2608 register char *strp;
2610 register enum tree_code code = TREE_CODE (exp);
2612 obstack_1grow (&permanent_obstack, (unsigned int) code);
2617 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2618 strp = (char *) &TREE_INT_CST_LOW (exp);
2619 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2623 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2624 strp = (char *) &TREE_REAL_CST (exp);
2625 len = sizeof TREE_REAL_CST (exp);
2629 if (flag_writable_strings)
2632 strp = TREE_STRING_POINTER (exp);
2633 len = TREE_STRING_LENGTH (exp);
2634 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2635 sizeof TREE_STRING_LENGTH (exp));
2639 record_constant_1 (TREE_REALPART (exp));
2640 record_constant_1 (TREE_IMAGPART (exp));
2644 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2646 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2647 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2648 obstack_blank (&permanent_obstack, nbytes);
2649 get_set_constructor_bytes
2650 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2657 int length = list_length (CONSTRUCTOR_ELTS (exp));
2660 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2662 /* For record constructors, insist that the types match.
2663 For arrays, just verify both constructors are for arrays. */
2664 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2665 type = TREE_TYPE (exp);
2668 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2670 /* For arrays, insist that the size in bytes match. */
2671 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2673 int size = int_size_in_bytes (TREE_TYPE (exp));
2674 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2677 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2679 if (TREE_VALUE (link))
2680 record_constant_1 (TREE_VALUE (link));
2685 obstack_grow (&permanent_obstack,
2686 (char *) &zero, sizeof zero);
2694 struct addr_const value;
2696 decode_addr_const (exp, &value);
2697 /* Record the offset. */
2698 obstack_grow (&permanent_obstack,
2699 (char *) &value.offset, sizeof value.offset);
2700 /* Record the symbol name. */
2701 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2702 strlen (XSTR (value.base, 0)) + 1);
2708 record_constant_1 (TREE_OPERAND (exp, 0));
2709 record_constant_1 (TREE_OPERAND (exp, 1));
2714 case NON_LVALUE_EXPR:
2715 record_constant_1 (TREE_OPERAND (exp, 0));
2722 /* Record constant contents. */
2723 obstack_grow (&permanent_obstack, strp, len);
2726 /* Record a list of constant expressions that were passed to
2727 output_constant_def but that could not be output right away. */
2729 struct deferred_constant
2731 struct deferred_constant *next;
2737 static struct deferred_constant *deferred_constants;
2739 /* Nonzero means defer output of addressed subconstants
2740 (i.e., those for which output_constant_def is called.) */
2741 static int defer_addressed_constants_flag;
2743 /* Start deferring output of subconstants. */
2746 defer_addressed_constants ()
2748 defer_addressed_constants_flag++;
2751 /* Stop deferring output of subconstants,
2752 and output now all those that have been deferred. */
2755 output_deferred_addressed_constants ()
2757 struct deferred_constant *p, *next;
2759 defer_addressed_constants_flag--;
2761 if (defer_addressed_constants_flag > 0)
2764 for (p = deferred_constants; p; p = next)
2766 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2771 deferred_constants = 0;
2774 /* Make a copy of the whole tree structure for a constant.
2775 This handles the same types of nodes that compare_constant
2776 and record_constant handle. */
2782 switch (TREE_CODE (exp))
2785 /* For ADDR_EXPR, we do not want to copy the decl whose address
2786 is requested. We do want to copy constants though. */
2787 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
2788 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2789 copy_constant (TREE_OPERAND (exp, 0)));
2791 return copy_node (exp);
2796 return copy_node (exp);
2799 return build_complex (TREE_TYPE (exp),
2800 copy_constant (TREE_REALPART (exp)),
2801 copy_constant (TREE_IMAGPART (exp)));
2805 return build (TREE_CODE (exp), TREE_TYPE (exp),
2806 copy_constant (TREE_OPERAND (exp, 0)),
2807 copy_constant (TREE_OPERAND (exp, 1)));
2811 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2812 copy_constant (TREE_OPERAND (exp, 0)));
2816 tree copy = copy_node (exp);
2817 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
2820 CONSTRUCTOR_ELTS (copy) = list;
2821 for (tail = list; tail; tail = TREE_CHAIN (tail))
2822 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
2823 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2824 for (tail = list; tail; tail = TREE_CHAIN (tail))
2825 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
2835 /* Return an rtx representing a reference to constant data in memory
2836 for the constant expression EXP.
2838 If assembler code for such a constant has already been output,
2839 return an rtx to refer to it.
2840 Otherwise, output such a constant in memory (or defer it for later)
2841 and generate an rtx for it.
2843 The TREE_CST_RTL of EXP is set up to point to that rtx.
2844 The const_hash_table records which constants already have label strings. */
2847 output_constant_def (exp)
2851 register struct constant_descriptor *desc;
2857 if (TREE_CST_RTL (exp))
2858 return TREE_CST_RTL (exp);
2860 /* Make sure any other constants whose addresses appear in EXP
2861 are assigned label numbers. */
2863 reloc = output_addressed_constants (exp);
2865 /* Compute hash code of EXP. Search the descriptors for that hash code
2866 to see if any of them describes EXP. If yes, the descriptor records
2867 the label number already assigned. */
2869 hash = const_hash (exp) % MAX_HASH_TABLE;
2871 for (desc = const_hash_table[hash]; desc; desc = desc->next)
2872 if (compare_constant (exp, desc))
2874 found = desc->label;
2880 /* No constant equal to EXP is known to have been output.
2881 Make a constant descriptor to enter EXP in the hash table.
2882 Assign the label number and record it in the descriptor for
2883 future calls to this function to find. */
2885 /* Create a string containing the label name, in LABEL. */
2886 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2888 desc = record_constant (exp);
2889 desc->next = const_hash_table[hash];
2891 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
2892 const_hash_table[hash] = desc;
2896 /* Create a string containing the label name, in LABEL. */
2897 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2900 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2902 push_obstacks_nochange ();
2903 if (TREE_PERMANENT (exp))
2904 end_temporary_allocation ();
2906 def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
2909 = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
2910 RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
2911 if (AGGREGATE_TYPE_P (TREE_TYPE (exp)))
2912 MEM_IN_STRUCT_P (TREE_CST_RTL (exp)) = 1;
2916 /* Optionally set flags or add text to the name to record information
2917 such as that it is a function name. If the name is changed, the macro
2918 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
2919 #ifdef ENCODE_SECTION_INFO
2920 ENCODE_SECTION_INFO (exp);
2923 /* If this is the first time we've seen this particular constant,
2924 output it (or defer its output for later). */
2927 if (defer_addressed_constants_flag)
2929 struct deferred_constant *p;
2930 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
2932 push_obstacks_nochange ();
2933 suspend_momentary ();
2934 p->exp = copy_constant (exp);
2937 p->labelno = const_labelno++;
2938 p->next = deferred_constants;
2939 deferred_constants = p;
2942 output_constant_def_contents (exp, reloc, const_labelno++);
2945 return TREE_CST_RTL (exp);
2948 /* Now output assembler code to define the label for EXP,
2949 and follow it with the data of EXP. */
2952 output_constant_def_contents (exp, reloc, labelno)
2959 if (IN_NAMED_SECTION (exp))
2960 named_section (exp, NULL);
2963 /* First switch to text section, except for writable strings. */
2964 #ifdef SELECT_SECTION
2965 SELECT_SECTION (exp, reloc);
2967 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
2968 || (flag_pic && reloc))
2971 readonly_data_section ();
2975 /* Align the location counter as required by EXP's data type. */
2976 align = TYPE_ALIGN (TREE_TYPE (exp));
2977 #ifdef CONSTANT_ALIGNMENT
2978 align = CONSTANT_ALIGNMENT (exp, align);
2981 if (align > BITS_PER_UNIT)
2983 if (!output_bytecode)
2985 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2989 BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2993 /* Output the label itself. */
2994 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
2996 /* Output the value of EXP. */
2997 output_constant (exp,
2998 (TREE_CODE (exp) == STRING_CST
2999 ? TREE_STRING_LENGTH (exp)
3000 : int_size_in_bytes (TREE_TYPE (exp))));
3004 /* Similar hash facility for making memory-constants
3005 from constant rtl-expressions. It is used on RISC machines
3006 where immediate integer arguments and constant addresses are restricted
3007 so that such constants must be stored in memory.
3009 This pool of constants is reinitialized for each function
3010 so each function gets its own constants-pool that comes right before it.
3012 All structures allocated here are discarded when functions are saved for
3013 inlining, so they do not need to be allocated permanently. */
3015 #define MAX_RTX_HASH_TABLE 61
3016 static struct constant_descriptor **const_rtx_hash_table;
3018 /* Structure to represent sufficient information about a constant so that
3019 it can be output when the constant pool is output, so that function
3020 integration can be done, and to simplify handling on machines that reference
3021 constant pool as base+displacement. */
3023 struct pool_constant
3025 struct constant_descriptor *desc;
3026 struct pool_constant *next;
3027 enum machine_mode mode;
3034 /* Pointers to first and last constant in pool. */
3036 static struct pool_constant *first_pool, *last_pool;
3038 /* Current offset in constant pool (does not include any machine-specific
3041 static int pool_offset;
3043 /* Structure used to maintain hash table mapping symbols used to their
3044 corresponding constants. */
3049 struct pool_constant *pool;
3050 struct pool_sym *next;
3053 static struct pool_sym **const_rtx_sym_hash_table;
3055 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3056 The argument is XSTR (... , 0) */
3058 #define SYMHASH(LABEL) \
3059 ((((HOST_WIDE_INT) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3061 /* Initialize constant pool hashing for next function. */
3064 init_const_rtx_hash_table ()
3066 const_rtx_hash_table
3067 = ((struct constant_descriptor **)
3068 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
3069 const_rtx_sym_hash_table
3070 = ((struct pool_sym **)
3071 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
3072 bzero ((char *) const_rtx_hash_table,
3073 MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
3074 bzero ((char *) const_rtx_sym_hash_table,
3075 MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
3077 first_pool = last_pool = 0;
3081 /* Save and restore status for a nested function. */
3084 save_varasm_status (p)
3087 p->const_rtx_hash_table = const_rtx_hash_table;
3088 p->const_rtx_sym_hash_table = const_rtx_sym_hash_table;
3089 p->first_pool = first_pool;
3090 p->last_pool = last_pool;
3091 p->pool_offset = pool_offset;
3095 restore_varasm_status (p)
3098 const_rtx_hash_table = p->const_rtx_hash_table;
3099 const_rtx_sym_hash_table = p->const_rtx_sym_hash_table;
3100 first_pool = p->first_pool;
3101 last_pool = p->last_pool;
3102 pool_offset = p->pool_offset;
3105 enum kind { RTX_DOUBLE, RTX_INT };
3109 #ifdef ONLY_INT_FIELDS
3110 unsigned int kind : 16;
3111 unsigned int mode : 16;
3113 enum kind kind : 16;
3114 enum machine_mode mode : 16;
3117 union real_extract du;
3118 struct addr_const addr;
3119 struct {HOST_WIDE_INT high, low;} di;
3123 /* Express an rtx for a constant integer (perhaps symbolic)
3124 as the sum of a symbol or label plus an explicit integer.
3125 They are stored into VALUE. */
3128 decode_rtx_const (mode, x, value)
3129 enum machine_mode mode;
3131 struct rtx_const *value;
3133 /* Clear the whole structure, including any gaps. */
3136 int *p = (int *) value;
3137 int *end = (int *) (value + 1);
3142 value->kind = RTX_INT; /* Most usual kind. */
3145 switch (GET_CODE (x))
3148 value->kind = RTX_DOUBLE;
3149 if (GET_MODE (x) != VOIDmode)
3151 value->mode = GET_MODE (x);
3152 bcopy ((char *) &CONST_DOUBLE_LOW (x),
3153 (char *) &value->un.du, sizeof value->un.du);
3157 value->un.di.low = CONST_DOUBLE_LOW (x);
3158 value->un.di.high = CONST_DOUBLE_HIGH (x);
3163 value->un.addr.offset = INTVAL (x);
3169 value->un.addr.base = x;
3174 if (GET_CODE (x) == PLUS)
3176 value->un.addr.base = XEXP (x, 0);
3177 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3179 value->un.addr.offset = INTVAL (XEXP (x, 1));
3181 else if (GET_CODE (x) == MINUS)
3183 value->un.addr.base = XEXP (x, 0);
3184 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
3186 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3196 if (value->kind == RTX_INT && value->un.addr.base != 0)
3197 switch (GET_CODE (value->un.addr.base))
3201 /* Use the string's address, not the SYMBOL_REF's address,
3202 for the sake of addresses of library routines.
3203 For a LABEL_REF, compare labels. */
3204 value->un.addr.base = XEXP (value->un.addr.base, 0);
3208 /* Given a MINUS expression, simplify it if both sides
3209 include the same symbol. */
3212 simplify_subtraction (x)
3215 struct rtx_const val0, val1;
3217 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3218 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3220 if (val0.un.addr.base == val1.un.addr.base)
3221 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3225 /* Compute a hash code for a constant RTL expression. */
3228 const_hash_rtx (mode, x)
3229 enum machine_mode mode;
3234 struct rtx_const value;
3235 decode_rtx_const (mode, x, &value);
3237 /* Compute hashing function */
3239 for (i = 0; i < sizeof value / sizeof (int); i++)
3240 hi += ((int *) &value)[i];
3242 hi &= (1 << HASHBITS) - 1;
3243 hi %= MAX_RTX_HASH_TABLE;
3247 /* Compare a constant rtl object X with a constant-descriptor DESC.
3248 Return 1 if DESC describes a constant with the same value as X. */
3251 compare_constant_rtx (mode, x, desc)
3252 enum machine_mode mode;
3254 struct constant_descriptor *desc;
3256 register int *p = (int *) desc->contents;
3259 struct rtx_const value;
3261 decode_rtx_const (mode, x, &value);
3262 strp = (int *) &value;
3263 len = sizeof value / sizeof (int);
3265 /* Compare constant contents. */
3267 if (*p++ != *strp++)
3273 /* Construct a constant descriptor for the rtl-expression X.
3274 It is up to the caller to enter the descriptor in the hash table. */
3276 static struct constant_descriptor *
3277 record_constant_rtx (mode, x)
3278 enum machine_mode mode;
3281 struct constant_descriptor *ptr;
3283 struct rtx_const value;
3285 decode_rtx_const (mode, x, &value);
3287 /* Put these things in the saveable obstack so we can ensure it won't
3288 be freed if we are called from combine or some other phase that discards
3289 memory allocated from function_obstack (current_obstack). */
3290 obstack_grow (saveable_obstack, &ptr, sizeof ptr);
3291 obstack_grow (saveable_obstack, &label, sizeof label);
3293 /* Record constant contents. */
3294 obstack_grow (saveable_obstack, &value, sizeof value);
3296 return (struct constant_descriptor *) obstack_finish (saveable_obstack);
3299 /* Given a constant rtx X, make (or find) a memory constant for its value
3300 and return a MEM rtx to refer to it in memory. */
3303 force_const_mem (mode, x)
3304 enum machine_mode mode;
3308 register struct constant_descriptor *desc;
3313 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3314 (this will always be true for floating CONST_DOUBLEs that have been
3315 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3316 use the previous copy. Otherwise, make a new one. Note that in
3317 the unlikely event that this same CONST_DOUBLE is used in two different
3318 modes in an alternating fashion, we will allocate a lot of different
3319 memory locations, but this should be extremely rare. */
3321 /* Don't use CONST_DOUBLE_MEM in a nested function.
3322 Nested functions have their own constant pools,
3323 so they can't share the same values in CONST_DOUBLE_MEM
3324 with the containing function. */
3325 if (outer_function_chain == 0)
3326 if (GET_CODE (x) == CONST_DOUBLE
3327 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3328 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3329 return CONST_DOUBLE_MEM (x);
3331 /* Compute hash code of X. Search the descriptors for that hash code
3332 to see if any of them describes X. If yes, the descriptor records
3333 the label number already assigned. */
3335 hash = const_hash_rtx (mode, x);
3337 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3338 if (compare_constant_rtx (mode, x, desc))
3340 found = desc->label;
3346 register struct pool_constant *pool;
3347 register struct pool_sym *sym;
3350 /* No constant equal to X is known to have been output.
3351 Make a constant descriptor to enter X in the hash table.
3352 Assign the label number and record it in the descriptor for
3353 future calls to this function to find. */
3355 desc = record_constant_rtx (mode, x);
3356 desc->next = const_rtx_hash_table[hash];
3357 const_rtx_hash_table[hash] = desc;
3359 /* Align the location counter as required by EXP's data type. */
3360 align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3361 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3362 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3364 pool_offset += align - 1;
3365 pool_offset &= ~ (align - 1);
3367 /* If RTL is not being placed into the saveable obstack, make a
3368 copy of X that is in the saveable obstack in case we are being
3369 called from combine or some other phase that discards memory
3370 it allocates. We need only do this if it is a CONST, since
3371 no other RTX should be allocated in this situation. */
3372 if (rtl_obstack != saveable_obstack
3373 && GET_CODE (x) == CONST)
3375 push_obstacks_nochange ();
3376 rtl_in_saveable_obstack ();
3378 x = gen_rtx (CONST, GET_MODE (x),
3379 gen_rtx (PLUS, GET_MODE (x),
3380 XEXP (XEXP (x, 0), 0), XEXP (XEXP (x, 0), 1)));
3384 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3386 pool = (struct pool_constant *) savealloc (sizeof (struct pool_constant));
3390 pool->labelno = const_labelno;
3391 pool->align = align;
3392 pool->offset = pool_offset;
3398 last_pool->next = pool;
3401 pool_offset += GET_MODE_SIZE (mode);
3403 /* Create a string containing the label name, in LABEL. */
3404 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3409 = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
3411 /* Add label to symbol hash table. */
3412 hash = SYMHASH (found);
3413 sym = (struct pool_sym *) savealloc (sizeof (struct pool_sym));
3416 sym->next = const_rtx_sym_hash_table[hash];
3417 const_rtx_sym_hash_table[hash] = sym;
3420 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3422 def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, found));
3424 RTX_UNCHANGING_P (def) = 1;
3425 /* Mark the symbol_ref as belonging to this constants pool. */
3426 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3427 current_function_uses_const_pool = 1;
3429 if (outer_function_chain == 0)
3430 if (GET_CODE (x) == CONST_DOUBLE)
3432 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3434 CONST_DOUBLE_CHAIN (x) = const_double_chain;
3435 const_double_chain = x;
3437 CONST_DOUBLE_MEM (x) = def;
3443 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3444 the corresponding pool_constant structure. */
3446 static struct pool_constant *
3447 find_pool_constant (addr)
3450 struct pool_sym *sym;
3451 char *label = XSTR (addr, 0);
3453 for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
3454 if (sym->label == label)
3460 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3463 get_pool_constant (addr)
3466 return (find_pool_constant (addr))->constant;
3469 /* Similar, return the mode. */
3472 get_pool_mode (addr)
3475 return (find_pool_constant (addr))->mode;
3478 /* Similar, return the offset in the constant pool. */
3481 get_pool_offset (addr)
3484 return (find_pool_constant (addr))->offset;
3487 /* Return the size of the constant pool. */
3495 /* Write all the constants in the constant pool. */
3498 output_constant_pool (fnname, fndecl)
3502 struct pool_constant *pool;
3504 union real_extract u;
3506 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3507 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3510 for (pool = first_pool; pool; pool = pool->next)
3514 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3515 whose CODE_LABEL has been deleted. This can occur if a jump table
3516 is eliminated by optimization. If so, write a constant of zero
3517 instead. Note that this can also happen by turning the
3518 CODE_LABEL into a NOTE. */
3519 if (((GET_CODE (x) == LABEL_REF
3520 && (INSN_DELETED_P (XEXP (x, 0))
3521 || GET_CODE (XEXP (x, 0)) == NOTE)))
3522 || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3523 && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3524 && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3525 || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3528 /* First switch to correct section. */
3529 #ifdef SELECT_RTX_SECTION
3530 SELECT_RTX_SECTION (pool->mode, x);
3532 readonly_data_section ();
3535 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3536 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3537 pool->align, pool->labelno, done);
3540 if (pool->align > 1)
3541 ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
3543 /* Output the label. */
3544 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3546 /* Output the value of the constant itself. */
3547 switch (GET_MODE_CLASS (pool->mode))
3550 if (GET_CODE (x) != CONST_DOUBLE)
3553 bcopy ((char *) &CONST_DOUBLE_LOW (x), (char *) &u, sizeof u);
3554 assemble_real (u.d, pool->mode);
3558 case MODE_PARTIAL_INT:
3559 assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3569 /* Done with this pool. */
3570 first_pool = last_pool = 0;
3573 /* Find all the constants whose addresses are referenced inside of EXP,
3574 and make sure assembler code with a label has been output for each one.
3575 Indicate whether an ADDR_EXPR has been encountered. */
3578 output_addressed_constants (exp)
3583 switch (TREE_CODE (exp))
3587 register tree constant = TREE_OPERAND (exp, 0);
3589 while (TREE_CODE (constant) == COMPONENT_REF)
3591 constant = TREE_OPERAND (constant, 0);
3594 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3595 || TREE_CODE (constant) == CONSTRUCTOR)
3596 /* No need to do anything here
3597 for addresses of variables or functions. */
3598 output_constant_def (constant);
3605 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3606 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3611 case NON_LVALUE_EXPR:
3612 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3618 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
3619 if (TREE_VALUE (link) != 0)
3620 reloc |= output_addressed_constants (TREE_VALUE (link));
3630 /* Output assembler code for constant EXP to FILE, with no label.
3631 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3632 Assumes output_addressed_constants has been done on EXP already.
3634 Generate exactly SIZE bytes of assembler data, padding at the end
3635 with zeros if necessary. SIZE must always be specified.
3637 SIZE is important for structure constructors,
3638 since trailing members may have been omitted from the constructor.
3639 It is also important for initialization of arrays from string constants
3640 since the full length of the string constant might not be wanted.
3641 It is also needed for initialization of unions, where the initializer's
3642 type is just one member, and that may not be as long as the union.
3644 There a case in which we would fail to output exactly SIZE bytes:
3645 for a structure constructor that wants to produce more than SIZE bytes.
3646 But such constructors will never be generated for any possible input. */
3649 output_constant (exp, size)
3653 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
3659 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
3660 That way we get the constant (we hope) inside it. Also, strip off any
3661 NOP_EXPR that converts between two record, union, array, or set types. */
3662 while ((TREE_CODE (exp) == NOP_EXPR
3663 && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
3664 || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
3665 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3666 exp = TREE_OPERAND (exp, 0);
3668 /* Allow a constructor with no elements for any data type.
3669 This means to fill the space with zeros. */
3670 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3672 if (output_bytecode)
3673 bc_emit_const_skip (size);
3675 assemble_zeros (size);
3686 case REFERENCE_TYPE:
3687 /* ??? What about (int)((float)(int)&foo + 4) */
3688 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3689 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3690 exp = TREE_OPERAND (exp, 0);
3692 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3693 EXPAND_INITIALIZER),
3695 error ("initializer for integer value is too complicated");
3700 if (TREE_CODE (exp) != REAL_CST)
3701 error ("initializer for floating value is not a floating constant");
3703 assemble_real (TREE_REAL_CST (exp),
3704 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
3709 output_constant (TREE_REALPART (exp), size / 2);
3710 output_constant (TREE_IMAGPART (exp), size / 2);
3711 size -= (size / 2) * 2;
3715 if (TREE_CODE (exp) == CONSTRUCTOR)
3717 output_constructor (exp, size);
3720 else if (TREE_CODE (exp) == STRING_CST)
3724 if (size > TREE_STRING_LENGTH (exp))
3726 excess = size - TREE_STRING_LENGTH (exp);
3727 size = TREE_STRING_LENGTH (exp);
3730 assemble_string (TREE_STRING_POINTER (exp), size);
3739 if (TREE_CODE (exp) == CONSTRUCTOR)
3740 output_constructor (exp, size);
3746 if (TREE_CODE (exp) == INTEGER_CST)
3747 assemble_integer (expand_expr (exp, NULL_RTX,
3748 VOIDmode, EXPAND_INITIALIZER),
3750 else if (TREE_CODE (exp) == CONSTRUCTOR)
3752 unsigned char *buffer = (unsigned char *) alloca (size);
3753 if (get_set_constructor_bytes (exp, buffer, size))
3755 assemble_string ((char *) buffer, size);
3758 error ("unknown set constructor type");
3763 assemble_zeros (size);
3766 /* Bytecode specific code to output assembler for integer. */
3769 bc_assemble_integer (exp, size)
3777 /* FIXME: is this fold() business going to be as good as the
3778 expand_expr() using EXPAND_SUM above in the RTL case? I
3780 FIXME: Copied as is from BC-GCC1; may need work. Don't hate. -bson */
3784 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
3785 exp = TREE_OPERAND (exp, 0);
3786 if (TREE_CODE (exp) == INTEGER_CST)
3791 else if (TREE_CODE (exp) == PLUS_EXPR)
3793 const_part = TREE_OPERAND (exp, 0);
3794 while (TREE_CODE (const_part) == NOP_EXPR
3795 || TREE_CODE (const_part) == CONVERT_EXPR)
3796 const_part = TREE_OPERAND (const_part, 0);
3797 addr_part = TREE_OPERAND (exp, 1);
3798 while (TREE_CODE (addr_part) == NOP_EXPR
3799 || TREE_CODE (addr_part) == CONVERT_EXPR)
3800 addr_part = TREE_OPERAND (addr_part, 0);
3801 if (TREE_CODE (const_part) != INTEGER_CST)
3802 tmp = const_part, const_part = addr_part, addr_part = tmp;
3803 if (TREE_CODE (const_part) != INTEGER_CST
3804 || TREE_CODE (addr_part) != ADDR_EXPR)
3805 abort (); /* FIXME: we really haven't considered
3806 all the possible cases here. */
3808 else if (TREE_CODE (exp) == ADDR_EXPR)
3810 const_part = integer_zero_node;
3814 abort (); /* FIXME: ditto previous. */
3820 char c = TREE_INT_CST_LOW (const_part);
3826 short s = TREE_INT_CST_LOW (const_part);
3827 bc_emit ((char *) &s, 2);
3832 int i = TREE_INT_CST_LOW (const_part);
3833 bc_emit ((char *) &i, 4);
3838 if (WORDS_BIG_ENDIAN)
3840 int i = TREE_INT_CST_HIGH (const_part);
3841 bc_emit ((char *) &i, 4);
3842 i = TREE_INT_CST_LOW (const_part);
3843 bc_emit ((char *) &i, 4);
3847 int i = TREE_INT_CST_LOW (const_part);
3848 bc_emit ((char *) &i, 4);
3849 i = TREE_INT_CST_HIGH (const_part);
3850 bc_emit ((char *) &i, 4);
3857 && TREE_CODE (TREE_OPERAND (addr_part, 0)) == VAR_DECL)
3858 bc_emit_labelref (IDENTIFIER_POINTER
3859 (DECL_ASSEMBLER_NAME (TREE_OPERAND (addr_part, 0))),
3860 TREE_INT_CST_LOW (const_part));
3862 abort (); /* FIXME: there may be more cases. */
3865 /* Subroutine of output_constant, used for CONSTRUCTORs
3866 (aggregate constants).
3867 Generate at least SIZE bytes, padding if necessary. */
3870 output_constructor (exp, size)
3874 register tree link, field = 0;
3875 HOST_WIDE_INT min_index = 0;
3876 /* Number of bytes output or skipped so far.
3877 In other words, current position within the constructor. */
3878 int total_bytes = 0;
3879 /* Non-zero means BYTE contains part of a byte, to be output. */
3880 int byte_buffer_in_use = 0;
3883 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
3886 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
3887 field = TYPE_FIELDS (TREE_TYPE (exp));
3889 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE
3890 && TYPE_DOMAIN (TREE_TYPE (exp)) != 0)
3892 = TREE_INT_CST_LOW (TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (exp))));
3894 /* As LINK goes through the elements of the constant,
3895 FIELD goes through the structure fields, if the constant is a structure.
3896 if the constant is a union, then we override this,
3897 by getting the field from the TREE_LIST element.
3898 But the constant could also be an array. Then FIELD is zero. */
3899 for (link = CONSTRUCTOR_ELTS (exp);
3901 link = TREE_CHAIN (link),
3902 field = field ? TREE_CHAIN (field) : 0)
3904 tree val = TREE_VALUE (link);
3907 /* the element in a union constructor specifies the proper field. */
3909 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
3910 || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
3912 /* if available, use the type given by link */
3913 if (TREE_PURPOSE (link) != 0)
3914 field = TREE_PURPOSE (link);
3917 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
3918 index = TREE_PURPOSE (link);
3920 /* Eliminate the marker that makes a cast not be an lvalue. */
3924 if (index && TREE_CODE (index) == RANGE_EXPR)
3926 register int fieldsize
3927 = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
3928 HOST_WIDE_INT lo_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 0));
3929 HOST_WIDE_INT hi_index = TREE_INT_CST_LOW (TREE_OPERAND (index, 1));
3930 HOST_WIDE_INT index;
3931 for (index = lo_index; index <= hi_index; index++)
3933 /* Output the element's initial value. */
3935 assemble_zeros (fieldsize);
3937 output_constant (val, fieldsize);
3939 /* Count its size. */
3940 total_bytes += fieldsize;
3943 else if (field == 0 || !DECL_BIT_FIELD (field))
3945 /* An element that is not a bit-field. */
3947 register int fieldsize;
3948 /* Since this structure is static,
3949 we know the positions are constant. */
3950 int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
3954 bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
3956 * (TREE_INT_CST_LOW (index) - min_index));
3958 /* Output any buffered-up bit-fields preceding this element. */
3959 if (byte_buffer_in_use)
3961 ASM_OUTPUT_BYTE (asm_out_file, byte);
3963 byte_buffer_in_use = 0;
3966 /* Advance to offset of this element.
3967 Note no alignment needed in an array, since that is guaranteed
3968 if each element has the proper size. */
3969 if ((field != 0 || index != 0) && bitpos != total_bytes)
3971 if (!output_bytecode)
3972 assemble_zeros (bitpos - total_bytes);
3974 bc_emit_const_skip (bitpos - total_bytes);
3975 total_bytes = bitpos;
3978 /* Determine size this element should occupy. */
3981 if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
3983 if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
3985 /* This avoids overflow trouble. */
3986 tree size_tree = size_binop (CEIL_DIV_EXPR,
3988 size_int (BITS_PER_UNIT));
3989 fieldsize = TREE_INT_CST_LOW (size_tree);
3993 fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
3994 fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
3998 fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
4000 /* Output the element's initial value. */
4002 assemble_zeros (fieldsize);
4004 output_constant (val, fieldsize);
4006 /* Count its size. */
4007 total_bytes += fieldsize;
4009 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4010 error ("invalid initial value for member `%s'",
4011 IDENTIFIER_POINTER (DECL_NAME (field)));
4014 /* Element that is a bit-field. */
4016 int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
4018 = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
4021 val = integer_zero_node;
4023 /* If this field does not start in this (or, next) byte,
4025 if (next_offset / BITS_PER_UNIT != total_bytes)
4027 /* Output remnant of any bit field in previous bytes. */
4028 if (byte_buffer_in_use)
4030 ASM_OUTPUT_BYTE (asm_out_file, byte);
4032 byte_buffer_in_use = 0;
4035 /* If still not at proper byte, advance to there. */
4036 if (next_offset / BITS_PER_UNIT != total_bytes)
4038 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4039 total_bytes = next_offset / BITS_PER_UNIT;
4043 if (! byte_buffer_in_use)
4046 /* We must split the element into pieces that fall within
4047 separate bytes, and combine each byte with previous or
4048 following bit-fields. */
4050 /* next_offset is the offset n fbits from the beginning of
4051 the structure to the next bit of this element to be processed.
4052 end_offset is the offset of the first bit past the end of
4054 while (next_offset < end_offset)
4058 HOST_WIDE_INT value;
4059 int next_byte = next_offset / BITS_PER_UNIT;
4060 int next_bit = next_offset % BITS_PER_UNIT;
4062 /* Advance from byte to byte
4063 within this element when necessary. */
4064 while (next_byte != total_bytes)
4066 ASM_OUTPUT_BYTE (asm_out_file, byte);
4071 /* Number of bits we can process at once
4072 (all part of the same byte). */
4073 this_time = MIN (end_offset - next_offset,
4074 BITS_PER_UNIT - next_bit);
4075 if (BYTES_BIG_ENDIAN)
4077 /* On big-endian machine, take the most significant bits
4078 first (of the bits that are significant)
4079 and put them into bytes from the most significant end. */
4080 shift = end_offset - next_offset - this_time;
4081 /* Don't try to take a bunch of bits that cross
4082 the word boundary in the INTEGER_CST. */
4083 if (shift < HOST_BITS_PER_WIDE_INT
4084 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4086 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4087 shift = HOST_BITS_PER_WIDE_INT;
4090 /* Now get the bits from the appropriate constant word. */
4091 if (shift < HOST_BITS_PER_WIDE_INT)
4093 value = TREE_INT_CST_LOW (val);
4095 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4097 value = TREE_INT_CST_HIGH (val);
4098 shift -= HOST_BITS_PER_WIDE_INT;
4102 byte |= (((value >> shift)
4103 & (((HOST_WIDE_INT) 1 << this_time) - 1))
4104 << (BITS_PER_UNIT - this_time - next_bit));
4108 /* On little-endian machines,
4109 take first the least significant bits of the value
4110 and pack them starting at the least significant
4111 bits of the bytes. */
4112 shift = (next_offset
4113 - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
4114 /* Don't try to take a bunch of bits that cross
4115 the word boundary in the INTEGER_CST. */
4116 if (shift < HOST_BITS_PER_WIDE_INT
4117 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4119 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
4120 shift = HOST_BITS_PER_WIDE_INT;
4123 /* Now get the bits from the appropriate constant word. */
4124 if (shift < HOST_BITS_PER_INT)
4125 value = TREE_INT_CST_LOW (val);
4126 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4128 value = TREE_INT_CST_HIGH (val);
4129 shift -= HOST_BITS_PER_WIDE_INT;
4133 byte |= (((value >> shift)
4134 & (((HOST_WIDE_INT) 1 << this_time) - 1))
4137 next_offset += this_time;
4138 byte_buffer_in_use = 1;
4142 if (byte_buffer_in_use)
4144 ASM_OUTPUT_BYTE (asm_out_file, byte);
4147 if (total_bytes < size)
4148 assemble_zeros (size - total_bytes);
4151 /* Output asm to handle ``#pragma weak'' */
4154 handle_pragma_weak (what, name, value)
4155 enum pragma_state what;
4158 #ifdef HANDLE_PRAGMA_WEAK
4159 if (what == ps_name || what == ps_value)
4161 struct weak_syms *weak =
4162 (struct weak_syms *)permalloc (sizeof (struct weak_syms));
4163 weak->next = weak_decls;
4164 weak->name = permalloc (strlen (name) + 1);
4165 strcpy (weak->name, name);
4167 if (what != ps_value)
4168 weak->value = NULL_PTR;
4172 weak->value = permalloc (strlen (value) + 1);
4173 strcpy (weak->value, value);
4178 else if (! (what == ps_done || what == ps_start))
4179 warning ("malformed `#pragma weak'");
4180 #endif /* HANDLE_PRAGMA_WEAK */
4183 /* Declare DECL to be a weak symbol. */
4189 if (! TREE_PUBLIC (decl))
4190 error_with_decl (decl, "weak declaration of `%s' must be public");
4191 else if (TREE_ASM_WRITTEN (decl))
4192 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4193 else if (SUPPORTS_WEAK)
4194 DECL_WEAK (decl) = 1;
4197 /* Emit any pending weak declarations. */
4202 #ifdef HANDLE_PRAGMA_WEAK
4203 if (HANDLE_PRAGMA_WEAK)
4205 struct weak_syms *t;
4206 for (t = weak_decls; t; t = t->next)
4208 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4210 ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4217 assemble_alias (decl, target)
4220 #ifdef ASM_OUTPUT_DEF
4223 make_decl_rtl (decl, (char *) 0, 1);
4224 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
4226 /* Make name accessible from other files, if appropriate. */
4228 if (TREE_PUBLIC (decl))
4230 #ifdef ASM_WEAKEN_LABEL
4231 if (DECL_WEAK (decl))
4232 ASM_WEAKEN_LABEL (asm_out_file, name);
4235 if (output_bytecode)
4236 BC_GLOBALIZE_LABEL (asm_out_file, name);
4238 ASM_GLOBALIZE_LABEL (asm_out_file, name);
4241 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4242 TREE_ASM_WRITTEN (decl) = 1;
4244 warning ("alias definitions not supported in this configuration");
4248 /* This determines whether or not we support link-once semantics. */
4249 #ifndef SUPPORTS_ONE_ONLY
4250 #ifdef MAKE_DECL_ONE_ONLY
4251 #define SUPPORTS_ONE_ONLY 1
4253 #define SUPPORTS_ONE_ONLY 0
4257 /* Returns 1 if the target configuration supports defining public symbols
4258 so that one of them will be chosen at link time instead of generating a
4259 multiply-defined symbol error, whether through the use of weak symbols or
4260 a target-specific mechanism for having duplicates discarded. */
4263 supports_one_only ()
4265 if (SUPPORTS_ONE_ONLY)
4267 return SUPPORTS_WEAK;
4270 /* Set up DECL as a public symbol that can be defined in multiple
4271 translation units without generating a linker error. */
4274 make_decl_one_only (decl)
4277 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4280 TREE_PUBLIC (decl) = 1;
4282 if (TREE_CODE (decl) == VAR_DECL
4283 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4284 DECL_COMMON (decl) = 1;
4285 else if (SUPPORTS_ONE_ONLY)
4287 #ifdef MAKE_DECL_ONE_ONLY
4288 MAKE_DECL_ONE_ONLY (decl);
4290 DECL_ONE_ONLY (decl) = 1;
4292 else if (SUPPORTS_WEAK)
4293 DECL_WEAK (decl) = 1;