1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993, 1994, 1995, 1996, 1997,
3 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
5 This file is part of GNU CC.
7 GNU CC is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU CC is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU CC; see the file COPYING. If not, write to
19 the Free Software Foundation, 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
23 /* This file handles generation of all the assembler code
24 *except* the instructions of a function.
25 This includes declarations of variables and their initial values.
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
38 #include "hard-reg-set.h"
51 #ifdef XCOFF_DEBUGGING_INFO
52 #include "xcoffout.h" /* Needed for external data
53 declarations for e.g. AIX 4.x. */
56 #ifndef TRAMPOLINE_ALIGNMENT
57 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
61 #define ASM_STABS_OP "\t.stabs\t"
64 /* Define the prefix to use when check_memory_usage_flag is enable. */
65 #define CHKR_PREFIX "_CHKR_"
66 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
68 /* The (assembler) name of the first globally-visible object output. */
69 const char *first_global_object_name
;
70 const char *weak_global_object_name
;
72 extern struct obstack permanent_obstack
;
73 #define obstack_chunk_alloc xmalloc
76 struct constant_descriptor
;
80 #define MAX_RTX_HASH_TABLE 61
84 /* Hash facility for making memory-constants
85 from constant rtl-expressions. It is used on RISC machines
86 where immediate integer arguments and constant addresses are restricted
87 so that such constants must be stored in memory.
89 This pool of constants is reinitialized for each function
90 so each function gets its own constants-pool that comes right before
92 struct constant_descriptor
**x_const_rtx_hash_table
;
93 struct pool_constant
**x_const_rtx_sym_hash_table
;
95 /* Pointers to first and last constant in pool. */
96 struct pool_constant
*x_first_pool
, *x_last_pool
;
98 /* Current offset in constant pool (does not include any machine-specific
102 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
103 They are chained through the CONST_DOUBLE_CHAIN.
104 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
105 In that case, CONST_DOUBLE_MEM is either a MEM,
106 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
107 rtx x_const_double_chain
;
110 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
111 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
112 #define first_pool (cfun->varasm->x_first_pool)
113 #define last_pool (cfun->varasm->x_last_pool)
114 #define pool_offset (cfun->varasm->x_pool_offset)
115 #define const_double_chain (cfun->varasm->x_const_double_chain)
117 /* Number for making the label on the next
118 constant that is stored in memory. */
122 /* Number for making the label on the next
123 static variable internal to a function. */
127 /* Carry information from ASM_DECLARE_OBJECT_NAME
128 to ASM_FINISH_DECLARE_OBJECT. */
130 int size_directive_output
;
132 /* The last decl for which assemble_variable was called,
133 if it did ASM_DECLARE_OBJECT_NAME.
134 If the last call to assemble_variable didn't do that,
137 tree last_assemble_variable_decl
;
139 static const char *strip_reg_name
PARAMS ((const char *));
140 static int contains_pointers_p
PARAMS ((tree
));
141 static void decode_addr_const
PARAMS ((tree
, struct addr_const
*));
142 static int const_hash
PARAMS ((tree
));
143 static int compare_constant
PARAMS ((tree
,
144 struct constant_descriptor
*));
145 static const unsigned char *compare_constant_1
PARAMS ((tree
, const unsigned char *));
146 static struct constant_descriptor
*record_constant
PARAMS ((tree
));
147 static void record_constant_1
PARAMS ((tree
));
148 static tree copy_constant
PARAMS ((tree
));
149 static void output_constant_def_contents
PARAMS ((tree
, int, int));
150 static void decode_rtx_const
PARAMS ((enum machine_mode
, rtx
,
151 struct rtx_const
*));
152 static int const_hash_rtx
PARAMS ((enum machine_mode
, rtx
));
153 static int compare_constant_rtx
PARAMS ((enum machine_mode
, rtx
,
154 struct constant_descriptor
*));
155 static struct constant_descriptor
*record_constant_rtx
PARAMS ((enum machine_mode
,
157 static struct pool_constant
*find_pool_constant
PARAMS ((struct function
*, rtx
));
158 static void mark_constant_pool
PARAMS ((void));
159 static void mark_constants
PARAMS ((rtx
));
160 static int mark_constant
PARAMS ((rtx
*current_rtx
, void *data
));
161 static int output_addressed_constants
PARAMS ((tree
));
162 static void output_after_function_constants
PARAMS ((void));
163 static unsigned HOST_WIDE_INT array_size_for_constructor
PARAMS ((tree
));
164 static void output_constructor
PARAMS ((tree
, int));
165 #ifdef ASM_WEAKEN_LABEL
166 static void remove_from_pending_weak_list
PARAMS ((const char *));
168 #ifdef ASM_OUTPUT_BSS
169 static void asm_output_bss
PARAMS ((FILE *, tree
, const char *, int, int));
171 #ifdef BSS_SECTION_ASM_OP
172 #ifdef ASM_OUTPUT_ALIGNED_BSS
173 static void asm_output_aligned_bss
PARAMS ((FILE *, tree
, const char *,
176 #endif /* BSS_SECTION_ASM_OP */
177 static void mark_pool_constant
PARAMS ((struct pool_constant
*));
178 static void mark_const_hash_entry
PARAMS ((void *));
179 static int mark_const_str_htab_1
PARAMS ((void **, void *));
180 static void mark_const_str_htab
PARAMS ((void *));
181 static hashval_t const_str_htab_hash
PARAMS ((const void *x
));
182 static int const_str_htab_eq
PARAMS ((const void *x
, const void *y
));
183 static void const_str_htab_del
PARAMS ((void *));
184 static void asm_emit_uninitialised
PARAMS ((tree
, const char*, int, int));
185 static void resolve_unique_section
PARAMS ((tree
, int));
187 static enum in_section
{ no_section
, in_text
, in_data
, in_named
188 #ifdef BSS_SECTION_ASM_OP
191 #ifdef EXTRA_SECTIONS
194 } in_section
= no_section
;
196 /* Return a non-zero value if DECL has a section attribute. */
197 #ifndef IN_NAMED_SECTION
198 #define IN_NAMED_SECTION(DECL) \
199 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
200 && DECL_SECTION_NAME (DECL) != NULL_TREE)
203 /* Text of section name when in_section == in_named. */
204 static const char *in_named_name
;
206 /* Define functions like text_section for any extra sections. */
207 #ifdef EXTRA_SECTION_FUNCTIONS
208 EXTRA_SECTION_FUNCTIONS
211 /* Tell assembler to switch to text section. */
216 if (in_section
!= in_text
)
218 fprintf (asm_out_file
, "%s\n", TEXT_SECTION_ASM_OP
);
219 in_section
= in_text
;
223 /* Tell assembler to switch to data section. */
228 if (in_section
!= in_data
)
230 if (flag_shared_data
)
232 #ifdef SHARED_SECTION_ASM_OP
233 fprintf (asm_out_file
, "%s\n", SHARED_SECTION_ASM_OP
);
235 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
239 fprintf (asm_out_file
, "%s\n", DATA_SECTION_ASM_OP
);
241 in_section
= in_data
;
244 /* Tell assembler to ALWAYS switch to data section, in case
245 it's not sure where it it. */
248 force_data_section ()
250 in_section
= no_section
;
254 /* Tell assembler to switch to read-only data section. This is normally
258 readonly_data_section ()
260 #ifdef READONLY_DATA_SECTION
261 READONLY_DATA_SECTION (); /* Note this can call data_section. */
267 /* Determine if we're in the text section. */
272 return in_section
== in_text
;
275 /* Determine if we're in the data section. */
280 return in_section
== in_data
;
283 /* Tell assembler to change to section NAME with attributes FLAGS. */
286 named_section_flags (name
, flags
, align
)
291 if (in_section
!= in_named
|| strcmp (name
, in_named_name
))
293 (* targetm
.asm_out
.named_section
) (name
, flags
, align
);
295 if (flags
& SECTION_FORGET
)
296 in_section
= no_section
;
299 in_named_name
= ggc_strdup (name
);
300 in_section
= in_named
;
305 /* Tell assembler to change to section NAME for DECL.
306 If DECL is NULL, just switch to section NAME.
307 If NAME is NULL, get the name from DECL.
308 If RELOC is 1, the initializer for DECL contains relocs. */
311 named_section (decl
, name
, reloc
)
318 if (decl
!= NULL_TREE
&& !DECL_P (decl
))
321 name
= TREE_STRING_POINTER (DECL_SECTION_NAME (decl
));
323 flags
= (* targetm
.section_type_flags
) (decl
, name
, reloc
);
324 named_section_flags (name
, flags
, 0);
327 /* If required, set DECL_SECTION_NAME to a unique name. */
330 resolve_unique_section (decl
, reloc
)
334 if (DECL_SECTION_NAME (decl
) == NULL_TREE
335 && (flag_function_sections
336 || (targetm
.have_named_sections
337 && DECL_ONE_ONLY (decl
))))
338 UNIQUE_SECTION (decl
, reloc
);
341 #ifdef BSS_SECTION_ASM_OP
343 /* Tell the assembler to switch to the bss section. */
348 if (in_section
!= in_bss
)
350 #ifdef SHARED_BSS_SECTION_ASM_OP
351 if (flag_shared_data
)
352 fprintf (asm_out_file
, "%s\n", SHARED_BSS_SECTION_ASM_OP
);
355 fprintf (asm_out_file
, "%s\n", BSS_SECTION_ASM_OP
);
361 #ifdef ASM_OUTPUT_BSS
363 /* Utility function for ASM_OUTPUT_BSS for targets to use if
364 they don't support alignments in .bss.
365 ??? It is believed that this function will work in most cases so such
366 support is localized here. */
369 asm_output_bss (file
, decl
, name
, size
, rounded
)
371 tree decl ATTRIBUTE_UNUSED
;
373 int size ATTRIBUTE_UNUSED
, rounded
;
375 ASM_GLOBALIZE_LABEL (file
, name
);
377 #ifdef ASM_DECLARE_OBJECT_NAME
378 last_assemble_variable_decl
= decl
;
379 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
381 /* Standard thing is just output label for the object. */
382 ASM_OUTPUT_LABEL (file
, name
);
383 #endif /* ASM_DECLARE_OBJECT_NAME */
384 ASM_OUTPUT_SKIP (file
, rounded
);
389 #ifdef ASM_OUTPUT_ALIGNED_BSS
391 /* Utility function for targets to use in implementing
392 ASM_OUTPUT_ALIGNED_BSS.
393 ??? It is believed that this function will work in most cases so such
394 support is localized here. */
397 asm_output_aligned_bss (file
, decl
, name
, size
, align
)
403 ASM_GLOBALIZE_LABEL (file
, name
);
405 ASM_OUTPUT_ALIGN (file
, floor_log2 (align
/ BITS_PER_UNIT
));
406 #ifdef ASM_DECLARE_OBJECT_NAME
407 last_assemble_variable_decl
= decl
;
408 ASM_DECLARE_OBJECT_NAME (file
, name
, decl
);
410 /* Standard thing is just output label for the object. */
411 ASM_OUTPUT_LABEL (file
, name
);
412 #endif /* ASM_DECLARE_OBJECT_NAME */
413 ASM_OUTPUT_SKIP (file
, size
? size
: 1);
418 #endif /* BSS_SECTION_ASM_OP */
420 /* Switch to the section for function DECL.
422 If DECL is NULL_TREE, switch to the text section.
423 ??? It's not clear that we will ever be passed NULL_TREE, but it's
424 safer to handle it. */
427 function_section (decl
)
430 if (decl
!= NULL_TREE
431 && DECL_SECTION_NAME (decl
) != NULL_TREE
)
432 named_section (decl
, (char *) 0, 0);
437 /* Switch to section for variable DECL.
439 RELOC is the `reloc' argument to SELECT_SECTION. */
442 variable_section (decl
, reloc
)
446 if (IN_NAMED_SECTION (decl
))
447 named_section (decl
, NULL
, reloc
);
450 /* C++ can have const variables that get initialized from constructors,
451 and thus can not be in a readonly section. We prevent this by
452 verifying that the initial value is constant for objects put in a
455 error_mark_node is used by the C front end to indicate that the
456 initializer has not been seen yet. In this case, we assume that
457 the initializer must be constant.
459 C++ uses error_mark_node for variables that have complicated
460 initializers, but these variables go in BSS so we won't be called
463 #ifdef SELECT_SECTION
464 SELECT_SECTION (decl
, reloc
);
466 if (DECL_READONLY_SECTION (decl
, reloc
))
467 readonly_data_section ();
474 /* Tell assembler to switch to the section for the exception handling
480 #if defined (EXCEPTION_SECTION)
481 EXCEPTION_SECTION ();
483 if (targetm
.have_named_sections
)
484 named_section (NULL_TREE
, ".gcc_except_table", 0);
488 readonly_data_section ();
492 /* Given NAME, a putative register name, discard any customary prefixes. */
495 strip_reg_name (name
)
498 #ifdef REGISTER_PREFIX
499 if (!strncmp (name
, REGISTER_PREFIX
, strlen (REGISTER_PREFIX
)))
500 name
+= strlen (REGISTER_PREFIX
);
502 if (name
[0] == '%' || name
[0] == '#')
507 /* Decode an `asm' spec for a declaration as a register name.
508 Return the register number, or -1 if nothing specified,
509 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
510 or -3 if ASMSPEC is `cc' and is not recognized,
511 or -4 if ASMSPEC is `memory' and is not recognized.
512 Accept an exact spelling or a decimal number.
513 Prefixes such as % are optional. */
516 decode_reg_name (asmspec
)
523 /* Get rid of confusing prefixes. */
524 asmspec
= strip_reg_name (asmspec
);
526 /* Allow a decimal number as a "register name". */
527 for (i
= strlen (asmspec
) - 1; i
>= 0; i
--)
528 if (! (asmspec
[i
] >= '0' && asmspec
[i
] <= '9'))
530 if (asmspec
[0] != 0 && i
< 0)
533 if (i
< FIRST_PSEUDO_REGISTER
&& i
>= 0)
539 for (i
= 0; i
< FIRST_PSEUDO_REGISTER
; i
++)
541 && ! strcmp (asmspec
, strip_reg_name (reg_names
[i
])))
544 #ifdef ADDITIONAL_REGISTER_NAMES
546 static struct { const char *name
; int number
; } table
[]
547 = ADDITIONAL_REGISTER_NAMES
;
549 for (i
= 0; i
< (int) ARRAY_SIZE (table
); i
++)
550 if (! strcmp (asmspec
, table
[i
].name
))
551 return table
[i
].number
;
553 #endif /* ADDITIONAL_REGISTER_NAMES */
555 if (!strcmp (asmspec
, "memory"))
558 if (!strcmp (asmspec
, "cc"))
567 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
568 have static storage duration. In other words, it should not be an
569 automatic variable, including PARM_DECLs.
571 There is, however, one exception: this function handles variables
572 explicitly placed in a particular register by the user.
574 ASMSPEC, if not 0, is the string which the user specified as the
575 assembler symbol name.
577 This is never called for PARM_DECL nodes. */
580 make_decl_rtl (decl
, asmspec
)
584 int top_level
= (DECL_CONTEXT (decl
) == NULL_TREE
);
585 const char *name
= 0;
586 const char *new_name
= 0;
589 /* Check that we are not being given an automatic variable. */
590 /* A weak alias has TREE_PUBLIC set but not the other bits. */
591 if (TREE_CODE (decl
) == PARM_DECL
592 || TREE_CODE (decl
) == RESULT_DECL
593 || (TREE_CODE (decl
) == VAR_DECL
594 && !TREE_STATIC (decl
)
595 && !TREE_PUBLIC (decl
)
596 && !DECL_EXTERNAL (decl
)
597 && !DECL_REGISTER (decl
)))
599 /* And that we were not given a type or a label. */
600 else if (TREE_CODE (decl
) == TYPE_DECL
601 || TREE_CODE (decl
) == LABEL_DECL
)
604 /* For a duplicate declaration, we can be called twice on the
605 same DECL node. Don't discard the RTL already made. */
606 if (DECL_RTL_SET_P (decl
))
608 /* If the old RTL had the wrong mode, fix the mode. */
609 if (GET_MODE (DECL_RTL (decl
)) != DECL_MODE (decl
))
611 rtx rtl
= DECL_RTL (decl
);
612 PUT_MODE (rtl
, DECL_MODE (decl
));
615 /* ??? Another way to do this would be to do what halfpic.c does
616 and maintain a hashed table of such critters. */
617 /* ??? Another way to do this would be to pass a flag bit to
618 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
619 /* Let the target reassign the RTL if it wants.
620 This is necessary, for example, when one machine specific
621 decl attribute overrides another. */
622 #ifdef REDO_SECTION_INFO_P
623 if (REDO_SECTION_INFO_P (decl
))
624 ENCODE_SECTION_INFO (decl
);
629 new_name
= name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
631 reg_number
= decode_reg_name (asmspec
);
632 if (reg_number
== -2)
634 /* ASMSPEC is given, and not the name of a register. Mark the
635 name with a star so assemble_name won't munge it. */
636 char *starred
= alloca (strlen (asmspec
) + 2);
638 strcpy (starred
+ 1, asmspec
);
642 if (TREE_CODE (decl
) != FUNCTION_DECL
&& DECL_REGISTER (decl
))
644 /* First detect errors in declaring global registers. */
645 if (reg_number
== -1)
646 error_with_decl (decl
, "register name not specified for `%s'");
647 else if (reg_number
< 0)
648 error_with_decl (decl
, "invalid register name for `%s'");
649 else if (TYPE_MODE (TREE_TYPE (decl
)) == BLKmode
)
650 error_with_decl (decl
,
651 "data type of `%s' isn't suitable for a register");
652 else if (! HARD_REGNO_MODE_OK (reg_number
, TYPE_MODE (TREE_TYPE (decl
))))
653 error_with_decl (decl
,
654 "register specified for `%s' isn't suitable for data type");
655 /* Now handle properly declared static register variables. */
660 if (DECL_INITIAL (decl
) != 0 && TREE_STATIC (decl
))
662 DECL_INITIAL (decl
) = 0;
663 error ("global register variable has initial value");
665 if (TREE_THIS_VOLATILE (decl
))
666 warning ("volatile register variables don't work as you might wish");
668 /* If the user specified one of the eliminables registers here,
669 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
670 confused with that register and be eliminated. Although this
671 usage is somewhat suspect, we nevertheless use the following
672 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
675 gen_rtx_REG (DECL_MODE (decl
),
676 FIRST_PSEUDO_REGISTER
));
677 REGNO (DECL_RTL (decl
)) = reg_number
;
678 REG_USERVAR_P (DECL_RTL (decl
)) = 1;
680 if (TREE_STATIC (decl
))
682 /* Make this register global, so not usable for anything
684 #ifdef ASM_DECLARE_REGISTER_GLOBAL
685 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file
, decl
, reg_number
, name
);
687 nregs
= HARD_REGNO_NREGS (reg_number
, DECL_MODE (decl
));
689 globalize_reg (reg_number
+ --nregs
);
692 /* As a register variable, it has no section. */
697 /* Now handle ordinary static variables and functions (in memory).
698 Also handle vars declared register invalidly. */
700 if (reg_number
>= 0 || reg_number
== -3)
701 error_with_decl (decl
,
702 "register name given for non-register variable `%s'");
704 /* Specifying a section attribute on a variable forces it into a
705 non-.bss section, and thus it cannot be common. */
706 if (TREE_CODE (decl
) == VAR_DECL
707 && DECL_SECTION_NAME (decl
) != NULL_TREE
708 && DECL_INITIAL (decl
) == NULL_TREE
709 && DECL_COMMON (decl
))
710 DECL_COMMON (decl
) = 0;
712 /* Can't use just the variable's own name for a variable
713 whose scope is less than the whole file, unless it's a member
714 of a local class (which will already be unambiguous).
715 Concatenate a distinguishing number. */
716 if (!top_level
&& !TREE_PUBLIC (decl
)
717 && ! (DECL_CONTEXT (decl
) && TYPE_P (DECL_CONTEXT (decl
)))
719 && name
== IDENTIFIER_POINTER (DECL_NAME (decl
)))
722 ASM_FORMAT_PRIVATE_NAME (label
, name
, var_labelno
);
727 /* When -fprefix-function-name is used, the functions
728 names are prefixed. Only nested function names are not
730 else if (flag_prefix_function_name
&& TREE_CODE (decl
) == FUNCTION_DECL
)
732 size_t name_len
= IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl
));
735 pname
= alloca (name_len
+ CHKR_PREFIX_SIZE
+ 1);
736 memcpy (pname
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
);
737 memcpy (pname
+ CHKR_PREFIX_SIZE
, name
, name_len
+ 1);
741 if (name
!= new_name
)
743 SET_DECL_ASSEMBLER_NAME (decl
, get_identifier (new_name
));
744 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
747 /* If this variable is to be treated as volatile, show its
748 tree node has side effects. */
749 if ((flag_volatile_global
&& TREE_CODE (decl
) == VAR_DECL
750 && TREE_PUBLIC (decl
))
751 || ((flag_volatile_static
&& TREE_CODE (decl
) == VAR_DECL
752 && (TREE_PUBLIC (decl
) || TREE_STATIC (decl
)))))
753 TREE_SIDE_EFFECTS (decl
) = 1;
755 SET_DECL_RTL (decl
, gen_rtx_MEM (DECL_MODE (decl
),
756 gen_rtx_SYMBOL_REF (Pmode
, name
)));
757 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl
), 0)) = DECL_WEAK (decl
);
758 if (TREE_CODE (decl
) != FUNCTION_DECL
)
759 set_mem_attributes (DECL_RTL (decl
), decl
, 1);
761 /* Optionally set flags or add text to the name to record information
762 such as that it is a function name.
763 If the name is changed, the macro ASM_OUTPUT_LABELREF
764 will have to know how to strip this information. */
765 #ifdef ENCODE_SECTION_INFO
766 ENCODE_SECTION_INFO (decl
);
770 /* Make the rtl for variable VAR be volatile.
771 Use this only for static variables. */
774 make_var_volatile (var
)
777 if (GET_CODE (DECL_RTL (var
)) != MEM
)
780 MEM_VOLATILE_P (DECL_RTL (var
)) = 1;
783 /* Output alignment directive to align for constant expression EXP. */
786 assemble_constant_align (exp
)
791 /* Align the location counter as required by EXP's data type. */
792 align
= TYPE_ALIGN (TREE_TYPE (exp
));
793 #ifdef CONSTANT_ALIGNMENT
794 align
= CONSTANT_ALIGNMENT (exp
, align
);
797 if (align
> BITS_PER_UNIT
)
798 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
801 /* Output a string of literal assembler code
802 for an `asm' keyword used between functions. */
805 assemble_asm (string
)
810 if (TREE_CODE (string
) == ADDR_EXPR
)
811 string
= TREE_OPERAND (string
, 0);
813 fprintf (asm_out_file
, "\t%s\n", TREE_STRING_POINTER (string
));
816 /* Record an element in the table of global destructors.
817 How this is done depends on what sort of assembler and linker
820 NAME should be the name of a global function to be called
821 at exit time. This name is output using assemble_name. */
824 assemble_destructor (name
)
827 #ifdef ASM_OUTPUT_DESTRUCTOR
828 ASM_OUTPUT_DESTRUCTOR (asm_out_file
, name
);
832 /* Now tell GNU LD that this is part of the static destructor set. */
833 /* This code works for any machine provided you use GNU as/ld. */
834 fprintf (asm_out_file
, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
835 assemble_name (asm_out_file
, name
);
836 fputc ('\n', asm_out_file
);
841 /* Likewise for global constructors. */
844 assemble_constructor (name
)
847 #ifdef ASM_OUTPUT_CONSTRUCTOR
848 ASM_OUTPUT_CONSTRUCTOR (asm_out_file
, name
);
852 /* Now tell GNU LD that this is part of the static constructor set. */
853 /* This code works for any machine provided you use GNU as/ld. */
854 fprintf (asm_out_file
, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP
);
855 assemble_name (asm_out_file
, name
);
856 fputc ('\n', asm_out_file
);
861 /* Likewise for entries we want to record for garbage collection.
862 Garbage collection is still under development. */
865 assemble_gc_entry (name
)
868 #ifdef ASM_OUTPUT_GC_ENTRY
869 ASM_OUTPUT_GC_ENTRY (asm_out_file
, name
);
873 /* Now tell GNU LD that this is part of the static constructor set. */
874 fprintf (asm_out_file
, "%s\"___PTR_LIST__\",22,0,0,", ASM_STABS_OP
);
875 assemble_name (asm_out_file
, name
);
876 fputc ('\n', asm_out_file
);
881 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
882 a non-zero value if the constant pool should be output before the
883 start of the function, or a zero value if the pool should output
884 after the end of the function. The default is to put it before the
887 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
888 #define CONSTANT_POOL_BEFORE_FUNCTION 1
891 /* Output assembler code for the constant pool of a function and associated
892 with defining the name of the function. DECL describes the function.
893 NAME is the function's name. For the constant pool, we use the current
894 constant pool data. */
897 assemble_start_function (decl
, fnname
)
903 /* The following code does not need preprocessing in the assembler. */
907 if (CONSTANT_POOL_BEFORE_FUNCTION
)
908 output_constant_pool (fnname
, decl
);
910 resolve_unique_section (decl
, 0);
911 function_section (decl
);
913 /* Tell assembler to move to target machine's alignment for functions. */
914 align
= floor_log2 (FUNCTION_BOUNDARY
/ BITS_PER_UNIT
);
916 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
918 /* Handle a user-specified function alignment.
919 Note that we still need to align to FUNCTION_BOUNDARY, as above,
920 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
921 if (align_functions_log
> align
)
923 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
924 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file
,
925 align_functions_log
, align_functions
-1);
927 ASM_OUTPUT_ALIGN (asm_out_file
, align_functions_log
);
931 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
932 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file
, fnname
);
935 (*debug_hooks
->begin_function
) (decl
);
937 /* Make function name accessible from other files, if appropriate. */
939 if (TREE_PUBLIC (decl
))
941 if (! first_global_object_name
)
946 STRIP_NAME_ENCODING (p
, fnname
);
947 name
= permalloc (strlen (p
) + 1);
950 if (! DECL_WEAK (decl
) && ! DECL_ONE_ONLY (decl
))
951 first_global_object_name
= name
;
953 weak_global_object_name
= name
;
956 #ifdef ASM_WEAKEN_LABEL
957 if (DECL_WEAK (decl
))
959 ASM_WEAKEN_LABEL (asm_out_file
, fnname
);
960 /* Remove this function from the pending weak list so that
961 we do not emit multiple .weak directives for it. */
962 remove_from_pending_weak_list
963 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
967 ASM_GLOBALIZE_LABEL (asm_out_file
, fnname
);
970 /* Do any machine/system dependent processing of the function name */
971 #ifdef ASM_DECLARE_FUNCTION_NAME
972 ASM_DECLARE_FUNCTION_NAME (asm_out_file
, fnname
, current_function_decl
);
974 /* Standard thing is just output label for the function. */
975 ASM_OUTPUT_LABEL (asm_out_file
, fnname
);
976 #endif /* ASM_DECLARE_FUNCTION_NAME */
979 /* Output assembler code associated with defining the size of the
980 function. DECL describes the function. NAME is the function's name. */
983 assemble_end_function (decl
, fnname
)
987 #ifdef ASM_DECLARE_FUNCTION_SIZE
988 ASM_DECLARE_FUNCTION_SIZE (asm_out_file
, fnname
, decl
);
990 if (! CONSTANT_POOL_BEFORE_FUNCTION
)
992 output_constant_pool (fnname
, decl
);
993 function_section (decl
); /* need to switch back */
996 /* Output any constants which should appear after the function. */
997 output_after_function_constants ();
1000 /* Assemble code to leave SIZE bytes of zeros. */
1003 assemble_zeros (size
)
1006 /* Do no output if -fsyntax-only. */
1007 if (flag_syntax_only
)
1010 #ifdef ASM_NO_SKIP_IN_TEXT
1011 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1012 so we must output 0s explicitly in the text section. */
1013 if (ASM_NO_SKIP_IN_TEXT
&& in_text_section ())
1017 for (i
= 0; i
< size
- 20; i
+= 20)
1020 fprintf (asm_out_file
,
1021 "%s0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP
);
1023 fprintf (asm_out_file
,
1024 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1030 fprintf (asm_out_file
, "%s0", ASM_BYTE_OP
);
1032 fprintf (asm_out_file
, "\tbyte 0");
1035 for (; i
< size
; i
++)
1036 fprintf (asm_out_file
, ",0");
1037 fprintf (asm_out_file
, "\n");
1043 ASM_OUTPUT_SKIP (asm_out_file
, size
);
1046 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1049 assemble_align (align
)
1052 if (align
> BITS_PER_UNIT
)
1053 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
1056 /* Assemble a string constant with the specified C string as contents. */
1059 assemble_string (p
, size
)
1066 /* If the string is very long, split it up. */
1070 int thissize
= size
- pos
;
1071 if (thissize
> maximum
)
1074 ASM_OUTPUT_ASCII (asm_out_file
, p
, thissize
);
1082 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1083 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1084 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1086 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1087 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1088 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1090 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1091 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1095 #if defined ASM_OUTPUT_ALIGNED_BSS
1096 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1097 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1099 #if defined ASM_OUTPUT_BSS
1100 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1101 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1107 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1108 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1109 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1111 #if defined ASM_OUTPUT_ALIGNED_COMMON
1112 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1113 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1115 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1116 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1121 asm_emit_uninitialised (decl
, name
, size
, rounded
)
1124 int size ATTRIBUTE_UNUSED
;
1125 int rounded ATTRIBUTE_UNUSED
;
1133 destination
= asm_dest_local
;
1135 if (TREE_PUBLIC (decl
))
1137 #if defined ASM_EMIT_BSS
1138 if (! DECL_COMMON (decl
))
1139 destination
= asm_dest_bss
;
1142 destination
= asm_dest_common
;
1145 if (flag_shared_data
)
1147 switch (destination
)
1149 #ifdef ASM_OUTPUT_SHARED_BSS
1151 ASM_OUTPUT_SHARED_BSS (asm_out_file
, decl
, name
, size
, rounded
);
1154 #ifdef ASM_OUTPUT_SHARED_COMMON
1155 case asm_dest_common
:
1156 ASM_OUTPUT_SHARED_COMMON (asm_out_file
, name
, size
, rounded
);
1159 #ifdef ASM_OUTPUT_SHARED_LOCAL
1160 case asm_dest_local
:
1161 ASM_OUTPUT_SHARED_LOCAL (asm_out_file
, name
, size
, rounded
);
1169 resolve_unique_section (decl
, 0);
1171 switch (destination
)
1175 ASM_EMIT_BSS (decl
, name
, size
, rounded
);
1178 case asm_dest_common
:
1179 ASM_EMIT_COMMON (decl
, name
, size
, rounded
);
1181 case asm_dest_local
:
1182 ASM_EMIT_LOCAL (decl
, name
, size
, rounded
);
1191 /* Assemble everything that is needed for a variable or function declaration.
1192 Not used for automatic variables, and not used for function definitions.
1193 Should not be called for variables of incomplete structure type.
1195 TOP_LEVEL is nonzero if this variable has file scope.
1196 AT_END is nonzero if this is the special handling, at end of compilation,
1197 to define things that have had only tentative definitions.
1198 DONT_OUTPUT_DATA if nonzero means don't actually output the
1199 initial value (that will be done by the caller). */
1202 assemble_variable (decl
, top_level
, at_end
, dont_output_data
)
1204 int top_level ATTRIBUTE_UNUSED
;
1205 int at_end ATTRIBUTE_UNUSED
;
1206 int dont_output_data
;
1208 register const char *name
;
1213 last_assemble_variable_decl
= 0;
1215 /* Normally no need to say anything here for external references,
1216 since assemble_external is called by the language-specific code
1217 when a declaration is first seen. */
1219 if (DECL_EXTERNAL (decl
))
1222 /* Output no assembler code for a function declaration.
1223 Only definitions of functions output anything. */
1225 if (TREE_CODE (decl
) == FUNCTION_DECL
)
1228 /* Do nothing for global register variables. */
1229 if (DECL_RTL_SET_P (decl
) && GET_CODE (DECL_RTL (decl
)) == REG
)
1231 TREE_ASM_WRITTEN (decl
) = 1;
1235 /* If type was incomplete when the variable was declared,
1236 see if it is complete now. */
1238 if (DECL_SIZE (decl
) == 0)
1239 layout_decl (decl
, 0);
1241 /* Still incomplete => don't allocate it; treat the tentative defn
1242 (which is what it must have been) as an `extern' reference. */
1244 if (!dont_output_data
&& DECL_SIZE (decl
) == 0)
1246 error_with_file_and_line (DECL_SOURCE_FILE (decl
),
1247 DECL_SOURCE_LINE (decl
),
1248 "storage size of `%s' isn't known",
1249 IDENTIFIER_POINTER (DECL_NAME (decl
)));
1250 TREE_ASM_WRITTEN (decl
) = 1;
1254 /* The first declaration of a variable that comes through this function
1255 decides whether it is global (in C, has external linkage)
1256 or local (in C, has internal linkage). So do nothing more
1257 if this function has already run. */
1259 if (TREE_ASM_WRITTEN (decl
))
1262 /* Make sure ENCODE_SECTION_INFO is invoked before we set ASM_WRITTEN. */
1263 decl_rtl
= DECL_RTL (decl
);
1265 TREE_ASM_WRITTEN (decl
) = 1;
1267 /* Do no output if -fsyntax-only. */
1268 if (flag_syntax_only
)
1273 if (! dont_output_data
1274 && ! host_integerp (DECL_SIZE_UNIT (decl
), 1))
1276 error_with_decl (decl
, "size of variable `%s' is too large");
1280 name
= XSTR (XEXP (decl_rtl
, 0), 0);
1281 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
)
1282 && ! first_global_object_name
1283 && ! (DECL_COMMON (decl
) && (DECL_INITIAL (decl
) == 0
1284 || DECL_INITIAL (decl
) == error_mark_node
))
1285 && ! DECL_WEAK (decl
)
1286 && ! DECL_ONE_ONLY (decl
))
1291 STRIP_NAME_ENCODING (p
, name
);
1292 xname
= permalloc (strlen (p
) + 1);
1294 first_global_object_name
= xname
;
1297 /* Compute the alignment of this data. */
1299 align
= DECL_ALIGN (decl
);
1301 /* In the case for initialing an array whose length isn't specified,
1302 where we have not yet been able to do the layout,
1303 figure out the proper alignment now. */
1304 if (dont_output_data
&& DECL_SIZE (decl
) == 0
1305 && TREE_CODE (TREE_TYPE (decl
)) == ARRAY_TYPE
)
1306 align
= MAX (align
, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl
))));
1308 /* Some object file formats have a maximum alignment which they support.
1309 In particular, a.out format supports a maximum alignment of 4. */
1310 #ifndef MAX_OFILE_ALIGNMENT
1311 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1313 if (align
> MAX_OFILE_ALIGNMENT
)
1315 warning_with_decl (decl
,
1316 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1317 MAX_OFILE_ALIGNMENT
/BITS_PER_UNIT
);
1318 align
= MAX_OFILE_ALIGNMENT
;
1321 /* On some machines, it is good to increase alignment sometimes. */
1322 #ifdef DATA_ALIGNMENT
1323 align
= DATA_ALIGNMENT (TREE_TYPE (decl
), align
);
1325 #ifdef CONSTANT_ALIGNMENT
1326 if (DECL_INITIAL (decl
) != 0 && DECL_INITIAL (decl
) != error_mark_node
)
1327 align
= CONSTANT_ALIGNMENT (DECL_INITIAL (decl
), align
);
1330 /* Reset the alignment in case we have made it tighter, so we can benefit
1331 from it in get_pointer_alignment. */
1332 DECL_ALIGN (decl
) = align
;
1334 /* Handle uninitialized definitions. */
1336 if ((DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
)
1337 /* If the target can't output uninitialized but not common global data
1338 in .bss, then we have to use .data. */
1339 #if ! defined ASM_EMIT_BSS
1340 && DECL_COMMON (decl
)
1342 && DECL_SECTION_NAME (decl
) == NULL_TREE
1343 && ! dont_output_data
)
1345 unsigned HOST_WIDE_INT size
= tree_low_cst (DECL_SIZE_UNIT (decl
), 1);
1346 unsigned HOST_WIDE_INT rounded
= size
;
1348 /* Don't allocate zero bytes of common,
1349 since that means "undefined external" in the linker. */
1353 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1354 so that each uninitialized object starts on such a boundary. */
1355 rounded
+= (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1;
1356 rounded
= (rounded
/ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1357 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1359 /* Don't continue this line--convex cc version 4.1 would lose. */
1360 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1361 if ((unsigned HOST_WIDE_INT
) DECL_ALIGN (decl
) / BITS_PER_UNIT
> rounded
)
1363 (decl
, "requested alignment for %s is greater than implemented alignment of %d.",rounded
);
1366 asm_emit_uninitialised (decl
, name
, size
, rounded
);
1371 /* Handle initialized definitions.
1372 Also handle uninitialized global definitions if -fno-common and the
1373 target doesn't support ASM_OUTPUT_BSS. */
1375 /* First make the assembler name(s) global if appropriate. */
1376 if (TREE_PUBLIC (decl
) && DECL_NAME (decl
))
1378 #ifdef ASM_WEAKEN_LABEL
1379 if (DECL_WEAK (decl
))
1381 ASM_WEAKEN_LABEL (asm_out_file
, name
);
1382 /* Remove this variable from the pending weak list so that
1383 we do not emit multiple .weak directives for it. */
1384 remove_from_pending_weak_list
1385 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
1389 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1392 /* Output any data that we will need to use the address of. */
1393 if (DECL_INITIAL (decl
) == error_mark_node
)
1394 reloc
= contains_pointers_p (TREE_TYPE (decl
));
1395 else if (DECL_INITIAL (decl
))
1396 reloc
= output_addressed_constants (DECL_INITIAL (decl
));
1398 /* Switch to the appropriate section. */
1399 resolve_unique_section (decl
, reloc
);
1400 variable_section (decl
, reloc
);
1402 /* dbxout.c needs to know this. */
1403 if (in_text_section ())
1404 DECL_IN_TEXT_SECTION (decl
) = 1;
1406 /* Output the alignment of this data. */
1407 if (align
> BITS_PER_UNIT
)
1408 ASM_OUTPUT_ALIGN (asm_out_file
,
1409 floor_log2 (DECL_ALIGN (decl
) / BITS_PER_UNIT
));
1411 /* Do any machine/system dependent processing of the object. */
1412 #ifdef ASM_DECLARE_OBJECT_NAME
1413 last_assemble_variable_decl
= decl
;
1414 ASM_DECLARE_OBJECT_NAME (asm_out_file
, name
, decl
);
1416 /* Standard thing is just output label for the object. */
1417 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1418 #endif /* ASM_DECLARE_OBJECT_NAME */
1420 if (!dont_output_data
)
1422 if (DECL_INITIAL (decl
))
1423 /* Output the actual data. */
1424 output_constant (DECL_INITIAL (decl
),
1425 tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1427 /* Leave space for it. */
1428 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl
), 1));
1432 /* Return 1 if type TYPE contains any pointers. */
1435 contains_pointers_p (type
)
1438 switch (TREE_CODE (type
))
1441 case REFERENCE_TYPE
:
1442 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1443 so I'll play safe and return 1. */
1449 case QUAL_UNION_TYPE
:
1452 /* For a type that has fields, see if the fields have pointers. */
1453 for (fields
= TYPE_FIELDS (type
); fields
; fields
= TREE_CHAIN (fields
))
1454 if (TREE_CODE (fields
) == FIELD_DECL
1455 && contains_pointers_p (TREE_TYPE (fields
)))
1461 /* An array type contains pointers if its element type does. */
1462 return contains_pointers_p (TREE_TYPE (type
));
1469 /* Output something to declare an external symbol to the assembler.
1470 (Most assemblers don't need this, so we normally output nothing.)
1471 Do nothing if DECL is not external. */
1474 assemble_external (decl
)
1475 tree decl ATTRIBUTE_UNUSED
;
1477 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1478 main body of this code is only rarely exercised. To provide some
1479 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1480 open. If it's not, we should not be calling this function. */
1484 #ifdef ASM_OUTPUT_EXTERNAL
1485 if (DECL_P (decl
) && DECL_EXTERNAL (decl
) && TREE_PUBLIC (decl
))
1487 rtx rtl
= DECL_RTL (decl
);
1489 if (GET_CODE (rtl
) == MEM
&& GET_CODE (XEXP (rtl
, 0)) == SYMBOL_REF
1490 && ! SYMBOL_REF_USED (XEXP (rtl
, 0)))
1492 /* Some systems do require some output. */
1493 SYMBOL_REF_USED (XEXP (rtl
, 0)) = 1;
1494 ASM_OUTPUT_EXTERNAL (asm_out_file
, decl
, XSTR (XEXP (rtl
, 0), 0));
1500 /* Similar, for calling a library function FUN. */
1503 assemble_external_libcall (fun
)
1504 rtx fun ATTRIBUTE_UNUSED
;
1506 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1507 /* Declare library function name external when first used, if nec. */
1508 if (! SYMBOL_REF_USED (fun
))
1510 SYMBOL_REF_USED (fun
) = 1;
1511 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file
, fun
);
1516 /* Declare the label NAME global. */
1519 assemble_global (name
)
1522 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
1525 /* Assemble a label named NAME. */
1528 assemble_label (name
)
1531 ASM_OUTPUT_LABEL (asm_out_file
, name
);
1534 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1535 If NAME starts with a *, the rest of NAME is output verbatim.
1536 Otherwise NAME is transformed in an implementation-defined way
1537 (usually by the addition of an underscore).
1538 Many macros in the tm file are defined to call this function. */
1541 assemble_name (file
, name
)
1545 const char *real_name
;
1548 STRIP_NAME_ENCODING (real_name
, name
);
1549 if (flag_prefix_function_name
1550 && ! memcmp (real_name
, CHKR_PREFIX
, CHKR_PREFIX_SIZE
))
1551 real_name
= real_name
+ CHKR_PREFIX_SIZE
;
1553 id
= maybe_get_identifier (real_name
);
1555 TREE_SYMBOL_REFERENCED (id
) = 1;
1558 fputs (&name
[1], file
);
1560 ASM_OUTPUT_LABELREF (file
, name
);
1563 /* Allocate SIZE bytes writable static space with a gensym name
1564 and return an RTX to refer to its address. */
1567 assemble_static_space (size
)
1571 const char *namestring
;
1575 if (flag_shared_data
)
1579 ASM_GENERATE_INTERNAL_LABEL (name
, "LF", const_labelno
);
1581 namestring
= ggc_strdup (name
);
1583 x
= gen_rtx_SYMBOL_REF (Pmode
, namestring
);
1585 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1586 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file
, NULL_TREE
, name
, size
,
1589 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1590 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file
, name
, size
, BIGGEST_ALIGNMENT
);
1593 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1594 so that each uninitialized object starts on such a boundary. */
1595 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1596 int rounded ATTRIBUTE_UNUSED
1597 = ((size
+ (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
) - 1)
1598 / (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
1599 * (BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
));
1600 ASM_OUTPUT_LOCAL (asm_out_file
, name
, size
, rounded
);
1607 /* Assemble the static constant template for function entry trampolines.
1608 This is done at most once per compilation.
1609 Returns an RTX for the address of the template. */
1611 #ifdef TRAMPOLINE_TEMPLATE
1613 assemble_trampoline_template ()
1619 /* By default, put trampoline templates in read-only data section. */
1621 #ifdef TRAMPOLINE_SECTION
1622 TRAMPOLINE_SECTION ();
1624 readonly_data_section ();
1627 /* Write the assembler code to define one. */
1628 align
= floor_log2 (TRAMPOLINE_ALIGNMENT
/ BITS_PER_UNIT
);
1630 ASM_OUTPUT_ALIGN (asm_out_file
, align
);
1632 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LTRAMP", 0);
1633 TRAMPOLINE_TEMPLATE (asm_out_file
);
1635 /* Record the rtl to refer to it. */
1636 ASM_GENERATE_INTERNAL_LABEL (label
, "LTRAMP", 0);
1637 name
= ggc_strdup (label
);
1638 return gen_rtx_SYMBOL_REF (Pmode
, name
);
1642 /* Assemble the integer constant X into an object of SIZE bytes.
1643 X must be either a CONST_INT or CONST_DOUBLE.
1645 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1646 non-zero, abort if we can't output the constant. */
1649 assemble_integer (x
, size
, force
)
1654 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1655 ASM_OUTPUT... macros. */
1659 #ifdef ASM_OUTPUT_CHAR
1661 ASM_OUTPUT_CHAR (asm_out_file
, x
);
1665 #ifdef ASM_OUTPUT_SHORT
1667 ASM_OUTPUT_SHORT (asm_out_file
, x
);
1671 #ifdef ASM_OUTPUT_INT
1673 ASM_OUTPUT_INT (asm_out_file
, x
);
1677 #ifdef ASM_OUTPUT_DOUBLE_INT
1679 ASM_OUTPUT_DOUBLE_INT (asm_out_file
, x
);
1683 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1685 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file
, x
);
1690 /* If we couldn't do it that way, there are two other possibilities: First,
1691 if the machine can output an explicit byte and this is a 1 byte constant,
1692 we can use ASM_OUTPUT_BYTE. */
1694 #ifdef ASM_OUTPUT_BYTE
1695 if (size
== 1 && GET_CODE (x
) == CONST_INT
)
1697 ASM_OUTPUT_BYTE (asm_out_file
, INTVAL (x
));
1702 /* Finally, if SIZE is larger than a single word, try to output the constant
1703 one word at a time. */
1705 if (size
> UNITS_PER_WORD
)
1708 enum machine_mode mode
1709 = mode_for_size (size
* BITS_PER_UNIT
, MODE_INT
, 0);
1712 for (i
= 0; i
< size
/ UNITS_PER_WORD
; i
++)
1714 word
= operand_subword (x
, i
, 0, mode
);
1719 if (! assemble_integer (word
, UNITS_PER_WORD
, 0))
1723 if (i
== size
/ UNITS_PER_WORD
)
1725 /* If we output at least one word and then could not finish,
1726 there is no valid way to continue. */
1737 /* Assemble the floating-point constant D into an object of size MODE. */
1740 assemble_real (d
, mode
)
1742 enum machine_mode mode
;
1744 jmp_buf output_constant_handler
;
1746 if (setjmp (output_constant_handler
))
1748 error ("floating point trap outputting a constant");
1749 #ifdef REAL_IS_NOT_DOUBLE
1750 memset ((char *) &d
, 0, sizeof d
);
1757 set_float_handler (output_constant_handler
);
1761 #ifdef ASM_OUTPUT_BYTE_FLOAT
1763 ASM_OUTPUT_BYTE_FLOAT (asm_out_file
, d
);
1766 #ifdef ASM_OUTPUT_SHORT_FLOAT
1768 ASM_OUTPUT_SHORT_FLOAT (asm_out_file
, d
);
1771 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1773 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file
, d
);
1776 #ifdef ASM_OUTPUT_FLOAT
1778 ASM_OUTPUT_FLOAT (asm_out_file
, d
);
1782 #ifdef ASM_OUTPUT_DOUBLE
1784 ASM_OUTPUT_DOUBLE (asm_out_file
, d
);
1788 #ifdef ASM_OUTPUT_LONG_DOUBLE
1791 ASM_OUTPUT_LONG_DOUBLE (asm_out_file
, d
);
1799 set_float_handler (NULL
);
1802 /* Here we combine duplicate floating constants to make
1803 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1805 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1806 For an integer, I0 is the low-order word and I1 is the high-order word.
1807 For a real number, I0 is the word with the low address
1808 and I1 is the word with the high address. */
1811 immed_double_const (i0
, i1
, mode
)
1812 HOST_WIDE_INT i0
, i1
;
1813 enum machine_mode mode
;
1817 if (GET_MODE_CLASS (mode
) == MODE_INT
1818 || GET_MODE_CLASS (mode
) == MODE_PARTIAL_INT
)
1820 /* We clear out all bits that don't belong in MODE, unless they and our
1821 sign bit are all one. So we get either a reasonable negative value
1822 or a reasonable unsigned value for this mode. */
1823 int width
= GET_MODE_BITSIZE (mode
);
1824 if (width
< HOST_BITS_PER_WIDE_INT
1825 && ((i0
& ((HOST_WIDE_INT
) (-1) << (width
- 1)))
1826 != ((HOST_WIDE_INT
) (-1) << (width
- 1))))
1827 i0
&= ((HOST_WIDE_INT
) 1 << width
) - 1, i1
= 0;
1828 else if (width
== HOST_BITS_PER_WIDE_INT
1829 && ! (i1
== ~0 && i0
< 0))
1831 else if (width
> 2 * HOST_BITS_PER_WIDE_INT
)
1832 /* We cannot represent this value as a constant. */
1835 /* If this would be an entire word for the target, but is not for
1836 the host, then sign-extend on the host so that the number will look
1837 the same way on the host that it would on the target.
1839 For example, when building a 64 bit alpha hosted 32 bit sparc
1840 targeted compiler, then we want the 32 bit unsigned value -1 to be
1841 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
1842 The later confuses the sparc backend. */
1844 if (width
< HOST_BITS_PER_WIDE_INT
1845 && (i0
& ((HOST_WIDE_INT
) 1 << (width
- 1))))
1846 i0
|= ((HOST_WIDE_INT
) (-1) << width
);
1848 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
1850 ??? Strictly speaking, this is wrong if we create a CONST_INT
1851 for a large unsigned constant with the size of MODE being
1852 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
1853 wider mode. In that case we will mis-interpret it as a negative
1856 Unfortunately, the only alternative is to make a CONST_DOUBLE
1857 for any constant in any mode if it is an unsigned constant larger
1858 than the maximum signed integer in an int on the host. However,
1859 doing this will break everyone that always expects to see a CONST_INT
1860 for SImode and smaller.
1862 We have always been making CONST_INTs in this case, so nothing new
1865 if (width
<= HOST_BITS_PER_WIDE_INT
)
1866 i1
= (i0
< 0) ? ~(HOST_WIDE_INT
) 0 : 0;
1868 /* If this integer fits in one word, return a CONST_INT. */
1869 if ((i1
== 0 && i0
>= 0)
1870 || (i1
== ~0 && i0
< 0))
1871 return GEN_INT (i0
);
1873 /* We use VOIDmode for integers. */
1877 /* Search the chain for an existing CONST_DOUBLE with the right value.
1878 If one is found, return it. */
1880 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
1881 if (CONST_DOUBLE_LOW (r
) == i0
&& CONST_DOUBLE_HIGH (r
) == i1
1882 && GET_MODE (r
) == mode
)
1885 /* No; make a new one and add it to the chain. */
1886 r
= gen_rtx_CONST_DOUBLE (mode
, const0_rtx
, i0
, i1
);
1888 /* Don't touch const_double_chain if not inside any function. */
1889 if (current_function_decl
!= 0)
1891 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
1892 const_double_chain
= r
;
1898 /* Return a CONST_DOUBLE for a specified `double' value
1899 and machine mode. */
1902 immed_real_const_1 (d
, mode
)
1904 enum machine_mode mode
;
1906 union real_extract u
;
1909 /* Get the desired `double' value as a sequence of ints
1910 since that is how they are stored in a CONST_DOUBLE. */
1914 /* Detect special cases. */
1915 if (REAL_VALUES_IDENTICAL (dconst0
, d
))
1916 return CONST0_RTX (mode
);
1918 /* Check for NaN first, because some ports (specifically the i386) do not
1919 emit correct ieee-fp code by default, and thus will generate a core
1920 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
1921 does a floating point comparison. */
1922 else if (! REAL_VALUE_ISNAN (d
) && REAL_VALUES_EQUAL (dconst1
, d
))
1923 return CONST1_RTX (mode
);
1925 if (sizeof u
== sizeof (HOST_WIDE_INT
))
1926 return immed_double_const (u
.i
[0], 0, mode
);
1927 if (sizeof u
== 2 * sizeof (HOST_WIDE_INT
))
1928 return immed_double_const (u
.i
[0], u
.i
[1], mode
);
1930 /* The rest of this function handles the case where
1931 a float value requires more than 2 ints of space.
1932 It will be deleted as dead code on machines that don't need it. */
1934 /* Search the chain for an existing CONST_DOUBLE with the right value.
1935 If one is found, return it. */
1937 for (r
= const_double_chain
; r
; r
= CONST_DOUBLE_CHAIN (r
))
1938 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
)
1939 && GET_MODE (r
) == mode
)
1942 /* No; make a new one and add it to the chain.
1944 We may be called by an optimizer which may be discarding any memory
1945 allocated during its processing (such as combine and loop). However,
1946 we will be leaving this constant on the chain, so we cannot tolerate
1948 r
= rtx_alloc (CONST_DOUBLE
);
1950 memcpy ((char *) &CONST_DOUBLE_LOW (r
), (char *) &u
, sizeof u
);
1952 /* If we aren't inside a function, don't put r on the
1953 const_double_chain. */
1954 if (current_function_decl
!= 0)
1956 CONST_DOUBLE_CHAIN (r
) = const_double_chain
;
1957 const_double_chain
= r
;
1960 CONST_DOUBLE_CHAIN (r
) = NULL_RTX
;
1962 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
1963 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
1964 is only through force_const_mem. */
1966 CONST_DOUBLE_MEM (r
) = const0_rtx
;
1971 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
1972 which must be a REAL_CST tree node. */
1975 immed_real_const (exp
)
1978 return immed_real_const_1 (TREE_REAL_CST (exp
), TYPE_MODE (TREE_TYPE (exp
)));
1981 /* At the end of a function, forget the memory-constants
1982 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
1983 Also clear out real_constant_chain and clear out all the chain-pointers. */
1986 clear_const_double_mem ()
1988 register rtx r
, next
;
1989 enum machine_mode mode
;
1992 for (r
= const_double_chain
; r
; r
= next
)
1994 next
= CONST_DOUBLE_CHAIN (r
);
1995 CONST_DOUBLE_CHAIN (r
) = 0;
1996 CONST_DOUBLE_MEM (r
) = cc0_rtx
;
1998 const_double_chain
= 0;
2000 for (i
= 0; i
<= 2; i
++)
2001 for (mode
= GET_CLASS_NARROWEST_MODE (MODE_FLOAT
); mode
!= VOIDmode
;
2002 mode
= GET_MODE_WIDER_MODE (mode
))
2004 r
= const_tiny_rtx
[i
][(int) mode
];
2005 CONST_DOUBLE_CHAIN (r
) = 0;
2006 CONST_DOUBLE_MEM (r
) = cc0_rtx
;
2010 /* Given an expression EXP with a constant value,
2011 reduce it to the sum of an assembler symbol and an integer.
2012 Store them both in the structure *VALUE.
2013 Abort if EXP does not reduce. */
2018 HOST_WIDE_INT offset
;
2022 decode_addr_const (exp
, value
)
2024 struct addr_const
*value
;
2026 register tree target
= TREE_OPERAND (exp
, 0);
2027 register int offset
= 0;
2032 if (TREE_CODE (target
) == COMPONENT_REF
2033 && host_integerp (byte_position (TREE_OPERAND (target
, 1)), 0))
2036 offset
+= int_byte_position (TREE_OPERAND (target
, 1));
2037 target
= TREE_OPERAND (target
, 0);
2039 else if (TREE_CODE (target
) == ARRAY_REF
2040 || TREE_CODE (target
) == ARRAY_RANGE_REF
)
2042 offset
+= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target
)), 1)
2043 * tree_low_cst (TREE_OPERAND (target
, 1), 0));
2044 target
= TREE_OPERAND (target
, 0);
2050 switch (TREE_CODE (target
))
2054 x
= DECL_RTL (target
);
2058 x
= gen_rtx_MEM (FUNCTION_MODE
,
2059 gen_rtx_LABEL_REF (VOIDmode
,
2060 label_rtx (TREE_OPERAND (exp
, 0))));
2068 x
= TREE_CST_RTL (target
);
2075 if (GET_CODE (x
) != MEM
)
2080 value
->offset
= offset
;
2083 enum kind
{ RTX_DOUBLE
, RTX_INT
};
2086 ENUM_BITFIELD(kind
) kind
: 16;
2087 ENUM_BITFIELD(machine_mode
) mode
: 16;
2089 union real_extract du
;
2090 struct addr_const addr
;
2091 struct {HOST_WIDE_INT high
, low
;} di
;
2095 /* Uniquize all constants that appear in memory.
2096 Each constant in memory thus far output is recorded
2097 in `const_hash_table' with a `struct constant_descriptor'
2098 that contains a polish representation of the value of
2101 We cannot store the trees in the hash table
2102 because the trees may be temporary. */
2104 struct constant_descriptor
2106 struct constant_descriptor
*next
;
2109 /* Make sure the data is reasonably aligned. */
2112 unsigned char contents
[1];
2113 #ifdef HAVE_LONG_DOUBLE
2122 #define MAX_HASH_TABLE 1009
2123 static struct constant_descriptor
*const_hash_table
[MAX_HASH_TABLE
];
2125 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2127 struct deferred_string
2134 static htab_t const_str_htab
;
2136 /* Mark a const_hash_table descriptor for GC. */
2139 mark_const_hash_entry (ptr
)
2142 struct constant_descriptor
*desc
= * (struct constant_descriptor
**) ptr
;
2146 ggc_mark_rtx (desc
->rtl
);
2151 /* Mark the hash-table element X (which is really a pointer to an
2152 struct deferred_string *). */
2155 mark_const_str_htab_1 (x
, data
)
2157 void *data ATTRIBUTE_UNUSED
;
2159 ggc_mark_tree (((struct deferred_string
*) *x
)->exp
);
2163 /* Mark a const_str_htab for GC. */
2166 mark_const_str_htab (htab
)
2169 htab_traverse (*((htab_t
*) htab
), mark_const_str_htab_1
, NULL
);
2172 /* Returns a hash code for X (which is a really a
2173 struct deferred_string *). */
2176 const_str_htab_hash (x
)
2179 return STRHASH (((const struct deferred_string
*) x
)->label
);
2182 /* Returns non-zero if the value represented by X (which is really a
2183 struct deferred_string *) is the same as that given by Y
2184 (which is really a char *). */
2187 const_str_htab_eq (x
, y
)
2191 return (((const struct deferred_string
*) x
)->label
== (const char *) y
);
2194 /* Delete the hash table entry dfsp. */
2197 const_str_htab_del (dfsp
)
2203 /* Compute a hash code for a constant expression. */
2209 register const char *p
;
2210 register int len
, hi
, i
;
2211 register enum tree_code code
= TREE_CODE (exp
);
2213 /* Either set P and LEN to the address and len of something to hash and
2214 exit the switch or return a value. */
2219 p
= (char *) &TREE_INT_CST (exp
);
2220 len
= sizeof TREE_INT_CST (exp
);
2224 p
= (char *) &TREE_REAL_CST (exp
);
2225 len
= sizeof TREE_REAL_CST (exp
);
2229 p
= TREE_STRING_POINTER (exp
);
2230 len
= TREE_STRING_LENGTH (exp
);
2234 return (const_hash (TREE_REALPART (exp
)) * 5
2235 + const_hash (TREE_IMAGPART (exp
)));
2238 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2242 len
= int_size_in_bytes (TREE_TYPE (exp
));
2243 tmp
= (char *) alloca (len
);
2244 get_set_constructor_bytes (exp
, (unsigned char *) tmp
, len
);
2252 /* For record type, include the type in the hashing.
2253 We do not do so for array types
2254 because (1) the sizes of the elements are sufficient
2255 and (2) distinct array types can have the same constructor.
2256 Instead, we include the array size because the constructor could
2258 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2259 hi
= ((unsigned long) TREE_TYPE (exp
) & ((1 << HASHBITS
) - 1))
2262 hi
= ((5 + int_size_in_bytes (TREE_TYPE (exp
)))
2263 & ((1 << HASHBITS
) - 1)) % MAX_HASH_TABLE
;
2265 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2266 if (TREE_VALUE (link
))
2268 = (hi
* 603 + const_hash (TREE_VALUE (link
))) % MAX_HASH_TABLE
;
2275 struct addr_const value
;
2277 decode_addr_const (exp
, &value
);
2278 if (GET_CODE (value
.base
) == SYMBOL_REF
)
2280 /* Don't hash the address of the SYMBOL_REF;
2281 only use the offset and the symbol name. */
2283 p
= XSTR (value
.base
, 0);
2284 for (i
= 0; p
[i
] != 0; i
++)
2285 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2287 else if (GET_CODE (value
.base
) == LABEL_REF
)
2288 hi
= value
.offset
+ CODE_LABEL_NUMBER (XEXP (value
.base
, 0)) * 13;
2292 hi
&= (1 << HASHBITS
) - 1;
2293 hi
%= MAX_HASH_TABLE
;
2299 return (const_hash (TREE_OPERAND (exp
, 0)) * 9
2300 + const_hash (TREE_OPERAND (exp
, 1)));
2304 case NON_LVALUE_EXPR
:
2305 return const_hash (TREE_OPERAND (exp
, 0)) * 7 + 2;
2308 /* A language specific constant. Just hash the code. */
2309 return (int) code
% MAX_HASH_TABLE
;
2312 /* Compute hashing function */
2314 for (i
= 0; i
< len
; i
++)
2315 hi
= ((hi
* 613) + (unsigned) (p
[i
]));
2317 hi
&= (1 << HASHBITS
) - 1;
2318 hi
%= MAX_HASH_TABLE
;
2322 /* Compare a constant expression EXP with a constant-descriptor DESC.
2323 Return 1 if DESC describes a constant with the same value as EXP. */
2326 compare_constant (exp
, desc
)
2328 struct constant_descriptor
*desc
;
2330 return 0 != compare_constant_1 (exp
, desc
->u
.contents
);
2333 /* Compare constant expression EXP with a substring P of a constant descriptor.
2334 If they match, return a pointer to the end of the substring matched.
2335 If they do not match, return 0.
2337 Since descriptors are written in polish prefix notation,
2338 this function can be used recursively to test one operand of EXP
2339 against a subdescriptor, and if it succeeds it returns the
2340 address of the subdescriptor for the next operand. */
2342 static const unsigned char *
2343 compare_constant_1 (exp
, p
)
2345 const unsigned char *p
;
2347 register const unsigned char *strp
;
2349 register enum tree_code code
= TREE_CODE (exp
);
2351 if (code
!= (enum tree_code
) *p
++)
2354 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2355 switch, or return the result of the comparison. */
2360 /* Integer constants are the same only if the same width of type. */
2361 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2364 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2365 len
= sizeof TREE_INT_CST (exp
);
2369 /* Real constants are the same only if the same width of type. */
2370 if (*p
++ != TYPE_PRECISION (TREE_TYPE (exp
)))
2373 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2374 len
= sizeof TREE_REAL_CST (exp
);
2378 if (flag_writable_strings
)
2381 if ((enum machine_mode
) *p
++ != TYPE_MODE (TREE_TYPE (exp
)))
2384 strp
= (const unsigned char *)TREE_STRING_POINTER (exp
);
2385 len
= TREE_STRING_LENGTH (exp
);
2386 if (memcmp ((char *) &TREE_STRING_LENGTH (exp
), p
,
2387 sizeof TREE_STRING_LENGTH (exp
)))
2390 p
+= sizeof TREE_STRING_LENGTH (exp
);
2394 p
= compare_constant_1 (TREE_REALPART (exp
), p
);
2398 return compare_constant_1 (TREE_IMAGPART (exp
), p
);
2401 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2403 int xlen
= len
= int_size_in_bytes (TREE_TYPE (exp
));
2404 unsigned char *tmp
= (unsigned char *) alloca (len
);
2406 get_set_constructor_bytes (exp
, tmp
, len
);
2407 strp
= (unsigned char *) tmp
;
2408 if (memcmp ((char *) &xlen
, p
, sizeof xlen
))
2417 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2419 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2420 int have_purpose
= 0;
2422 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2423 if (TREE_PURPOSE (link
))
2426 if (memcmp ((char *) &length
, p
, sizeof length
))
2431 /* For record constructors, insist that the types match.
2432 For arrays, just verify both constructors are for arrays.
2433 Then insist that either both or none have any TREE_PURPOSE
2435 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2436 type
= TREE_TYPE (exp
);
2440 if (memcmp ((char *) &type
, p
, sizeof type
))
2443 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2445 if (memcmp ((char *) &mode
, p
, sizeof mode
))
2453 if (memcmp ((char *) &have_purpose
, p
, sizeof have_purpose
))
2456 p
+= sizeof have_purpose
;
2458 /* For arrays, insist that the size in bytes match. */
2459 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2461 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2463 if (memcmp ((char *) &size
, p
, sizeof size
))
2469 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2471 if (TREE_VALUE (link
))
2473 if ((p
= compare_constant_1 (TREE_VALUE (link
), p
)) == 0)
2480 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2486 if (TREE_PURPOSE (link
)
2487 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2489 if (memcmp ((char *) &TREE_PURPOSE (link
), p
,
2490 sizeof TREE_PURPOSE (link
)))
2493 p
+= sizeof TREE_PURPOSE (link
);
2495 else if (TREE_PURPOSE (link
))
2497 if ((p
= compare_constant_1 (TREE_PURPOSE (link
), p
)) == 0)
2500 else if (have_purpose
)
2504 if (memcmp ((char *) &zero
, p
, sizeof zero
))
2516 struct addr_const value
;
2518 decode_addr_const (exp
, &value
);
2519 strp
= (unsigned char *) &value
.offset
;
2520 len
= sizeof value
.offset
;
2521 /* Compare the offset. */
2523 if (*p
++ != *strp
++)
2526 /* Compare symbol name. */
2527 strp
= (const unsigned char *) XSTR (value
.base
, 0);
2528 len
= strlen ((const char *) strp
) + 1;
2535 p
= compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2539 return compare_constant_1 (TREE_OPERAND (exp
, 1), p
);
2543 case NON_LVALUE_EXPR
:
2544 return compare_constant_1 (TREE_OPERAND (exp
, 0), p
);
2547 if (lang_expand_constant
)
2549 exp
= (*lang_expand_constant
) (exp
);
2550 return compare_constant_1 (exp
, p
);
2555 /* Compare constant contents. */
2557 if (*p
++ != *strp
++)
2563 /* Construct a constant descriptor for the expression EXP.
2564 It is up to the caller to enter the descriptor in the hash table. */
2566 static struct constant_descriptor
*
2567 record_constant (exp
)
2570 struct constant_descriptor
*next
= 0;
2575 /* Make a struct constant_descriptor. The first three pointers will
2576 be filled in later. Here we just leave space for them. */
2578 obstack_grow (&permanent_obstack
, (char *) &next
, sizeof next
);
2579 obstack_grow (&permanent_obstack
, (char *) &label
, sizeof label
);
2580 obstack_grow (&permanent_obstack
, (char *) &rtl
, sizeof rtl
);
2582 /* Align the descriptor for the data payload. */
2583 pad
= (offsetof (struct constant_descriptor
, u
)
2584 - offsetof(struct constant_descriptor
, rtl
)
2585 - sizeof(next
->rtl
));
2587 obstack_blank (&permanent_obstack
, pad
);
2589 record_constant_1 (exp
);
2590 return (struct constant_descriptor
*) obstack_finish (&permanent_obstack
);
2593 /* Add a description of constant expression EXP
2594 to the object growing in `permanent_obstack'.
2595 No need to return its address; the caller will get that
2596 from the obstack when the object is complete. */
2599 record_constant_1 (exp
)
2602 register const unsigned char *strp
;
2604 register enum tree_code code
= TREE_CODE (exp
);
2606 obstack_1grow (&permanent_obstack
, (unsigned int) code
);
2611 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2612 strp
= (unsigned char *) &TREE_INT_CST (exp
);
2613 len
= sizeof TREE_INT_CST (exp
);
2617 obstack_1grow (&permanent_obstack
, TYPE_PRECISION (TREE_TYPE (exp
)));
2618 strp
= (unsigned char *) &TREE_REAL_CST (exp
);
2619 len
= sizeof TREE_REAL_CST (exp
);
2623 if (flag_writable_strings
)
2626 obstack_1grow (&permanent_obstack
, TYPE_MODE (TREE_TYPE (exp
)));
2627 strp
= (const unsigned char *) TREE_STRING_POINTER (exp
);
2628 len
= TREE_STRING_LENGTH (exp
);
2629 obstack_grow (&permanent_obstack
, (char *) &TREE_STRING_LENGTH (exp
),
2630 sizeof TREE_STRING_LENGTH (exp
));
2634 record_constant_1 (TREE_REALPART (exp
));
2635 record_constant_1 (TREE_IMAGPART (exp
));
2639 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2641 int nbytes
= int_size_in_bytes (TREE_TYPE (exp
));
2642 obstack_grow (&permanent_obstack
, &nbytes
, sizeof (nbytes
));
2643 obstack_blank (&permanent_obstack
, nbytes
);
2644 get_set_constructor_bytes
2645 (exp
, (unsigned char *) permanent_obstack
.next_free
-nbytes
,
2652 int length
= list_length (CONSTRUCTOR_ELTS (exp
));
2653 enum machine_mode mode
= TYPE_MODE (TREE_TYPE (exp
));
2655 int have_purpose
= 0;
2657 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2658 if (TREE_PURPOSE (link
))
2661 obstack_grow (&permanent_obstack
, (char *) &length
, sizeof length
);
2663 /* For record constructors, insist that the types match.
2664 For arrays, just verify both constructors are for arrays
2665 of the same mode. Then insist that either both or none
2666 have any TREE_PURPOSE values. */
2667 if (TREE_CODE (TREE_TYPE (exp
)) == RECORD_TYPE
)
2668 type
= TREE_TYPE (exp
);
2672 obstack_grow (&permanent_obstack
, (char *) &type
, sizeof type
);
2673 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2674 obstack_grow (&permanent_obstack
, &mode
, sizeof mode
);
2676 obstack_grow (&permanent_obstack
, (char *) &have_purpose
,
2677 sizeof have_purpose
);
2679 /* For arrays, insist that the size in bytes match. */
2680 if (TREE_CODE (TREE_TYPE (exp
)) == ARRAY_TYPE
)
2682 HOST_WIDE_INT size
= int_size_in_bytes (TREE_TYPE (exp
));
2683 obstack_grow (&permanent_obstack
, (char *) &size
, sizeof size
);
2686 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
2688 if (TREE_VALUE (link
))
2689 record_constant_1 (TREE_VALUE (link
));
2694 obstack_grow (&permanent_obstack
,
2695 (char *) &zero
, sizeof zero
);
2698 if (TREE_PURPOSE (link
)
2699 && TREE_CODE (TREE_PURPOSE (link
)) == FIELD_DECL
)
2700 obstack_grow (&permanent_obstack
,
2701 (char *) &TREE_PURPOSE (link
),
2702 sizeof TREE_PURPOSE (link
));
2703 else if (TREE_PURPOSE (link
))
2704 record_constant_1 (TREE_PURPOSE (link
));
2705 else if (have_purpose
)
2709 obstack_grow (&permanent_obstack
,
2710 (char *) &zero
, sizeof zero
);
2718 struct addr_const value
;
2720 decode_addr_const (exp
, &value
);
2721 /* Record the offset. */
2722 obstack_grow (&permanent_obstack
,
2723 (char *) &value
.offset
, sizeof value
.offset
);
2725 switch (GET_CODE (value
.base
))
2728 /* Record the symbol name. */
2729 obstack_grow (&permanent_obstack
, XSTR (value
.base
, 0),
2730 strlen (XSTR (value
.base
, 0)) + 1);
2733 /* Record the address of the CODE_LABEL. It may not have
2734 been emitted yet, so it's UID may be zero. But pointer
2735 identity is good enough. */
2736 obstack_grow (&permanent_obstack
, &XEXP (value
.base
, 0),
2748 record_constant_1 (TREE_OPERAND (exp
, 0));
2749 record_constant_1 (TREE_OPERAND (exp
, 1));
2754 case NON_LVALUE_EXPR
:
2755 record_constant_1 (TREE_OPERAND (exp
, 0));
2759 if (lang_expand_constant
)
2761 exp
= (*lang_expand_constant
) (exp
);
2762 record_constant_1 (exp
);
2767 /* Record constant contents. */
2768 obstack_grow (&permanent_obstack
, strp
, len
);
2771 /* Record a list of constant expressions that were passed to
2772 output_constant_def but that could not be output right away. */
2774 struct deferred_constant
2776 struct deferred_constant
*next
;
2782 static struct deferred_constant
*deferred_constants
;
2784 /* Another list of constants which should be output after the
2786 static struct deferred_constant
*after_function_constants
;
2788 /* Nonzero means defer output of addressed subconstants
2789 (i.e., those for which output_constant_def is called.) */
2790 static int defer_addressed_constants_flag
;
2792 /* Start deferring output of subconstants. */
2795 defer_addressed_constants ()
2797 defer_addressed_constants_flag
++;
2800 /* Stop deferring output of subconstants,
2801 and output now all those that have been deferred. */
2804 output_deferred_addressed_constants ()
2806 struct deferred_constant
*p
, *next
;
2808 defer_addressed_constants_flag
--;
2810 if (defer_addressed_constants_flag
> 0)
2813 for (p
= deferred_constants
; p
; p
= next
)
2815 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2820 deferred_constants
= 0;
2823 /* Output any constants which should appear after a function. */
2826 output_after_function_constants ()
2828 struct deferred_constant
*p
, *next
;
2830 for (p
= after_function_constants
; p
; p
= next
)
2832 output_constant_def_contents (p
->exp
, p
->reloc
, p
->labelno
);
2837 after_function_constants
= 0;
2840 /* Make a copy of the whole tree structure for a constant.
2841 This handles the same types of nodes that compare_constant
2842 and record_constant handle. */
2848 switch (TREE_CODE (exp
))
2851 /* For ADDR_EXPR, we do not want to copy the decl whose address
2852 is requested. We do want to copy constants though. */
2853 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp
, 0))) == 'c')
2854 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2855 copy_constant (TREE_OPERAND (exp
, 0)));
2857 return copy_node (exp
);
2862 return copy_node (exp
);
2865 return build_complex (TREE_TYPE (exp
),
2866 copy_constant (TREE_REALPART (exp
)),
2867 copy_constant (TREE_IMAGPART (exp
)));
2871 return build (TREE_CODE (exp
), TREE_TYPE (exp
),
2872 copy_constant (TREE_OPERAND (exp
, 0)),
2873 copy_constant (TREE_OPERAND (exp
, 1)));
2877 case NON_LVALUE_EXPR
:
2878 return build1 (TREE_CODE (exp
), TREE_TYPE (exp
),
2879 copy_constant (TREE_OPERAND (exp
, 0)));
2883 tree copy
= copy_node (exp
);
2884 tree list
= copy_list (CONSTRUCTOR_ELTS (exp
));
2887 CONSTRUCTOR_ELTS (copy
) = list
;
2888 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2889 TREE_VALUE (tail
) = copy_constant (TREE_VALUE (tail
));
2890 if (TREE_CODE (TREE_TYPE (exp
)) == SET_TYPE
)
2891 for (tail
= list
; tail
; tail
= TREE_CHAIN (tail
))
2892 TREE_PURPOSE (tail
) = copy_constant (TREE_PURPOSE (tail
));
2902 /* Return an rtx representing a reference to constant data in memory
2903 for the constant expression EXP.
2905 If assembler code for such a constant has already been output,
2906 return an rtx to refer to it.
2907 Otherwise, output such a constant in memory (or defer it for later)
2908 and generate an rtx for it.
2910 If DEFER is non-zero, the output of string constants can be deferred
2911 and output only if referenced in the function after all optimizations.
2913 The TREE_CST_RTL of EXP is set up to point to that rtx.
2914 The const_hash_table records which constants already have label strings. */
2917 output_constant_def (exp
, defer
)
2922 register struct constant_descriptor
*desc
;
2923 struct deferred_string
**defstr
;
2927 int after_function
= 0;
2930 if (TREE_CST_RTL (exp
))
2931 return TREE_CST_RTL (exp
);
2933 /* Make sure any other constants whose addresses appear in EXP
2934 are assigned label numbers. */
2936 reloc
= output_addressed_constants (exp
);
2938 /* Compute hash code of EXP. Search the descriptors for that hash code
2939 to see if any of them describes EXP. If yes, the descriptor records
2940 the label number already assigned. */
2942 hash
= const_hash (exp
) % MAX_HASH_TABLE
;
2944 for (desc
= const_hash_table
[hash
]; desc
; desc
= desc
->next
)
2945 if (compare_constant (exp
, desc
))
2950 /* No constant equal to EXP is known to have been output.
2951 Make a constant descriptor to enter EXP in the hash table.
2952 Assign the label number and record it in the descriptor for
2953 future calls to this function to find. */
2955 /* Create a string containing the label name, in LABEL. */
2956 labelno
= const_labelno
++;
2957 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", labelno
);
2959 desc
= record_constant (exp
);
2960 desc
->next
= const_hash_table
[hash
];
2961 desc
->label
= ggc_strdup (label
);
2962 const_hash_table
[hash
] = desc
;
2964 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2966 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp
)),
2967 gen_rtx_SYMBOL_REF (Pmode
, desc
->label
));
2969 set_mem_attributes (desc
->rtl
, exp
, 1);
2974 TREE_CST_RTL (exp
) = desc
->rtl
;
2976 /* Optionally set flags or add text to the name to record information
2977 such as that it is a function name. If the name is changed, the macro
2978 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
2979 #ifdef ENCODE_SECTION_INFO
2980 /* A previously-processed constant would already have section info
2984 ENCODE_SECTION_INFO (exp
);
2985 desc
->rtl
= TREE_CST_RTL (exp
);
2986 desc
->label
= XSTR (XEXP (desc
->rtl
, 0), 0);
2990 #ifdef CONSTANT_AFTER_FUNCTION_P
2991 if (current_function_decl
!= 0
2992 && CONSTANT_AFTER_FUNCTION_P (exp
))
2997 && STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0))
2998 && (!defer
|| defer_addressed_constants_flag
|| after_function
))
3000 defstr
= (struct deferred_string
**)
3001 htab_find_slot_with_hash (const_str_htab
, desc
->label
,
3002 STRHASH (desc
->label
), NO_INSERT
);
3005 /* If the string is currently deferred but we need to output it now,
3006 remove it from deferred string hash table. */
3008 labelno
= (*defstr
)->labelno
;
3009 STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0)) = 0;
3010 htab_clear_slot (const_str_htab
, (void **) defstr
);
3014 /* If this is the first time we've seen this particular constant,
3015 output it (or defer its output for later). */
3018 if (defer_addressed_constants_flag
|| after_function
)
3020 struct deferred_constant
*p
;
3021 p
= (struct deferred_constant
*) xmalloc (sizeof (struct deferred_constant
));
3023 p
->exp
= copy_constant (exp
);
3025 p
->labelno
= labelno
;
3028 p
->next
= after_function_constants
;
3029 after_function_constants
= p
;
3033 p
->next
= deferred_constants
;
3034 deferred_constants
= p
;
3039 /* Do no output if -fsyntax-only. */
3040 if (! flag_syntax_only
)
3042 if (TREE_CODE (exp
) != STRING_CST
3044 || flag_writable_strings
3045 || (defstr
= (struct deferred_string
**)
3046 htab_find_slot_with_hash (const_str_htab
,
3048 STRHASH (desc
->label
),
3050 output_constant_def_contents (exp
, reloc
, labelno
);
3053 struct deferred_string
*p
;
3055 p
= (struct deferred_string
*)
3056 xmalloc (sizeof (struct deferred_string
));
3058 p
->exp
= copy_constant (exp
);
3059 p
->label
= desc
->label
;
3060 p
->labelno
= labelno
;
3062 STRING_POOL_ADDRESS_P (XEXP (desc
->rtl
, 0)) = 1;
3068 return TREE_CST_RTL (exp
);
3071 /* Now output assembler code to define the label for EXP,
3072 and follow it with the data of EXP. */
3075 output_constant_def_contents (exp
, reloc
, labelno
)
3082 if (IN_NAMED_SECTION (exp
))
3083 named_section (exp
, NULL
, reloc
);
3086 /* First switch to text section, except for writable strings. */
3087 #ifdef SELECT_SECTION
3088 SELECT_SECTION (exp
, reloc
);
3090 if (((TREE_CODE (exp
) == STRING_CST
) && flag_writable_strings
)
3091 || (flag_pic
&& reloc
))
3094 readonly_data_section ();
3098 /* Align the location counter as required by EXP's data type. */
3099 align
= TYPE_ALIGN (TREE_TYPE (exp
));
3100 #ifdef CONSTANT_ALIGNMENT
3101 align
= CONSTANT_ALIGNMENT (exp
, align
);
3104 if (align
> BITS_PER_UNIT
)
3105 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (align
/ BITS_PER_UNIT
));
3107 /* Output the label itself. */
3108 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", labelno
);
3110 /* Output the value of EXP. */
3111 output_constant (exp
,
3112 (TREE_CODE (exp
) == STRING_CST
3113 ? MAX (TREE_STRING_LENGTH (exp
),
3114 int_size_in_bytes (TREE_TYPE (exp
)))
3115 : int_size_in_bytes (TREE_TYPE (exp
))));
3119 /* Structure to represent sufficient information about a constant so that
3120 it can be output when the constant pool is output, so that function
3121 integration can be done, and to simplify handling on machines that reference
3122 constant pool as base+displacement. */
3124 struct pool_constant
3126 struct constant_descriptor
*desc
;
3127 struct pool_constant
*next
, *next_sym
;
3130 enum machine_mode mode
;
3137 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3138 The argument is XSTR (... , 0) */
3140 #define SYMHASH(LABEL) \
3141 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3143 /* Initialize constant pool hashing for a new function. */
3146 init_varasm_status (f
)
3149 struct varasm_status
*p
;
3150 p
= (struct varasm_status
*) xmalloc (sizeof (struct varasm_status
));
3152 p
->x_const_rtx_hash_table
3153 = ((struct constant_descriptor
**)
3154 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct constant_descriptor
*)));
3155 p
->x_const_rtx_sym_hash_table
3156 = ((struct pool_constant
**)
3157 xcalloc (MAX_RTX_HASH_TABLE
, sizeof (struct pool_constant
*)));
3159 p
->x_first_pool
= p
->x_last_pool
= 0;
3160 p
->x_pool_offset
= 0;
3161 p
->x_const_double_chain
= 0;
3164 /* Mark PC for GC. */
3167 mark_pool_constant (pc
)
3168 struct pool_constant
*pc
;
3173 ggc_mark_rtx (pc
->constant
);
3178 /* Mark P for GC. */
3181 mark_varasm_status (p
)
3182 struct varasm_status
*p
;
3187 mark_pool_constant (p
->x_first_pool
);
3188 ggc_mark_rtx (p
->x_const_double_chain
);
3191 /* Clear out all parts of the state in F that can safely be discarded
3192 after the function has been compiled, to let garbage collection
3193 reclaim the memory. */
3196 free_varasm_status (f
)
3199 struct varasm_status
*p
;
3204 /* Clear out the hash tables. */
3205 for (i
= 0; i
< MAX_RTX_HASH_TABLE
; ++i
)
3207 struct constant_descriptor
* cd
;
3209 cd
= p
->x_const_rtx_hash_table
[i
];
3211 struct constant_descriptor
* next
= cd
->next
;
3217 free (p
->x_const_rtx_hash_table
);
3218 free (p
->x_const_rtx_sym_hash_table
);
3224 /* Express an rtx for a constant integer (perhaps symbolic)
3225 as the sum of a symbol or label plus an explicit integer.
3226 They are stored into VALUE. */
3229 decode_rtx_const (mode
, x
, value
)
3230 enum machine_mode mode
;
3232 struct rtx_const
*value
;
3234 /* Clear the whole structure, including any gaps. */
3235 memset (value
, 0, sizeof (struct rtx_const
));
3237 value
->kind
= RTX_INT
; /* Most usual kind. */
3240 switch (GET_CODE (x
))
3243 value
->kind
= RTX_DOUBLE
;
3244 if (GET_MODE (x
) != VOIDmode
)
3246 value
->mode
= GET_MODE (x
);
3247 memcpy ((char *) &value
->un
.du
,
3248 (char *) &CONST_DOUBLE_LOW (x
), sizeof value
->un
.du
);
3252 value
->un
.di
.low
= CONST_DOUBLE_LOW (x
);
3253 value
->un
.di
.high
= CONST_DOUBLE_HIGH (x
);
3258 value
->un
.addr
.offset
= INTVAL (x
);
3264 value
->un
.addr
.base
= x
;
3269 if (GET_CODE (x
) == PLUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3271 value
->un
.addr
.base
= XEXP (x
, 0);
3272 value
->un
.addr
.offset
= INTVAL (XEXP (x
, 1));
3274 else if (GET_CODE (x
) == MINUS
&& GET_CODE (XEXP (x
, 1)) == CONST_INT
)
3276 value
->un
.addr
.base
= XEXP (x
, 0);
3277 value
->un
.addr
.offset
= - INTVAL (XEXP (x
, 1));
3281 value
->un
.addr
.base
= x
;
3282 value
->un
.addr
.offset
= 0;
3290 if (value
->kind
== RTX_INT
&& value
->un
.addr
.base
!= 0)
3291 switch (GET_CODE (value
->un
.addr
.base
))
3294 /* Use the string's address, not the SYMBOL_REF's address,
3295 for the sake of addresses of library routines. */
3296 value
->un
.addr
.base
= (rtx
) XSTR (value
->un
.addr
.base
, 0);
3300 /* For a LABEL_REF, compare labels. */
3301 value
->un
.addr
.base
= XEXP (value
->un
.addr
.base
, 0);
3308 /* Given a MINUS expression, simplify it if both sides
3309 include the same symbol. */
3312 simplify_subtraction (x
)
3315 struct rtx_const val0
, val1
;
3317 decode_rtx_const (GET_MODE (x
), XEXP (x
, 0), &val0
);
3318 decode_rtx_const (GET_MODE (x
), XEXP (x
, 1), &val1
);
3320 if (val0
.un
.addr
.base
== val1
.un
.addr
.base
)
3321 return GEN_INT (val0
.un
.addr
.offset
- val1
.un
.addr
.offset
);
3325 /* Compute a hash code for a constant RTL expression. */
3328 const_hash_rtx (mode
, x
)
3329 enum machine_mode mode
;
3335 struct rtx_const value
;
3336 decode_rtx_const (mode
, x
, &value
);
3338 /* Compute hashing function */
3340 for (i
= 0; i
< sizeof value
/ sizeof (int); i
++)
3341 hi
+= ((int *) &value
)[i
];
3343 hi
&= (1 << HASHBITS
) - 1;
3344 hi
%= MAX_RTX_HASH_TABLE
;
3348 /* Compare a constant rtl object X with a constant-descriptor DESC.
3349 Return 1 if DESC describes a constant with the same value as X. */
3352 compare_constant_rtx (mode
, x
, desc
)
3353 enum machine_mode mode
;
3355 struct constant_descriptor
*desc
;
3357 register int *p
= (int *) desc
->u
.contents
;
3360 struct rtx_const value
;
3362 decode_rtx_const (mode
, x
, &value
);
3363 strp
= (int *) &value
;
3364 len
= sizeof value
/ sizeof (int);
3366 /* Compare constant contents. */
3368 if (*p
++ != *strp
++)
3374 /* Construct a constant descriptor for the rtl-expression X.
3375 It is up to the caller to enter the descriptor in the hash table. */
3377 static struct constant_descriptor
*
3378 record_constant_rtx (mode
, x
)
3379 enum machine_mode mode
;
3382 struct constant_descriptor
*ptr
;
3384 ptr
= ((struct constant_descriptor
*)
3385 xcalloc (1, (offsetof (struct constant_descriptor
, u
)
3386 + sizeof (struct rtx_const
))));
3387 decode_rtx_const (mode
, x
, (struct rtx_const
*) ptr
->u
.contents
);
3392 /* Given a constant rtx X, make (or find) a memory constant for its value
3393 and return a MEM rtx to refer to it in memory. */
3396 force_const_mem (mode
, x
)
3397 enum machine_mode mode
;
3401 register struct constant_descriptor
*desc
;
3403 const char *found
= 0;
3406 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3407 (this will always be true for floating CONST_DOUBLEs that have been
3408 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3409 use the previous copy. Otherwise, make a new one. Note that in
3410 the unlikely event that this same CONST_DOUBLE is used in two different
3411 modes in an alternating fashion, we will allocate a lot of different
3412 memory locations, but this should be extremely rare. */
3414 if (GET_CODE (x
) == CONST_DOUBLE
3415 && GET_CODE (CONST_DOUBLE_MEM (x
)) == MEM
3416 && GET_MODE (CONST_DOUBLE_MEM (x
)) == mode
)
3417 return CONST_DOUBLE_MEM (x
);
3419 /* Compute hash code of X. Search the descriptors for that hash code
3420 to see if any of them describes X. If yes, the descriptor records
3421 the label number already assigned. */
3423 hash
= const_hash_rtx (mode
, x
);
3425 for (desc
= const_rtx_hash_table
[hash
]; desc
; desc
= desc
->next
)
3426 if (compare_constant_rtx (mode
, x
, desc
))
3428 found
= desc
->label
;
3434 register struct pool_constant
*pool
;
3437 /* No constant equal to X is known to have been output.
3438 Make a constant descriptor to enter X in the hash table.
3439 Assign the label number and record it in the descriptor for
3440 future calls to this function to find. */
3442 desc
= record_constant_rtx (mode
, x
);
3443 desc
->next
= const_rtx_hash_table
[hash
];
3444 const_rtx_hash_table
[hash
] = desc
;
3446 /* Align the location counter as required by EXP's data type. */
3447 align
= (mode
== VOIDmode
) ? UNITS_PER_WORD
: GET_MODE_SIZE (mode
);
3448 if (align
> BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
)
3449 align
= BIGGEST_ALIGNMENT
/ BITS_PER_UNIT
;
3450 #ifdef CONSTANT_ALIGNMENT
3451 align
= CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode
, 0), x
),
3452 align
* BITS_PER_UNIT
) / BITS_PER_UNIT
;
3455 pool_offset
+= align
- 1;
3456 pool_offset
&= ~ (align
- 1);
3458 if (GET_CODE (x
) == LABEL_REF
)
3459 LABEL_PRESERVE_P (XEXP (x
, 0)) = 1;
3461 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3463 pool
= (struct pool_constant
*) ggc_alloc (sizeof (struct pool_constant
));
3467 pool
->labelno
= const_labelno
;
3468 pool
->align
= align
;
3469 pool
->offset
= pool_offset
;
3476 last_pool
->next
= pool
;
3479 pool_offset
+= GET_MODE_SIZE (mode
);
3481 /* Create a string containing the label name, in LABEL. */
3482 ASM_GENERATE_INTERNAL_LABEL (label
, "LC", const_labelno
);
3486 desc
->label
= found
= ggc_strdup (label
);
3488 /* Add label to symbol hash table. */
3489 hash
= SYMHASH (found
);
3490 pool
->label
= found
;
3491 pool
->next_sym
= const_rtx_sym_hash_table
[hash
];
3492 const_rtx_sym_hash_table
[hash
] = pool
;
3495 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3497 def
= gen_rtx_MEM (mode
, gen_rtx_SYMBOL_REF (Pmode
, found
));
3498 set_mem_attributes (def
, type_for_mode (mode
, 0), 1);
3499 RTX_UNCHANGING_P (def
) = 1;
3501 /* Mark the symbol_ref as belonging to this constants pool. */
3502 CONSTANT_POOL_ADDRESS_P (XEXP (def
, 0)) = 1;
3503 current_function_uses_const_pool
= 1;
3505 if (GET_CODE (x
) == CONST_DOUBLE
)
3507 if (CONST_DOUBLE_MEM (x
) == cc0_rtx
)
3509 CONST_DOUBLE_CHAIN (x
) = const_double_chain
;
3510 const_double_chain
= x
;
3512 CONST_DOUBLE_MEM (x
) = def
;
3518 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3519 the corresponding pool_constant structure. */
3521 static struct pool_constant
*
3522 find_pool_constant (f
, addr
)
3526 struct pool_constant
*pool
;
3527 const char *label
= XSTR (addr
, 0);
3529 for (pool
= f
->varasm
->x_const_rtx_sym_hash_table
[SYMHASH (label
)]; pool
;
3530 pool
= pool
->next_sym
)
3531 if (pool
->label
== label
)
3537 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3540 get_pool_constant (addr
)
3543 return (find_pool_constant (cfun
, addr
))->constant
;
3546 /* Likewise, but for the constant pool of a specific function. */
3549 get_pool_constant_for_function (f
, addr
)
3553 return (find_pool_constant (f
, addr
))->constant
;
3556 /* Similar, return the mode. */
3559 get_pool_mode (addr
)
3562 return (find_pool_constant (cfun
, addr
))->mode
;
3566 get_pool_mode_for_function (f
, addr
)
3570 return (find_pool_constant (f
, addr
))->mode
;
3573 /* Similar, return the offset in the constant pool. */
3576 get_pool_offset (addr
)
3579 return (find_pool_constant (cfun
, addr
))->offset
;
3582 /* Return the size of the constant pool. */
3590 /* Write all the constants in the constant pool. */
3593 output_constant_pool (fnname
, fndecl
)
3594 const char *fnname ATTRIBUTE_UNUSED
;
3595 tree fndecl ATTRIBUTE_UNUSED
;
3597 struct pool_constant
*pool
;
3599 union real_extract u
;
3601 /* It is possible for gcc to call force_const_mem and then to later
3602 discard the instructions which refer to the constant. In such a
3603 case we do not need to output the constant. */
3604 mark_constant_pool ();
3606 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3607 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3610 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3619 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3620 whose CODE_LABEL has been deleted. This can occur if a jump table
3621 is eliminated by optimization. If so, write a constant of zero
3622 instead. Note that this can also happen by turning the
3623 CODE_LABEL into a NOTE. */
3624 /* ??? This seems completely and utterly wrong. Certainly it's
3625 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3626 functioning even with INSN_DELETED_P and friends. */
3629 switch (GET_CODE (x
))
3632 if (GET_CODE (XEXP (x
, 0)) != PLUS
3633 || GET_CODE (XEXP (XEXP (x
, 0), 0)) != LABEL_REF
)
3635 tmp
= XEXP (XEXP (x
, 0), 0);
3640 if (INSN_DELETED_P (tmp
)
3641 || (GET_CODE (tmp
) == NOTE
3642 && NOTE_LINE_NUMBER (tmp
) == NOTE_INSN_DELETED
))
3653 /* First switch to correct section. */
3654 #ifdef SELECT_RTX_SECTION
3655 SELECT_RTX_SECTION (pool
->mode
, x
);
3657 readonly_data_section ();
3660 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3661 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file
, x
, pool
->mode
,
3662 pool
->align
, pool
->labelno
, done
);
3665 if (pool
->align
> 1)
3666 ASM_OUTPUT_ALIGN (asm_out_file
, floor_log2 (pool
->align
));
3668 /* Output the label. */
3669 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file
, "LC", pool
->labelno
);
3671 /* Output the value of the constant itself. */
3672 switch (GET_MODE_CLASS (pool
->mode
))
3675 if (GET_CODE (x
) != CONST_DOUBLE
)
3678 memcpy ((char *) &u
, (char *) &CONST_DOUBLE_LOW (x
), sizeof u
);
3679 assemble_real (u
.d
, pool
->mode
);
3683 case MODE_PARTIAL_INT
:
3684 assemble_integer (x
, GET_MODE_SIZE (pool
->mode
), 1);
3691 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3697 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3698 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file
, fnname
, fndecl
, pool_offset
);
3701 /* Done with this pool. */
3702 first_pool
= last_pool
= 0;
3705 /* Look through the instructions for this function, and mark all the
3706 entries in the constant pool which are actually being used.
3707 Emit used deferred strings. */
3710 mark_constant_pool ()
3713 struct pool_constant
*pool
;
3715 if (first_pool
== 0 && htab_elements (const_str_htab
) == 0)
3718 for (pool
= first_pool
; pool
; pool
= pool
->next
)
3721 for (insn
= get_insns (); insn
; insn
= NEXT_INSN (insn
))
3723 mark_constants (PATTERN (insn
));
3725 for (insn
= current_function_epilogue_delay_list
;
3727 insn
= XEXP (insn
, 1))
3729 mark_constants (PATTERN (insn
));
3732 /* Look through appropriate parts of X, marking all entries in the
3733 constant pool which are actually being used. Entries that are only
3734 referenced by other constants are also marked as used. Emit
3735 deferred strings that are used. */
3742 register const char *format_ptr
;
3747 if (GET_CODE (x
) == SYMBOL_REF
)
3749 mark_constant (&x
, NULL
);
3752 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3753 a MEM, but does not constitute a use of that MEM. */
3754 else if (GET_CODE (x
) == CONST_DOUBLE
)
3757 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3758 insns, not any notes that may be attached. We don't want to mark
3759 a constant just because it happens to appear in a REG_EQUIV note. */
3762 mark_constants (PATTERN (x
));
3766 format_ptr
= GET_RTX_FORMAT (GET_CODE (x
));
3768 for (i
= 0; i
< GET_RTX_LENGTH (GET_CODE (x
)); i
++)
3770 switch (*format_ptr
++)
3773 mark_constants (XEXP (x
, i
));
3777 if (XVEC (x
, i
) != 0)
3781 for (j
= 0; j
< XVECLEN (x
, i
); j
++)
3782 mark_constants (XVECEXP (x
, i
, j
));
3801 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3802 to as used. Emit referenced deferred strings. This function can
3803 be used with for_each_rtx () to mark all SYMBOL_REFs in an rtx. */
3806 mark_constant (current_rtx
, data
)
3808 void *data ATTRIBUTE_UNUSED
;
3810 rtx x
= *current_rtx
;
3814 else if (GET_CODE(x
) == CONST_DOUBLE
)
3815 /* Never search inside a CONST_DOUBLE because CONST_DOUBLE_MEM may
3816 be a MEM but does not constitute a use of that MEM. */
3818 else if (GET_CODE (x
) == SYMBOL_REF
)
3820 if (CONSTANT_POOL_ADDRESS_P (x
))
3822 struct pool_constant
*pool
= find_pool_constant (cfun
, x
);
3823 if (pool
->mark
== 0) {
3825 for_each_rtx (&(pool
->constant
), &mark_constant
, NULL
);
3830 else if (STRING_POOL_ADDRESS_P (x
))
3832 struct deferred_string
**defstr
;
3834 defstr
= (struct deferred_string
**)
3835 htab_find_slot_with_hash (const_str_htab
, XSTR (x
, 0),
3836 STRHASH (XSTR (x
, 0)), NO_INSERT
);
3839 struct deferred_string
*p
= *defstr
;
3841 STRING_POOL_ADDRESS_P (x
) = 0;
3842 output_constant_def_contents (p
->exp
, 0, p
->labelno
);
3843 htab_clear_slot (const_str_htab
, (void **) defstr
);
3850 /* Find all the constants whose addresses are referenced inside of EXP,
3851 and make sure assembler code with a label has been output for each one.
3852 Indicate whether an ADDR_EXPR has been encountered. */
3855 output_addressed_constants (exp
)
3860 /* Give the front-end a chance to convert VALUE to something that
3861 looks more like a constant to the back-end. */
3862 if (lang_expand_constant
)
3863 exp
= (*lang_expand_constant
) (exp
);
3865 switch (TREE_CODE (exp
))
3869 register tree constant
= TREE_OPERAND (exp
, 0);
3871 while (TREE_CODE (constant
) == COMPONENT_REF
)
3873 constant
= TREE_OPERAND (constant
, 0);
3876 if (TREE_CODE_CLASS (TREE_CODE (constant
)) == 'c'
3877 || TREE_CODE (constant
) == CONSTRUCTOR
)
3878 /* No need to do anything here
3879 for addresses of variables or functions. */
3880 output_constant_def (constant
, 0);
3887 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3888 reloc
|= output_addressed_constants (TREE_OPERAND (exp
, 1));
3893 case NON_LVALUE_EXPR
:
3894 reloc
= output_addressed_constants (TREE_OPERAND (exp
, 0));
3900 for (link
= CONSTRUCTOR_ELTS (exp
); link
; link
= TREE_CHAIN (link
))
3901 if (TREE_VALUE (link
) != 0)
3902 reloc
|= output_addressed_constants (TREE_VALUE (link
));
3912 /* Return nonzero if VALUE is a valid constant-valued expression
3913 for use in initializing a static variable; one that can be an
3914 element of a "constant" initializer.
3916 Return null_pointer_node if the value is absolute;
3917 if it is relocatable, return the variable that determines the relocation.
3918 We assume that VALUE has been folded as much as possible;
3919 therefore, we do not need to check for such things as
3920 arithmetic-combinations of integers. */
3923 initializer_constant_valid_p (value
, endtype
)
3927 /* Give the front-end a chance to convert VALUE to something that
3928 looks more like a constant to the back-end. */
3929 if (lang_expand_constant
)
3930 value
= (*lang_expand_constant
) (value
);
3932 switch (TREE_CODE (value
))
3935 if ((TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
3936 || TREE_CODE (TREE_TYPE (value
)) == RECORD_TYPE
)
3937 && TREE_CONSTANT (value
)
3938 && CONSTRUCTOR_ELTS (value
))
3940 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value
)),
3943 return TREE_STATIC (value
) ? null_pointer_node
: 0;
3949 return null_pointer_node
;
3952 return staticp (TREE_OPERAND (value
, 0)) ? TREE_OPERAND (value
, 0) : 0;
3954 case NON_LVALUE_EXPR
:
3955 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3959 /* Allow conversions between pointer types. */
3960 if (POINTER_TYPE_P (TREE_TYPE (value
))
3961 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3962 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3964 /* Allow conversions between real types. */
3965 if (FLOAT_TYPE_P (TREE_TYPE (value
))
3966 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3967 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3969 /* Allow length-preserving conversions between integer types. */
3970 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3971 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3972 && (TYPE_PRECISION (TREE_TYPE (value
))
3973 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3974 return initializer_constant_valid_p (TREE_OPERAND (value
, 0), endtype
);
3976 /* Allow conversions between other integer types only if
3978 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3979 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
3981 tree inner
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3983 if (inner
== null_pointer_node
)
3984 return null_pointer_node
;
3988 /* Allow (int) &foo provided int is as wide as a pointer. */
3989 if (INTEGRAL_TYPE_P (TREE_TYPE (value
))
3990 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0)))
3991 && (TYPE_PRECISION (TREE_TYPE (value
))
3992 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0)))))
3993 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
3996 /* Likewise conversions from int to pointers, but also allow
3997 conversions from 0. */
3998 if (POINTER_TYPE_P (TREE_TYPE (value
))
3999 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value
, 0))))
4001 if (integer_zerop (TREE_OPERAND (value
, 0)))
4002 return null_pointer_node
;
4003 else if (TYPE_PRECISION (TREE_TYPE (value
))
4004 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value
, 0))))
4005 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4009 /* Allow conversions to union types if the value inside is okay. */
4010 if (TREE_CODE (TREE_TYPE (value
)) == UNION_TYPE
)
4011 return initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4016 if (! INTEGRAL_TYPE_P (endtype
)
4017 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4019 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4021 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4023 /* If either term is absolute, use the other terms relocation. */
4024 if (valid0
== null_pointer_node
)
4026 if (valid1
== null_pointer_node
)
4032 if (! INTEGRAL_TYPE_P (endtype
)
4033 || TYPE_PRECISION (endtype
) >= POINTER_SIZE
)
4035 tree valid0
= initializer_constant_valid_p (TREE_OPERAND (value
, 0),
4037 tree valid1
= initializer_constant_valid_p (TREE_OPERAND (value
, 1),
4039 /* Win if second argument is absolute. */
4040 if (valid1
== null_pointer_node
)
4042 /* Win if both arguments have the same relocation.
4043 Then the value is absolute. */
4044 if (valid0
== valid1
&& valid0
!= 0)
4045 return null_pointer_node
;
4047 /* Since GCC guarantees that string constants are unique in the
4048 generated code, a subtraction between two copies of the same
4049 constant string is absolute. */
4050 if (valid0
&& TREE_CODE (valid0
) == STRING_CST
&&
4051 valid1
&& TREE_CODE (valid1
) == STRING_CST
&&
4052 TREE_STRING_POINTER (valid0
) == TREE_STRING_POINTER (valid1
))
4053 return null_pointer_node
;
4056 /* Support differences between labels. */
4057 if (INTEGRAL_TYPE_P (endtype
))
4060 op0
= TREE_OPERAND (value
, 0);
4061 op1
= TREE_OPERAND (value
, 1);
4065 if (TREE_CODE (op0
) == ADDR_EXPR
4066 && TREE_CODE (TREE_OPERAND (op0
, 0)) == LABEL_DECL
4067 && TREE_CODE (op1
) == ADDR_EXPR
4068 && TREE_CODE (TREE_OPERAND (op1
, 0)) == LABEL_DECL
)
4069 return null_pointer_node
;
4080 /* Output assembler code for constant EXP to FILE, with no label.
4081 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4082 Assumes output_addressed_constants has been done on EXP already.
4084 Generate exactly SIZE bytes of assembler data, padding at the end
4085 with zeros if necessary. SIZE must always be specified.
4087 SIZE is important for structure constructors,
4088 since trailing members may have been omitted from the constructor.
4089 It is also important for initialization of arrays from string constants
4090 since the full length of the string constant might not be wanted.
4091 It is also needed for initialization of unions, where the initializer's
4092 type is just one member, and that may not be as long as the union.
4094 There a case in which we would fail to output exactly SIZE bytes:
4095 for a structure constructor that wants to produce more than SIZE bytes.
4096 But such constructors will never be generated for any possible input. */
4099 output_constant (exp
, size
)
4103 register enum tree_code code
= TREE_CODE (TREE_TYPE (exp
));
4105 /* Some front-ends use constants other than the standard
4106 language-indepdent varieties, but which may still be output
4107 directly. Give the front-end a chance to convert EXP to a
4108 language-independent representation. */
4109 if (lang_expand_constant
)
4111 exp
= (*lang_expand_constant
) (exp
);
4112 code
= TREE_CODE (TREE_TYPE (exp
));
4115 if (size
== 0 || flag_syntax_only
)
4118 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4119 That way we get the constant (we hope) inside it. Also, strip off any
4120 NOP_EXPR that converts between two record, union, array, or set types
4121 or a CONVERT_EXPR that converts to a union TYPE. */
4122 while ((TREE_CODE (exp
) == NOP_EXPR
4123 && (TREE_TYPE (exp
) == TREE_TYPE (TREE_OPERAND (exp
, 0))
4124 || AGGREGATE_TYPE_P (TREE_TYPE (exp
))))
4125 || (TREE_CODE (exp
) == CONVERT_EXPR
4126 && code
== UNION_TYPE
)
4127 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4129 exp
= TREE_OPERAND (exp
, 0);
4130 code
= TREE_CODE (TREE_TYPE (exp
));
4133 /* Allow a constructor with no elements for any data type.
4134 This means to fill the space with zeros. */
4135 if (TREE_CODE (exp
) == CONSTRUCTOR
&& CONSTRUCTOR_ELTS (exp
) == 0)
4137 assemble_zeros (size
);
4148 case REFERENCE_TYPE
:
4149 /* ??? What about (int)((float)(int)&foo + 4) */
4150 while (TREE_CODE (exp
) == NOP_EXPR
|| TREE_CODE (exp
) == CONVERT_EXPR
4151 || TREE_CODE (exp
) == NON_LVALUE_EXPR
)
4152 exp
= TREE_OPERAND (exp
, 0);
4154 if (! assemble_integer (expand_expr (exp
, NULL_RTX
, VOIDmode
,
4155 EXPAND_INITIALIZER
),
4157 error ("initializer for integer value is too complicated");
4162 if (TREE_CODE (exp
) != REAL_CST
)
4163 error ("initializer for floating value is not a floating constant");
4165 assemble_real (TREE_REAL_CST (exp
),
4166 mode_for_size (size
* BITS_PER_UNIT
, MODE_FLOAT
, 0));
4171 output_constant (TREE_REALPART (exp
), size
/ 2);
4172 output_constant (TREE_IMAGPART (exp
), size
/ 2);
4173 size
-= (size
/ 2) * 2;
4177 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4179 output_constructor (exp
, size
);
4182 else if (TREE_CODE (exp
) == STRING_CST
)
4186 if (size
> TREE_STRING_LENGTH (exp
))
4188 excess
= size
- TREE_STRING_LENGTH (exp
);
4189 size
= TREE_STRING_LENGTH (exp
);
4192 assemble_string (TREE_STRING_POINTER (exp
), size
);
4201 if (TREE_CODE (exp
) == CONSTRUCTOR
)
4202 output_constructor (exp
, size
);
4208 if (TREE_CODE (exp
) == INTEGER_CST
)
4209 assemble_integer (expand_expr (exp
, NULL_RTX
,
4210 VOIDmode
, EXPAND_INITIALIZER
),
4212 else if (TREE_CODE (exp
) == CONSTRUCTOR
)
4214 unsigned char *buffer
= (unsigned char *) alloca (size
);
4215 if (get_set_constructor_bytes (exp
, buffer
, size
))
4217 assemble_string ((char *) buffer
, size
);
4220 error ("unknown set constructor type");
4228 assemble_zeros (size
);
4232 /* Subroutine of output_constructor, used for computing the size of
4233 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4234 type with an unspecified upper bound. */
4236 static unsigned HOST_WIDE_INT
4237 array_size_for_constructor (val
)
4242 max_index
= NULL_TREE
;
4243 for (i
= CONSTRUCTOR_ELTS (val
); i
; i
= TREE_CHAIN (i
))
4245 tree index
= TREE_PURPOSE (i
);
4247 if (TREE_CODE (index
) == RANGE_EXPR
)
4248 index
= TREE_OPERAND (index
, 1);
4249 if (max_index
== NULL_TREE
|| tree_int_cst_lt (max_index
, index
))
4253 if (max_index
== NULL_TREE
)
4256 /* Compute the total number of array elements. */
4257 i
= size_binop (MINUS_EXPR
, convert (sizetype
, max_index
),
4259 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val
)))));
4260 i
= size_binop (PLUS_EXPR
, i
, convert (sizetype
, integer_one_node
));
4262 /* Multiply by the array element unit size to find number of bytes. */
4263 i
= size_binop (MULT_EXPR
, i
, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val
))));
4265 return tree_low_cst (i
, 1);
4268 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4269 Generate at least SIZE bytes, padding if necessary. */
4272 output_constructor (exp
, size
)
4276 tree type
= TREE_TYPE (exp
);
4277 register tree link
, field
= 0;
4279 /* Number of bytes output or skipped so far.
4280 In other words, current position within the constructor. */
4281 HOST_WIDE_INT total_bytes
= 0;
4282 /* Non-zero means BYTE contains part of a byte, to be output. */
4283 int byte_buffer_in_use
= 0;
4284 register int byte
= 0;
4286 if (HOST_BITS_PER_WIDE_INT
< BITS_PER_UNIT
)
4289 if (TREE_CODE (type
) == RECORD_TYPE
)
4290 field
= TYPE_FIELDS (type
);
4292 if (TREE_CODE (type
) == ARRAY_TYPE
4293 && TYPE_DOMAIN (type
) != 0)
4294 min_index
= TYPE_MIN_VALUE (TYPE_DOMAIN (type
));
4296 /* As LINK goes through the elements of the constant,
4297 FIELD goes through the structure fields, if the constant is a structure.
4298 if the constant is a union, then we override this,
4299 by getting the field from the TREE_LIST element.
4300 But the constant could also be an array. Then FIELD is zero.
4302 There is always a maximum of one element in the chain LINK for unions
4303 (even if the initializer in a source program incorrectly contains
4305 for (link
= CONSTRUCTOR_ELTS (exp
);
4307 link
= TREE_CHAIN (link
),
4308 field
= field
? TREE_CHAIN (field
) : 0)
4310 tree val
= TREE_VALUE (link
);
4313 /* The element in a union constructor specifies the proper field
4315 if ((TREE_CODE (type
) == RECORD_TYPE
|| TREE_CODE (type
) == UNION_TYPE
4316 || TREE_CODE (type
) == QUAL_UNION_TYPE
)
4317 && TREE_PURPOSE (link
) != 0)
4318 field
= TREE_PURPOSE (link
);
4320 else if (TREE_CODE (type
) == ARRAY_TYPE
)
4321 index
= TREE_PURPOSE (link
);
4323 /* Eliminate the marker that makes a cast not be an lvalue. */
4327 if (index
&& TREE_CODE (index
) == RANGE_EXPR
)
4329 unsigned HOST_WIDE_INT fieldsize
4330 = int_size_in_bytes (TREE_TYPE (type
));
4331 HOST_WIDE_INT lo_index
= tree_low_cst (TREE_OPERAND (index
, 0), 0);
4332 HOST_WIDE_INT hi_index
= tree_low_cst (TREE_OPERAND (index
, 1), 0);
4333 HOST_WIDE_INT index
;
4335 for (index
= lo_index
; index
<= hi_index
; index
++)
4337 /* Output the element's initial value. */
4339 assemble_zeros (fieldsize
);
4341 output_constant (val
, fieldsize
);
4343 /* Count its size. */
4344 total_bytes
+= fieldsize
;
4347 else if (field
== 0 || !DECL_BIT_FIELD (field
))
4349 /* An element that is not a bit-field. */
4351 unsigned HOST_WIDE_INT fieldsize
;
4352 /* Since this structure is static,
4353 we know the positions are constant. */
4354 HOST_WIDE_INT pos
= field
? int_byte_position (field
) : 0;
4357 pos
= (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val
)), 1)
4358 * (tree_low_cst (index
, 0) - tree_low_cst (min_index
, 0)));
4360 /* Output any buffered-up bit-fields preceding this element. */
4361 if (byte_buffer_in_use
)
4363 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4365 byte_buffer_in_use
= 0;
4368 /* Advance to offset of this element.
4369 Note no alignment needed in an array, since that is guaranteed
4370 if each element has the proper size. */
4371 if ((field
!= 0 || index
!= 0) && pos
!= total_bytes
)
4373 assemble_zeros (pos
- total_bytes
);
4377 else if (field
!= 0 && DECL_PACKED (field
))
4378 /* Some assemblers automaticallly align a datum according to its
4379 size if no align directive is specified. The datum, however,
4380 may be declared with 'packed' attribute, so we have to disable
4382 ASM_OUTPUT_ALIGN (asm_out_file
, 0);
4384 /* Determine size this element should occupy. */
4389 /* If this is an array with an unspecified upper bound,
4390 the initializer determines the size. */
4391 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4392 but we cannot do this until the deprecated support for
4393 initializing zero-length array members is removed. */
4394 if (TREE_CODE (TREE_TYPE (field
)) == ARRAY_TYPE
4395 && TYPE_DOMAIN (TREE_TYPE (field
))
4396 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field
))))
4398 fieldsize
= array_size_for_constructor (val
);
4399 /* Given a non-empty initialization, this field had
4401 if (fieldsize
!= 0 && TREE_CHAIN (field
) != NULL_TREE
)
4404 else if (DECL_SIZE_UNIT (field
))
4406 /* ??? This can't be right. If the decl size overflows
4407 a host integer we will silently emit no data. */
4408 if (host_integerp (DECL_SIZE_UNIT (field
), 1))
4409 fieldsize
= tree_low_cst (DECL_SIZE_UNIT (field
), 1);
4413 fieldsize
= int_size_in_bytes (TREE_TYPE (type
));
4415 /* Output the element's initial value. */
4417 assemble_zeros (fieldsize
);
4419 output_constant (val
, fieldsize
);
4421 /* Count its size. */
4422 total_bytes
+= fieldsize
;
4424 else if (val
!= 0 && TREE_CODE (val
) != INTEGER_CST
)
4425 error ("invalid initial value for member `%s'",
4426 IDENTIFIER_POINTER (DECL_NAME (field
)));
4429 /* Element that is a bit-field. */
4431 HOST_WIDE_INT next_offset
= int_bit_position (field
);
4432 HOST_WIDE_INT end_offset
4433 = (next_offset
+ tree_low_cst (DECL_SIZE (field
), 1));
4436 val
= integer_zero_node
;
4438 /* If this field does not start in this (or, next) byte,
4440 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4442 /* Output remnant of any bit field in previous bytes. */
4443 if (byte_buffer_in_use
)
4445 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4447 byte_buffer_in_use
= 0;
4450 /* If still not at proper byte, advance to there. */
4451 if (next_offset
/ BITS_PER_UNIT
!= total_bytes
)
4453 assemble_zeros (next_offset
/ BITS_PER_UNIT
- total_bytes
);
4454 total_bytes
= next_offset
/ BITS_PER_UNIT
;
4458 if (! byte_buffer_in_use
)
4461 /* We must split the element into pieces that fall within
4462 separate bytes, and combine each byte with previous or
4463 following bit-fields. */
4465 /* next_offset is the offset n fbits from the beginning of
4466 the structure to the next bit of this element to be processed.
4467 end_offset is the offset of the first bit past the end of
4469 while (next_offset
< end_offset
)
4473 HOST_WIDE_INT value
;
4474 HOST_WIDE_INT next_byte
= next_offset
/ BITS_PER_UNIT
;
4475 HOST_WIDE_INT next_bit
= next_offset
% BITS_PER_UNIT
;
4477 /* Advance from byte to byte
4478 within this element when necessary. */
4479 while (next_byte
!= total_bytes
)
4481 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4486 /* Number of bits we can process at once
4487 (all part of the same byte). */
4488 this_time
= MIN (end_offset
- next_offset
,
4489 BITS_PER_UNIT
- next_bit
);
4490 if (BYTES_BIG_ENDIAN
)
4492 /* On big-endian machine, take the most significant bits
4493 first (of the bits that are significant)
4494 and put them into bytes from the most significant end. */
4495 shift
= end_offset
- next_offset
- this_time
;
4497 /* Don't try to take a bunch of bits that cross
4498 the word boundary in the INTEGER_CST. We can
4499 only select bits from the LOW or HIGH part
4501 if (shift
< HOST_BITS_PER_WIDE_INT
4502 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4504 this_time
= shift
+ this_time
- HOST_BITS_PER_WIDE_INT
;
4505 shift
= HOST_BITS_PER_WIDE_INT
;
4508 /* Now get the bits from the appropriate constant word. */
4509 if (shift
< HOST_BITS_PER_WIDE_INT
)
4510 value
= TREE_INT_CST_LOW (val
);
4511 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4513 value
= TREE_INT_CST_HIGH (val
);
4514 shift
-= HOST_BITS_PER_WIDE_INT
;
4519 /* Get the result. This works only when:
4520 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4521 byte
|= (((value
>> shift
)
4522 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4523 << (BITS_PER_UNIT
- this_time
- next_bit
));
4527 /* On little-endian machines,
4528 take first the least significant bits of the value
4529 and pack them starting at the least significant
4530 bits of the bytes. */
4531 shift
= next_offset
- int_bit_position (field
);
4533 /* Don't try to take a bunch of bits that cross
4534 the word boundary in the INTEGER_CST. We can
4535 only select bits from the LOW or HIGH part
4537 if (shift
< HOST_BITS_PER_WIDE_INT
4538 && shift
+ this_time
> HOST_BITS_PER_WIDE_INT
)
4539 this_time
= (HOST_BITS_PER_WIDE_INT
- shift
);
4541 /* Now get the bits from the appropriate constant word. */
4542 if (shift
< HOST_BITS_PER_WIDE_INT
)
4543 value
= TREE_INT_CST_LOW (val
);
4544 else if (shift
< 2 * HOST_BITS_PER_WIDE_INT
)
4546 value
= TREE_INT_CST_HIGH (val
);
4547 shift
-= HOST_BITS_PER_WIDE_INT
;
4552 /* Get the result. This works only when:
4553 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4554 byte
|= (((value
>> shift
)
4555 & (((HOST_WIDE_INT
) 2 << (this_time
- 1)) - 1))
4559 next_offset
+= this_time
;
4560 byte_buffer_in_use
= 1;
4565 if (byte_buffer_in_use
)
4567 ASM_OUTPUT_BYTE (asm_out_file
, byte
);
4571 if (total_bytes
< size
)
4572 assemble_zeros (size
- total_bytes
);
4575 #ifdef HANDLE_PRAGMA_WEAK
4576 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4577 associatd with NAME. */
4580 add_weak (name
, value
)
4584 struct weak_syms
*weak
;
4586 weak
= (struct weak_syms
*) permalloc (sizeof (struct weak_syms
));
4591 weak
->next
= weak_decls
;
4593 weak
->value
= value
;
4598 #endif /* HANDLE_PRAGMA_WEAK */
4600 /* Declare DECL to be a weak symbol. */
4606 if (! TREE_PUBLIC (decl
))
4607 error_with_decl (decl
, "weak declaration of `%s' must be public");
4608 else if (TREE_ASM_WRITTEN (decl
))
4609 error_with_decl (decl
, "weak declaration of `%s' must precede definition");
4610 else if (SUPPORTS_WEAK
)
4611 DECL_WEAK (decl
) = 1;
4612 #ifdef HANDLE_PRAGMA_WEAK
4613 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)), NULL
);
4617 /* Emit any pending weak declarations. */
4619 #ifdef HANDLE_PRAGMA_WEAK
4620 struct weak_syms
* weak_decls
;
4626 #ifdef HANDLE_PRAGMA_WEAK
4627 if (HANDLE_PRAGMA_WEAK
)
4629 struct weak_syms
*t
;
4630 for (t
= weak_decls
; t
; t
= t
->next
)
4633 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, t
->name
, t
->value
);
4639 /* Remove NAME from the pending list of weak symbols. This prevents
4640 the compiler from emitting multiple .weak directives which confuses
4642 #ifdef ASM_WEAKEN_LABEL
4644 remove_from_pending_weak_list (name
)
4645 const char *name ATTRIBUTE_UNUSED
;
4647 #ifdef HANDLE_PRAGMA_WEAK
4648 if (HANDLE_PRAGMA_WEAK
)
4650 struct weak_syms
*t
;
4651 for (t
= weak_decls
; t
; t
= t
->next
)
4653 if (t
->name
&& strcmp (name
, t
->name
) == 0)
4662 assemble_alias (decl
, target
)
4663 tree decl
, target ATTRIBUTE_UNUSED
;
4667 /* We must force creation of DECL_RTL for debug info generation, even though
4668 we don't use it here. */
4669 make_decl_rtl (decl
, NULL
);
4671 name
= IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
));
4673 #ifdef ASM_OUTPUT_DEF
4674 /* Make name accessible from other files, if appropriate. */
4676 if (TREE_PUBLIC (decl
))
4678 #ifdef ASM_WEAKEN_LABEL
4679 if (DECL_WEAK (decl
))
4681 ASM_WEAKEN_LABEL (asm_out_file
, name
);
4682 /* Remove this function from the pending weak list so that
4683 we do not emit multiple .weak directives for it. */
4684 remove_from_pending_weak_list
4685 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl
)));
4689 ASM_GLOBALIZE_LABEL (asm_out_file
, name
);
4692 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4693 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file
, decl
, target
);
4695 ASM_OUTPUT_DEF (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4697 TREE_ASM_WRITTEN (decl
) = 1;
4699 #ifdef ASM_OUTPUT_WEAK_ALIAS
4700 if (! DECL_WEAK (decl
))
4701 warning ("only weak aliases are supported in this configuration");
4703 ASM_OUTPUT_WEAK_ALIAS (asm_out_file
, name
, IDENTIFIER_POINTER (target
));
4704 TREE_ASM_WRITTEN (decl
) = 1;
4706 warning ("alias definitions not supported in this configuration; ignored");
4711 /* Returns 1 if the target configuration supports defining public symbols
4712 so that one of them will be chosen at link time instead of generating a
4713 multiply-defined symbol error, whether through the use of weak symbols or
4714 a target-specific mechanism for having duplicates discarded. */
4717 supports_one_only ()
4719 if (SUPPORTS_ONE_ONLY
)
4721 return SUPPORTS_WEAK
;
4724 /* Set up DECL as a public symbol that can be defined in multiple
4725 translation units without generating a linker error. */
4728 make_decl_one_only (decl
)
4731 if (TREE_CODE (decl
) != VAR_DECL
&& TREE_CODE (decl
) != FUNCTION_DECL
)
4734 TREE_PUBLIC (decl
) = 1;
4736 if (TREE_CODE (decl
) == VAR_DECL
4737 && (DECL_INITIAL (decl
) == 0 || DECL_INITIAL (decl
) == error_mark_node
))
4738 DECL_COMMON (decl
) = 1;
4739 else if (SUPPORTS_ONE_ONLY
)
4741 #ifdef MAKE_DECL_ONE_ONLY
4742 MAKE_DECL_ONE_ONLY (decl
);
4744 DECL_ONE_ONLY (decl
) = 1;
4746 else if (SUPPORTS_WEAK
)
4747 DECL_WEAK (decl
) = 1;
4755 const_str_htab
= htab_create (128, const_str_htab_hash
, const_str_htab_eq
,
4756 const_str_htab_del
);
4757 ggc_add_root (const_hash_table
, MAX_HASH_TABLE
, sizeof const_hash_table
[0],
4758 mark_const_hash_entry
);
4759 ggc_add_root (&const_str_htab
, 1, sizeof const_str_htab
,
4760 mark_const_str_htab
);
4763 /* Select a set of attributes for section NAME based on the properties
4764 of DECL and whether or not RELOC indicates that DECL's initializer
4765 might contain runtime relocations.
4767 We make the section read-only and executable for a function decl,
4768 read-only for a const data decl, and writable for a non-const data decl.
4770 If the section has already been defined, to not allow it to have
4771 different attributes, as (1) this is ambiguous since we're not seeing
4772 all the declarations up front and (2) some assemblers (e.g. SVR4)
4773 do not recoginize section redefinitions. */
4776 default_section_type_flags (decl
, name
, reloc
)
4783 unsigned int **slot
;
4785 /* The names we put in the hashtable will always be the unique
4786 versions gived to us by the stringtable, so we can just use
4787 their addresses as the keys. */
4789 htab
= htab_create (31, htab_hash_pointer
, htab_eq_pointer
, NULL
);
4791 if (decl
&& TREE_CODE (decl
) == FUNCTION_DECL
)
4792 flags
= SECTION_CODE
;
4793 else if (decl
&& DECL_READONLY_SECTION (decl
, reloc
))
4796 flags
= SECTION_WRITE
;
4798 if (decl
&& DECL_ONE_ONLY (decl
))
4799 flags
|= SECTION_LINKONCE
;
4801 if (strcmp (name
, ".bss") == 0
4802 || strncmp (name
, ".bss.", 5) == 0
4803 || strncmp (name
, ".gnu.linkonce.b.", 16) == 0
4804 || strcmp (name
, ".sbss") == 0
4805 || strncmp (name
, ".sbss.", 6) == 0
4806 || strncmp (name
, ".gnu.linkonce.sb.", 17) == 0)
4807 flags
|= SECTION_BSS
;
4809 /* See if we already have an entry for this section. */
4810 slot
= (unsigned int **) htab_find_slot (htab
, name
, INSERT
);
4813 *slot
= (unsigned int *) xmalloc (sizeof (unsigned int));
4818 if (decl
&& **slot
!= flags
)
4819 error_with_decl (decl
, "%s causes a section type conflict");
4825 /* Output assembly to switch to section NAME with attribute FLAGS.
4826 Four variants for common object file formats. */
4829 default_no_named_section (name
, flags
, align
)
4830 const char *name ATTRIBUTE_UNUSED
;
4831 unsigned int flags ATTRIBUTE_UNUSED
;
4832 unsigned int align ATTRIBUTE_UNUSED
;
4834 /* Some object formats don't support named sections at all. The
4835 front-end should already have flagged this as an error. */
4840 default_elf_asm_named_section (name
, flags
, align
)
4843 unsigned int align ATTRIBUTE_UNUSED
;
4845 char flagchars
[8], *f
= flagchars
;
4848 if (!(flags
& SECTION_DEBUG
))
4850 if (flags
& SECTION_WRITE
)
4852 if (flags
& SECTION_CODE
)
4854 if (flags
& SECTION_SMALL
)
4858 if (flags
& SECTION_BSS
)
4863 fprintf (asm_out_file
, "\t.section\t%s,\"%s\",@%s\n",
4864 name
, flagchars
, type
);
4868 default_coff_asm_named_section (name
, flags
, align
)
4871 unsigned int align ATTRIBUTE_UNUSED
;
4873 char flagchars
[8], *f
= flagchars
;
4875 if (flags
& SECTION_WRITE
)
4877 if (flags
& SECTION_CODE
)
4881 fprintf (asm_out_file
, "\t.section\t%s,\"%s\"\n", name
, flagchars
);
4885 default_pe_asm_named_section (name
, flags
, align
)
4888 unsigned int align ATTRIBUTE_UNUSED
;
4890 default_coff_asm_named_section (name
, flags
, align
);
4892 if (flags
& SECTION_LINKONCE
)
4894 /* Functions may have been compiled at various levels of
4895 optimization so we can't use `same_size' here.
4896 Instead, have the linker pick one. */
4897 fprintf (asm_out_file
, "\t.linkonce %s\n",
4898 (flags
& SECTION_CODE
? "discard" : "same_size"));