* expr.c (store_field): Don't set MEM_ALIAS_SET for a field
[official-gcc.git] / gcc / varasm.c
blobf8cfe1fb2492e675351c1f4aad513981eb79778d
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)
10 any later version.
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. */
30 #include "config.h"
31 #include "system.h"
32 #include <setjmp.h>
33 #include "rtl.h"
34 #include "tree.h"
35 #include "flags.h"
36 #include "function.h"
37 #include "expr.h"
38 #include "hard-reg-set.h"
39 #include "regs.h"
40 #include "output.h"
41 #include "real.h"
42 #include "toplev.h"
43 #include "dbxout.h"
44 #include "sdbout.h"
45 #include "obstack.h"
46 #include "hashtab.h"
47 #include "c-pragma.h"
48 #include "ggc.h"
49 #include "tm_p.h"
51 #ifdef XCOFF_DEBUGGING_INFO
52 #include "xcoffout.h"
53 #endif
55 #ifndef TRAMPOLINE_ALIGNMENT
56 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
57 #endif
59 #ifndef ASM_STABS_OP
60 #define ASM_STABS_OP "\t.stabs\t"
61 #endif
63 /* Define the prefix to use when check_memory_usage_flag is enable. */
64 #define CHKR_PREFIX "_CHKR_"
65 #define CHKR_PREFIX_SIZE (sizeof (CHKR_PREFIX) - 1)
67 /* File in which assembler code is being written. */
69 extern FILE *asm_out_file;
71 /* The (assembler) name of the first globally-visible object output. */
72 const char *first_global_object_name;
73 const char *weak_global_object_name;
75 extern struct obstack permanent_obstack;
76 #define obstack_chunk_alloc xmalloc
78 struct addr_const;
79 struct constant_descriptor;
80 struct rtx_const;
81 struct pool_constant;
83 #define MAX_RTX_HASH_TABLE 61
85 struct varasm_status
87 /* Hash facility for making memory-constants
88 from constant rtl-expressions. It is used on RISC machines
89 where immediate integer arguments and constant addresses are restricted
90 so that such constants must be stored in memory.
92 This pool of constants is reinitialized for each function
93 so each function gets its own constants-pool that comes right before
94 it. */
95 struct constant_descriptor **x_const_rtx_hash_table;
96 struct pool_constant **x_const_rtx_sym_hash_table;
98 /* Pointers to first and last constant in pool. */
99 struct pool_constant *x_first_pool, *x_last_pool;
101 /* Current offset in constant pool (does not include any machine-specific
102 header). */
103 int x_pool_offset;
105 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
106 They are chained through the CONST_DOUBLE_CHAIN.
107 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
108 In that case, CONST_DOUBLE_MEM is either a MEM,
109 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet. */
110 rtx x_const_double_chain;
113 #define const_rtx_hash_table (cfun->varasm->x_const_rtx_hash_table)
114 #define const_rtx_sym_hash_table (cfun->varasm->x_const_rtx_sym_hash_table)
115 #define first_pool (cfun->varasm->x_first_pool)
116 #define last_pool (cfun->varasm->x_last_pool)
117 #define pool_offset (cfun->varasm->x_pool_offset)
118 #define const_double_chain (cfun->varasm->x_const_double_chain)
120 /* Number for making the label on the next
121 constant that is stored in memory. */
123 int const_labelno;
125 /* Number for making the label on the next
126 static variable internal to a function. */
128 int var_labelno;
130 /* Carry information from ASM_DECLARE_OBJECT_NAME
131 to ASM_FINISH_DECLARE_OBJECT. */
133 int size_directive_output;
135 /* The last decl for which assemble_variable was called,
136 if it did ASM_DECLARE_OBJECT_NAME.
137 If the last call to assemble_variable didn't do that,
138 this holds 0. */
140 tree last_assemble_variable_decl;
142 static const char *strip_reg_name PARAMS ((const char *));
143 static int contains_pointers_p PARAMS ((tree));
144 static void decode_addr_const PARAMS ((tree, struct addr_const *));
145 static int const_hash PARAMS ((tree));
146 static int compare_constant PARAMS ((tree,
147 struct constant_descriptor *));
148 static const unsigned char *compare_constant_1 PARAMS ((tree, const unsigned char *));
149 static struct constant_descriptor *record_constant PARAMS ((tree));
150 static void record_constant_1 PARAMS ((tree));
151 static tree copy_constant PARAMS ((tree));
152 static void output_constant_def_contents PARAMS ((tree, int, int));
153 static void decode_rtx_const PARAMS ((enum machine_mode, rtx,
154 struct rtx_const *));
155 static int const_hash_rtx PARAMS ((enum machine_mode, rtx));
156 static int compare_constant_rtx PARAMS ((enum machine_mode, rtx,
157 struct constant_descriptor *));
158 static struct constant_descriptor *record_constant_rtx PARAMS ((enum machine_mode,
159 rtx));
160 static struct pool_constant *find_pool_constant PARAMS ((struct function *, rtx));
161 static void mark_constant_pool PARAMS ((void));
162 static void mark_constants PARAMS ((rtx));
163 static int mark_constant PARAMS ((rtx *current_rtx, void *data));
164 static int output_addressed_constants PARAMS ((tree));
165 static void output_after_function_constants PARAMS ((void));
166 static unsigned HOST_WIDE_INT array_size_for_constructor PARAMS ((tree));
167 static void output_constructor PARAMS ((tree, int));
168 #ifdef ASM_WEAKEN_LABEL
169 static void remove_from_pending_weak_list PARAMS ((const char *));
170 #endif
171 #ifdef ASM_OUTPUT_BSS
172 static void asm_output_bss PARAMS ((FILE *, tree, const char *, int, int));
173 #endif
174 #ifdef BSS_SECTION_ASM_OP
175 #ifdef ASM_OUTPUT_ALIGNED_BSS
176 static void asm_output_aligned_bss PARAMS ((FILE *, tree, const char *,
177 int, int));
178 #endif
179 #endif /* BSS_SECTION_ASM_OP */
180 static void mark_pool_constant PARAMS ((struct pool_constant *));
181 static void mark_const_hash_entry PARAMS ((void *));
182 static int mark_const_str_htab_1 PARAMS ((void **, void *));
183 static void mark_const_str_htab PARAMS ((void *));
184 static hashval_t const_str_htab_hash PARAMS ((const void *x));
185 static int const_str_htab_eq PARAMS ((const void *x, const void *y));
186 static void const_str_htab_del PARAMS ((void *));
187 static void asm_emit_uninitialised PARAMS ((tree, const char*, int, int));
189 static enum in_section { no_section, in_text, in_data, in_named
190 #ifdef BSS_SECTION_ASM_OP
191 , in_bss
192 #endif
193 #ifdef EH_FRAME_SECTION_ASM_OP
194 , in_eh_frame
195 #endif
196 #ifdef EXTRA_SECTIONS
197 , EXTRA_SECTIONS
198 #endif
199 } in_section = no_section;
201 /* Return a non-zero value if DECL has a section attribute. */
202 #ifndef IN_NAMED_SECTION
203 #define IN_NAMED_SECTION(DECL) \
204 ((TREE_CODE (DECL) == FUNCTION_DECL || TREE_CODE (DECL) == VAR_DECL) \
205 && DECL_SECTION_NAME (DECL) != NULL_TREE)
206 #endif
208 /* Text of section name when in_section == in_named. */
209 static const char *in_named_name;
211 /* Define functions like text_section for any extra sections. */
212 #ifdef EXTRA_SECTION_FUNCTIONS
213 EXTRA_SECTION_FUNCTIONS
214 #endif
216 /* Tell assembler to switch to text section. */
218 void
219 text_section ()
221 if (in_section != in_text)
223 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
224 in_section = in_text;
228 /* Tell assembler to switch to data section. */
230 void
231 data_section ()
233 if (in_section != in_data)
235 if (flag_shared_data)
237 #ifdef SHARED_SECTION_ASM_OP
238 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
239 #else
240 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
241 #endif
243 else
244 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
246 in_section = in_data;
249 /* Tell assembler to ALWAYS switch to data section, in case
250 it's not sure where it it. */
252 void
253 force_data_section ()
255 in_section = no_section;
256 data_section ();
259 /* Tell assembler to switch to read-only data section. This is normally
260 the text section. */
262 void
263 readonly_data_section ()
265 #ifdef READONLY_DATA_SECTION
266 READONLY_DATA_SECTION (); /* Note this can call data_section. */
267 #else
268 text_section ();
269 #endif
272 /* Determine if we're in the text section. */
275 in_text_section ()
277 return in_section == in_text;
280 /* Determine if we're in the data section. */
283 in_data_section ()
285 return in_section == in_data;
288 /* Tell assembler to change to section NAME for DECL.
289 If DECL is NULL, just switch to section NAME.
290 If NAME is NULL, get the name from DECL.
291 If RELOC is 1, the initializer for DECL contains relocs. */
293 void
294 named_section (decl, name, reloc)
295 tree decl;
296 const char *name;
297 int reloc ATTRIBUTE_UNUSED;
299 if (decl != NULL_TREE && !DECL_P (decl))
300 abort ();
301 if (name == NULL)
302 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
304 if (in_section != in_named || strcmp (name, in_named_name))
306 #ifdef ASM_OUTPUT_SECTION_NAME
307 ASM_OUTPUT_SECTION_NAME (asm_out_file, decl, name, reloc);
308 #else
309 /* Section attributes are not supported if this macro isn't provided -
310 some host formats don't support them at all. The front-end should
311 already have flagged this as an error. */
312 abort ();
313 #endif
315 in_named_name = ggc_strdup (name);
316 in_section = in_named;
320 #ifdef BSS_SECTION_ASM_OP
322 /* Tell the assembler to switch to the bss section. */
324 void
325 bss_section ()
327 if (in_section != in_bss)
329 #ifdef SHARED_BSS_SECTION_ASM_OP
330 if (flag_shared_data)
331 fprintf (asm_out_file, "%s\n", SHARED_BSS_SECTION_ASM_OP);
332 else
333 #endif
334 fprintf (asm_out_file, "%s\n", BSS_SECTION_ASM_OP);
336 in_section = in_bss;
340 #ifdef ASM_OUTPUT_BSS
342 /* Utility function for ASM_OUTPUT_BSS for targets to use if
343 they don't support alignments in .bss.
344 ??? It is believed that this function will work in most cases so such
345 support is localized here. */
347 static void
348 asm_output_bss (file, decl, name, size, rounded)
349 FILE *file;
350 tree decl ATTRIBUTE_UNUSED;
351 const char *name;
352 int size ATTRIBUTE_UNUSED, rounded;
354 ASM_GLOBALIZE_LABEL (file, name);
355 bss_section ();
356 #ifdef ASM_DECLARE_OBJECT_NAME
357 last_assemble_variable_decl = decl;
358 ASM_DECLARE_OBJECT_NAME (file, name, decl);
359 #else
360 /* Standard thing is just output label for the object. */
361 ASM_OUTPUT_LABEL (file, name);
362 #endif /* ASM_DECLARE_OBJECT_NAME */
363 ASM_OUTPUT_SKIP (file, rounded);
366 #endif
368 #ifdef ASM_OUTPUT_ALIGNED_BSS
370 /* Utility function for targets to use in implementing
371 ASM_OUTPUT_ALIGNED_BSS.
372 ??? It is believed that this function will work in most cases so such
373 support is localized here. */
375 static void
376 asm_output_aligned_bss (file, decl, name, size, align)
377 FILE *file;
378 tree decl;
379 const char *name;
380 int size, align;
382 ASM_GLOBALIZE_LABEL (file, name);
383 bss_section ();
384 ASM_OUTPUT_ALIGN (file, floor_log2 (align / BITS_PER_UNIT));
385 #ifdef ASM_DECLARE_OBJECT_NAME
386 last_assemble_variable_decl = decl;
387 ASM_DECLARE_OBJECT_NAME (file, name, decl);
388 #else
389 /* Standard thing is just output label for the object. */
390 ASM_OUTPUT_LABEL (file, name);
391 #endif /* ASM_DECLARE_OBJECT_NAME */
392 ASM_OUTPUT_SKIP (file, size ? size : 1);
395 #endif
397 #endif /* BSS_SECTION_ASM_OP */
399 #ifdef EH_FRAME_SECTION_ASM_OP
400 void
401 eh_frame_section ()
403 if (in_section != in_eh_frame)
405 fprintf (asm_out_file, "%s\n", EH_FRAME_SECTION_ASM_OP);
406 in_section = in_eh_frame;
409 #endif
411 /* Switch to the section for function DECL.
413 If DECL is NULL_TREE, switch to the text section.
414 ??? It's not clear that we will ever be passed NULL_TREE, but it's
415 safer to handle it. */
417 void
418 function_section (decl)
419 tree decl;
421 if (decl != NULL_TREE
422 && DECL_SECTION_NAME (decl) != NULL_TREE)
423 named_section (decl, (char *) 0, 0);
424 else
425 text_section ();
428 /* Switch to section for variable DECL.
430 RELOC is the `reloc' argument to SELECT_SECTION. */
432 void
433 variable_section (decl, reloc)
434 tree decl;
435 int reloc;
437 if (IN_NAMED_SECTION (decl))
438 named_section (decl, NULL, reloc);
439 else
441 /* C++ can have const variables that get initialized from constructors,
442 and thus can not be in a readonly section. We prevent this by
443 verifying that the initial value is constant for objects put in a
444 readonly section.
446 error_mark_node is used by the C front end to indicate that the
447 initializer has not been seen yet. In this case, we assume that
448 the initializer must be constant.
450 C++ uses error_mark_node for variables that have complicated
451 initializers, but these variables go in BSS so we won't be called
452 for them. */
454 #ifdef SELECT_SECTION
455 SELECT_SECTION (decl, reloc);
456 #else
457 if (DECL_READONLY_SECTION (decl, reloc))
458 readonly_data_section ();
459 else
460 data_section ();
461 #endif
465 /* Tell assembler to switch to the section for the exception handling
466 table. */
468 void
469 exception_section ()
471 #if defined (EXCEPTION_SECTION)
472 EXCEPTION_SECTION ();
473 #else
474 #ifdef ASM_OUTPUT_SECTION_NAME
475 named_section (NULL_TREE, ".gcc_except_table", 0);
476 #else
477 if (flag_pic)
478 data_section ();
479 else
480 readonly_data_section ();
481 #endif
482 #endif
485 /* Given NAME, a putative register name, discard any customary prefixes. */
487 static const char *
488 strip_reg_name (name)
489 const char *name;
491 #ifdef REGISTER_PREFIX
492 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
493 name += strlen (REGISTER_PREFIX);
494 #endif
495 if (name[0] == '%' || name[0] == '#')
496 name++;
497 return name;
500 /* Decode an `asm' spec for a declaration as a register name.
501 Return the register number, or -1 if nothing specified,
502 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
503 or -3 if ASMSPEC is `cc' and is not recognized,
504 or -4 if ASMSPEC is `memory' and is not recognized.
505 Accept an exact spelling or a decimal number.
506 Prefixes such as % are optional. */
509 decode_reg_name (asmspec)
510 const char *asmspec;
512 if (asmspec != 0)
514 int i;
516 /* Get rid of confusing prefixes. */
517 asmspec = strip_reg_name (asmspec);
519 /* Allow a decimal number as a "register name". */
520 for (i = strlen (asmspec) - 1; i >= 0; i--)
521 if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
522 break;
523 if (asmspec[0] != 0 && i < 0)
525 i = atoi (asmspec);
526 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
527 return i;
528 else
529 return -2;
532 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
533 if (reg_names[i][0]
534 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
535 return i;
537 #ifdef ADDITIONAL_REGISTER_NAMES
539 static struct { const char *name; int number; } table[]
540 = ADDITIONAL_REGISTER_NAMES;
542 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
543 if (! strcmp (asmspec, table[i].name))
544 return table[i].number;
546 #endif /* ADDITIONAL_REGISTER_NAMES */
548 if (!strcmp (asmspec, "memory"))
549 return -4;
551 if (!strcmp (asmspec, "cc"))
552 return -3;
554 return -2;
557 return -1;
560 /* Create the DECL_RTL for a VAR_DECL or FUNCTION_DECL. DECL should
561 have static storage duration. In other words, it should not be an
562 automatic variable, including PARM_DECLs.
564 There is, however, one exception: this function handles variables
565 explicitly placed in a particular register by the user.
567 ASMSPEC, if not 0, is the string which the user specified as the
568 assembler symbol name.
570 This is never called for PARM_DECL nodes. */
572 void
573 make_decl_rtl (decl, asmspec)
574 tree decl;
575 const char *asmspec;
577 int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
578 const char *name = 0;
579 const char *new_name = 0;
580 int reg_number;
582 /* Check that we are not being given an automatic variable. */
583 /* A weak alias has TREE_PUBLIC set but not the other bits. */
584 if (TREE_CODE (decl) == PARM_DECL
585 || TREE_CODE (decl) == RESULT_DECL
586 || (TREE_CODE (decl) == VAR_DECL
587 && !TREE_STATIC (decl)
588 && !TREE_PUBLIC (decl)
589 && !DECL_EXTERNAL (decl)
590 && !DECL_REGISTER (decl)))
591 abort ();
592 /* And that we were not given a type or a label. */
593 else if (TREE_CODE (decl) == TYPE_DECL
594 || TREE_CODE (decl) == LABEL_DECL)
595 abort ();
597 /* For a duplicate declaration, we can be called twice on the
598 same DECL node. Don't discard the RTL already made. */
599 if (DECL_RTL_SET_P (decl))
601 /* If the old RTL had the wrong mode, fix the mode. */
602 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
604 rtx rtl = DECL_RTL (decl);
605 PUT_MODE (rtl, DECL_MODE (decl));
608 /* ??? Another way to do this would be to do what halfpic.c does
609 and maintain a hashed table of such critters. */
610 /* ??? Another way to do this would be to pass a flag bit to
611 ENCODE_SECTION_INFO saying whether this is a new decl or not. */
612 /* Let the target reassign the RTL if it wants.
613 This is necessary, for example, when one machine specific
614 decl attribute overrides another. */
615 #ifdef REDO_SECTION_INFO_P
616 if (REDO_SECTION_INFO_P (decl))
617 ENCODE_SECTION_INFO (decl);
618 #endif
619 return;
622 new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
624 reg_number = decode_reg_name (asmspec);
625 if (reg_number == -2)
627 /* ASMSPEC is given, and not the name of a register. Mark the
628 name with a star so assemble_name won't munge it. */
629 char *starred = alloca (strlen (asmspec) + 2);
630 starred[0] = '*';
631 strcpy (starred + 1, asmspec);
632 new_name = starred;
635 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
637 /* First detect errors in declaring global registers. */
638 if (reg_number == -1)
639 error_with_decl (decl, "register name not specified for `%s'");
640 else if (reg_number < 0)
641 error_with_decl (decl, "invalid register name for `%s'");
642 else if (TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
643 error_with_decl (decl,
644 "data type of `%s' isn't suitable for a register");
645 else if (! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
646 error_with_decl (decl,
647 "register specified for `%s' isn't suitable for data type");
648 /* Now handle properly declared static register variables. */
649 else
651 int nregs;
653 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
655 DECL_INITIAL (decl) = 0;
656 error ("global register variable has initial value");
658 if (TREE_THIS_VOLATILE (decl))
659 warning ("volatile register variables don't work as you might wish");
661 /* If the user specified one of the eliminables registers here,
662 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
663 confused with that register and be eliminated. Although this
664 usage is somewhat suspect, we nevertheless use the following
665 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
667 SET_DECL_RTL (decl,
668 gen_rtx_REG (DECL_MODE (decl),
669 FIRST_PSEUDO_REGISTER));
670 REGNO (DECL_RTL (decl)) = reg_number;
671 REG_USERVAR_P (DECL_RTL (decl)) = 1;
673 if (TREE_STATIC (decl))
675 /* Make this register global, so not usable for anything
676 else. */
677 #ifdef ASM_DECLARE_REGISTER_GLOBAL
678 ASM_DECLARE_REGISTER_GLOBAL (asm_out_file, decl, reg_number, name);
679 #endif
680 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
681 while (nregs > 0)
682 globalize_reg (reg_number + --nregs);
685 /* As a register variable, it has no section. */
686 return;
690 /* Now handle ordinary static variables and functions (in memory).
691 Also handle vars declared register invalidly. */
693 if (reg_number >= 0 || reg_number == -3)
694 error_with_decl (decl,
695 "register name given for non-register variable `%s'");
697 /* Specifying a section attribute on a variable forces it into a
698 non-.bss section, and thus it cannot be common. */
699 if (TREE_CODE (decl) == VAR_DECL
700 && DECL_SECTION_NAME (decl) != NULL_TREE
701 && DECL_INITIAL (decl) == NULL_TREE
702 && DECL_COMMON (decl))
703 DECL_COMMON (decl) = 0;
705 /* Can't use just the variable's own name for a variable
706 whose scope is less than the whole file, unless it's a member
707 of a local class (which will already be unambiguous).
708 Concatenate a distinguishing number. */
709 if (!top_level && !TREE_PUBLIC (decl)
710 && ! (DECL_CONTEXT (decl) && TYPE_P (DECL_CONTEXT (decl)))
711 && asmspec == 0
712 && name == IDENTIFIER_POINTER (DECL_NAME (decl)))
714 char *label;
715 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
716 var_labelno++;
717 new_name = label;
720 /* When -fprefix-function-name is used, the functions
721 names are prefixed. Only nested function names are not
722 prefixed. */
723 else if (flag_prefix_function_name && TREE_CODE (decl) == FUNCTION_DECL)
725 size_t name_len = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl));
726 char *pname;
728 pname = alloca (name_len + CHKR_PREFIX_SIZE + 1);
729 memcpy (pname, CHKR_PREFIX, CHKR_PREFIX_SIZE);
730 memcpy (pname + CHKR_PREFIX_SIZE, name, name_len + 1);
731 new_name = pname;
734 if (name != new_name)
736 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
737 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
740 /* If this variable is to be treated as volatile, show its
741 tree node has side effects. */
742 if ((flag_volatile_global && TREE_CODE (decl) == VAR_DECL
743 && TREE_PUBLIC (decl))
744 || ((flag_volatile_static && TREE_CODE (decl) == VAR_DECL
745 && (TREE_PUBLIC (decl) || TREE_STATIC (decl)))))
746 TREE_SIDE_EFFECTS (decl) = 1;
748 SET_DECL_RTL (decl, gen_rtx_MEM (DECL_MODE (decl),
749 gen_rtx_SYMBOL_REF (Pmode, name)));
750 SYMBOL_REF_WEAK (XEXP (DECL_RTL (decl), 0)) = DECL_WEAK (decl);
751 if (TREE_CODE (decl) != FUNCTION_DECL)
752 set_mem_attributes (DECL_RTL (decl), decl, 1);
754 /* Optionally set flags or add text to the name to record information
755 such as that it is a function name.
756 If the name is changed, the macro ASM_OUTPUT_LABELREF
757 will have to know how to strip this information. */
758 #ifdef ENCODE_SECTION_INFO
759 ENCODE_SECTION_INFO (decl);
760 #endif
763 /* Make the rtl for variable VAR be volatile.
764 Use this only for static variables. */
766 void
767 make_var_volatile (var)
768 tree var;
770 if (GET_CODE (DECL_RTL (var)) != MEM)
771 abort ();
773 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
776 /* Output alignment directive to align for constant expression EXP. */
778 void
779 assemble_constant_align (exp)
780 tree exp;
782 int align;
784 /* Align the location counter as required by EXP's data type. */
785 align = TYPE_ALIGN (TREE_TYPE (exp));
786 #ifdef CONSTANT_ALIGNMENT
787 align = CONSTANT_ALIGNMENT (exp, align);
788 #endif
790 if (align > BITS_PER_UNIT)
791 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
794 /* Output a string of literal assembler code
795 for an `asm' keyword used between functions. */
797 void
798 assemble_asm (string)
799 tree string;
801 app_enable ();
803 if (TREE_CODE (string) == ADDR_EXPR)
804 string = TREE_OPERAND (string, 0);
806 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
809 #if 0 /* This should no longer be needed, because
810 flag_gnu_linker should be 0 on these systems,
811 which should prevent any output
812 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
813 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
814 #ifndef ASM_OUTPUT_CONSTRUCTOR
815 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
816 #endif
817 #ifndef ASM_OUTPUT_DESTRUCTOR
818 #define ASM_OUTPUT_DESTRUCTOR(file, name)
819 #endif
820 #endif
821 #endif /* 0 */
823 /* Record an element in the table of global destructors.
824 How this is done depends on what sort of assembler and linker
825 are in use.
827 NAME should be the name of a global function to be called
828 at exit time. This name is output using assemble_name. */
830 void
831 assemble_destructor (name)
832 const char *name;
834 #ifdef ASM_OUTPUT_DESTRUCTOR
835 ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
836 #else
837 if (flag_gnu_linker)
839 /* Now tell GNU LD that this is part of the static destructor set. */
840 /* This code works for any machine provided you use GNU as/ld. */
841 fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
842 assemble_name (asm_out_file, name);
843 fputc ('\n', asm_out_file);
845 #endif
848 /* Likewise for global constructors. */
850 void
851 assemble_constructor (name)
852 const char *name;
854 #ifdef ASM_OUTPUT_CONSTRUCTOR
855 ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
856 #else
857 if (flag_gnu_linker)
859 /* Now tell GNU LD that this is part of the static constructor set. */
860 /* This code works for any machine provided you use GNU as/ld. */
861 fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
862 assemble_name (asm_out_file, name);
863 fputc ('\n', asm_out_file);
865 #endif
868 /* Likewise for entries we want to record for garbage collection.
869 Garbage collection is still under development. */
871 void
872 assemble_gc_entry (name)
873 const char *name;
875 #ifdef ASM_OUTPUT_GC_ENTRY
876 ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
877 #else
878 if (flag_gnu_linker)
880 /* Now tell GNU LD that this is part of the static constructor set. */
881 fprintf (asm_out_file, "%s\"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
882 assemble_name (asm_out_file, name);
883 fputc ('\n', asm_out_file);
885 #endif
888 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
889 a non-zero value if the constant pool should be output before the
890 start of the function, or a zero value if the pool should output
891 after the end of the function. The default is to put it before the
892 start. */
894 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
895 #define CONSTANT_POOL_BEFORE_FUNCTION 1
896 #endif
898 /* Output assembler code for the constant pool of a function and associated
899 with defining the name of the function. DECL describes the function.
900 NAME is the function's name. For the constant pool, we use the current
901 constant pool data. */
903 void
904 assemble_start_function (decl, fnname)
905 tree decl;
906 const char *fnname;
908 int align;
910 /* The following code does not need preprocessing in the assembler. */
912 app_disable ();
914 if (CONSTANT_POOL_BEFORE_FUNCTION)
915 output_constant_pool (fnname, decl);
917 #ifdef ASM_OUTPUT_SECTION_NAME
918 /* If the function is to be put in its own section and it's not in a section
919 already, indicate so. */
920 if ((flag_function_sections
921 && DECL_SECTION_NAME (decl) == NULL_TREE)
922 || UNIQUE_SECTION_P (decl))
923 UNIQUE_SECTION (decl, 0);
924 #endif
926 function_section (decl);
928 /* Tell assembler to move to target machine's alignment for functions. */
929 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
930 if (align > 0)
931 ASM_OUTPUT_ALIGN (asm_out_file, align);
933 /* Handle a user-specified function alignment.
934 Note that we still need to align to FUNCTION_BOUNDARY, as above,
935 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
936 if (align_functions_log > align)
938 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
939 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
940 align_functions_log, align_functions-1);
941 #else
942 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
943 #endif
946 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
947 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
948 #endif
950 #ifdef SDB_DEBUGGING_INFO
951 /* Output SDB definition of the function. */
952 if (write_symbols == SDB_DEBUG)
953 sdbout_mark_begin_function ();
954 #endif
956 #ifdef DBX_DEBUGGING_INFO
957 /* Output DBX definition of the function. */
958 if (write_symbols == DBX_DEBUG)
959 dbxout_begin_function (decl);
960 #endif
962 /* Make function name accessible from other files, if appropriate. */
964 if (TREE_PUBLIC (decl))
966 if (! first_global_object_name)
968 const char *p;
969 char *name;
971 STRIP_NAME_ENCODING (p, fnname);
972 name = permalloc (strlen (p) + 1);
973 strcpy (name, p);
975 if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
976 first_global_object_name = name;
977 else
978 weak_global_object_name = name;
981 #ifdef ASM_WEAKEN_LABEL
982 if (DECL_WEAK (decl))
984 ASM_WEAKEN_LABEL (asm_out_file, fnname);
985 /* Remove this function from the pending weak list so that
986 we do not emit multiple .weak directives for it. */
987 remove_from_pending_weak_list
988 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
990 else
991 #endif
992 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
995 /* Do any machine/system dependent processing of the function name */
996 #ifdef ASM_DECLARE_FUNCTION_NAME
997 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
998 #else
999 /* Standard thing is just output label for the function. */
1000 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1001 #endif /* ASM_DECLARE_FUNCTION_NAME */
1004 /* Output assembler code associated with defining the size of the
1005 function. DECL describes the function. NAME is the function's name. */
1007 void
1008 assemble_end_function (decl, fnname)
1009 tree decl;
1010 const char *fnname;
1012 #ifdef ASM_DECLARE_FUNCTION_SIZE
1013 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1014 #endif
1015 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1017 output_constant_pool (fnname, decl);
1018 function_section (decl); /* need to switch back */
1021 /* Output any constants which should appear after the function. */
1022 output_after_function_constants ();
1025 /* Assemble code to leave SIZE bytes of zeros. */
1027 void
1028 assemble_zeros (size)
1029 int size;
1031 /* Do no output if -fsyntax-only. */
1032 if (flag_syntax_only)
1033 return;
1035 #ifdef ASM_NO_SKIP_IN_TEXT
1036 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1037 so we must output 0s explicitly in the text section. */
1038 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1040 int i;
1042 for (i = 0; i < size - 20; i += 20)
1044 #ifdef ASM_BYTE_OP
1045 fprintf (asm_out_file,
1046 "%s0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
1047 #else
1048 fprintf (asm_out_file,
1049 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1050 #endif
1052 if (i < size)
1054 #ifdef ASM_BYTE_OP
1055 fprintf (asm_out_file, "%s0", ASM_BYTE_OP);
1056 #else
1057 fprintf (asm_out_file, "\tbyte 0");
1058 #endif
1059 i++;
1060 for (; i < size; i++)
1061 fprintf (asm_out_file, ",0");
1062 fprintf (asm_out_file, "\n");
1065 else
1066 #endif
1067 if (size > 0)
1068 ASM_OUTPUT_SKIP (asm_out_file, size);
1071 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1073 void
1074 assemble_align (align)
1075 int align;
1077 if (align > BITS_PER_UNIT)
1078 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1081 /* Assemble a string constant with the specified C string as contents. */
1083 void
1084 assemble_string (p, size)
1085 const char *p;
1086 int size;
1088 int pos = 0;
1089 int maximum = 2000;
1091 /* If the string is very long, split it up. */
1093 while (pos < size)
1095 int thissize = size - pos;
1096 if (thissize > maximum)
1097 thissize = maximum;
1099 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1101 pos += thissize;
1102 p += thissize;
1107 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1108 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1109 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1110 #else
1111 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1112 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1113 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1114 #else
1115 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1116 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1117 #endif
1118 #endif
1120 #if defined ASM_OUTPUT_ALIGNED_BSS
1121 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1122 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1123 #else
1124 #if defined ASM_OUTPUT_BSS
1125 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1126 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1127 #else
1128 #undef ASM_EMIT_BSS
1129 #endif
1130 #endif
1132 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1133 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1134 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1135 #else
1136 #if defined ASM_OUTPUT_ALIGNED_COMMON
1137 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1138 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1139 #else
1140 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1141 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1142 #endif
1143 #endif
1145 static void
1146 asm_emit_uninitialised (decl, name, size, rounded)
1147 tree decl;
1148 const char * name;
1149 int size ATTRIBUTE_UNUSED;
1150 int rounded ATTRIBUTE_UNUSED;
1152 enum
1154 asm_dest_common,
1155 asm_dest_bss,
1156 asm_dest_local
1158 destination = asm_dest_local;
1160 if (TREE_PUBLIC (decl))
1162 #if defined ASM_EMIT_BSS
1163 if (! DECL_COMMON (decl))
1164 destination = asm_dest_bss;
1165 else
1166 #endif
1167 destination = asm_dest_common;
1170 if (flag_shared_data)
1172 switch (destination)
1174 #ifdef ASM_OUTPUT_SHARED_BSS
1175 case asm_dest_bss:
1176 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1177 return;
1178 #endif
1179 #ifdef ASM_OUTPUT_SHARED_COMMON
1180 case asm_dest_common:
1181 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1182 return;
1183 #endif
1184 #ifdef ASM_OUTPUT_SHARED_LOCAL
1185 case asm_dest_local:
1186 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1187 return;
1188 #endif
1189 default:
1190 break;
1194 #ifdef ASM_OUTPUT_SECTION_NAME
1195 /* We already know that DECL_SECTION_NAME() == NULL. */
1196 if (flag_data_sections != 0 || UNIQUE_SECTION_P (decl))
1197 UNIQUE_SECTION (decl, 0);
1198 #endif
1200 switch (destination)
1202 #ifdef ASM_EMIT_BSS
1203 case asm_dest_bss:
1204 ASM_EMIT_BSS (decl, name, size, rounded);
1205 break;
1206 #endif
1207 case asm_dest_common:
1208 ASM_EMIT_COMMON (decl, name, size, rounded);
1209 break;
1210 case asm_dest_local:
1211 ASM_EMIT_LOCAL (decl, name, size, rounded);
1212 break;
1213 default:
1214 abort ();
1217 return;
1220 /* Assemble everything that is needed for a variable or function declaration.
1221 Not used for automatic variables, and not used for function definitions.
1222 Should not be called for variables of incomplete structure type.
1224 TOP_LEVEL is nonzero if this variable has file scope.
1225 AT_END is nonzero if this is the special handling, at end of compilation,
1226 to define things that have had only tentative definitions.
1227 DONT_OUTPUT_DATA if nonzero means don't actually output the
1228 initial value (that will be done by the caller). */
1230 void
1231 assemble_variable (decl, top_level, at_end, dont_output_data)
1232 tree decl;
1233 int top_level ATTRIBUTE_UNUSED;
1234 int at_end ATTRIBUTE_UNUSED;
1235 int dont_output_data;
1237 register const char *name;
1238 unsigned int align;
1239 int reloc = 0;
1240 enum in_section saved_in_section;
1242 last_assemble_variable_decl = 0;
1244 if (DECL_RTL_SET_P (decl) && GET_CODE (DECL_RTL (decl)) == REG)
1246 /* Do output symbol info for global register variables, but do nothing
1247 else for them. */
1249 if (TREE_ASM_WRITTEN (decl))
1250 return;
1251 TREE_ASM_WRITTEN (decl) = 1;
1253 /* Do no output if -fsyntax-only. */
1254 if (flag_syntax_only)
1255 return;
1257 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1258 /* File-scope global variables are output here. */
1259 if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1260 && top_level)
1261 dbxout_symbol (decl, 0);
1262 #endif
1263 #ifdef SDB_DEBUGGING_INFO
1264 if (write_symbols == SDB_DEBUG && top_level
1265 /* Leave initialized global vars for end of compilation;
1266 see comment in compile_file. */
1267 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1268 sdbout_symbol (decl, 0);
1269 #endif
1271 /* Don't output any DWARF debugging information for variables here.
1272 In the case of local variables, the information for them is output
1273 when we do our recursive traversal of the tree representation for
1274 the entire containing function. In the case of file-scope variables,
1275 we output information for all of them at the very end of compilation
1276 while we are doing our final traversal of the chain of file-scope
1277 declarations. */
1279 return;
1282 /* Normally no need to say anything here for external references,
1283 since assemble_external is called by the language-specific code
1284 when a declaration is first seen. */
1286 if (DECL_EXTERNAL (decl))
1287 return;
1289 /* Output no assembler code for a function declaration.
1290 Only definitions of functions output anything. */
1292 if (TREE_CODE (decl) == FUNCTION_DECL)
1293 return;
1295 /* If type was incomplete when the variable was declared,
1296 see if it is complete now. */
1298 if (DECL_SIZE (decl) == 0)
1299 layout_decl (decl, 0);
1301 /* Still incomplete => don't allocate it; treat the tentative defn
1302 (which is what it must have been) as an `extern' reference. */
1304 if (!dont_output_data && DECL_SIZE (decl) == 0)
1306 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1307 DECL_SOURCE_LINE (decl),
1308 "storage size of `%s' isn't known",
1309 IDENTIFIER_POINTER (DECL_NAME (decl)));
1310 TREE_ASM_WRITTEN (decl) = 1;
1311 return;
1314 /* The first declaration of a variable that comes through this function
1315 decides whether it is global (in C, has external linkage)
1316 or local (in C, has internal linkage). So do nothing more
1317 if this function has already run. */
1319 if (TREE_ASM_WRITTEN (decl))
1320 return;
1322 TREE_ASM_WRITTEN (decl) = 1;
1324 /* Do no output if -fsyntax-only. */
1325 if (flag_syntax_only)
1326 return;
1328 app_disable ();
1330 if (! dont_output_data
1331 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1333 error_with_decl (decl, "size of variable `%s' is too large");
1334 goto finish;
1337 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1338 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1339 && ! first_global_object_name
1340 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1341 || DECL_INITIAL (decl) == error_mark_node))
1342 && ! DECL_WEAK (decl)
1343 && ! DECL_ONE_ONLY (decl))
1345 const char *p;
1346 char *xname;
1348 STRIP_NAME_ENCODING (p, name);
1349 xname = permalloc (strlen (p) + 1);
1350 strcpy (xname, p);
1351 first_global_object_name = xname;
1354 /* Compute the alignment of this data. */
1356 align = DECL_ALIGN (decl);
1358 /* In the case for initialing an array whose length isn't specified,
1359 where we have not yet been able to do the layout,
1360 figure out the proper alignment now. */
1361 if (dont_output_data && DECL_SIZE (decl) == 0
1362 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1363 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1365 /* Some object file formats have a maximum alignment which they support.
1366 In particular, a.out format supports a maximum alignment of 4. */
1367 #ifndef MAX_OFILE_ALIGNMENT
1368 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1369 #endif
1370 if (align > MAX_OFILE_ALIGNMENT)
1372 warning_with_decl (decl,
1373 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1374 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1375 align = MAX_OFILE_ALIGNMENT;
1378 /* On some machines, it is good to increase alignment sometimes. */
1379 #ifdef DATA_ALIGNMENT
1380 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1381 #endif
1382 #ifdef CONSTANT_ALIGNMENT
1383 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1384 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1385 #endif
1387 /* Reset the alignment in case we have made it tighter, so we can benefit
1388 from it in get_pointer_alignment. */
1389 DECL_ALIGN (decl) = align;
1391 /* Handle uninitialized definitions. */
1393 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1394 /* If the target can't output uninitialized but not common global data
1395 in .bss, then we have to use .data. */
1396 #if ! defined ASM_EMIT_BSS
1397 && DECL_COMMON (decl)
1398 #endif
1399 && DECL_SECTION_NAME (decl) == NULL_TREE
1400 && ! dont_output_data)
1402 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1403 unsigned HOST_WIDE_INT rounded = size;
1405 /* Don't allocate zero bytes of common,
1406 since that means "undefined external" in the linker. */
1407 if (size == 0)
1408 rounded = 1;
1410 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1411 so that each uninitialized object starts on such a boundary. */
1412 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1413 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1414 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1416 /* Don't continue this line--convex cc version 4.1 would lose. */
1417 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1418 if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1419 warning_with_decl
1420 (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
1421 #endif
1423 #ifdef DBX_DEBUGGING_INFO
1424 /* File-scope global variables are output here. */
1425 if (write_symbols == DBX_DEBUG && top_level)
1426 dbxout_symbol (decl, 0);
1427 #endif
1428 #ifdef SDB_DEBUGGING_INFO
1429 if (write_symbols == SDB_DEBUG && top_level
1430 /* Leave initialized global vars for end of compilation;
1431 see comment in compile_file. */
1432 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1433 sdbout_symbol (decl, 0);
1434 #endif
1436 /* Don't output any DWARF debugging information for variables here.
1437 In the case of local variables, the information for them is output
1438 when we do our recursive traversal of the tree representation for
1439 the entire containing function. In the case of file-scope variables,
1440 we output information for all of them at the very end of compilation
1441 while we are doing our final traversal of the chain of file-scope
1442 declarations. */
1444 #if 0 /* ??? We should either delete this or add a comment describing what
1445 it was intended to do and why we shouldn't delete it. */
1446 if (flag_shared_data)
1447 data_section ();
1448 #endif
1449 asm_emit_uninitialised (decl, name, size, rounded);
1451 goto finish;
1454 /* Handle initialized definitions.
1455 Also handle uninitialized global definitions if -fno-common and the
1456 target doesn't support ASM_OUTPUT_BSS. */
1458 /* First make the assembler name(s) global if appropriate. */
1459 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1461 #ifdef ASM_WEAKEN_LABEL
1462 if (DECL_WEAK (decl))
1464 ASM_WEAKEN_LABEL (asm_out_file, name);
1465 /* Remove this variable from the pending weak list so that
1466 we do not emit multiple .weak directives for it. */
1467 remove_from_pending_weak_list
1468 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1470 else
1471 #endif
1472 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1474 #if 0
1475 for (d = equivalents; d; d = TREE_CHAIN (d))
1477 tree e = TREE_VALUE (d);
1478 if (TREE_PUBLIC (e) && DECL_NAME (e))
1479 ASM_GLOBALIZE_LABEL (asm_out_file,
1480 XSTR (XEXP (DECL_RTL (e), 0), 0));
1482 #endif
1484 /* Output any data that we will need to use the address of. */
1485 if (DECL_INITIAL (decl) == error_mark_node)
1486 reloc = contains_pointers_p (TREE_TYPE (decl));
1487 else if (DECL_INITIAL (decl))
1488 reloc = output_addressed_constants (DECL_INITIAL (decl));
1490 #ifdef ASM_OUTPUT_SECTION_NAME
1491 if ((flag_data_sections != 0 && DECL_SECTION_NAME (decl) == NULL_TREE)
1492 || UNIQUE_SECTION_P (decl))
1493 UNIQUE_SECTION (decl, reloc);
1494 #endif
1496 /* Switch to the appropriate section. */
1497 variable_section (decl, reloc);
1499 /* dbxout.c needs to know this. */
1500 if (in_text_section ())
1501 DECL_IN_TEXT_SECTION (decl) = 1;
1503 /* Record current section so we can restore it if dbxout.c clobbers it. */
1504 saved_in_section = in_section;
1506 /* Output the dbx info now that we have chosen the section. */
1508 #ifdef DBX_DEBUGGING_INFO
1509 /* File-scope global variables are output here. */
1510 if (write_symbols == DBX_DEBUG && top_level)
1511 dbxout_symbol (decl, 0);
1512 #endif
1513 #ifdef SDB_DEBUGGING_INFO
1514 if (write_symbols == SDB_DEBUG && top_level
1515 /* Leave initialized global vars for end of compilation;
1516 see comment in compile_file. */
1517 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1518 sdbout_symbol (decl, 0);
1519 #endif
1521 /* Don't output any DWARF debugging information for variables here.
1522 In the case of local variables, the information for them is output
1523 when we do our recursive traversal of the tree representation for
1524 the entire containing function. In the case of file-scope variables,
1525 we output information for all of them at the very end of compilation
1526 while we are doing our final traversal of the chain of file-scope
1527 declarations. */
1529 /* If the debugging output changed sections, reselect the section
1530 that's supposed to be selected. */
1531 if (in_section != saved_in_section)
1532 variable_section (decl, reloc);
1534 /* Output the alignment of this data. */
1535 if (align > BITS_PER_UNIT)
1536 ASM_OUTPUT_ALIGN (asm_out_file,
1537 floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1539 /* Do any machine/system dependent processing of the object. */
1540 #ifdef ASM_DECLARE_OBJECT_NAME
1541 last_assemble_variable_decl = decl;
1542 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1543 #else
1544 /* Standard thing is just output label for the object. */
1545 ASM_OUTPUT_LABEL (asm_out_file, name);
1546 #endif /* ASM_DECLARE_OBJECT_NAME */
1548 if (!dont_output_data)
1550 if (DECL_INITIAL (decl))
1551 /* Output the actual data. */
1552 output_constant (DECL_INITIAL (decl),
1553 tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1554 else
1555 /* Leave space for it. */
1556 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1559 finish:
1560 #ifdef XCOFF_DEBUGGING_INFO
1561 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1562 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1563 and `aa' hasn't been output yet, the assembler generates a stab entry with
1564 a value of zero, in addition to creating an unnecessary external entry
1565 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1567 /* File-scope global variables are output here. */
1568 if (write_symbols == XCOFF_DEBUG && top_level)
1570 saved_in_section = in_section;
1572 dbxout_symbol (decl, 0);
1574 if (in_section != saved_in_section)
1575 variable_section (decl, reloc);
1577 #else
1578 /* There must be a statement after a label. */
1580 #endif
1583 /* Return 1 if type TYPE contains any pointers. */
1585 static int
1586 contains_pointers_p (type)
1587 tree type;
1589 switch (TREE_CODE (type))
1591 case POINTER_TYPE:
1592 case REFERENCE_TYPE:
1593 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1594 so I'll play safe and return 1. */
1595 case OFFSET_TYPE:
1596 return 1;
1598 case RECORD_TYPE:
1599 case UNION_TYPE:
1600 case QUAL_UNION_TYPE:
1602 tree fields;
1603 /* For a type that has fields, see if the fields have pointers. */
1604 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1605 if (TREE_CODE (fields) == FIELD_DECL
1606 && contains_pointers_p (TREE_TYPE (fields)))
1607 return 1;
1608 return 0;
1611 case ARRAY_TYPE:
1612 /* An array type contains pointers if its element type does. */
1613 return contains_pointers_p (TREE_TYPE (type));
1615 default:
1616 return 0;
1620 /* Output something to declare an external symbol to the assembler.
1621 (Most assemblers don't need this, so we normally output nothing.)
1622 Do nothing if DECL is not external. */
1624 void
1625 assemble_external (decl)
1626 tree decl ATTRIBUTE_UNUSED;
1628 /* Because most platforms do not define ASM_OUTPUT_EXTERNAL, the
1629 main body of this code is only rarely exercised. To provide some
1630 testing, on all platforms, we make sure that the ASM_OUT_FILE is
1631 open. If it's not, we should not be calling this function. */
1632 if (!asm_out_file)
1633 abort ();
1635 #ifdef ASM_OUTPUT_EXTERNAL
1636 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1638 rtx rtl = DECL_RTL (decl);
1640 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1641 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1643 /* Some systems do require some output. */
1644 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1645 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1648 #endif
1651 /* Similar, for calling a library function FUN. */
1653 void
1654 assemble_external_libcall (fun)
1655 rtx fun ATTRIBUTE_UNUSED;
1657 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1658 /* Declare library function name external when first used, if nec. */
1659 if (! SYMBOL_REF_USED (fun))
1661 SYMBOL_REF_USED (fun) = 1;
1662 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1664 #endif
1667 /* Declare the label NAME global. */
1669 void
1670 assemble_global (name)
1671 const char *name;
1673 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1676 /* Assemble a label named NAME. */
1678 void
1679 assemble_label (name)
1680 const char *name;
1682 ASM_OUTPUT_LABEL (asm_out_file, name);
1685 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1686 If NAME starts with a *, the rest of NAME is output verbatim.
1687 Otherwise NAME is transformed in an implementation-defined way
1688 (usually by the addition of an underscore).
1689 Many macros in the tm file are defined to call this function. */
1691 void
1692 assemble_name (file, name)
1693 FILE *file;
1694 const char *name;
1696 const char *real_name;
1697 tree id;
1699 STRIP_NAME_ENCODING (real_name, name);
1700 if (flag_prefix_function_name
1701 && ! memcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
1702 real_name = real_name + CHKR_PREFIX_SIZE;
1704 id = maybe_get_identifier (real_name);
1705 if (id)
1706 TREE_SYMBOL_REFERENCED (id) = 1;
1708 if (name[0] == '*')
1709 fputs (&name[1], file);
1710 else
1711 ASM_OUTPUT_LABELREF (file, name);
1714 /* Allocate SIZE bytes writable static space with a gensym name
1715 and return an RTX to refer to its address. */
1718 assemble_static_space (size)
1719 int size;
1721 char name[12];
1722 const char *namestring;
1723 rtx x;
1725 #if 0
1726 if (flag_shared_data)
1727 data_section ();
1728 #endif
1730 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1731 ++const_labelno;
1732 namestring = ggc_strdup (name);
1734 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1736 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1737 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1738 BIGGEST_ALIGNMENT);
1739 #else
1740 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1741 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1742 #else
1744 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1745 so that each uninitialized object starts on such a boundary. */
1746 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1747 int rounded ATTRIBUTE_UNUSED
1748 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1749 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1750 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1751 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1753 #endif
1754 #endif
1755 return x;
1758 /* Assemble the static constant template for function entry trampolines.
1759 This is done at most once per compilation.
1760 Returns an RTX for the address of the template. */
1762 #ifdef TRAMPOLINE_TEMPLATE
1764 assemble_trampoline_template ()
1766 char label[256];
1767 const char *name;
1768 int align;
1770 /* By default, put trampoline templates in read-only data section. */
1772 #ifdef TRAMPOLINE_SECTION
1773 TRAMPOLINE_SECTION ();
1774 #else
1775 readonly_data_section ();
1776 #endif
1778 /* Write the assembler code to define one. */
1779 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1780 if (align > 0)
1781 ASM_OUTPUT_ALIGN (asm_out_file, align);
1783 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1784 TRAMPOLINE_TEMPLATE (asm_out_file);
1786 /* Record the rtl to refer to it. */
1787 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1788 name = ggc_strdup (label);
1789 return gen_rtx_SYMBOL_REF (Pmode, name);
1791 #endif
1793 /* Assemble the integer constant X into an object of SIZE bytes.
1794 X must be either a CONST_INT or CONST_DOUBLE.
1796 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1797 non-zero, abort if we can't output the constant. */
1800 assemble_integer (x, size, force)
1801 rtx x;
1802 int size;
1803 int force;
1805 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1806 ASM_OUTPUT... macros. */
1808 switch (size)
1810 #ifdef ASM_OUTPUT_CHAR
1811 case 1:
1812 ASM_OUTPUT_CHAR (asm_out_file, x);
1813 return 1;
1814 #endif
1816 #ifdef ASM_OUTPUT_SHORT
1817 case 2:
1818 ASM_OUTPUT_SHORT (asm_out_file, x);
1819 return 1;
1820 #endif
1822 #ifdef ASM_OUTPUT_INT
1823 case 4:
1824 ASM_OUTPUT_INT (asm_out_file, x);
1825 return 1;
1826 #endif
1828 #ifdef ASM_OUTPUT_DOUBLE_INT
1829 case 8:
1830 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1831 return 1;
1832 #endif
1834 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1835 case 16:
1836 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1837 return 1;
1838 #endif
1841 /* If we couldn't do it that way, there are two other possibilities: First,
1842 if the machine can output an explicit byte and this is a 1 byte constant,
1843 we can use ASM_OUTPUT_BYTE. */
1845 #ifdef ASM_OUTPUT_BYTE
1846 if (size == 1 && GET_CODE (x) == CONST_INT)
1848 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1849 return 1;
1851 #endif
1853 /* Finally, if SIZE is larger than a single word, try to output the constant
1854 one word at a time. */
1856 if (size > UNITS_PER_WORD)
1858 int i;
1859 enum machine_mode mode
1860 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1861 rtx word;
1863 for (i = 0; i < size / UNITS_PER_WORD; i++)
1865 word = operand_subword (x, i, 0, mode);
1867 if (word == 0)
1868 break;
1870 if (! assemble_integer (word, UNITS_PER_WORD, 0))
1871 break;
1874 if (i == size / UNITS_PER_WORD)
1875 return 1;
1876 /* If we output at least one word and then could not finish,
1877 there is no valid way to continue. */
1878 if (i > 0)
1879 abort ();
1882 if (force)
1883 abort ();
1885 return 0;
1888 /* Assemble the floating-point constant D into an object of size MODE. */
1890 void
1891 assemble_real (d, mode)
1892 REAL_VALUE_TYPE d;
1893 enum machine_mode mode;
1895 jmp_buf output_constant_handler;
1897 if (setjmp (output_constant_handler))
1899 error ("floating point trap outputting a constant");
1900 #ifdef REAL_IS_NOT_DOUBLE
1901 memset ((char *) &d, 0, sizeof d);
1902 d = dconst0;
1903 #else
1904 d = 0;
1905 #endif
1908 set_float_handler (output_constant_handler);
1910 switch (mode)
1912 #ifdef ASM_OUTPUT_BYTE_FLOAT
1913 case QFmode:
1914 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1915 break;
1916 #endif
1917 #ifdef ASM_OUTPUT_SHORT_FLOAT
1918 case HFmode:
1919 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1920 break;
1921 #endif
1922 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1923 case TQFmode:
1924 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
1925 break;
1926 #endif
1927 #ifdef ASM_OUTPUT_FLOAT
1928 case SFmode:
1929 ASM_OUTPUT_FLOAT (asm_out_file, d);
1930 break;
1931 #endif
1933 #ifdef ASM_OUTPUT_DOUBLE
1934 case DFmode:
1935 ASM_OUTPUT_DOUBLE (asm_out_file, d);
1936 break;
1937 #endif
1939 #ifdef ASM_OUTPUT_LONG_DOUBLE
1940 case XFmode:
1941 case TFmode:
1942 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1943 break;
1944 #endif
1946 default:
1947 abort ();
1950 set_float_handler (NULL_PTR);
1953 /* Here we combine duplicate floating constants to make
1954 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1956 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1957 For an integer, I0 is the low-order word and I1 is the high-order word.
1958 For a real number, I0 is the word with the low address
1959 and I1 is the word with the high address. */
1962 immed_double_const (i0, i1, mode)
1963 HOST_WIDE_INT i0, i1;
1964 enum machine_mode mode;
1966 register rtx r;
1968 if (GET_MODE_CLASS (mode) == MODE_INT
1969 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1971 /* We clear out all bits that don't belong in MODE, unless they and our
1972 sign bit are all one. So we get either a reasonable negative value
1973 or a reasonable unsigned value for this mode. */
1974 int width = GET_MODE_BITSIZE (mode);
1975 if (width < HOST_BITS_PER_WIDE_INT
1976 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
1977 != ((HOST_WIDE_INT) (-1) << (width - 1))))
1978 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
1979 else if (width == HOST_BITS_PER_WIDE_INT
1980 && ! (i1 == ~0 && i0 < 0))
1981 i1 = 0;
1982 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
1983 /* We cannot represent this value as a constant. */
1984 abort ();
1986 /* If this would be an entire word for the target, but is not for
1987 the host, then sign-extend on the host so that the number will look
1988 the same way on the host that it would on the target.
1990 For example, when building a 64 bit alpha hosted 32 bit sparc
1991 targeted compiler, then we want the 32 bit unsigned value -1 to be
1992 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
1993 The later confuses the sparc backend. */
1995 if (BITS_PER_WORD < HOST_BITS_PER_WIDE_INT && BITS_PER_WORD == width
1996 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
1997 i0 |= ((HOST_WIDE_INT) (-1) << width);
1999 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
2001 ??? Strictly speaking, this is wrong if we create a CONST_INT
2002 for a large unsigned constant with the size of MODE being
2003 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
2004 wider mode. In that case we will mis-interpret it as a negative
2005 number.
2007 Unfortunately, the only alternative is to make a CONST_DOUBLE
2008 for any constant in any mode if it is an unsigned constant larger
2009 than the maximum signed integer in an int on the host. However,
2010 doing this will break everyone that always expects to see a CONST_INT
2011 for SImode and smaller.
2013 We have always been making CONST_INTs in this case, so nothing new
2014 is being broken. */
2016 if (width <= HOST_BITS_PER_WIDE_INT)
2017 i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2019 /* If this integer fits in one word, return a CONST_INT. */
2020 if ((i1 == 0 && i0 >= 0)
2021 || (i1 == ~0 && i0 < 0))
2022 return GEN_INT (i0);
2024 /* We use VOIDmode for integers. */
2025 mode = VOIDmode;
2028 /* Search the chain for an existing CONST_DOUBLE with the right value.
2029 If one is found, return it. */
2030 if (cfun != 0)
2031 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2032 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2033 && GET_MODE (r) == mode)
2034 return r;
2036 /* No; make a new one and add it to the chain. */
2037 r = gen_rtx_CONST_DOUBLE (mode, const0_rtx, i0, i1);
2039 /* Don't touch const_double_chain if not inside any function. */
2040 if (current_function_decl != 0)
2042 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2043 const_double_chain = r;
2046 return r;
2049 /* Return a CONST_DOUBLE for a specified `double' value
2050 and machine mode. */
2053 immed_real_const_1 (d, mode)
2054 REAL_VALUE_TYPE d;
2055 enum machine_mode mode;
2057 union real_extract u;
2058 register rtx r;
2060 /* Get the desired `double' value as a sequence of ints
2061 since that is how they are stored in a CONST_DOUBLE. */
2063 u.d = d;
2065 /* Detect special cases. But be careful we don't use a CONST_DOUBLE
2066 that's from a parent function since it may be in its constant pool. */
2067 if (REAL_VALUES_IDENTICAL (dconst0, d)
2068 && (cfun == 0 || decl_function_context (current_function_decl) == 0))
2069 return CONST0_RTX (mode);
2071 /* Check for NaN first, because some ports (specifically the i386) do not
2072 emit correct ieee-fp code by default, and thus will generate a core
2073 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2074 does a floating point comparison. */
2075 else if ((! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2076 && (cfun == 0
2077 || decl_function_context (current_function_decl) == 0))
2078 return CONST1_RTX (mode);
2080 if (sizeof u == sizeof (HOST_WIDE_INT))
2081 return immed_double_const (u.i[0], 0, mode);
2082 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2083 return immed_double_const (u.i[0], u.i[1], mode);
2085 /* The rest of this function handles the case where
2086 a float value requires more than 2 ints of space.
2087 It will be deleted as dead code on machines that don't need it. */
2089 /* Search the chain for an existing CONST_DOUBLE with the right value.
2090 If one is found, return it. */
2091 if (cfun != 0)
2092 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2093 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2094 && GET_MODE (r) == mode)
2095 return r;
2097 /* No; make a new one and add it to the chain.
2099 We may be called by an optimizer which may be discarding any memory
2100 allocated during its processing (such as combine and loop). However,
2101 we will be leaving this constant on the chain, so we cannot tolerate
2102 freed memory. */
2103 r = rtx_alloc (CONST_DOUBLE);
2104 PUT_MODE (r, mode);
2105 memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u);
2107 /* If we aren't inside a function, don't put r on the
2108 const_double_chain. */
2109 if (current_function_decl != 0)
2111 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2112 const_double_chain = r;
2114 else
2115 CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2117 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2118 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2119 is only through force_const_mem. */
2121 CONST_DOUBLE_MEM (r) = const0_rtx;
2123 return r;
2126 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2127 which must be a REAL_CST tree node. */
2130 immed_real_const (exp)
2131 tree exp;
2133 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2136 /* At the end of a function, forget the memory-constants
2137 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2138 Also clear out real_constant_chain and clear out all the chain-pointers. */
2140 void
2141 clear_const_double_mem ()
2143 register rtx r, next;
2145 for (r = const_double_chain; r; r = next)
2147 next = CONST_DOUBLE_CHAIN (r);
2148 CONST_DOUBLE_CHAIN (r) = 0;
2149 CONST_DOUBLE_MEM (r) = cc0_rtx;
2151 const_double_chain = 0;
2154 /* Given an expression EXP with a constant value,
2155 reduce it to the sum of an assembler symbol and an integer.
2156 Store them both in the structure *VALUE.
2157 Abort if EXP does not reduce. */
2159 struct addr_const
2161 rtx base;
2162 HOST_WIDE_INT offset;
2165 static void
2166 decode_addr_const (exp, value)
2167 tree exp;
2168 struct addr_const *value;
2170 register tree target = TREE_OPERAND (exp, 0);
2171 register int offset = 0;
2172 register rtx x;
2174 while (1)
2176 if (TREE_CODE (target) == COMPONENT_REF
2177 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2180 offset += int_byte_position (TREE_OPERAND (target, 1));
2181 target = TREE_OPERAND (target, 0);
2183 else if (TREE_CODE (target) == ARRAY_REF)
2185 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2186 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2187 target = TREE_OPERAND (target, 0);
2189 else
2190 break;
2193 switch (TREE_CODE (target))
2195 case VAR_DECL:
2196 case FUNCTION_DECL:
2197 x = DECL_RTL (target);
2198 break;
2200 case LABEL_DECL:
2201 x = gen_rtx_MEM (FUNCTION_MODE,
2202 gen_rtx_LABEL_REF (VOIDmode,
2203 label_rtx (TREE_OPERAND (exp, 0))));
2204 break;
2206 case REAL_CST:
2207 case STRING_CST:
2208 case COMPLEX_CST:
2209 case CONSTRUCTOR:
2210 case INTEGER_CST:
2211 x = TREE_CST_RTL (target);
2212 break;
2214 default:
2215 abort ();
2218 if (GET_CODE (x) != MEM)
2219 abort ();
2220 x = XEXP (x, 0);
2222 value->base = x;
2223 value->offset = offset;
2226 struct rtx_const
2228 #ifdef ONLY_INT_FIELDS
2229 unsigned int kind : 16;
2230 unsigned int mode : 16;
2231 #else
2232 enum kind kind : 16;
2233 enum machine_mode mode : 16;
2234 #endif
2235 union {
2236 union real_extract du;
2237 struct addr_const addr;
2238 struct {HOST_WIDE_INT high, low;} di;
2239 } un;
2242 /* Uniquize all constants that appear in memory.
2243 Each constant in memory thus far output is recorded
2244 in `const_hash_table' with a `struct constant_descriptor'
2245 that contains a polish representation of the value of
2246 the constant.
2248 We cannot store the trees in the hash table
2249 because the trees may be temporary. */
2251 struct constant_descriptor
2253 struct constant_descriptor *next;
2254 const char *label;
2255 rtx rtl;
2256 /* Make sure the data is reasonably aligned. */
2257 union
2259 unsigned char contents[1];
2260 #ifdef HAVE_LONG_DOUBLE
2261 long double d;
2262 #else
2263 double d;
2264 #endif
2265 } u;
2268 #define HASHBITS 30
2269 #define MAX_HASH_TABLE 1009
2270 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2272 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2274 struct deferred_string
2276 const char *label;
2277 tree exp;
2278 int labelno;
2281 static htab_t const_str_htab;
2283 /* Mark a const_hash_table descriptor for GC. */
2285 static void
2286 mark_const_hash_entry (ptr)
2287 void *ptr;
2289 struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2291 while (desc)
2293 ggc_mark_rtx (desc->rtl);
2294 desc = desc->next;
2298 /* Mark the hash-table element X (which is really a pointer to an
2299 struct deferred_string *). */
2301 static int
2302 mark_const_str_htab_1 (x, data)
2303 void **x;
2304 void *data ATTRIBUTE_UNUSED;
2306 ggc_mark_tree (((struct deferred_string *) *x)->exp);
2307 return 1;
2310 /* Mark a const_str_htab for GC. */
2312 static void
2313 mark_const_str_htab (htab)
2314 void *htab;
2316 htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2319 /* Returns a hash code for X (which is a really a
2320 struct deferred_string *). */
2322 static hashval_t
2323 const_str_htab_hash (x)
2324 const void *x;
2326 return STRHASH (((const struct deferred_string *) x)->label);
2329 /* Returns non-zero if the value represented by X (which is really a
2330 struct deferred_string *) is the same as that given by Y
2331 (which is really a char *). */
2333 static int
2334 const_str_htab_eq (x, y)
2335 const void *x;
2336 const void *y;
2338 return (((const struct deferred_string *) x)->label == (const char *) y);
2341 /* Delete the hash table entry dfsp. */
2343 static void
2344 const_str_htab_del (dfsp)
2345 void *dfsp;
2347 free (dfsp);
2350 /* Compute a hash code for a constant expression. */
2352 static int
2353 const_hash (exp)
2354 tree exp;
2356 register const char *p;
2357 register int len, hi, i;
2358 register enum tree_code code = TREE_CODE (exp);
2360 /* Either set P and LEN to the address and len of something to hash and
2361 exit the switch or return a value. */
2363 switch (code)
2365 case INTEGER_CST:
2366 p = (char *) &TREE_INT_CST (exp);
2367 len = sizeof TREE_INT_CST (exp);
2368 break;
2370 case REAL_CST:
2371 p = (char *) &TREE_REAL_CST (exp);
2372 len = sizeof TREE_REAL_CST (exp);
2373 break;
2375 case STRING_CST:
2376 p = TREE_STRING_POINTER (exp);
2377 len = TREE_STRING_LENGTH (exp);
2378 break;
2380 case COMPLEX_CST:
2381 return (const_hash (TREE_REALPART (exp)) * 5
2382 + const_hash (TREE_IMAGPART (exp)));
2384 case CONSTRUCTOR:
2385 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2387 char *tmp;
2389 len = int_size_in_bytes (TREE_TYPE (exp));
2390 tmp = (char *) alloca (len);
2391 get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2392 p = tmp;
2393 break;
2395 else
2397 register tree link;
2399 /* For record type, include the type in the hashing.
2400 We do not do so for array types
2401 because (1) the sizes of the elements are sufficient
2402 and (2) distinct array types can have the same constructor.
2403 Instead, we include the array size because the constructor could
2404 be shorter. */
2405 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2406 hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2407 % MAX_HASH_TABLE;
2408 else
2409 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2410 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2412 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2413 if (TREE_VALUE (link))
2415 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2417 return hi;
2420 case ADDR_EXPR:
2422 struct addr_const value;
2424 decode_addr_const (exp, &value);
2425 if (GET_CODE (value.base) == SYMBOL_REF)
2427 /* Don't hash the address of the SYMBOL_REF;
2428 only use the offset and the symbol name. */
2429 hi = value.offset;
2430 p = XSTR (value.base, 0);
2431 for (i = 0; p[i] != 0; i++)
2432 hi = ((hi * 613) + (unsigned) (p[i]));
2434 else if (GET_CODE (value.base) == LABEL_REF)
2435 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2436 else
2437 abort();
2439 hi &= (1 << HASHBITS) - 1;
2440 hi %= MAX_HASH_TABLE;
2442 return hi;
2444 case PLUS_EXPR:
2445 case MINUS_EXPR:
2446 return (const_hash (TREE_OPERAND (exp, 0)) * 9
2447 + const_hash (TREE_OPERAND (exp, 1)));
2449 case NOP_EXPR:
2450 case CONVERT_EXPR:
2451 case NON_LVALUE_EXPR:
2452 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2454 default:
2455 /* A language specific constant. Just hash the code. */
2456 return (int) code % MAX_HASH_TABLE;
2459 /* Compute hashing function */
2460 hi = len;
2461 for (i = 0; i < len; i++)
2462 hi = ((hi * 613) + (unsigned) (p[i]));
2464 hi &= (1 << HASHBITS) - 1;
2465 hi %= MAX_HASH_TABLE;
2466 return hi;
2469 /* Compare a constant expression EXP with a constant-descriptor DESC.
2470 Return 1 if DESC describes a constant with the same value as EXP. */
2472 static int
2473 compare_constant (exp, desc)
2474 tree exp;
2475 struct constant_descriptor *desc;
2477 return 0 != compare_constant_1 (exp, desc->u.contents);
2480 /* Compare constant expression EXP with a substring P of a constant descriptor.
2481 If they match, return a pointer to the end of the substring matched.
2482 If they do not match, return 0.
2484 Since descriptors are written in polish prefix notation,
2485 this function can be used recursively to test one operand of EXP
2486 against a subdescriptor, and if it succeeds it returns the
2487 address of the subdescriptor for the next operand. */
2489 static const unsigned char *
2490 compare_constant_1 (exp, p)
2491 tree exp;
2492 const unsigned char *p;
2494 register const unsigned char *strp;
2495 register int len;
2496 register enum tree_code code = TREE_CODE (exp);
2498 if (code != (enum tree_code) *p++)
2499 return 0;
2501 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2502 switch, or return the result of the comparison. */
2504 switch (code)
2506 case INTEGER_CST:
2507 /* Integer constants are the same only if the same width of type. */
2508 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2509 return 0;
2511 strp = (unsigned char *) &TREE_INT_CST (exp);
2512 len = sizeof TREE_INT_CST (exp);
2513 break;
2515 case REAL_CST:
2516 /* Real constants are the same only if the same width of type. */
2517 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2518 return 0;
2520 strp = (unsigned char *) &TREE_REAL_CST (exp);
2521 len = sizeof TREE_REAL_CST (exp);
2522 break;
2524 case STRING_CST:
2525 if (flag_writable_strings)
2526 return 0;
2528 if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2529 return 0;
2531 strp = (const unsigned char *)TREE_STRING_POINTER (exp);
2532 len = TREE_STRING_LENGTH (exp);
2533 if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2534 sizeof TREE_STRING_LENGTH (exp)))
2535 return 0;
2537 p += sizeof TREE_STRING_LENGTH (exp);
2538 break;
2540 case COMPLEX_CST:
2541 p = compare_constant_1 (TREE_REALPART (exp), p);
2542 if (p == 0)
2543 return 0;
2545 return compare_constant_1 (TREE_IMAGPART (exp), p);
2547 case CONSTRUCTOR:
2548 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2550 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2551 unsigned char *tmp = (unsigned char *) alloca (len);
2553 get_set_constructor_bytes (exp, tmp, len);
2554 strp = (unsigned char *) tmp;
2555 if (memcmp ((char *) &xlen, p, sizeof xlen))
2556 return 0;
2558 p += sizeof xlen;
2559 break;
2561 else
2563 register tree link;
2564 int length = list_length (CONSTRUCTOR_ELTS (exp));
2565 tree type;
2566 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2567 int have_purpose = 0;
2569 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2570 if (TREE_PURPOSE (link))
2571 have_purpose = 1;
2573 if (memcmp ((char *) &length, p, sizeof length))
2574 return 0;
2576 p += sizeof length;
2578 /* For record constructors, insist that the types match.
2579 For arrays, just verify both constructors are for arrays.
2580 Then insist that either both or none have any TREE_PURPOSE
2581 values. */
2582 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2583 type = TREE_TYPE (exp);
2584 else
2585 type = 0;
2587 if (memcmp ((char *) &type, p, sizeof type))
2588 return 0;
2590 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2592 if (memcmp ((char *) &mode, p, sizeof mode))
2593 return 0;
2595 p += sizeof mode;
2598 p += sizeof type;
2600 if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2601 return 0;
2603 p += sizeof have_purpose;
2605 /* For arrays, insist that the size in bytes match. */
2606 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2608 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2610 if (memcmp ((char *) &size, p, sizeof size))
2611 return 0;
2613 p += sizeof size;
2616 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2618 if (TREE_VALUE (link))
2620 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2621 return 0;
2623 else
2625 tree zero = 0;
2627 if (memcmp ((char *) &zero, p, sizeof zero))
2628 return 0;
2630 p += sizeof zero;
2633 if (TREE_PURPOSE (link)
2634 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2636 if (memcmp ((char *) &TREE_PURPOSE (link), p,
2637 sizeof TREE_PURPOSE (link)))
2638 return 0;
2640 p += sizeof TREE_PURPOSE (link);
2642 else if (TREE_PURPOSE (link))
2644 if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2645 return 0;
2647 else if (have_purpose)
2649 int zero = 0;
2651 if (memcmp ((char *) &zero, p, sizeof zero))
2652 return 0;
2654 p += sizeof zero;
2658 return p;
2661 case ADDR_EXPR:
2663 struct addr_const value;
2665 decode_addr_const (exp, &value);
2666 strp = (unsigned char *) &value.offset;
2667 len = sizeof value.offset;
2668 /* Compare the offset. */
2669 while (--len >= 0)
2670 if (*p++ != *strp++)
2671 return 0;
2673 /* Compare symbol name. */
2674 strp = (const unsigned char *) XSTR (value.base, 0);
2675 len = strlen ((const char *) strp) + 1;
2677 break;
2679 case PLUS_EXPR:
2680 case MINUS_EXPR:
2681 case RANGE_EXPR:
2682 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2683 if (p == 0)
2684 return 0;
2686 return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2688 case NOP_EXPR:
2689 case CONVERT_EXPR:
2690 case NON_LVALUE_EXPR:
2691 return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2693 default:
2694 if (lang_expand_constant)
2696 exp = (*lang_expand_constant) (exp);
2697 return compare_constant_1 (exp, p);
2699 return 0;
2702 /* Compare constant contents. */
2703 while (--len >= 0)
2704 if (*p++ != *strp++)
2705 return 0;
2707 return p;
2710 /* Construct a constant descriptor for the expression EXP.
2711 It is up to the caller to enter the descriptor in the hash table. */
2713 static struct constant_descriptor *
2714 record_constant (exp)
2715 tree exp;
2717 struct constant_descriptor *next = 0;
2718 char *label = 0;
2719 rtx rtl = 0;
2720 int pad;
2722 /* Make a struct constant_descriptor. The first three pointers will
2723 be filled in later. Here we just leave space for them. */
2725 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2726 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2727 obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2729 /* Align the descriptor for the data payload. */
2730 pad = (offsetof (struct constant_descriptor, u)
2731 - offsetof(struct constant_descriptor, rtl)
2732 - sizeof(next->rtl));
2733 if (pad > 0)
2734 obstack_blank (&permanent_obstack, pad);
2736 record_constant_1 (exp);
2737 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2740 /* Add a description of constant expression EXP
2741 to the object growing in `permanent_obstack'.
2742 No need to return its address; the caller will get that
2743 from the obstack when the object is complete. */
2745 static void
2746 record_constant_1 (exp)
2747 tree exp;
2749 register const unsigned char *strp;
2750 register int len;
2751 register enum tree_code code = TREE_CODE (exp);
2753 obstack_1grow (&permanent_obstack, (unsigned int) code);
2755 switch (code)
2757 case INTEGER_CST:
2758 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2759 strp = (unsigned char *) &TREE_INT_CST (exp);
2760 len = sizeof TREE_INT_CST (exp);
2761 break;
2763 case REAL_CST:
2764 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2765 strp = (unsigned char *) &TREE_REAL_CST (exp);
2766 len = sizeof TREE_REAL_CST (exp);
2767 break;
2769 case STRING_CST:
2770 if (flag_writable_strings)
2771 return;
2773 obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2774 strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2775 len = TREE_STRING_LENGTH (exp);
2776 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2777 sizeof TREE_STRING_LENGTH (exp));
2778 break;
2780 case COMPLEX_CST:
2781 record_constant_1 (TREE_REALPART (exp));
2782 record_constant_1 (TREE_IMAGPART (exp));
2783 return;
2785 case CONSTRUCTOR:
2786 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2788 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2789 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2790 obstack_blank (&permanent_obstack, nbytes);
2791 get_set_constructor_bytes
2792 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2793 nbytes);
2794 return;
2796 else
2798 register tree link;
2799 int length = list_length (CONSTRUCTOR_ELTS (exp));
2800 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2801 tree type;
2802 int have_purpose = 0;
2804 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2805 if (TREE_PURPOSE (link))
2806 have_purpose = 1;
2808 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2810 /* For record constructors, insist that the types match.
2811 For arrays, just verify both constructors are for arrays
2812 of the same mode. Then insist that either both or none
2813 have any TREE_PURPOSE values. */
2814 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2815 type = TREE_TYPE (exp);
2816 else
2817 type = 0;
2819 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2820 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2821 obstack_grow (&permanent_obstack, &mode, sizeof mode);
2823 obstack_grow (&permanent_obstack, (char *) &have_purpose,
2824 sizeof have_purpose);
2826 /* For arrays, insist that the size in bytes match. */
2827 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2829 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2830 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2833 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2835 if (TREE_VALUE (link))
2836 record_constant_1 (TREE_VALUE (link));
2837 else
2839 tree zero = 0;
2841 obstack_grow (&permanent_obstack,
2842 (char *) &zero, sizeof zero);
2845 if (TREE_PURPOSE (link)
2846 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2847 obstack_grow (&permanent_obstack,
2848 (char *) &TREE_PURPOSE (link),
2849 sizeof TREE_PURPOSE (link));
2850 else if (TREE_PURPOSE (link))
2851 record_constant_1 (TREE_PURPOSE (link));
2852 else if (have_purpose)
2854 int zero = 0;
2856 obstack_grow (&permanent_obstack,
2857 (char *) &zero, sizeof zero);
2861 return;
2863 case ADDR_EXPR:
2865 struct addr_const value;
2867 decode_addr_const (exp, &value);
2868 /* Record the offset. */
2869 obstack_grow (&permanent_obstack,
2870 (char *) &value.offset, sizeof value.offset);
2872 switch (GET_CODE (value.base))
2874 case SYMBOL_REF:
2875 /* Record the symbol name. */
2876 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2877 strlen (XSTR (value.base, 0)) + 1);
2878 break;
2879 case LABEL_REF:
2880 /* Record the address of the CODE_LABEL. It may not have
2881 been emitted yet, so it's UID may be zero. But pointer
2882 identity is good enough. */
2883 obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
2884 sizeof (rtx));
2885 break;
2886 default:
2887 abort ();
2890 return;
2892 case PLUS_EXPR:
2893 case MINUS_EXPR:
2894 case RANGE_EXPR:
2895 record_constant_1 (TREE_OPERAND (exp, 0));
2896 record_constant_1 (TREE_OPERAND (exp, 1));
2897 return;
2899 case NOP_EXPR:
2900 case CONVERT_EXPR:
2901 case NON_LVALUE_EXPR:
2902 record_constant_1 (TREE_OPERAND (exp, 0));
2903 return;
2905 default:
2906 if (lang_expand_constant)
2908 exp = (*lang_expand_constant) (exp);
2909 record_constant_1 (exp);
2911 return;
2914 /* Record constant contents. */
2915 obstack_grow (&permanent_obstack, strp, len);
2918 /* Record a list of constant expressions that were passed to
2919 output_constant_def but that could not be output right away. */
2921 struct deferred_constant
2923 struct deferred_constant *next;
2924 tree exp;
2925 int reloc;
2926 int labelno;
2929 static struct deferred_constant *deferred_constants;
2931 /* Another list of constants which should be output after the
2932 function. */
2933 static struct deferred_constant *after_function_constants;
2935 /* Nonzero means defer output of addressed subconstants
2936 (i.e., those for which output_constant_def is called.) */
2937 static int defer_addressed_constants_flag;
2939 /* Start deferring output of subconstants. */
2941 void
2942 defer_addressed_constants ()
2944 defer_addressed_constants_flag++;
2947 /* Stop deferring output of subconstants,
2948 and output now all those that have been deferred. */
2950 void
2951 output_deferred_addressed_constants ()
2953 struct deferred_constant *p, *next;
2955 defer_addressed_constants_flag--;
2957 if (defer_addressed_constants_flag > 0)
2958 return;
2960 for (p = deferred_constants; p; p = next)
2962 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2963 next = p->next;
2964 free (p);
2967 deferred_constants = 0;
2970 /* Output any constants which should appear after a function. */
2972 static void
2973 output_after_function_constants ()
2975 struct deferred_constant *p, *next;
2977 for (p = after_function_constants; p; p = next)
2979 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2980 next = p->next;
2981 free (p);
2984 after_function_constants = 0;
2987 /* Make a copy of the whole tree structure for a constant.
2988 This handles the same types of nodes that compare_constant
2989 and record_constant handle. */
2991 static tree
2992 copy_constant (exp)
2993 tree exp;
2995 switch (TREE_CODE (exp))
2997 case ADDR_EXPR:
2998 /* For ADDR_EXPR, we do not want to copy the decl whose address
2999 is requested. We do want to copy constants though. */
3000 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
3001 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3002 copy_constant (TREE_OPERAND (exp, 0)));
3003 else
3004 return copy_node (exp);
3006 case INTEGER_CST:
3007 case REAL_CST:
3008 case STRING_CST:
3009 return copy_node (exp);
3011 case COMPLEX_CST:
3012 return build_complex (TREE_TYPE (exp),
3013 copy_constant (TREE_REALPART (exp)),
3014 copy_constant (TREE_IMAGPART (exp)));
3016 case PLUS_EXPR:
3017 case MINUS_EXPR:
3018 return build (TREE_CODE (exp), TREE_TYPE (exp),
3019 copy_constant (TREE_OPERAND (exp, 0)),
3020 copy_constant (TREE_OPERAND (exp, 1)));
3022 case NOP_EXPR:
3023 case CONVERT_EXPR:
3024 case NON_LVALUE_EXPR:
3025 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3026 copy_constant (TREE_OPERAND (exp, 0)));
3028 case CONSTRUCTOR:
3030 tree copy = copy_node (exp);
3031 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3032 tree tail;
3034 CONSTRUCTOR_ELTS (copy) = list;
3035 for (tail = list; tail; tail = TREE_CHAIN (tail))
3036 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3037 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3038 for (tail = list; tail; tail = TREE_CHAIN (tail))
3039 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3041 return copy;
3044 default:
3045 abort ();
3049 /* Return an rtx representing a reference to constant data in memory
3050 for the constant expression EXP.
3052 If assembler code for such a constant has already been output,
3053 return an rtx to refer to it.
3054 Otherwise, output such a constant in memory (or defer it for later)
3055 and generate an rtx for it.
3057 If DEFER is non-zero, the output of string constants can be deferred
3058 and output only if referenced in the function after all optimizations.
3060 The TREE_CST_RTL of EXP is set up to point to that rtx.
3061 The const_hash_table records which constants already have label strings. */
3064 output_constant_def (exp, defer)
3065 tree exp;
3066 int defer;
3068 register int hash;
3069 register struct constant_descriptor *desc;
3070 struct deferred_string **defstr;
3071 char label[256];
3072 int reloc;
3073 int found = 1;
3074 int after_function = 0;
3075 int labelno = -1;
3077 if (TREE_CST_RTL (exp))
3078 return TREE_CST_RTL (exp);
3080 /* Make sure any other constants whose addresses appear in EXP
3081 are assigned label numbers. */
3083 reloc = output_addressed_constants (exp);
3085 /* Compute hash code of EXP. Search the descriptors for that hash code
3086 to see if any of them describes EXP. If yes, the descriptor records
3087 the label number already assigned. */
3089 hash = const_hash (exp) % MAX_HASH_TABLE;
3091 for (desc = const_hash_table[hash]; desc; desc = desc->next)
3092 if (compare_constant (exp, desc))
3093 break;
3095 if (desc == 0)
3097 /* No constant equal to EXP is known to have been output.
3098 Make a constant descriptor to enter EXP in the hash table.
3099 Assign the label number and record it in the descriptor for
3100 future calls to this function to find. */
3102 /* Create a string containing the label name, in LABEL. */
3103 labelno = const_labelno++;
3104 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3106 desc = record_constant (exp);
3107 desc->next = const_hash_table[hash];
3108 desc->label = ggc_strdup (label);
3109 const_hash_table[hash] = desc;
3111 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3112 desc->rtl
3113 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3114 gen_rtx_SYMBOL_REF (Pmode, desc->label));
3116 set_mem_attributes (desc->rtl, exp, 1);
3118 found = 0;
3121 TREE_CST_RTL (exp) = desc->rtl;
3123 /* Optionally set flags or add text to the name to record information
3124 such as that it is a function name. If the name is changed, the macro
3125 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3126 #ifdef ENCODE_SECTION_INFO
3127 /* A previously-processed constant would already have section info
3128 encoded in it. */
3129 if (! found)
3131 ENCODE_SECTION_INFO (exp);
3132 desc->rtl = TREE_CST_RTL (exp);
3133 desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3135 #endif
3137 #ifdef CONSTANT_AFTER_FUNCTION_P
3138 if (current_function_decl != 0
3139 && CONSTANT_AFTER_FUNCTION_P (exp))
3140 after_function = 1;
3141 #endif
3143 if (found
3144 && STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0))
3145 && (!defer || defer_addressed_constants_flag || after_function))
3147 defstr = (struct deferred_string **)
3148 htab_find_slot_with_hash (const_str_htab, desc->label,
3149 STRHASH (desc->label), NO_INSERT);
3150 if (defstr)
3152 /* If the string is currently deferred but we need to output it now,
3153 remove it from deferred string hash table. */
3154 found = 0;
3155 labelno = (*defstr)->labelno;
3156 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 0;
3157 htab_clear_slot (const_str_htab, (void **) defstr);
3161 /* If this is the first time we've seen this particular constant,
3162 output it (or defer its output for later). */
3163 if (! found)
3165 if (defer_addressed_constants_flag || after_function)
3167 struct deferred_constant *p;
3168 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
3170 p->exp = copy_constant (exp);
3171 p->reloc = reloc;
3172 p->labelno = labelno;
3173 if (after_function)
3175 p->next = after_function_constants;
3176 after_function_constants = p;
3178 else
3180 p->next = deferred_constants;
3181 deferred_constants = p;
3184 else
3186 /* Do no output if -fsyntax-only. */
3187 if (! flag_syntax_only)
3189 if (TREE_CODE (exp) != STRING_CST
3190 || !defer
3191 || flag_writable_strings
3192 || (defstr = (struct deferred_string **)
3193 htab_find_slot_with_hash (const_str_htab,
3194 desc->label,
3195 STRHASH (desc->label),
3196 INSERT)) == NULL)
3197 output_constant_def_contents (exp, reloc, labelno);
3198 else
3200 struct deferred_string *p;
3202 p = (struct deferred_string *)
3203 xmalloc (sizeof (struct deferred_string));
3205 p->exp = copy_constant (exp);
3206 p->label = desc->label;
3207 p->labelno = labelno;
3208 *defstr = p;
3209 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 1;
3215 return TREE_CST_RTL (exp);
3218 /* Now output assembler code to define the label for EXP,
3219 and follow it with the data of EXP. */
3221 static void
3222 output_constant_def_contents (exp, reloc, labelno)
3223 tree exp;
3224 int reloc;
3225 int labelno;
3227 int align;
3229 if (IN_NAMED_SECTION (exp))
3230 named_section (exp, NULL, reloc);
3231 else
3233 /* First switch to text section, except for writable strings. */
3234 #ifdef SELECT_SECTION
3235 SELECT_SECTION (exp, reloc);
3236 #else
3237 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3238 || (flag_pic && reloc))
3239 data_section ();
3240 else
3241 readonly_data_section ();
3242 #endif
3245 /* Align the location counter as required by EXP's data type. */
3246 align = TYPE_ALIGN (TREE_TYPE (exp));
3247 #ifdef CONSTANT_ALIGNMENT
3248 align = CONSTANT_ALIGNMENT (exp, align);
3249 #endif
3251 if (align > BITS_PER_UNIT)
3252 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3254 /* Output the label itself. */
3255 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3257 /* Output the value of EXP. */
3258 output_constant (exp,
3259 (TREE_CODE (exp) == STRING_CST
3260 ? TREE_STRING_LENGTH (exp)
3261 : int_size_in_bytes (TREE_TYPE (exp))));
3265 /* Structure to represent sufficient information about a constant so that
3266 it can be output when the constant pool is output, so that function
3267 integration can be done, and to simplify handling on machines that reference
3268 constant pool as base+displacement. */
3270 struct pool_constant
3272 struct constant_descriptor *desc;
3273 struct pool_constant *next, *next_sym;
3274 const char *label;
3275 rtx constant;
3276 enum machine_mode mode;
3277 int labelno;
3278 int align;
3279 int offset;
3280 int mark;
3283 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3284 The argument is XSTR (... , 0) */
3286 #define SYMHASH(LABEL) \
3287 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3289 /* Initialize constant pool hashing for a new function. */
3291 void
3292 init_varasm_status (f)
3293 struct function *f;
3295 struct varasm_status *p;
3296 p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3297 f->varasm = p;
3298 p->x_const_rtx_hash_table
3299 = ((struct constant_descriptor **)
3300 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3301 p->x_const_rtx_sym_hash_table
3302 = ((struct pool_constant **)
3303 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3305 p->x_first_pool = p->x_last_pool = 0;
3306 p->x_pool_offset = 0;
3307 p->x_const_double_chain = 0;
3310 /* Mark PC for GC. */
3312 static void
3313 mark_pool_constant (pc)
3314 struct pool_constant *pc;
3316 while (pc)
3318 ggc_mark (pc);
3319 ggc_mark_rtx (pc->constant);
3320 pc = pc->next;
3324 /* Mark P for GC. */
3326 void
3327 mark_varasm_status (p)
3328 struct varasm_status *p;
3330 if (p == NULL)
3331 return;
3333 mark_pool_constant (p->x_first_pool);
3334 ggc_mark_rtx (p->x_const_double_chain);
3337 /* Clear out all parts of the state in F that can safely be discarded
3338 after the function has been compiled, to let garbage collection
3339 reclaim the memory. */
3341 void
3342 free_varasm_status (f)
3343 struct function *f;
3345 struct varasm_status *p;
3346 int i;
3348 p = f->varasm;
3350 /* Clear out the hash tables. */
3351 for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3353 struct constant_descriptor* cd;
3355 cd = p->x_const_rtx_hash_table[i];
3356 while (cd) {
3357 struct constant_descriptor* next = cd->next;
3358 free (cd);
3359 cd = next;
3363 free (p->x_const_rtx_hash_table);
3364 free (p->x_const_rtx_sym_hash_table);
3365 free (p);
3366 f->varasm = NULL;
3369 enum kind { RTX_DOUBLE, RTX_INT };
3371 /* Express an rtx for a constant integer (perhaps symbolic)
3372 as the sum of a symbol or label plus an explicit integer.
3373 They are stored into VALUE. */
3375 static void
3376 decode_rtx_const (mode, x, value)
3377 enum machine_mode mode;
3378 rtx x;
3379 struct rtx_const *value;
3381 /* Clear the whole structure, including any gaps. */
3382 memset (value, 0, sizeof (struct rtx_const));
3384 value->kind = RTX_INT; /* Most usual kind. */
3385 value->mode = mode;
3387 switch (GET_CODE (x))
3389 case CONST_DOUBLE:
3390 value->kind = RTX_DOUBLE;
3391 if (GET_MODE (x) != VOIDmode)
3393 value->mode = GET_MODE (x);
3394 memcpy ((char *) &value->un.du,
3395 (char *) &CONST_DOUBLE_LOW (x), sizeof value->un.du);
3397 else
3399 value->un.di.low = CONST_DOUBLE_LOW (x);
3400 value->un.di.high = CONST_DOUBLE_HIGH (x);
3402 break;
3404 case CONST_INT:
3405 value->un.addr.offset = INTVAL (x);
3406 break;
3408 case SYMBOL_REF:
3409 case LABEL_REF:
3410 case PC:
3411 value->un.addr.base = x;
3412 break;
3414 case CONST:
3415 x = XEXP (x, 0);
3416 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3418 value->un.addr.base = XEXP (x, 0);
3419 value->un.addr.offset = INTVAL (XEXP (x, 1));
3421 else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3423 value->un.addr.base = XEXP (x, 0);
3424 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3426 else
3428 value->un.addr.base = x;
3429 value->un.addr.offset = 0;
3431 break;
3433 default:
3434 abort ();
3437 if (value->kind == RTX_INT && value->un.addr.base != 0)
3438 switch (GET_CODE (value->un.addr.base))
3440 case SYMBOL_REF:
3441 /* Use the string's address, not the SYMBOL_REF's address,
3442 for the sake of addresses of library routines. */
3443 value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3444 break;
3446 case LABEL_REF:
3447 /* For a LABEL_REF, compare labels. */
3448 value->un.addr.base = XEXP (value->un.addr.base, 0);
3450 default:
3451 break;
3455 /* Given a MINUS expression, simplify it if both sides
3456 include the same symbol. */
3459 simplify_subtraction (x)
3460 rtx x;
3462 struct rtx_const val0, val1;
3464 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3465 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3467 if (val0.un.addr.base == val1.un.addr.base)
3468 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3469 return x;
3472 /* Compute a hash code for a constant RTL expression. */
3474 static int
3475 const_hash_rtx (mode, x)
3476 enum machine_mode mode;
3477 rtx x;
3479 register int hi;
3480 register size_t i;
3482 struct rtx_const value;
3483 decode_rtx_const (mode, x, &value);
3485 /* Compute hashing function */
3486 hi = 0;
3487 for (i = 0; i < sizeof value / sizeof (int); i++)
3488 hi += ((int *) &value)[i];
3490 hi &= (1 << HASHBITS) - 1;
3491 hi %= MAX_RTX_HASH_TABLE;
3492 return hi;
3495 /* Compare a constant rtl object X with a constant-descriptor DESC.
3496 Return 1 if DESC describes a constant with the same value as X. */
3498 static int
3499 compare_constant_rtx (mode, x, desc)
3500 enum machine_mode mode;
3501 rtx x;
3502 struct constant_descriptor *desc;
3504 register int *p = (int *) desc->u.contents;
3505 register int *strp;
3506 register int len;
3507 struct rtx_const value;
3509 decode_rtx_const (mode, x, &value);
3510 strp = (int *) &value;
3511 len = sizeof value / sizeof (int);
3513 /* Compare constant contents. */
3514 while (--len >= 0)
3515 if (*p++ != *strp++)
3516 return 0;
3518 return 1;
3521 /* Construct a constant descriptor for the rtl-expression X.
3522 It is up to the caller to enter the descriptor in the hash table. */
3524 static struct constant_descriptor *
3525 record_constant_rtx (mode, x)
3526 enum machine_mode mode;
3527 rtx x;
3529 struct constant_descriptor *ptr;
3531 ptr = ((struct constant_descriptor *)
3532 xcalloc (1, (offsetof (struct constant_descriptor, u)
3533 + sizeof (struct rtx_const))));
3534 decode_rtx_const (mode, x, (struct rtx_const *) ptr->u.contents);
3536 return ptr;
3539 /* Given a constant rtx X, make (or find) a memory constant for its value
3540 and return a MEM rtx to refer to it in memory. */
3543 force_const_mem (mode, x)
3544 enum machine_mode mode;
3545 rtx x;
3547 register int hash;
3548 register struct constant_descriptor *desc;
3549 char label[256];
3550 const char *found = 0;
3551 rtx def;
3553 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3554 (this will always be true for floating CONST_DOUBLEs that have been
3555 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3556 use the previous copy. Otherwise, make a new one. Note that in
3557 the unlikely event that this same CONST_DOUBLE is used in two different
3558 modes in an alternating fashion, we will allocate a lot of different
3559 memory locations, but this should be extremely rare. */
3561 if (GET_CODE (x) == CONST_DOUBLE
3562 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3563 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3564 return CONST_DOUBLE_MEM (x);
3566 /* Compute hash code of X. Search the descriptors for that hash code
3567 to see if any of them describes X. If yes, the descriptor records
3568 the label number already assigned. */
3570 hash = const_hash_rtx (mode, x);
3572 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3573 if (compare_constant_rtx (mode, x, desc))
3575 found = desc->label;
3576 break;
3579 if (found == 0)
3581 register struct pool_constant *pool;
3582 int align;
3584 /* No constant equal to X is known to have been output.
3585 Make a constant descriptor to enter X in the hash table.
3586 Assign the label number and record it in the descriptor for
3587 future calls to this function to find. */
3589 desc = record_constant_rtx (mode, x);
3590 desc->next = const_rtx_hash_table[hash];
3591 const_rtx_hash_table[hash] = desc;
3593 /* Align the location counter as required by EXP's data type. */
3594 align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3595 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3596 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3597 #ifdef CONSTANT_ALIGNMENT
3598 align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x),
3599 align * BITS_PER_UNIT) / BITS_PER_UNIT;
3600 #endif
3602 pool_offset += align - 1;
3603 pool_offset &= ~ (align - 1);
3605 if (GET_CODE (x) == LABEL_REF)
3606 LABEL_PRESERVE_P (XEXP (x, 0)) = 1;
3608 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3610 pool = (struct pool_constant *) ggc_alloc (sizeof (struct pool_constant));
3611 pool->desc = desc;
3612 pool->constant = x;
3613 pool->mode = mode;
3614 pool->labelno = const_labelno;
3615 pool->align = align;
3616 pool->offset = pool_offset;
3617 pool->mark = 1;
3618 pool->next = 0;
3620 if (last_pool == 0)
3621 first_pool = pool;
3622 else
3623 last_pool->next = pool;
3625 last_pool = pool;
3626 pool_offset += GET_MODE_SIZE (mode);
3628 /* Create a string containing the label name, in LABEL. */
3629 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3631 ++const_labelno;
3633 desc->label = found = ggc_strdup (label);
3635 /* Add label to symbol hash table. */
3636 hash = SYMHASH (found);
3637 pool->label = found;
3638 pool->next_sym = const_rtx_sym_hash_table[hash];
3639 const_rtx_sym_hash_table[hash] = pool;
3642 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3644 def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, found));
3645 set_mem_attributes (def, type_for_mode (mode, 0), 1);
3646 RTX_UNCHANGING_P (def) = 1;
3648 /* Mark the symbol_ref as belonging to this constants pool. */
3649 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3650 current_function_uses_const_pool = 1;
3652 if (GET_CODE (x) == CONST_DOUBLE)
3654 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3656 CONST_DOUBLE_CHAIN (x) = const_double_chain;
3657 const_double_chain = x;
3659 CONST_DOUBLE_MEM (x) = def;
3662 return def;
3665 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3666 the corresponding pool_constant structure. */
3668 static struct pool_constant *
3669 find_pool_constant (f, addr)
3670 struct function *f;
3671 rtx addr;
3673 struct pool_constant *pool;
3674 const char *label = XSTR (addr, 0);
3676 for (pool = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; pool;
3677 pool = pool->next_sym)
3678 if (pool->label == label)
3679 return pool;
3681 abort ();
3684 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3687 get_pool_constant (addr)
3688 rtx addr;
3690 return (find_pool_constant (cfun, addr))->constant;
3693 /* Likewise, but for the constant pool of a specific function. */
3696 get_pool_constant_for_function (f, addr)
3697 struct function *f;
3698 rtx addr;
3700 return (find_pool_constant (f, addr))->constant;
3703 /* Similar, return the mode. */
3705 enum machine_mode
3706 get_pool_mode (addr)
3707 rtx addr;
3709 return (find_pool_constant (cfun, addr))->mode;
3712 enum machine_mode
3713 get_pool_mode_for_function (f, addr)
3714 struct function *f;
3715 rtx addr;
3717 return (find_pool_constant (f, addr))->mode;
3720 /* Similar, return the offset in the constant pool. */
3723 get_pool_offset (addr)
3724 rtx addr;
3726 return (find_pool_constant (cfun, addr))->offset;
3729 /* Return the size of the constant pool. */
3732 get_pool_size ()
3734 return pool_offset;
3737 /* Write all the constants in the constant pool. */
3739 void
3740 output_constant_pool (fnname, fndecl)
3741 const char *fnname ATTRIBUTE_UNUSED;
3742 tree fndecl ATTRIBUTE_UNUSED;
3744 struct pool_constant *pool;
3745 rtx x;
3746 union real_extract u;
3748 /* It is possible for gcc to call force_const_mem and then to later
3749 discard the instructions which refer to the constant. In such a
3750 case we do not need to output the constant. */
3751 mark_constant_pool ();
3753 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3754 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3755 #endif
3757 for (pool = first_pool; pool; pool = pool->next)
3759 rtx tmp;
3761 x = pool->constant;
3763 if (! pool->mark)
3764 continue;
3766 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3767 whose CODE_LABEL has been deleted. This can occur if a jump table
3768 is eliminated by optimization. If so, write a constant of zero
3769 instead. Note that this can also happen by turning the
3770 CODE_LABEL into a NOTE. */
3771 /* ??? This seems completely and utterly wrong. Certainly it's
3772 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3773 functioning even with INSN_DELETED_P and friends. */
3775 tmp = x;
3776 switch (GET_CODE (x))
3778 case CONST:
3779 if (GET_CODE (XEXP (x, 0)) != PLUS
3780 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3781 break;
3782 tmp = XEXP (XEXP (x, 0), 0);
3783 /* FALLTHRU */
3785 case LABEL_REF:
3786 tmp = XEXP (x, 0);
3787 if (INSN_DELETED_P (tmp)
3788 || (GET_CODE (tmp) == NOTE
3789 && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3791 abort ();
3792 x = const0_rtx;
3794 break;
3796 default:
3797 break;
3800 /* First switch to correct section. */
3801 #ifdef SELECT_RTX_SECTION
3802 SELECT_RTX_SECTION (pool->mode, x);
3803 #else
3804 readonly_data_section ();
3805 #endif
3807 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3808 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3809 pool->align, pool->labelno, done);
3810 #endif
3812 if (pool->align > 1)
3813 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (pool->align));
3815 /* Output the label. */
3816 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3818 /* Output the value of the constant itself. */
3819 switch (GET_MODE_CLASS (pool->mode))
3821 case MODE_FLOAT:
3822 if (GET_CODE (x) != CONST_DOUBLE)
3823 abort ();
3825 memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
3826 assemble_real (u.d, pool->mode);
3827 break;
3829 case MODE_INT:
3830 case MODE_PARTIAL_INT:
3831 assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3832 break;
3834 default:
3835 abort ();
3838 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3839 done: ;
3840 #endif
3844 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3845 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3846 #endif
3848 /* Done with this pool. */
3849 first_pool = last_pool = 0;
3852 /* Look through the instructions for this function, and mark all the
3853 entries in the constant pool which are actually being used.
3854 Emit used deferred strings. */
3856 static void
3857 mark_constant_pool ()
3859 register rtx insn;
3860 struct pool_constant *pool;
3862 if (first_pool == 0 && htab_elements (const_str_htab) == 0)
3863 return;
3865 for (pool = first_pool; pool; pool = pool->next)
3866 pool->mark = 0;
3868 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3869 if (INSN_P (insn))
3870 mark_constants (PATTERN (insn));
3872 for (insn = current_function_epilogue_delay_list;
3873 insn;
3874 insn = XEXP (insn, 1))
3875 if (INSN_P (insn))
3876 mark_constants (PATTERN (insn));
3879 /* Look through appropriate parts of X, marking all entries in the
3880 constant pool which are actually being used. Entries that are only
3881 referenced by other constants are also marked as used. Emit
3882 deferred strings that are used. */
3884 static void
3885 mark_constants (x)
3886 rtx x;
3888 register int i;
3889 register const char *format_ptr;
3891 if (x == 0)
3892 return;
3894 if (GET_CODE (x) == SYMBOL_REF)
3896 mark_constant (&x, NULL);
3897 return;
3899 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3900 a MEM, but does not constitute a use of that MEM. */
3901 else if (GET_CODE (x) == CONST_DOUBLE)
3902 return;
3904 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3905 insns, not any notes that may be attached. We don't want to mark
3906 a constant just because it happens to appear in a REG_EQUIV note. */
3907 if (INSN_P (x))
3909 mark_constants (PATTERN (x));
3910 return;
3913 format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3915 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
3917 switch (*format_ptr++)
3919 case 'e':
3920 mark_constants (XEXP (x, i));
3921 break;
3923 case 'E':
3924 if (XVEC (x, i) != 0)
3926 register int j;
3928 for (j = 0; j < XVECLEN (x, i); j++)
3929 mark_constants (XVECEXP (x, i, j));
3931 break;
3933 case 'S':
3934 case 's':
3935 case '0':
3936 case 'i':
3937 case 'w':
3938 case 'n':
3939 case 'u':
3940 break;
3942 default:
3943 abort ();
3948 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3949 to as used. Emit referenced deferred strings. This function can
3950 be used with for_each_rtx () to mark all SYMBOL_REFs in an rtx. */
3952 static int
3953 mark_constant (current_rtx, data)
3954 rtx *current_rtx;
3955 void *data ATTRIBUTE_UNUSED;
3957 rtx x = *current_rtx;
3959 if (x == NULL_RTX)
3960 return 0;
3961 else if (GET_CODE(x) == CONST_DOUBLE)
3962 /* Never search inside a CONST_DOUBLE because CONST_DOUBLE_MEM may
3963 be a MEM but does not constitute a use of that MEM. */
3964 return -1;
3965 else if (GET_CODE (x) == SYMBOL_REF)
3967 if (CONSTANT_POOL_ADDRESS_P (x))
3969 struct pool_constant *pool = find_pool_constant (cfun, x);
3970 if (pool->mark == 0) {
3971 pool->mark = 1;
3972 for_each_rtx (&(pool->constant), &mark_constant, NULL);
3974 else
3975 return -1;
3977 else if (STRING_POOL_ADDRESS_P (x))
3979 struct deferred_string **defstr;
3981 defstr = (struct deferred_string **)
3982 htab_find_slot_with_hash (const_str_htab, XSTR (x, 0),
3983 STRHASH (XSTR (x, 0)), NO_INSERT);
3984 if (defstr)
3986 struct deferred_string *p = *defstr;
3988 STRING_POOL_ADDRESS_P (x) = 0;
3989 output_constant_def_contents (p->exp, 0, p->labelno);
3990 htab_clear_slot (const_str_htab, (void **) defstr);
3994 return 0;
3997 /* Find all the constants whose addresses are referenced inside of EXP,
3998 and make sure assembler code with a label has been output for each one.
3999 Indicate whether an ADDR_EXPR has been encountered. */
4001 static int
4002 output_addressed_constants (exp)
4003 tree exp;
4005 int reloc = 0;
4007 /* Give the front-end a chance to convert VALUE to something that
4008 looks more like a constant to the back-end. */
4009 if (lang_expand_constant)
4010 exp = (*lang_expand_constant) (exp);
4012 switch (TREE_CODE (exp))
4014 case ADDR_EXPR:
4016 register tree constant = TREE_OPERAND (exp, 0);
4018 while (TREE_CODE (constant) == COMPONENT_REF)
4020 constant = TREE_OPERAND (constant, 0);
4023 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
4024 || TREE_CODE (constant) == CONSTRUCTOR)
4025 /* No need to do anything here
4026 for addresses of variables or functions. */
4027 output_constant_def (constant, 0);
4029 reloc = 1;
4030 break;
4032 case PLUS_EXPR:
4033 case MINUS_EXPR:
4034 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4035 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
4036 break;
4038 case NOP_EXPR:
4039 case CONVERT_EXPR:
4040 case NON_LVALUE_EXPR:
4041 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4042 break;
4044 case CONSTRUCTOR:
4046 register tree link;
4047 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
4048 if (TREE_VALUE (link) != 0)
4049 reloc |= output_addressed_constants (TREE_VALUE (link));
4051 break;
4053 default:
4054 break;
4056 return reloc;
4059 /* Return nonzero if VALUE is a valid constant-valued expression
4060 for use in initializing a static variable; one that can be an
4061 element of a "constant" initializer.
4063 Return null_pointer_node if the value is absolute;
4064 if it is relocatable, return the variable that determines the relocation.
4065 We assume that VALUE has been folded as much as possible;
4066 therefore, we do not need to check for such things as
4067 arithmetic-combinations of integers. */
4069 tree
4070 initializer_constant_valid_p (value, endtype)
4071 tree value;
4072 tree endtype;
4074 /* Give the front-end a chance to convert VALUE to something that
4075 looks more like a constant to the back-end. */
4076 if (lang_expand_constant)
4077 value = (*lang_expand_constant) (value);
4079 switch (TREE_CODE (value))
4081 case CONSTRUCTOR:
4082 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4083 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4084 && TREE_CONSTANT (value)
4085 && CONSTRUCTOR_ELTS (value))
4086 return
4087 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4088 endtype);
4090 return TREE_STATIC (value) ? null_pointer_node : 0;
4092 case INTEGER_CST:
4093 case REAL_CST:
4094 case STRING_CST:
4095 case COMPLEX_CST:
4096 return null_pointer_node;
4098 case ADDR_EXPR:
4099 return staticp (TREE_OPERAND (value, 0)) ? TREE_OPERAND (value, 0) : 0;
4101 case NON_LVALUE_EXPR:
4102 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4104 case CONVERT_EXPR:
4105 case NOP_EXPR:
4106 /* Allow conversions between pointer types. */
4107 if (POINTER_TYPE_P (TREE_TYPE (value))
4108 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4109 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4111 /* Allow conversions between real types. */
4112 if (FLOAT_TYPE_P (TREE_TYPE (value))
4113 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4114 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4116 /* Allow length-preserving conversions between integer types. */
4117 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4118 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4119 && (TYPE_PRECISION (TREE_TYPE (value))
4120 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4121 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4123 /* Allow conversions between other integer types only if
4124 explicit value. */
4125 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4126 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4128 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4129 endtype);
4130 if (inner == null_pointer_node)
4131 return null_pointer_node;
4132 break;
4135 /* Allow (int) &foo provided int is as wide as a pointer. */
4136 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4137 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4138 && (TYPE_PRECISION (TREE_TYPE (value))
4139 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4140 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4141 endtype);
4143 /* Likewise conversions from int to pointers, but also allow
4144 conversions from 0. */
4145 if (POINTER_TYPE_P (TREE_TYPE (value))
4146 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4148 if (integer_zerop (TREE_OPERAND (value, 0)))
4149 return null_pointer_node;
4150 else if (TYPE_PRECISION (TREE_TYPE (value))
4151 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4152 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4153 endtype);
4156 /* Allow conversions to union types if the value inside is okay. */
4157 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4158 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4159 endtype);
4160 break;
4162 case PLUS_EXPR:
4163 if (! INTEGRAL_TYPE_P (endtype)
4164 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4166 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4167 endtype);
4168 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4169 endtype);
4170 /* If either term is absolute, use the other terms relocation. */
4171 if (valid0 == null_pointer_node)
4172 return valid1;
4173 if (valid1 == null_pointer_node)
4174 return valid0;
4176 break;
4178 case MINUS_EXPR:
4179 if (! INTEGRAL_TYPE_P (endtype)
4180 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4182 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4183 endtype);
4184 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4185 endtype);
4186 /* Win if second argument is absolute. */
4187 if (valid1 == null_pointer_node)
4188 return valid0;
4189 /* Win if both arguments have the same relocation.
4190 Then the value is absolute. */
4191 if (valid0 == valid1 && valid0 != 0)
4192 return null_pointer_node;
4194 /* Since GCC guarantees that string constants are unique in the
4195 generated code, a subtraction between two copies of the same
4196 constant string is absolute. */
4197 if (valid0 && TREE_CODE (valid0) == STRING_CST &&
4198 valid1 && TREE_CODE (valid1) == STRING_CST &&
4199 TREE_STRING_POINTER (valid0) == TREE_STRING_POINTER (valid1))
4200 return null_pointer_node;
4203 /* Support differences between labels. */
4204 if (INTEGRAL_TYPE_P (endtype))
4206 tree op0, op1;
4207 op0 = TREE_OPERAND (value, 0);
4208 op1 = TREE_OPERAND (value, 1);
4209 STRIP_NOPS (op0);
4210 STRIP_NOPS (op1);
4212 if (TREE_CODE (op0) == ADDR_EXPR
4213 && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
4214 && TREE_CODE (op1) == ADDR_EXPR
4215 && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
4216 return null_pointer_node;
4218 break;
4220 default:
4221 break;
4224 return 0;
4227 /* Output assembler code for constant EXP to FILE, with no label.
4228 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4229 Assumes output_addressed_constants has been done on EXP already.
4231 Generate exactly SIZE bytes of assembler data, padding at the end
4232 with zeros if necessary. SIZE must always be specified.
4234 SIZE is important for structure constructors,
4235 since trailing members may have been omitted from the constructor.
4236 It is also important for initialization of arrays from string constants
4237 since the full length of the string constant might not be wanted.
4238 It is also needed for initialization of unions, where the initializer's
4239 type is just one member, and that may not be as long as the union.
4241 There a case in which we would fail to output exactly SIZE bytes:
4242 for a structure constructor that wants to produce more than SIZE bytes.
4243 But such constructors will never be generated for any possible input. */
4245 void
4246 output_constant (exp, size)
4247 register tree exp;
4248 register int size;
4250 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
4252 /* Some front-ends use constants other than the standard
4253 language-indepdent varieties, but which may still be output
4254 directly. Give the front-end a chance to convert EXP to a
4255 language-independent representation. */
4256 if (lang_expand_constant)
4258 exp = (*lang_expand_constant) (exp);
4259 code = TREE_CODE (TREE_TYPE (exp));
4262 if (size == 0 || flag_syntax_only)
4263 return;
4265 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4266 That way we get the constant (we hope) inside it. Also, strip off any
4267 NOP_EXPR that converts between two record, union, array, or set types
4268 or a CONVERT_EXPR that converts to a union TYPE. */
4269 while ((TREE_CODE (exp) == NOP_EXPR
4270 && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
4271 || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
4272 || (TREE_CODE (exp) == CONVERT_EXPR
4273 && code == UNION_TYPE)
4274 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4276 exp = TREE_OPERAND (exp, 0);
4277 code = TREE_CODE (TREE_TYPE (exp));
4280 /* Allow a constructor with no elements for any data type.
4281 This means to fill the space with zeros. */
4282 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
4284 assemble_zeros (size);
4285 return;
4288 switch (code)
4290 case CHAR_TYPE:
4291 case BOOLEAN_TYPE:
4292 case INTEGER_TYPE:
4293 case ENUMERAL_TYPE:
4294 case POINTER_TYPE:
4295 case REFERENCE_TYPE:
4296 /* ??? What about (int)((float)(int)&foo + 4) */
4297 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4298 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4299 exp = TREE_OPERAND (exp, 0);
4301 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4302 EXPAND_INITIALIZER),
4303 size, 0))
4304 error ("initializer for integer value is too complicated");
4305 size = 0;
4306 break;
4308 case REAL_TYPE:
4309 if (TREE_CODE (exp) != REAL_CST)
4310 error ("initializer for floating value is not a floating constant");
4312 assemble_real (TREE_REAL_CST (exp),
4313 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
4314 size = 0;
4315 break;
4317 case COMPLEX_TYPE:
4318 output_constant (TREE_REALPART (exp), size / 2);
4319 output_constant (TREE_IMAGPART (exp), size / 2);
4320 size -= (size / 2) * 2;
4321 break;
4323 case ARRAY_TYPE:
4324 if (TREE_CODE (exp) == CONSTRUCTOR)
4326 output_constructor (exp, size);
4327 return;
4329 else if (TREE_CODE (exp) == STRING_CST)
4331 int excess = 0;
4333 if (size > TREE_STRING_LENGTH (exp))
4335 excess = size - TREE_STRING_LENGTH (exp);
4336 size = TREE_STRING_LENGTH (exp);
4339 assemble_string (TREE_STRING_POINTER (exp), size);
4340 size = excess;
4342 else
4343 abort ();
4344 break;
4346 case RECORD_TYPE:
4347 case UNION_TYPE:
4348 if (TREE_CODE (exp) == CONSTRUCTOR)
4349 output_constructor (exp, size);
4350 else
4351 abort ();
4352 return;
4354 case SET_TYPE:
4355 if (TREE_CODE (exp) == INTEGER_CST)
4356 assemble_integer (expand_expr (exp, NULL_RTX,
4357 VOIDmode, EXPAND_INITIALIZER),
4358 size, 1);
4359 else if (TREE_CODE (exp) == CONSTRUCTOR)
4361 unsigned char *buffer = (unsigned char *) alloca (size);
4362 if (get_set_constructor_bytes (exp, buffer, size))
4363 abort ();
4364 assemble_string ((char *) buffer, size);
4366 else
4367 error ("unknown set constructor type");
4368 return;
4370 default:
4371 break; /* ??? */
4374 if (size > 0)
4375 assemble_zeros (size);
4379 /* Subroutine of output_constructor, used for computing the size of
4380 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4381 type with an unspecified upper bound. */
4383 static unsigned HOST_WIDE_INT
4384 array_size_for_constructor (val)
4385 tree val;
4387 tree max_index, i;
4389 max_index = NULL_TREE;
4390 for (i = CONSTRUCTOR_ELTS (val); i ; i = TREE_CHAIN (i))
4392 tree index = TREE_PURPOSE (i);
4394 if (TREE_CODE (index) == RANGE_EXPR)
4395 index = TREE_OPERAND (index, 1);
4396 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4397 max_index = index;
4400 if (max_index == NULL_TREE)
4401 return 0;
4403 /* Compute the total number of array elements. */
4404 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4405 convert (sizetype,
4406 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4407 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
4409 /* Multiply by the array element unit size to find number of bytes. */
4410 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4412 return tree_low_cst (i, 1);
4415 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4416 Generate at least SIZE bytes, padding if necessary. */
4418 static void
4419 output_constructor (exp, size)
4420 tree exp;
4421 int size;
4423 tree type = TREE_TYPE (exp);
4424 register tree link, field = 0;
4425 tree min_index = 0;
4426 /* Number of bytes output or skipped so far.
4427 In other words, current position within the constructor. */
4428 HOST_WIDE_INT total_bytes = 0;
4429 /* Non-zero means BYTE contains part of a byte, to be output. */
4430 int byte_buffer_in_use = 0;
4431 register int byte = 0;
4433 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4434 abort ();
4436 if (TREE_CODE (type) == RECORD_TYPE)
4437 field = TYPE_FIELDS (type);
4439 if (TREE_CODE (type) == ARRAY_TYPE
4440 && TYPE_DOMAIN (type) != 0)
4441 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4443 /* As LINK goes through the elements of the constant,
4444 FIELD goes through the structure fields, if the constant is a structure.
4445 if the constant is a union, then we override this,
4446 by getting the field from the TREE_LIST element.
4447 But the constant could also be an array. Then FIELD is zero.
4449 There is always a maximum of one element in the chain LINK for unions
4450 (even if the initializer in a source program incorrectly contains
4451 more one). */
4452 for (link = CONSTRUCTOR_ELTS (exp);
4453 link;
4454 link = TREE_CHAIN (link),
4455 field = field ? TREE_CHAIN (field) : 0)
4457 tree val = TREE_VALUE (link);
4458 tree index = 0;
4460 /* The element in a union constructor specifies the proper field
4461 or index. */
4462 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4463 || TREE_CODE (type) == QUAL_UNION_TYPE)
4464 && TREE_PURPOSE (link) != 0)
4465 field = TREE_PURPOSE (link);
4467 else if (TREE_CODE (type) == ARRAY_TYPE)
4468 index = TREE_PURPOSE (link);
4470 /* Eliminate the marker that makes a cast not be an lvalue. */
4471 if (val != 0)
4472 STRIP_NOPS (val);
4474 if (index && TREE_CODE (index) == RANGE_EXPR)
4476 unsigned HOST_WIDE_INT fieldsize
4477 = int_size_in_bytes (TREE_TYPE (type));
4478 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4479 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4480 HOST_WIDE_INT index;
4482 for (index = lo_index; index <= hi_index; index++)
4484 /* Output the element's initial value. */
4485 if (val == 0)
4486 assemble_zeros (fieldsize);
4487 else
4488 output_constant (val, fieldsize);
4490 /* Count its size. */
4491 total_bytes += fieldsize;
4494 else if (field == 0 || !DECL_BIT_FIELD (field))
4496 /* An element that is not a bit-field. */
4498 unsigned HOST_WIDE_INT fieldsize;
4499 /* Since this structure is static,
4500 we know the positions are constant. */
4501 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4503 if (index != 0)
4504 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4505 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4507 /* Output any buffered-up bit-fields preceding this element. */
4508 if (byte_buffer_in_use)
4510 ASM_OUTPUT_BYTE (asm_out_file, byte);
4511 total_bytes++;
4512 byte_buffer_in_use = 0;
4515 /* Advance to offset of this element.
4516 Note no alignment needed in an array, since that is guaranteed
4517 if each element has the proper size. */
4518 if ((field != 0 || index != 0) && pos != total_bytes)
4520 assemble_zeros (pos - total_bytes);
4521 total_bytes = pos;
4524 else if (field != 0 && DECL_PACKED (field))
4525 /* Some assemblers automaticallly align a datum according to its
4526 size if no align directive is specified. The datum, however,
4527 may be declared with 'packed' attribute, so we have to disable
4528 such a feature. */
4529 ASM_OUTPUT_ALIGN (asm_out_file, 0);
4531 /* Determine size this element should occupy. */
4532 if (field)
4534 fieldsize = 0;
4536 /* If this is an array with an unspecified upper bound,
4537 the initializer determines the size. */
4538 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4539 but we cannot do this until the deprecated support for
4540 initializing zero-length array members is removed. */
4541 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4542 && TYPE_DOMAIN (TREE_TYPE (field))
4543 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4545 fieldsize = array_size_for_constructor (val);
4546 /* Given a non-empty initialization, this field had
4547 better be last. */
4548 if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
4549 abort ();
4551 else if (DECL_SIZE_UNIT (field))
4553 /* ??? This can't be right. If the decl size overflows
4554 a host integer we will silently emit no data. */
4555 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4556 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4559 else
4560 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4562 /* Output the element's initial value. */
4563 if (val == 0)
4564 assemble_zeros (fieldsize);
4565 else
4566 output_constant (val, fieldsize);
4568 /* Count its size. */
4569 total_bytes += fieldsize;
4571 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4572 error ("invalid initial value for member `%s'",
4573 IDENTIFIER_POINTER (DECL_NAME (field)));
4574 else
4576 /* Element that is a bit-field. */
4578 HOST_WIDE_INT next_offset = int_bit_position (field);
4579 HOST_WIDE_INT end_offset
4580 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4582 if (val == 0)
4583 val = integer_zero_node;
4585 /* If this field does not start in this (or, next) byte,
4586 skip some bytes. */
4587 if (next_offset / BITS_PER_UNIT != total_bytes)
4589 /* Output remnant of any bit field in previous bytes. */
4590 if (byte_buffer_in_use)
4592 ASM_OUTPUT_BYTE (asm_out_file, byte);
4593 total_bytes++;
4594 byte_buffer_in_use = 0;
4597 /* If still not at proper byte, advance to there. */
4598 if (next_offset / BITS_PER_UNIT != total_bytes)
4600 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4601 total_bytes = next_offset / BITS_PER_UNIT;
4605 if (! byte_buffer_in_use)
4606 byte = 0;
4608 /* We must split the element into pieces that fall within
4609 separate bytes, and combine each byte with previous or
4610 following bit-fields. */
4612 /* next_offset is the offset n fbits from the beginning of
4613 the structure to the next bit of this element to be processed.
4614 end_offset is the offset of the first bit past the end of
4615 this element. */
4616 while (next_offset < end_offset)
4618 int this_time;
4619 int shift;
4620 HOST_WIDE_INT value;
4621 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4622 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4624 /* Advance from byte to byte
4625 within this element when necessary. */
4626 while (next_byte != total_bytes)
4628 ASM_OUTPUT_BYTE (asm_out_file, byte);
4629 total_bytes++;
4630 byte = 0;
4633 /* Number of bits we can process at once
4634 (all part of the same byte). */
4635 this_time = MIN (end_offset - next_offset,
4636 BITS_PER_UNIT - next_bit);
4637 if (BYTES_BIG_ENDIAN)
4639 /* On big-endian machine, take the most significant bits
4640 first (of the bits that are significant)
4641 and put them into bytes from the most significant end. */
4642 shift = end_offset - next_offset - this_time;
4644 /* Don't try to take a bunch of bits that cross
4645 the word boundary in the INTEGER_CST. We can
4646 only select bits from the LOW or HIGH part
4647 not from both. */
4648 if (shift < HOST_BITS_PER_WIDE_INT
4649 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4651 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4652 shift = HOST_BITS_PER_WIDE_INT;
4655 /* Now get the bits from the appropriate constant word. */
4656 if (shift < HOST_BITS_PER_WIDE_INT)
4657 value = TREE_INT_CST_LOW (val);
4658 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4660 value = TREE_INT_CST_HIGH (val);
4661 shift -= HOST_BITS_PER_WIDE_INT;
4663 else
4664 abort ();
4666 /* Get the result. This works only when:
4667 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4668 byte |= (((value >> shift)
4669 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4670 << (BITS_PER_UNIT - this_time - next_bit));
4672 else
4674 /* On little-endian machines,
4675 take first the least significant bits of the value
4676 and pack them starting at the least significant
4677 bits of the bytes. */
4678 shift = next_offset - int_bit_position (field);
4680 /* Don't try to take a bunch of bits that cross
4681 the word boundary in the INTEGER_CST. We can
4682 only select bits from the LOW or HIGH part
4683 not from both. */
4684 if (shift < HOST_BITS_PER_WIDE_INT
4685 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4686 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4688 /* Now get the bits from the appropriate constant word. */
4689 if (shift < HOST_BITS_PER_WIDE_INT)
4690 value = TREE_INT_CST_LOW (val);
4691 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4693 value = TREE_INT_CST_HIGH (val);
4694 shift -= HOST_BITS_PER_WIDE_INT;
4696 else
4697 abort ();
4699 /* Get the result. This works only when:
4700 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4701 byte |= (((value >> shift)
4702 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4703 << next_bit);
4706 next_offset += this_time;
4707 byte_buffer_in_use = 1;
4712 if (byte_buffer_in_use)
4714 ASM_OUTPUT_BYTE (asm_out_file, byte);
4715 total_bytes++;
4718 if (total_bytes < size)
4719 assemble_zeros (size - total_bytes);
4722 #ifdef HANDLE_PRAGMA_WEAK
4723 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4724 associatd with NAME. */
4727 add_weak (name, value)
4728 const char *name;
4729 const char *value;
4731 struct weak_syms *weak;
4733 weak = (struct weak_syms *) permalloc (sizeof (struct weak_syms));
4735 if (weak == NULL)
4736 return 0;
4738 weak->next = weak_decls;
4739 weak->name = name;
4740 weak->value = value;
4741 weak_decls = weak;
4743 return 1;
4745 #endif /* HANDLE_PRAGMA_WEAK */
4747 /* Declare DECL to be a weak symbol. */
4749 void
4750 declare_weak (decl)
4751 tree decl;
4753 if (! TREE_PUBLIC (decl))
4754 error_with_decl (decl, "weak declaration of `%s' must be public");
4755 else if (TREE_ASM_WRITTEN (decl))
4756 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4757 else if (SUPPORTS_WEAK)
4758 DECL_WEAK (decl) = 1;
4759 #ifdef HANDLE_PRAGMA_WEAK
4760 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4761 #endif
4764 /* Emit any pending weak declarations. */
4766 #ifdef HANDLE_PRAGMA_WEAK
4767 struct weak_syms * weak_decls;
4768 #endif
4770 void
4771 weak_finish ()
4773 #ifdef HANDLE_PRAGMA_WEAK
4774 if (HANDLE_PRAGMA_WEAK)
4776 struct weak_syms *t;
4777 for (t = weak_decls; t; t = t->next)
4779 if (t->name)
4781 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4782 if (t->value)
4783 ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4787 #endif
4790 /* Remove NAME from the pending list of weak symbols. This prevents
4791 the compiler from emitting multiple .weak directives which confuses
4792 some assemblers. */
4793 #ifdef ASM_WEAKEN_LABEL
4794 static void
4795 remove_from_pending_weak_list (name)
4796 const char *name ATTRIBUTE_UNUSED;
4798 #ifdef HANDLE_PRAGMA_WEAK
4799 if (HANDLE_PRAGMA_WEAK)
4801 struct weak_syms *t;
4802 for (t = weak_decls; t; t = t->next)
4804 if (t->name && strcmp (name, t->name) == 0)
4805 t->name = NULL;
4808 #endif
4810 #endif
4812 void
4813 assemble_alias (decl, target)
4814 tree decl, target ATTRIBUTE_UNUSED;
4816 const char *name;
4818 /* We must force creation of DECL_RTL for debug info generation, even though
4819 we don't use it here. */
4820 make_decl_rtl (decl, NULL_PTR);
4822 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4824 #ifdef ASM_OUTPUT_DEF
4825 /* Make name accessible from other files, if appropriate. */
4827 if (TREE_PUBLIC (decl))
4829 #ifdef ASM_WEAKEN_LABEL
4830 if (DECL_WEAK (decl))
4832 ASM_WEAKEN_LABEL (asm_out_file, name);
4833 /* Remove this function from the pending weak list so that
4834 we do not emit multiple .weak directives for it. */
4835 remove_from_pending_weak_list
4836 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4838 else
4839 #endif
4840 ASM_GLOBALIZE_LABEL (asm_out_file, name);
4843 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4844 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4845 #else
4846 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4847 #endif
4848 TREE_ASM_WRITTEN (decl) = 1;
4849 #else
4850 #ifdef ASM_OUTPUT_WEAK_ALIAS
4851 if (! DECL_WEAK (decl))
4852 warning ("only weak aliases are supported in this configuration");
4854 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4855 TREE_ASM_WRITTEN (decl) = 1;
4856 #else
4857 warning ("alias definitions not supported in this configuration; ignored");
4858 #endif
4859 #endif
4862 /* Returns 1 if the target configuration supports defining public symbols
4863 so that one of them will be chosen at link time instead of generating a
4864 multiply-defined symbol error, whether through the use of weak symbols or
4865 a target-specific mechanism for having duplicates discarded. */
4868 supports_one_only ()
4870 if (SUPPORTS_ONE_ONLY)
4871 return 1;
4872 return SUPPORTS_WEAK;
4875 /* Set up DECL as a public symbol that can be defined in multiple
4876 translation units without generating a linker error. */
4878 void
4879 make_decl_one_only (decl)
4880 tree decl;
4882 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4883 abort ();
4885 TREE_PUBLIC (decl) = 1;
4887 if (TREE_CODE (decl) == VAR_DECL
4888 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4889 DECL_COMMON (decl) = 1;
4890 else if (SUPPORTS_ONE_ONLY)
4892 #ifdef MAKE_DECL_ONE_ONLY
4893 MAKE_DECL_ONE_ONLY (decl);
4894 #endif
4895 DECL_ONE_ONLY (decl) = 1;
4897 else if (SUPPORTS_WEAK)
4898 DECL_WEAK (decl) = 1;
4899 else
4900 abort ();
4903 void
4904 init_varasm_once ()
4906 const_str_htab = htab_create (128, const_str_htab_hash, const_str_htab_eq,
4907 const_str_htab_del);
4908 ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
4909 mark_const_hash_entry);
4910 ggc_add_root (&const_str_htab, 1, sizeof const_str_htab,
4911 mark_const_str_htab);
4914 /* Extra support for EH values. */
4915 void
4916 assemble_eh_label (name)
4917 const char *name;
4919 #ifdef ASM_OUTPUT_EH_LABEL
4920 ASM_OUTPUT_EH_LABEL (asm_out_file, name);
4921 #else
4922 assemble_label (name);
4923 #endif
4926 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
4928 void
4929 assemble_eh_align (align)
4930 int align;
4932 #ifdef ASM_OUTPUT_EH_ALIGN
4933 if (align > BITS_PER_UNIT)
4934 ASM_OUTPUT_EH_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
4935 #else
4936 assemble_align (align);
4937 #endif
4941 /* On some platforms, we may want to specify a special mechansim to
4942 output EH data when generating with a function.. */
4944 assemble_eh_integer (x, size, force)
4945 rtx x;
4946 int size;
4947 int force;
4950 switch (size)
4952 #ifdef ASM_OUTPUT_EH_CHAR
4953 case 1:
4954 ASM_OUTPUT_EH_CHAR (asm_out_file, x);
4955 return 1;
4956 #endif
4958 #ifdef ASM_OUTPUT_EH_SHORT
4959 case 2:
4960 ASM_OUTPUT_EH_SHORT (asm_out_file, x);
4961 return 1;
4962 #endif
4964 #ifdef ASM_OUTPUT_EH_INT
4965 case 4:
4966 ASM_OUTPUT_EH_INT (asm_out_file, x);
4967 return 1;
4968 #endif
4970 #ifdef ASM_OUTPUT_EH_DOUBLE_INT
4971 case 8:
4972 ASM_OUTPUT_EH_DOUBLE_INT (asm_out_file, x);
4973 return 1;
4974 #endif
4976 default:
4977 break;
4979 return (assemble_integer (x, size, force));