expmed.c (store_bit_field): Truncate CONST_INTs.
[gcc.git] / gcc / varasm.c
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.
4
5 This file is part of GNU CC.
6
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.
11
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.
16
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. */
21
22
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.
26
27 We also output the assembler code for constants stored in memory
28 and are responsible for combining constants with the same value. */
29
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"
50
51 #ifdef XCOFF_DEBUGGING_INFO
52 #include "xcoffout.h"
53 #endif
54
55 #ifndef TRAMPOLINE_ALIGNMENT
56 #define TRAMPOLINE_ALIGNMENT FUNCTION_BOUNDARY
57 #endif
58
59 #ifndef ASM_STABS_OP
60 #define ASM_STABS_OP "\t.stabs\t"
61 #endif
62
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)
66
67 /* File in which assembler code is being written. */
68
69 extern FILE *asm_out_file;
70
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;
74
75 extern struct obstack permanent_obstack;
76 #define obstack_chunk_alloc xmalloc
77
78 struct addr_const;
79 struct constant_descriptor;
80 struct rtx_const;
81 struct pool_constant;
82
83 #define MAX_RTX_HASH_TABLE 61
84
85 struct varasm_status
86 {
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.
91
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;
97
98 /* Pointers to first and last constant in pool. */
99 struct pool_constant *x_first_pool, *x_last_pool;
100
101 /* Current offset in constant pool (does not include any machine-specific
102 header). */
103 int x_pool_offset;
104
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;
111 };
112
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)
119
120 /* Number for making the label on the next
121 constant that is stored in memory. */
122
123 int const_labelno;
124
125 /* Number for making the label on the next
126 static variable internal to a function. */
127
128 int var_labelno;
129
130 /* Carry information from ASM_DECLARE_OBJECT_NAME
131 to ASM_FINISH_DECLARE_OBJECT. */
132
133 int size_directive_output;
134
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. */
139
140 tree last_assemble_variable_decl;
141
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));
188 \f
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;
200
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
207
208 /* Text of section name when in_section == in_named. */
209 static const char *in_named_name;
210
211 /* Define functions like text_section for any extra sections. */
212 #ifdef EXTRA_SECTION_FUNCTIONS
213 EXTRA_SECTION_FUNCTIONS
214 #endif
215
216 /* Tell assembler to switch to text section. */
217
218 void
219 text_section ()
220 {
221 if (in_section != in_text)
222 {
223 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
224 in_section = in_text;
225 }
226 }
227
228 /* Tell assembler to switch to data section. */
229
230 void
231 data_section ()
232 {
233 if (in_section != in_data)
234 {
235 if (flag_shared_data)
236 {
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
242 }
243 else
244 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
245
246 in_section = in_data;
247 }
248 }
249 /* Tell assembler to ALWAYS switch to data section, in case
250 it's not sure where it it. */
251
252 void
253 force_data_section ()
254 {
255 in_section = no_section;
256 data_section ();
257 }
258
259 /* Tell assembler to switch to read-only data section. This is normally
260 the text section. */
261
262 void
263 readonly_data_section ()
264 {
265 #ifdef READONLY_DATA_SECTION
266 READONLY_DATA_SECTION (); /* Note this can call data_section. */
267 #else
268 text_section ();
269 #endif
270 }
271
272 /* Determine if we're in the text section. */
273
274 int
275 in_text_section ()
276 {
277 return in_section == in_text;
278 }
279
280 /* Determine if we're in the data section. */
281
282 int
283 in_data_section ()
284 {
285 return in_section == in_data;
286 }
287
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. */
292
293 void
294 named_section (decl, name, reloc)
295 tree decl;
296 const char *name;
297 int reloc ATTRIBUTE_UNUSED;
298 {
299 if (decl != NULL_TREE && !DECL_P (decl))
300 abort ();
301 if (name == NULL)
302 name = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
303
304 if (in_section != in_named || strcmp (name, in_named_name))
305 {
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
314
315 in_named_name = ggc_strdup (name);
316 in_section = in_named;
317 }
318 }
319
320 #ifdef BSS_SECTION_ASM_OP
321
322 /* Tell the assembler to switch to the bss section. */
323
324 void
325 bss_section ()
326 {
327 if (in_section != in_bss)
328 {
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);
335
336 in_section = in_bss;
337 }
338 }
339
340 #ifdef ASM_OUTPUT_BSS
341
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. */
346
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;
353 {
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);
364 }
365
366 #endif
367
368 #ifdef ASM_OUTPUT_ALIGNED_BSS
369
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. */
374
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;
381 {
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);
393 }
394
395 #endif
396
397 #endif /* BSS_SECTION_ASM_OP */
398
399 #ifdef EH_FRAME_SECTION_ASM_OP
400 void
401 eh_frame_section ()
402 {
403 if (in_section != in_eh_frame)
404 {
405 fprintf (asm_out_file, "%s\n", EH_FRAME_SECTION_ASM_OP);
406 in_section = in_eh_frame;
407 }
408 }
409 #endif
410
411 /* Switch to the section for function DECL.
412
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. */
416
417 void
418 function_section (decl)
419 tree decl;
420 {
421 if (decl != NULL_TREE
422 && DECL_SECTION_NAME (decl) != NULL_TREE)
423 named_section (decl, (char *) 0, 0);
424 else
425 text_section ();
426 }
427
428 /* Switch to section for variable DECL.
429
430 RELOC is the `reloc' argument to SELECT_SECTION. */
431
432 void
433 variable_section (decl, reloc)
434 tree decl;
435 int reloc;
436 {
437 if (IN_NAMED_SECTION (decl))
438 named_section (decl, NULL, reloc);
439 else
440 {
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.
445
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.
449
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. */
453
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
462 }
463 }
464
465 /* Tell assembler to switch to the section for the exception handling
466 table. */
467
468 void
469 exception_section ()
470 {
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
483 }
484 \f
485 /* Given NAME, a putative register name, discard any customary prefixes. */
486
487 static const char *
488 strip_reg_name (name)
489 const char *name;
490 {
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;
498 }
499 \f
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. */
507
508 int
509 decode_reg_name (asmspec)
510 const char *asmspec;
511 {
512 if (asmspec != 0)
513 {
514 int i;
515
516 /* Get rid of confusing prefixes. */
517 asmspec = strip_reg_name (asmspec);
518
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)
524 {
525 i = atoi (asmspec);
526 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
527 return i;
528 else
529 return -2;
530 }
531
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;
536
537 #ifdef ADDITIONAL_REGISTER_NAMES
538 {
539 static struct { const char *name; int number; } table[]
540 = ADDITIONAL_REGISTER_NAMES;
541
542 for (i = 0; i < (int) ARRAY_SIZE (table); i++)
543 if (! strcmp (asmspec, table[i].name))
544 return table[i].number;
545 }
546 #endif /* ADDITIONAL_REGISTER_NAMES */
547
548 if (!strcmp (asmspec, "memory"))
549 return -4;
550
551 if (!strcmp (asmspec, "cc"))
552 return -3;
553
554 return -2;
555 }
556
557 return -1;
558 }
559 \f
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.
563
564 There is, however, one exception: this function handles variables
565 explicitly placed in a particular register by the user.
566
567 ASMSPEC, if not 0, is the string which the user specified as the
568 assembler symbol name.
569
570 This is never called for PARM_DECL nodes. */
571
572 void
573 make_decl_rtl (decl, asmspec)
574 tree decl;
575 const char *asmspec;
576 {
577 int top_level = (DECL_CONTEXT (decl) == NULL_TREE);
578 const char *name = 0;
579 const char *new_name = 0;
580 int reg_number;
581
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 ();
596
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))
600 {
601 /* If the old RTL had the wrong mode, fix the mode. */
602 if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
603 {
604 rtx rtl = DECL_RTL (decl);
605 PUT_MODE (rtl, DECL_MODE (decl));
606 }
607
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;
620 }
621
622 new_name = name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
623
624 reg_number = decode_reg_name (asmspec);
625 if (reg_number == -2)
626 {
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;
633 }
634
635 if (TREE_CODE (decl) != FUNCTION_DECL && DECL_REGISTER (decl))
636 {
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
650 {
651 int nregs;
652
653 if (DECL_INITIAL (decl) != 0 && TREE_STATIC (decl))
654 {
655 DECL_INITIAL (decl) = 0;
656 error ("global register variable has initial value");
657 }
658 if (TREE_THIS_VOLATILE (decl))
659 warning ("volatile register variables don't work as you might wish");
660
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. */
666
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;
672
673 if (TREE_STATIC (decl))
674 {
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);
683 }
684
685 /* As a register variable, it has no section. */
686 return;
687 }
688 }
689
690 /* Now handle ordinary static variables and functions (in memory).
691 Also handle vars declared register invalidly. */
692
693 if (reg_number >= 0 || reg_number == -3)
694 error_with_decl (decl,
695 "register name given for non-register variable `%s'");
696
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;
704
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)))
713 {
714 char *label;
715 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
716 var_labelno++;
717 new_name = label;
718 }
719
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)
724 {
725 size_t name_len = IDENTIFIER_LENGTH (DECL_ASSEMBLER_NAME (decl));
726 char *pname;
727
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;
732 }
733
734 if (name != new_name)
735 {
736 SET_DECL_ASSEMBLER_NAME (decl, get_identifier (new_name));
737 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
738 }
739
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;
747
748 SET_DECL_RTL (decl, gen_rtx_MEM (DECL_MODE (decl),
749 gen_rtx_SYMBOL_REF (Pmode, name)));
750 if (TREE_CODE (decl) != FUNCTION_DECL)
751 set_mem_attributes (DECL_RTL (decl), decl, 1);
752
753 /* Optionally set flags or add text to the name to record information
754 such as that it is a function name.
755 If the name is changed, the macro ASM_OUTPUT_LABELREF
756 will have to know how to strip this information. */
757 #ifdef ENCODE_SECTION_INFO
758 ENCODE_SECTION_INFO (decl);
759 #endif
760 }
761
762 /* Make the rtl for variable VAR be volatile.
763 Use this only for static variables. */
764
765 void
766 make_var_volatile (var)
767 tree var;
768 {
769 if (GET_CODE (DECL_RTL (var)) != MEM)
770 abort ();
771
772 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
773 }
774 \f
775 /* Output alignment directive to align for constant expression EXP. */
776
777 void
778 assemble_constant_align (exp)
779 tree exp;
780 {
781 int align;
782
783 /* Align the location counter as required by EXP's data type. */
784 align = TYPE_ALIGN (TREE_TYPE (exp));
785 #ifdef CONSTANT_ALIGNMENT
786 align = CONSTANT_ALIGNMENT (exp, align);
787 #endif
788
789 if (align > BITS_PER_UNIT)
790 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
791 }
792
793 /* Output a string of literal assembler code
794 for an `asm' keyword used between functions. */
795
796 void
797 assemble_asm (string)
798 tree string;
799 {
800 app_enable ();
801
802 if (TREE_CODE (string) == ADDR_EXPR)
803 string = TREE_OPERAND (string, 0);
804
805 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
806 }
807
808 #if 0 /* This should no longer be needed, because
809 flag_gnu_linker should be 0 on these systems,
810 which should prevent any output
811 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
812 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
813 #ifndef ASM_OUTPUT_CONSTRUCTOR
814 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
815 #endif
816 #ifndef ASM_OUTPUT_DESTRUCTOR
817 #define ASM_OUTPUT_DESTRUCTOR(file, name)
818 #endif
819 #endif
820 #endif /* 0 */
821
822 /* Record an element in the table of global destructors.
823 How this is done depends on what sort of assembler and linker
824 are in use.
825
826 NAME should be the name of a global function to be called
827 at exit time. This name is output using assemble_name. */
828
829 void
830 assemble_destructor (name)
831 const char *name;
832 {
833 #ifdef ASM_OUTPUT_DESTRUCTOR
834 ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
835 #else
836 if (flag_gnu_linker)
837 {
838 /* Now tell GNU LD that this is part of the static destructor set. */
839 /* This code works for any machine provided you use GNU as/ld. */
840 fprintf (asm_out_file, "%s\"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
841 assemble_name (asm_out_file, name);
842 fputc ('\n', asm_out_file);
843 }
844 #endif
845 }
846
847 /* Likewise for global constructors. */
848
849 void
850 assemble_constructor (name)
851 const char *name;
852 {
853 #ifdef ASM_OUTPUT_CONSTRUCTOR
854 ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
855 #else
856 if (flag_gnu_linker)
857 {
858 /* Now tell GNU LD that this is part of the static constructor set. */
859 /* This code works for any machine provided you use GNU as/ld. */
860 fprintf (asm_out_file, "%s\"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
861 assemble_name (asm_out_file, name);
862 fputc ('\n', asm_out_file);
863 }
864 #endif
865 }
866
867 /* Likewise for entries we want to record for garbage collection.
868 Garbage collection is still under development. */
869
870 void
871 assemble_gc_entry (name)
872 const char *name;
873 {
874 #ifdef ASM_OUTPUT_GC_ENTRY
875 ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
876 #else
877 if (flag_gnu_linker)
878 {
879 /* Now tell GNU LD that this is part of the static constructor set. */
880 fprintf (asm_out_file, "%s\"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
881 assemble_name (asm_out_file, name);
882 fputc ('\n', asm_out_file);
883 }
884 #endif
885 }
886 \f
887 /* CONSTANT_POOL_BEFORE_FUNCTION may be defined as an expression with
888 a non-zero value if the constant pool should be output before the
889 start of the function, or a zero value if the pool should output
890 after the end of the function. The default is to put it before the
891 start. */
892
893 #ifndef CONSTANT_POOL_BEFORE_FUNCTION
894 #define CONSTANT_POOL_BEFORE_FUNCTION 1
895 #endif
896
897 /* Output assembler code for the constant pool of a function and associated
898 with defining the name of the function. DECL describes the function.
899 NAME is the function's name. For the constant pool, we use the current
900 constant pool data. */
901
902 void
903 assemble_start_function (decl, fnname)
904 tree decl;
905 const char *fnname;
906 {
907 int align;
908
909 /* The following code does not need preprocessing in the assembler. */
910
911 app_disable ();
912
913 if (CONSTANT_POOL_BEFORE_FUNCTION)
914 output_constant_pool (fnname, decl);
915
916 #ifdef ASM_OUTPUT_SECTION_NAME
917 /* If the function is to be put in its own section and it's not in a section
918 already, indicate so. */
919 if ((flag_function_sections
920 && DECL_SECTION_NAME (decl) == NULL_TREE)
921 || UNIQUE_SECTION_P (decl))
922 UNIQUE_SECTION (decl, 0);
923 #endif
924
925 function_section (decl);
926
927 /* Tell assembler to move to target machine's alignment for functions. */
928 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
929 if (align > 0)
930 ASM_OUTPUT_ALIGN (asm_out_file, align);
931
932 /* Handle a user-specified function alignment.
933 Note that we still need to align to FUNCTION_BOUNDARY, as above,
934 because ASM_OUTPUT_MAX_SKIP_ALIGN might not do any alignment at all. */
935 if (align_functions_log > align)
936 {
937 #ifdef ASM_OUTPUT_MAX_SKIP_ALIGN
938 ASM_OUTPUT_MAX_SKIP_ALIGN (asm_out_file,
939 align_functions_log, align_functions-1);
940 #else
941 ASM_OUTPUT_ALIGN (asm_out_file, align_functions_log);
942 #endif
943 }
944
945 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
946 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
947 #endif
948
949 #ifdef SDB_DEBUGGING_INFO
950 /* Output SDB definition of the function. */
951 if (write_symbols == SDB_DEBUG)
952 sdbout_mark_begin_function ();
953 #endif
954
955 #ifdef DBX_DEBUGGING_INFO
956 /* Output DBX definition of the function. */
957 if (write_symbols == DBX_DEBUG)
958 dbxout_begin_function (decl);
959 #endif
960
961 /* Make function name accessible from other files, if appropriate. */
962
963 if (TREE_PUBLIC (decl))
964 {
965 if (! first_global_object_name)
966 {
967 const char *p;
968 char *name;
969
970 STRIP_NAME_ENCODING (p, fnname);
971 name = permalloc (strlen (p) + 1);
972 strcpy (name, p);
973
974 if (! DECL_WEAK (decl) && ! DECL_ONE_ONLY (decl))
975 first_global_object_name = name;
976 else
977 weak_global_object_name = name;
978 }
979
980 #ifdef ASM_WEAKEN_LABEL
981 if (DECL_WEAK (decl))
982 {
983 ASM_WEAKEN_LABEL (asm_out_file, fnname);
984 /* Remove this function from the pending weak list so that
985 we do not emit multiple .weak directives for it. */
986 remove_from_pending_weak_list
987 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
988 }
989 else
990 #endif
991 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
992 }
993
994 /* Do any machine/system dependent processing of the function name */
995 #ifdef ASM_DECLARE_FUNCTION_NAME
996 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
997 #else
998 /* Standard thing is just output label for the function. */
999 ASM_OUTPUT_LABEL (asm_out_file, fnname);
1000 #endif /* ASM_DECLARE_FUNCTION_NAME */
1001 }
1002
1003 /* Output assembler code associated with defining the size of the
1004 function. DECL describes the function. NAME is the function's name. */
1005
1006 void
1007 assemble_end_function (decl, fnname)
1008 tree decl;
1009 const char *fnname;
1010 {
1011 #ifdef ASM_DECLARE_FUNCTION_SIZE
1012 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
1013 #endif
1014 if (! CONSTANT_POOL_BEFORE_FUNCTION)
1015 {
1016 output_constant_pool (fnname, decl);
1017 function_section (decl); /* need to switch back */
1018 }
1019
1020 /* Output any constants which should appear after the function. */
1021 output_after_function_constants ();
1022 }
1023 \f
1024 /* Assemble code to leave SIZE bytes of zeros. */
1025
1026 void
1027 assemble_zeros (size)
1028 int size;
1029 {
1030 /* Do no output if -fsyntax-only. */
1031 if (flag_syntax_only)
1032 return;
1033
1034 #ifdef ASM_NO_SKIP_IN_TEXT
1035 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
1036 so we must output 0s explicitly in the text section. */
1037 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
1038 {
1039 int i;
1040
1041 for (i = 0; i < size - 20; i += 20)
1042 {
1043 #ifdef ASM_BYTE_OP
1044 fprintf (asm_out_file,
1045 "%s0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
1046 #else
1047 fprintf (asm_out_file,
1048 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
1049 #endif
1050 }
1051 if (i < size)
1052 {
1053 #ifdef ASM_BYTE_OP
1054 fprintf (asm_out_file, "%s0", ASM_BYTE_OP);
1055 #else
1056 fprintf (asm_out_file, "\tbyte 0");
1057 #endif
1058 i++;
1059 for (; i < size; i++)
1060 fprintf (asm_out_file, ",0");
1061 fprintf (asm_out_file, "\n");
1062 }
1063 }
1064 else
1065 #endif
1066 if (size > 0)
1067 ASM_OUTPUT_SKIP (asm_out_file, size);
1068 }
1069
1070 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
1071
1072 void
1073 assemble_align (align)
1074 int align;
1075 {
1076 if (align > BITS_PER_UNIT)
1077 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1078 }
1079
1080 /* Assemble a string constant with the specified C string as contents. */
1081
1082 void
1083 assemble_string (p, size)
1084 const char *p;
1085 int size;
1086 {
1087 int pos = 0;
1088 int maximum = 2000;
1089
1090 /* If the string is very long, split it up. */
1091
1092 while (pos < size)
1093 {
1094 int thissize = size - pos;
1095 if (thissize > maximum)
1096 thissize = maximum;
1097
1098 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
1099
1100 pos += thissize;
1101 p += thissize;
1102 }
1103 }
1104
1105 \f
1106 #if defined ASM_OUTPUT_ALIGNED_DECL_LOCAL
1107 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1108 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1109 #else
1110 #if defined ASM_OUTPUT_ALIGNED_LOCAL
1111 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1112 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, DECL_ALIGN (decl))
1113 #else
1114 #define ASM_EMIT_LOCAL(decl, name, size, rounded) \
1115 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded)
1116 #endif
1117 #endif
1118
1119 #if defined ASM_OUTPUT_ALIGNED_BSS
1120 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1121 ASM_OUTPUT_ALIGNED_BSS (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1122 #else
1123 #if defined ASM_OUTPUT_BSS
1124 #define ASM_EMIT_BSS(decl, name, size, rounded) \
1125 ASM_OUTPUT_BSS (asm_out_file, decl, name, size, rounded)
1126 #else
1127 #undef ASM_EMIT_BSS
1128 #endif
1129 #endif
1130
1131 #if defined ASM_OUTPUT_ALIGNED_DECL_COMMON
1132 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1133 ASM_OUTPUT_ALIGNED_DECL_COMMON (asm_out_file, decl, name, size, DECL_ALIGN (decl))
1134 #else
1135 #if defined ASM_OUTPUT_ALIGNED_COMMON
1136 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1137 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size, DECL_ALIGN (decl))
1138 #else
1139 #define ASM_EMIT_COMMON(decl, name, size, rounded) \
1140 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded)
1141 #endif
1142 #endif
1143
1144 static void
1145 asm_emit_uninitialised (decl, name, size, rounded)
1146 tree decl;
1147 const char * name;
1148 int size ATTRIBUTE_UNUSED;
1149 int rounded ATTRIBUTE_UNUSED;
1150 {
1151 enum
1152 {
1153 asm_dest_common,
1154 asm_dest_bss,
1155 asm_dest_local
1156 }
1157 destination = asm_dest_local;
1158
1159 if (TREE_PUBLIC (decl))
1160 {
1161 #if defined ASM_EMIT_BSS
1162 if (! DECL_COMMON (decl))
1163 destination = asm_dest_bss;
1164 else
1165 #endif
1166 destination = asm_dest_common;
1167 }
1168
1169 if (flag_shared_data)
1170 {
1171 switch (destination)
1172 {
1173 #ifdef ASM_OUTPUT_SHARED_BSS
1174 case asm_dest_bss:
1175 ASM_OUTPUT_SHARED_BSS (asm_out_file, decl, name, size, rounded);
1176 return;
1177 #endif
1178 #ifdef ASM_OUTPUT_SHARED_COMMON
1179 case asm_dest_common:
1180 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
1181 return;
1182 #endif
1183 #ifdef ASM_OUTPUT_SHARED_LOCAL
1184 case asm_dest_local:
1185 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1186 return;
1187 #endif
1188 default:
1189 break;
1190 }
1191 }
1192
1193 #ifdef ASM_OUTPUT_SECTION_NAME
1194 /* We already know that DECL_SECTION_NAME() == NULL. */
1195 if (flag_data_sections != 0 || UNIQUE_SECTION_P (decl))
1196 UNIQUE_SECTION (decl, 0);
1197 #endif
1198
1199 switch (destination)
1200 {
1201 #ifdef ASM_EMIT_BSS
1202 case asm_dest_bss:
1203 ASM_EMIT_BSS (decl, name, size, rounded);
1204 break;
1205 #endif
1206 case asm_dest_common:
1207 ASM_EMIT_COMMON (decl, name, size, rounded);
1208 break;
1209 case asm_dest_local:
1210 ASM_EMIT_LOCAL (decl, name, size, rounded);
1211 break;
1212 default:
1213 abort ();
1214 }
1215
1216 return;
1217 }
1218
1219 /* Assemble everything that is needed for a variable or function declaration.
1220 Not used for automatic variables, and not used for function definitions.
1221 Should not be called for variables of incomplete structure type.
1222
1223 TOP_LEVEL is nonzero if this variable has file scope.
1224 AT_END is nonzero if this is the special handling, at end of compilation,
1225 to define things that have had only tentative definitions.
1226 DONT_OUTPUT_DATA if nonzero means don't actually output the
1227 initial value (that will be done by the caller). */
1228
1229 void
1230 assemble_variable (decl, top_level, at_end, dont_output_data)
1231 tree decl;
1232 int top_level ATTRIBUTE_UNUSED;
1233 int at_end ATTRIBUTE_UNUSED;
1234 int dont_output_data;
1235 {
1236 register const char *name;
1237 unsigned int align;
1238 int reloc = 0;
1239 enum in_section saved_in_section;
1240
1241 last_assemble_variable_decl = 0;
1242
1243 if (DECL_RTL_SET_P (decl) && GET_CODE (DECL_RTL (decl)) == REG)
1244 {
1245 /* Do output symbol info for global register variables, but do nothing
1246 else for them. */
1247
1248 if (TREE_ASM_WRITTEN (decl))
1249 return;
1250 TREE_ASM_WRITTEN (decl) = 1;
1251
1252 /* Do no output if -fsyntax-only. */
1253 if (flag_syntax_only)
1254 return;
1255
1256 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
1257 /* File-scope global variables are output here. */
1258 if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
1259 && top_level)
1260 dbxout_symbol (decl, 0);
1261 #endif
1262 #ifdef SDB_DEBUGGING_INFO
1263 if (write_symbols == SDB_DEBUG && top_level
1264 /* Leave initialized global vars for end of compilation;
1265 see comment in compile_file. */
1266 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1267 sdbout_symbol (decl, 0);
1268 #endif
1269
1270 /* Don't output any DWARF debugging information for variables here.
1271 In the case of local variables, the information for them is output
1272 when we do our recursive traversal of the tree representation for
1273 the entire containing function. In the case of file-scope variables,
1274 we output information for all of them at the very end of compilation
1275 while we are doing our final traversal of the chain of file-scope
1276 declarations. */
1277
1278 return;
1279 }
1280
1281 /* Normally no need to say anything here for external references,
1282 since assemble_external is called by the language-specific code
1283 when a declaration is first seen. */
1284
1285 if (DECL_EXTERNAL (decl))
1286 return;
1287
1288 /* Output no assembler code for a function declaration.
1289 Only definitions of functions output anything. */
1290
1291 if (TREE_CODE (decl) == FUNCTION_DECL)
1292 return;
1293
1294 /* If type was incomplete when the variable was declared,
1295 see if it is complete now. */
1296
1297 if (DECL_SIZE (decl) == 0)
1298 layout_decl (decl, 0);
1299
1300 /* Still incomplete => don't allocate it; treat the tentative defn
1301 (which is what it must have been) as an `extern' reference. */
1302
1303 if (!dont_output_data && DECL_SIZE (decl) == 0)
1304 {
1305 error_with_file_and_line (DECL_SOURCE_FILE (decl),
1306 DECL_SOURCE_LINE (decl),
1307 "storage size of `%s' isn't known",
1308 IDENTIFIER_POINTER (DECL_NAME (decl)));
1309 TREE_ASM_WRITTEN (decl) = 1;
1310 return;
1311 }
1312
1313 /* The first declaration of a variable that comes through this function
1314 decides whether it is global (in C, has external linkage)
1315 or local (in C, has internal linkage). So do nothing more
1316 if this function has already run. */
1317
1318 if (TREE_ASM_WRITTEN (decl))
1319 return;
1320
1321 TREE_ASM_WRITTEN (decl) = 1;
1322
1323 /* Do no output if -fsyntax-only. */
1324 if (flag_syntax_only)
1325 return;
1326
1327 app_disable ();
1328
1329 if (! dont_output_data
1330 && ! host_integerp (DECL_SIZE_UNIT (decl), 1))
1331 {
1332 error_with_decl (decl, "size of variable `%s' is too large");
1333 goto finish;
1334 }
1335
1336 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
1337 if (TREE_PUBLIC (decl) && DECL_NAME (decl)
1338 && ! first_global_object_name
1339 && ! (DECL_COMMON (decl) && (DECL_INITIAL (decl) == 0
1340 || DECL_INITIAL (decl) == error_mark_node))
1341 && ! DECL_WEAK (decl)
1342 && ! DECL_ONE_ONLY (decl))
1343 {
1344 const char *p;
1345 char *xname;
1346
1347 STRIP_NAME_ENCODING (p, name);
1348 xname = permalloc (strlen (p) + 1);
1349 strcpy (xname, p);
1350 first_global_object_name = xname;
1351 }
1352
1353 /* Compute the alignment of this data. */
1354
1355 align = DECL_ALIGN (decl);
1356
1357 /* In the case for initialing an array whose length isn't specified,
1358 where we have not yet been able to do the layout,
1359 figure out the proper alignment now. */
1360 if (dont_output_data && DECL_SIZE (decl) == 0
1361 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1362 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1363
1364 /* Some object file formats have a maximum alignment which they support.
1365 In particular, a.out format supports a maximum alignment of 4. */
1366 #ifndef MAX_OFILE_ALIGNMENT
1367 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1368 #endif
1369 if (align > MAX_OFILE_ALIGNMENT)
1370 {
1371 warning_with_decl (decl,
1372 "alignment of `%s' is greater than maximum object file alignment. Using %d.",
1373 MAX_OFILE_ALIGNMENT/BITS_PER_UNIT);
1374 align = MAX_OFILE_ALIGNMENT;
1375 }
1376
1377 /* On some machines, it is good to increase alignment sometimes. */
1378 #ifdef DATA_ALIGNMENT
1379 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1380 #endif
1381 #ifdef CONSTANT_ALIGNMENT
1382 if (DECL_INITIAL (decl) != 0 && DECL_INITIAL (decl) != error_mark_node)
1383 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1384 #endif
1385
1386 /* Reset the alignment in case we have made it tighter, so we can benefit
1387 from it in get_pointer_alignment. */
1388 DECL_ALIGN (decl) = align;
1389
1390 /* Handle uninitialized definitions. */
1391
1392 if ((DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node)
1393 /* If the target can't output uninitialized but not common global data
1394 in .bss, then we have to use .data. */
1395 #if ! defined ASM_EMIT_BSS
1396 && DECL_COMMON (decl)
1397 #endif
1398 && DECL_SECTION_NAME (decl) == NULL_TREE
1399 && ! dont_output_data)
1400 {
1401 unsigned HOST_WIDE_INT size = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
1402 unsigned HOST_WIDE_INT rounded = size;
1403
1404 /* Don't allocate zero bytes of common,
1405 since that means "undefined external" in the linker. */
1406 if (size == 0)
1407 rounded = 1;
1408
1409 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1410 so that each uninitialized object starts on such a boundary. */
1411 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
1412 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1413 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1414
1415 /* Don't continue this line--convex cc version 4.1 would lose. */
1416 #if !defined(ASM_OUTPUT_ALIGNED_COMMON) && !defined(ASM_OUTPUT_ALIGNED_DECL_COMMON) && !defined(ASM_OUTPUT_ALIGNED_BSS)
1417 if ((unsigned HOST_WIDE_INT) DECL_ALIGN (decl) / BITS_PER_UNIT > rounded)
1418 warning_with_decl
1419 (decl, "requested alignment for %s is greater than implemented alignment of %d.",rounded);
1420 #endif
1421
1422 #ifdef DBX_DEBUGGING_INFO
1423 /* File-scope global variables are output here. */
1424 if (write_symbols == DBX_DEBUG && top_level)
1425 dbxout_symbol (decl, 0);
1426 #endif
1427 #ifdef SDB_DEBUGGING_INFO
1428 if (write_symbols == SDB_DEBUG && top_level
1429 /* Leave initialized global vars for end of compilation;
1430 see comment in compile_file. */
1431 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1432 sdbout_symbol (decl, 0);
1433 #endif
1434
1435 /* Don't output any DWARF debugging information for variables here.
1436 In the case of local variables, the information for them is output
1437 when we do our recursive traversal of the tree representation for
1438 the entire containing function. In the case of file-scope variables,
1439 we output information for all of them at the very end of compilation
1440 while we are doing our final traversal of the chain of file-scope
1441 declarations. */
1442
1443 #if 0 /* ??? We should either delete this or add a comment describing what
1444 it was intended to do and why we shouldn't delete it. */
1445 if (flag_shared_data)
1446 data_section ();
1447 #endif
1448 asm_emit_uninitialised (decl, name, size, rounded);
1449
1450 goto finish;
1451 }
1452
1453 /* Handle initialized definitions.
1454 Also handle uninitialized global definitions if -fno-common and the
1455 target doesn't support ASM_OUTPUT_BSS. */
1456
1457 /* First make the assembler name(s) global if appropriate. */
1458 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1459 {
1460 #ifdef ASM_WEAKEN_LABEL
1461 if (DECL_WEAK (decl))
1462 {
1463 ASM_WEAKEN_LABEL (asm_out_file, name);
1464 /* Remove this variable from the pending weak list so that
1465 we do not emit multiple .weak directives for it. */
1466 remove_from_pending_weak_list
1467 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
1468 }
1469 else
1470 #endif
1471 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1472 }
1473 #if 0
1474 for (d = equivalents; d; d = TREE_CHAIN (d))
1475 {
1476 tree e = TREE_VALUE (d);
1477 if (TREE_PUBLIC (e) && DECL_NAME (e))
1478 ASM_GLOBALIZE_LABEL (asm_out_file,
1479 XSTR (XEXP (DECL_RTL (e), 0), 0));
1480 }
1481 #endif
1482
1483 /* Output any data that we will need to use the address of. */
1484 if (DECL_INITIAL (decl) == error_mark_node)
1485 reloc = contains_pointers_p (TREE_TYPE (decl));
1486 else if (DECL_INITIAL (decl))
1487 reloc = output_addressed_constants (DECL_INITIAL (decl));
1488
1489 #ifdef ASM_OUTPUT_SECTION_NAME
1490 if ((flag_data_sections != 0 && DECL_SECTION_NAME (decl) == NULL_TREE)
1491 || UNIQUE_SECTION_P (decl))
1492 UNIQUE_SECTION (decl, reloc);
1493 #endif
1494
1495 /* Switch to the appropriate section. */
1496 variable_section (decl, reloc);
1497
1498 /* dbxout.c needs to know this. */
1499 if (in_text_section ())
1500 DECL_IN_TEXT_SECTION (decl) = 1;
1501
1502 /* Record current section so we can restore it if dbxout.c clobbers it. */
1503 saved_in_section = in_section;
1504
1505 /* Output the dbx info now that we have chosen the section. */
1506
1507 #ifdef DBX_DEBUGGING_INFO
1508 /* File-scope global variables are output here. */
1509 if (write_symbols == DBX_DEBUG && top_level)
1510 dbxout_symbol (decl, 0);
1511 #endif
1512 #ifdef SDB_DEBUGGING_INFO
1513 if (write_symbols == SDB_DEBUG && top_level
1514 /* Leave initialized global vars for end of compilation;
1515 see comment in compile_file. */
1516 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1517 sdbout_symbol (decl, 0);
1518 #endif
1519
1520 /* Don't output any DWARF debugging information for variables here.
1521 In the case of local variables, the information for them is output
1522 when we do our recursive traversal of the tree representation for
1523 the entire containing function. In the case of file-scope variables,
1524 we output information for all of them at the very end of compilation
1525 while we are doing our final traversal of the chain of file-scope
1526 declarations. */
1527
1528 /* If the debugging output changed sections, reselect the section
1529 that's supposed to be selected. */
1530 if (in_section != saved_in_section)
1531 variable_section (decl, reloc);
1532
1533 /* Output the alignment of this data. */
1534 if (align > BITS_PER_UNIT)
1535 ASM_OUTPUT_ALIGN (asm_out_file,
1536 floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT));
1537
1538 /* Do any machine/system dependent processing of the object. */
1539 #ifdef ASM_DECLARE_OBJECT_NAME
1540 last_assemble_variable_decl = decl;
1541 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1542 #else
1543 /* Standard thing is just output label for the object. */
1544 ASM_OUTPUT_LABEL (asm_out_file, name);
1545 #endif /* ASM_DECLARE_OBJECT_NAME */
1546
1547 if (!dont_output_data)
1548 {
1549 if (DECL_INITIAL (decl))
1550 /* Output the actual data. */
1551 output_constant (DECL_INITIAL (decl),
1552 tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1553 else
1554 /* Leave space for it. */
1555 assemble_zeros (tree_low_cst (DECL_SIZE_UNIT (decl), 1));
1556 }
1557
1558 finish:
1559 #ifdef XCOFF_DEBUGGING_INFO
1560 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1561 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1562 and `aa' hasn't been output yet, the assembler generates a stab entry with
1563 a value of zero, in addition to creating an unnecessary external entry
1564 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1565
1566 /* File-scope global variables are output here. */
1567 if (write_symbols == XCOFF_DEBUG && top_level)
1568 {
1569 saved_in_section = in_section;
1570
1571 dbxout_symbol (decl, 0);
1572
1573 if (in_section != saved_in_section)
1574 variable_section (decl, reloc);
1575 }
1576 #else
1577 /* There must be a statement after a label. */
1578 ;
1579 #endif
1580 }
1581
1582 /* Return 1 if type TYPE contains any pointers. */
1583
1584 static int
1585 contains_pointers_p (type)
1586 tree type;
1587 {
1588 switch (TREE_CODE (type))
1589 {
1590 case POINTER_TYPE:
1591 case REFERENCE_TYPE:
1592 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1593 so I'll play safe and return 1. */
1594 case OFFSET_TYPE:
1595 return 1;
1596
1597 case RECORD_TYPE:
1598 case UNION_TYPE:
1599 case QUAL_UNION_TYPE:
1600 {
1601 tree fields;
1602 /* For a type that has fields, see if the fields have pointers. */
1603 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1604 if (TREE_CODE (fields) == FIELD_DECL
1605 && contains_pointers_p (TREE_TYPE (fields)))
1606 return 1;
1607 return 0;
1608 }
1609
1610 case ARRAY_TYPE:
1611 /* An array type contains pointers if its element type does. */
1612 return contains_pointers_p (TREE_TYPE (type));
1613
1614 default:
1615 return 0;
1616 }
1617 }
1618
1619 /* Output something to declare an external symbol to the assembler.
1620 (Most assemblers don't need this, so we normally output nothing.)
1621 Do nothing if DECL is not external. */
1622
1623 void
1624 assemble_external (decl)
1625 tree decl ATTRIBUTE_UNUSED;
1626 {
1627 #ifdef ASM_OUTPUT_EXTERNAL
1628 if (DECL_P (decl) && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1629 {
1630 rtx rtl = DECL_RTL (decl);
1631
1632 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1633 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1634 {
1635 /* Some systems do require some output. */
1636 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1637 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1638 }
1639 }
1640 #endif
1641 }
1642
1643 /* Similar, for calling a library function FUN. */
1644
1645 void
1646 assemble_external_libcall (fun)
1647 rtx fun ATTRIBUTE_UNUSED;
1648 {
1649 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1650 /* Declare library function name external when first used, if nec. */
1651 if (! SYMBOL_REF_USED (fun))
1652 {
1653 SYMBOL_REF_USED (fun) = 1;
1654 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1655 }
1656 #endif
1657 }
1658
1659 /* Declare the label NAME global. */
1660
1661 void
1662 assemble_global (name)
1663 const char *name;
1664 {
1665 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1666 }
1667
1668 /* Assemble a label named NAME. */
1669
1670 void
1671 assemble_label (name)
1672 const char *name;
1673 {
1674 ASM_OUTPUT_LABEL (asm_out_file, name);
1675 }
1676
1677 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1678 If NAME starts with a *, the rest of NAME is output verbatim.
1679 Otherwise NAME is transformed in an implementation-defined way
1680 (usually by the addition of an underscore).
1681 Many macros in the tm file are defined to call this function. */
1682
1683 void
1684 assemble_name (file, name)
1685 FILE *file;
1686 const char *name;
1687 {
1688 const char *real_name;
1689 tree id;
1690
1691 STRIP_NAME_ENCODING (real_name, name);
1692 if (flag_prefix_function_name
1693 && ! memcmp (real_name, CHKR_PREFIX, CHKR_PREFIX_SIZE))
1694 real_name = real_name + CHKR_PREFIX_SIZE;
1695
1696 id = maybe_get_identifier (real_name);
1697 if (id)
1698 TREE_SYMBOL_REFERENCED (id) = 1;
1699
1700 if (name[0] == '*')
1701 fputs (&name[1], file);
1702 else
1703 ASM_OUTPUT_LABELREF (file, name);
1704 }
1705
1706 /* Allocate SIZE bytes writable static space with a gensym name
1707 and return an RTX to refer to its address. */
1708
1709 rtx
1710 assemble_static_space (size)
1711 int size;
1712 {
1713 char name[12];
1714 const char *namestring;
1715 rtx x;
1716
1717 #if 0
1718 if (flag_shared_data)
1719 data_section ();
1720 #endif
1721
1722 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1723 ++const_labelno;
1724 namestring = ggc_strdup (name);
1725
1726 x = gen_rtx_SYMBOL_REF (Pmode, namestring);
1727
1728 #ifdef ASM_OUTPUT_ALIGNED_DECL_LOCAL
1729 ASM_OUTPUT_ALIGNED_DECL_LOCAL (asm_out_file, NULL_TREE, name, size,
1730 BIGGEST_ALIGNMENT);
1731 #else
1732 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1733 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1734 #else
1735 {
1736 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1737 so that each uninitialized object starts on such a boundary. */
1738 /* Variable `rounded' might or might not be used in ASM_OUTPUT_LOCAL. */
1739 int rounded ATTRIBUTE_UNUSED
1740 = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1741 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1742 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1743 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1744 }
1745 #endif
1746 #endif
1747 return x;
1748 }
1749
1750 /* Assemble the static constant template for function entry trampolines.
1751 This is done at most once per compilation.
1752 Returns an RTX for the address of the template. */
1753
1754 #ifdef TRAMPOLINE_TEMPLATE
1755 rtx
1756 assemble_trampoline_template ()
1757 {
1758 char label[256];
1759 const char *name;
1760 int align;
1761
1762 /* By default, put trampoline templates in read-only data section. */
1763
1764 #ifdef TRAMPOLINE_SECTION
1765 TRAMPOLINE_SECTION ();
1766 #else
1767 readonly_data_section ();
1768 #endif
1769
1770 /* Write the assembler code to define one. */
1771 align = floor_log2 (TRAMPOLINE_ALIGNMENT / BITS_PER_UNIT);
1772 if (align > 0)
1773 ASM_OUTPUT_ALIGN (asm_out_file, align);
1774
1775 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1776 TRAMPOLINE_TEMPLATE (asm_out_file);
1777
1778 /* Record the rtl to refer to it. */
1779 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1780 name = ggc_strdup (label);
1781 return gen_rtx_SYMBOL_REF (Pmode, name);
1782 }
1783 #endif
1784 \f
1785 /* Assemble the integer constant X into an object of SIZE bytes.
1786 X must be either a CONST_INT or CONST_DOUBLE.
1787
1788 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1789 non-zero, abort if we can't output the constant. */
1790
1791 int
1792 assemble_integer (x, size, force)
1793 rtx x;
1794 int size;
1795 int force;
1796 {
1797 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1798 ASM_OUTPUT... macros. */
1799
1800 switch (size)
1801 {
1802 #ifdef ASM_OUTPUT_CHAR
1803 case 1:
1804 ASM_OUTPUT_CHAR (asm_out_file, x);
1805 return 1;
1806 #endif
1807
1808 #ifdef ASM_OUTPUT_SHORT
1809 case 2:
1810 ASM_OUTPUT_SHORT (asm_out_file, x);
1811 return 1;
1812 #endif
1813
1814 #ifdef ASM_OUTPUT_INT
1815 case 4:
1816 ASM_OUTPUT_INT (asm_out_file, x);
1817 return 1;
1818 #endif
1819
1820 #ifdef ASM_OUTPUT_DOUBLE_INT
1821 case 8:
1822 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1823 return 1;
1824 #endif
1825
1826 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1827 case 16:
1828 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1829 return 1;
1830 #endif
1831 }
1832
1833 /* If we couldn't do it that way, there are two other possibilities: First,
1834 if the machine can output an explicit byte and this is a 1 byte constant,
1835 we can use ASM_OUTPUT_BYTE. */
1836
1837 #ifdef ASM_OUTPUT_BYTE
1838 if (size == 1 && GET_CODE (x) == CONST_INT)
1839 {
1840 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1841 return 1;
1842 }
1843 #endif
1844
1845 /* Finally, if SIZE is larger than a single word, try to output the constant
1846 one word at a time. */
1847
1848 if (size > UNITS_PER_WORD)
1849 {
1850 int i;
1851 enum machine_mode mode
1852 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1853 rtx word;
1854
1855 for (i = 0; i < size / UNITS_PER_WORD; i++)
1856 {
1857 word = operand_subword (x, i, 0, mode);
1858
1859 if (word == 0)
1860 break;
1861
1862 if (! assemble_integer (word, UNITS_PER_WORD, 0))
1863 break;
1864 }
1865
1866 if (i == size / UNITS_PER_WORD)
1867 return 1;
1868 /* If we output at least one word and then could not finish,
1869 there is no valid way to continue. */
1870 if (i > 0)
1871 abort ();
1872 }
1873
1874 if (force)
1875 abort ();
1876
1877 return 0;
1878 }
1879 \f
1880 /* Assemble the floating-point constant D into an object of size MODE. */
1881
1882 void
1883 assemble_real (d, mode)
1884 REAL_VALUE_TYPE d;
1885 enum machine_mode mode;
1886 {
1887 jmp_buf output_constant_handler;
1888
1889 if (setjmp (output_constant_handler))
1890 {
1891 error ("floating point trap outputting a constant");
1892 #ifdef REAL_IS_NOT_DOUBLE
1893 memset ((char *) &d, 0, sizeof d);
1894 d = dconst0;
1895 #else
1896 d = 0;
1897 #endif
1898 }
1899
1900 set_float_handler (output_constant_handler);
1901
1902 switch (mode)
1903 {
1904 #ifdef ASM_OUTPUT_BYTE_FLOAT
1905 case QFmode:
1906 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1907 break;
1908 #endif
1909 #ifdef ASM_OUTPUT_SHORT_FLOAT
1910 case HFmode:
1911 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1912 break;
1913 #endif
1914 #ifdef ASM_OUTPUT_THREE_QUARTER_FLOAT
1915 case TQFmode:
1916 ASM_OUTPUT_THREE_QUARTER_FLOAT (asm_out_file, d);
1917 break;
1918 #endif
1919 #ifdef ASM_OUTPUT_FLOAT
1920 case SFmode:
1921 ASM_OUTPUT_FLOAT (asm_out_file, d);
1922 break;
1923 #endif
1924
1925 #ifdef ASM_OUTPUT_DOUBLE
1926 case DFmode:
1927 ASM_OUTPUT_DOUBLE (asm_out_file, d);
1928 break;
1929 #endif
1930
1931 #ifdef ASM_OUTPUT_LONG_DOUBLE
1932 case XFmode:
1933 case TFmode:
1934 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1935 break;
1936 #endif
1937
1938 default:
1939 abort ();
1940 }
1941
1942 set_float_handler (NULL_PTR);
1943 }
1944 \f
1945 /* Here we combine duplicate floating constants to make
1946 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1947
1948 /* Return a CONST_DOUBLE or CONST_INT for a value specified as a pair of ints.
1949 For an integer, I0 is the low-order word and I1 is the high-order word.
1950 For a real number, I0 is the word with the low address
1951 and I1 is the word with the high address. */
1952
1953 rtx
1954 immed_double_const (i0, i1, mode)
1955 HOST_WIDE_INT i0, i1;
1956 enum machine_mode mode;
1957 {
1958 register rtx r;
1959
1960 if (GET_MODE_CLASS (mode) == MODE_INT
1961 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1962 {
1963 /* We clear out all bits that don't belong in MODE, unless they and our
1964 sign bit are all one. So we get either a reasonable negative value
1965 or a reasonable unsigned value for this mode. */
1966 int width = GET_MODE_BITSIZE (mode);
1967 if (width < HOST_BITS_PER_WIDE_INT
1968 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
1969 != ((HOST_WIDE_INT) (-1) << (width - 1))))
1970 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
1971 else if (width == HOST_BITS_PER_WIDE_INT
1972 && ! (i1 == ~0 && i0 < 0))
1973 i1 = 0;
1974 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
1975 /* We cannot represent this value as a constant. */
1976 abort ();
1977
1978 /* If this would be an entire word for the target, but is not for
1979 the host, then sign-extend on the host so that the number will look
1980 the same way on the host that it would on the target.
1981
1982 For example, when building a 64 bit alpha hosted 32 bit sparc
1983 targeted compiler, then we want the 32 bit unsigned value -1 to be
1984 represented as a 64 bit value -1, and not as 0x00000000ffffffff.
1985 The later confuses the sparc backend. */
1986
1987 if (width < HOST_BITS_PER_WIDE_INT
1988 && (i0 & ((HOST_WIDE_INT) 1 << (width - 1))))
1989 i0 |= ((HOST_WIDE_INT) (-1) << width);
1990
1991 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
1992
1993 ??? Strictly speaking, this is wrong if we create a CONST_INT
1994 for a large unsigned constant with the size of MODE being
1995 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
1996 wider mode. In that case we will mis-interpret it as a negative
1997 number.
1998
1999 Unfortunately, the only alternative is to make a CONST_DOUBLE
2000 for any constant in any mode if it is an unsigned constant larger
2001 than the maximum signed integer in an int on the host. However,
2002 doing this will break everyone that always expects to see a CONST_INT
2003 for SImode and smaller.
2004
2005 We have always been making CONST_INTs in this case, so nothing new
2006 is being broken. */
2007
2008 if (width <= HOST_BITS_PER_WIDE_INT)
2009 i1 = (i0 < 0) ? ~(HOST_WIDE_INT) 0 : 0;
2010
2011 /* If this integer fits in one word, return a CONST_INT. */
2012 if ((i1 == 0 && i0 >= 0)
2013 || (i1 == ~0 && i0 < 0))
2014 return GEN_INT (i0);
2015
2016 /* We use VOIDmode for integers. */
2017 mode = VOIDmode;
2018 }
2019
2020 /* Search the chain for an existing CONST_DOUBLE with the right value.
2021 If one is found, return it. */
2022 if (cfun != 0)
2023 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2024 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
2025 && GET_MODE (r) == mode)
2026 return r;
2027
2028 /* No; make a new one and add it to the chain. */
2029 r = gen_rtx_CONST_DOUBLE (mode, const0_rtx, i0, i1);
2030
2031 /* Don't touch const_double_chain if not inside any function. */
2032 if (current_function_decl != 0)
2033 {
2034 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2035 const_double_chain = r;
2036 }
2037
2038 return r;
2039 }
2040
2041 /* Return a CONST_DOUBLE for a specified `double' value
2042 and machine mode. */
2043
2044 rtx
2045 immed_real_const_1 (d, mode)
2046 REAL_VALUE_TYPE d;
2047 enum machine_mode mode;
2048 {
2049 union real_extract u;
2050 register rtx r;
2051
2052 /* Get the desired `double' value as a sequence of ints
2053 since that is how they are stored in a CONST_DOUBLE. */
2054
2055 u.d = d;
2056
2057 /* Detect special cases. But be careful we don't use a CONST_DOUBLE
2058 that's from a parent function since it may be in its constant pool. */
2059 if (REAL_VALUES_IDENTICAL (dconst0, d)
2060 && (cfun == 0 || decl_function_context (current_function_decl) == 0))
2061 return CONST0_RTX (mode);
2062
2063 /* Check for NaN first, because some ports (specifically the i386) do not
2064 emit correct ieee-fp code by default, and thus will generate a core
2065 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
2066 does a floating point comparison. */
2067 else if ((! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
2068 && (cfun == 0
2069 || decl_function_context (current_function_decl) == 0))
2070 return CONST1_RTX (mode);
2071
2072 if (sizeof u == sizeof (HOST_WIDE_INT))
2073 return immed_double_const (u.i[0], 0, mode);
2074 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
2075 return immed_double_const (u.i[0], u.i[1], mode);
2076
2077 /* The rest of this function handles the case where
2078 a float value requires more than 2 ints of space.
2079 It will be deleted as dead code on machines that don't need it. */
2080
2081 /* Search the chain for an existing CONST_DOUBLE with the right value.
2082 If one is found, return it. */
2083 if (cfun != 0)
2084 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
2085 if (! memcmp ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u)
2086 && GET_MODE (r) == mode)
2087 return r;
2088
2089 /* No; make a new one and add it to the chain.
2090
2091 We may be called by an optimizer which may be discarding any memory
2092 allocated during its processing (such as combine and loop). However,
2093 we will be leaving this constant on the chain, so we cannot tolerate
2094 freed memory. */
2095 r = rtx_alloc (CONST_DOUBLE);
2096 PUT_MODE (r, mode);
2097 memcpy ((char *) &CONST_DOUBLE_LOW (r), (char *) &u, sizeof u);
2098
2099 /* If we aren't inside a function, don't put r on the
2100 const_double_chain. */
2101 if (current_function_decl != 0)
2102 {
2103 CONST_DOUBLE_CHAIN (r) = const_double_chain;
2104 const_double_chain = r;
2105 }
2106 else
2107 CONST_DOUBLE_CHAIN (r) = NULL_RTX;
2108
2109 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
2110 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
2111 is only through force_const_mem. */
2112
2113 CONST_DOUBLE_MEM (r) = const0_rtx;
2114
2115 return r;
2116 }
2117
2118 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
2119 which must be a REAL_CST tree node. */
2120
2121 rtx
2122 immed_real_const (exp)
2123 tree exp;
2124 {
2125 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
2126 }
2127
2128 /* At the end of a function, forget the memory-constants
2129 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
2130 Also clear out real_constant_chain and clear out all the chain-pointers. */
2131
2132 void
2133 clear_const_double_mem ()
2134 {
2135 register rtx r, next;
2136
2137 for (r = const_double_chain; r; r = next)
2138 {
2139 next = CONST_DOUBLE_CHAIN (r);
2140 CONST_DOUBLE_CHAIN (r) = 0;
2141 CONST_DOUBLE_MEM (r) = cc0_rtx;
2142 }
2143 const_double_chain = 0;
2144 }
2145 \f
2146 /* Given an expression EXP with a constant value,
2147 reduce it to the sum of an assembler symbol and an integer.
2148 Store them both in the structure *VALUE.
2149 Abort if EXP does not reduce. */
2150
2151 struct addr_const
2152 {
2153 rtx base;
2154 HOST_WIDE_INT offset;
2155 };
2156
2157 static void
2158 decode_addr_const (exp, value)
2159 tree exp;
2160 struct addr_const *value;
2161 {
2162 register tree target = TREE_OPERAND (exp, 0);
2163 register int offset = 0;
2164 register rtx x;
2165
2166 while (1)
2167 {
2168 if (TREE_CODE (target) == COMPONENT_REF
2169 && host_integerp (byte_position (TREE_OPERAND (target, 1)), 0))
2170
2171 {
2172 offset += int_byte_position (TREE_OPERAND (target, 1));
2173 target = TREE_OPERAND (target, 0);
2174 }
2175 else if (TREE_CODE (target) == ARRAY_REF)
2176 {
2177 offset += (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (target)), 1)
2178 * tree_low_cst (TREE_OPERAND (target, 1), 0));
2179 target = TREE_OPERAND (target, 0);
2180 }
2181 else
2182 break;
2183 }
2184
2185 switch (TREE_CODE (target))
2186 {
2187 case VAR_DECL:
2188 case FUNCTION_DECL:
2189 x = DECL_RTL (target);
2190 break;
2191
2192 case LABEL_DECL:
2193 x = gen_rtx_MEM (FUNCTION_MODE,
2194 gen_rtx_LABEL_REF (VOIDmode,
2195 label_rtx (TREE_OPERAND (exp, 0))));
2196 break;
2197
2198 case REAL_CST:
2199 case STRING_CST:
2200 case COMPLEX_CST:
2201 case CONSTRUCTOR:
2202 case INTEGER_CST:
2203 x = TREE_CST_RTL (target);
2204 break;
2205
2206 default:
2207 abort ();
2208 }
2209
2210 if (GET_CODE (x) != MEM)
2211 abort ();
2212 x = XEXP (x, 0);
2213
2214 value->base = x;
2215 value->offset = offset;
2216 }
2217 \f
2218 enum kind { RTX_DOUBLE, RTX_INT };
2219 struct rtx_const
2220 {
2221 ENUM_BITFIELD(kind) kind : 16;
2222 ENUM_BITFIELD(machine_mode) mode : 16;
2223 union {
2224 union real_extract du;
2225 struct addr_const addr;
2226 struct {HOST_WIDE_INT high, low;} di;
2227 } un;
2228 };
2229
2230 /* Uniquize all constants that appear in memory.
2231 Each constant in memory thus far output is recorded
2232 in `const_hash_table' with a `struct constant_descriptor'
2233 that contains a polish representation of the value of
2234 the constant.
2235
2236 We cannot store the trees in the hash table
2237 because the trees may be temporary. */
2238
2239 struct constant_descriptor
2240 {
2241 struct constant_descriptor *next;
2242 const char *label;
2243 rtx rtl;
2244 /* Make sure the data is reasonably aligned. */
2245 union
2246 {
2247 unsigned char contents[1];
2248 #ifdef HAVE_LONG_DOUBLE
2249 long double d;
2250 #else
2251 double d;
2252 #endif
2253 } u;
2254 };
2255
2256 #define HASHBITS 30
2257 #define MAX_HASH_TABLE 1009
2258 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
2259
2260 #define STRHASH(x) ((hashval_t)((long)(x) >> 3))
2261
2262 struct deferred_string
2263 {
2264 const char *label;
2265 tree exp;
2266 int labelno;
2267 };
2268
2269 static htab_t const_str_htab;
2270
2271 /* Mark a const_hash_table descriptor for GC. */
2272
2273 static void
2274 mark_const_hash_entry (ptr)
2275 void *ptr;
2276 {
2277 struct constant_descriptor *desc = * (struct constant_descriptor **) ptr;
2278
2279 while (desc)
2280 {
2281 ggc_mark_rtx (desc->rtl);
2282 desc = desc->next;
2283 }
2284 }
2285
2286 /* Mark the hash-table element X (which is really a pointer to an
2287 struct deferred_string *). */
2288
2289 static int
2290 mark_const_str_htab_1 (x, data)
2291 void **x;
2292 void *data ATTRIBUTE_UNUSED;
2293 {
2294 ggc_mark_tree (((struct deferred_string *) *x)->exp);
2295 return 1;
2296 }
2297
2298 /* Mark a const_str_htab for GC. */
2299
2300 static void
2301 mark_const_str_htab (htab)
2302 void *htab;
2303 {
2304 htab_traverse (*((htab_t *) htab), mark_const_str_htab_1, NULL);
2305 }
2306
2307 /* Returns a hash code for X (which is a really a
2308 struct deferred_string *). */
2309
2310 static hashval_t
2311 const_str_htab_hash (x)
2312 const void *x;
2313 {
2314 return STRHASH (((const struct deferred_string *) x)->label);
2315 }
2316
2317 /* Returns non-zero if the value represented by X (which is really a
2318 struct deferred_string *) is the same as that given by Y
2319 (which is really a char *). */
2320
2321 static int
2322 const_str_htab_eq (x, y)
2323 const void *x;
2324 const void *y;
2325 {
2326 return (((const struct deferred_string *) x)->label == (const char *) y);
2327 }
2328
2329 /* Delete the hash table entry dfsp. */
2330
2331 static void
2332 const_str_htab_del (dfsp)
2333 void *dfsp;
2334 {
2335 free (dfsp);
2336 }
2337
2338 /* Compute a hash code for a constant expression. */
2339
2340 static int
2341 const_hash (exp)
2342 tree exp;
2343 {
2344 register const char *p;
2345 register int len, hi, i;
2346 register enum tree_code code = TREE_CODE (exp);
2347
2348 /* Either set P and LEN to the address and len of something to hash and
2349 exit the switch or return a value. */
2350
2351 switch (code)
2352 {
2353 case INTEGER_CST:
2354 p = (char *) &TREE_INT_CST (exp);
2355 len = sizeof TREE_INT_CST (exp);
2356 break;
2357
2358 case REAL_CST:
2359 p = (char *) &TREE_REAL_CST (exp);
2360 len = sizeof TREE_REAL_CST (exp);
2361 break;
2362
2363 case STRING_CST:
2364 p = TREE_STRING_POINTER (exp);
2365 len = TREE_STRING_LENGTH (exp);
2366 break;
2367
2368 case COMPLEX_CST:
2369 return (const_hash (TREE_REALPART (exp)) * 5
2370 + const_hash (TREE_IMAGPART (exp)));
2371
2372 case CONSTRUCTOR:
2373 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2374 {
2375 char *tmp;
2376
2377 len = int_size_in_bytes (TREE_TYPE (exp));
2378 tmp = (char *) alloca (len);
2379 get_set_constructor_bytes (exp, (unsigned char *) tmp, len);
2380 p = tmp;
2381 break;
2382 }
2383 else
2384 {
2385 register tree link;
2386
2387 /* For record type, include the type in the hashing.
2388 We do not do so for array types
2389 because (1) the sizes of the elements are sufficient
2390 and (2) distinct array types can have the same constructor.
2391 Instead, we include the array size because the constructor could
2392 be shorter. */
2393 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2394 hi = ((unsigned long) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
2395 % MAX_HASH_TABLE;
2396 else
2397 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
2398 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
2399
2400 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2401 if (TREE_VALUE (link))
2402 hi
2403 = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
2404
2405 return hi;
2406 }
2407
2408 case ADDR_EXPR:
2409 {
2410 struct addr_const value;
2411
2412 decode_addr_const (exp, &value);
2413 if (GET_CODE (value.base) == SYMBOL_REF)
2414 {
2415 /* Don't hash the address of the SYMBOL_REF;
2416 only use the offset and the symbol name. */
2417 hi = value.offset;
2418 p = XSTR (value.base, 0);
2419 for (i = 0; p[i] != 0; i++)
2420 hi = ((hi * 613) + (unsigned) (p[i]));
2421 }
2422 else if (GET_CODE (value.base) == LABEL_REF)
2423 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2424 else
2425 abort();
2426
2427 hi &= (1 << HASHBITS) - 1;
2428 hi %= MAX_HASH_TABLE;
2429 }
2430 return hi;
2431
2432 case PLUS_EXPR:
2433 case MINUS_EXPR:
2434 return (const_hash (TREE_OPERAND (exp, 0)) * 9
2435 + const_hash (TREE_OPERAND (exp, 1)));
2436
2437 case NOP_EXPR:
2438 case CONVERT_EXPR:
2439 case NON_LVALUE_EXPR:
2440 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2441
2442 default:
2443 /* A language specific constant. Just hash the code. */
2444 return (int) code % MAX_HASH_TABLE;
2445 }
2446
2447 /* Compute hashing function */
2448 hi = len;
2449 for (i = 0; i < len; i++)
2450 hi = ((hi * 613) + (unsigned) (p[i]));
2451
2452 hi &= (1 << HASHBITS) - 1;
2453 hi %= MAX_HASH_TABLE;
2454 return hi;
2455 }
2456 \f
2457 /* Compare a constant expression EXP with a constant-descriptor DESC.
2458 Return 1 if DESC describes a constant with the same value as EXP. */
2459
2460 static int
2461 compare_constant (exp, desc)
2462 tree exp;
2463 struct constant_descriptor *desc;
2464 {
2465 return 0 != compare_constant_1 (exp, desc->u.contents);
2466 }
2467
2468 /* Compare constant expression EXP with a substring P of a constant descriptor.
2469 If they match, return a pointer to the end of the substring matched.
2470 If they do not match, return 0.
2471
2472 Since descriptors are written in polish prefix notation,
2473 this function can be used recursively to test one operand of EXP
2474 against a subdescriptor, and if it succeeds it returns the
2475 address of the subdescriptor for the next operand. */
2476
2477 static const unsigned char *
2478 compare_constant_1 (exp, p)
2479 tree exp;
2480 const unsigned char *p;
2481 {
2482 register const unsigned char *strp;
2483 register int len;
2484 register enum tree_code code = TREE_CODE (exp);
2485
2486 if (code != (enum tree_code) *p++)
2487 return 0;
2488
2489 /* Either set STRP, P and LEN to pointers and length to compare and exit the
2490 switch, or return the result of the comparison. */
2491
2492 switch (code)
2493 {
2494 case INTEGER_CST:
2495 /* Integer constants are the same only if the same width of type. */
2496 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2497 return 0;
2498
2499 strp = (unsigned char *) &TREE_INT_CST (exp);
2500 len = sizeof TREE_INT_CST (exp);
2501 break;
2502
2503 case REAL_CST:
2504 /* Real constants are the same only if the same width of type. */
2505 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2506 return 0;
2507
2508 strp = (unsigned char *) &TREE_REAL_CST (exp);
2509 len = sizeof TREE_REAL_CST (exp);
2510 break;
2511
2512 case STRING_CST:
2513 if (flag_writable_strings)
2514 return 0;
2515
2516 if ((enum machine_mode) *p++ != TYPE_MODE (TREE_TYPE (exp)))
2517 return 0;
2518
2519 strp = (const unsigned char *)TREE_STRING_POINTER (exp);
2520 len = TREE_STRING_LENGTH (exp);
2521 if (memcmp ((char *) &TREE_STRING_LENGTH (exp), p,
2522 sizeof TREE_STRING_LENGTH (exp)))
2523 return 0;
2524
2525 p += sizeof TREE_STRING_LENGTH (exp);
2526 break;
2527
2528 case COMPLEX_CST:
2529 p = compare_constant_1 (TREE_REALPART (exp), p);
2530 if (p == 0)
2531 return 0;
2532
2533 return compare_constant_1 (TREE_IMAGPART (exp), p);
2534
2535 case CONSTRUCTOR:
2536 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2537 {
2538 int xlen = len = int_size_in_bytes (TREE_TYPE (exp));
2539 unsigned char *tmp = (unsigned char *) alloca (len);
2540
2541 get_set_constructor_bytes (exp, tmp, len);
2542 strp = (unsigned char *) tmp;
2543 if (memcmp ((char *) &xlen, p, sizeof xlen))
2544 return 0;
2545
2546 p += sizeof xlen;
2547 break;
2548 }
2549 else
2550 {
2551 register tree link;
2552 int length = list_length (CONSTRUCTOR_ELTS (exp));
2553 tree type;
2554 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2555 int have_purpose = 0;
2556
2557 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2558 if (TREE_PURPOSE (link))
2559 have_purpose = 1;
2560
2561 if (memcmp ((char *) &length, p, sizeof length))
2562 return 0;
2563
2564 p += sizeof length;
2565
2566 /* For record constructors, insist that the types match.
2567 For arrays, just verify both constructors are for arrays.
2568 Then insist that either both or none have any TREE_PURPOSE
2569 values. */
2570 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2571 type = TREE_TYPE (exp);
2572 else
2573 type = 0;
2574
2575 if (memcmp ((char *) &type, p, sizeof type))
2576 return 0;
2577
2578 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2579 {
2580 if (memcmp ((char *) &mode, p, sizeof mode))
2581 return 0;
2582
2583 p += sizeof mode;
2584 }
2585
2586 p += sizeof type;
2587
2588 if (memcmp ((char *) &have_purpose, p, sizeof have_purpose))
2589 return 0;
2590
2591 p += sizeof have_purpose;
2592
2593 /* For arrays, insist that the size in bytes match. */
2594 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2595 {
2596 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2597
2598 if (memcmp ((char *) &size, p, sizeof size))
2599 return 0;
2600
2601 p += sizeof size;
2602 }
2603
2604 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2605 {
2606 if (TREE_VALUE (link))
2607 {
2608 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2609 return 0;
2610 }
2611 else
2612 {
2613 tree zero = 0;
2614
2615 if (memcmp ((char *) &zero, p, sizeof zero))
2616 return 0;
2617
2618 p += sizeof zero;
2619 }
2620
2621 if (TREE_PURPOSE (link)
2622 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2623 {
2624 if (memcmp ((char *) &TREE_PURPOSE (link), p,
2625 sizeof TREE_PURPOSE (link)))
2626 return 0;
2627
2628 p += sizeof TREE_PURPOSE (link);
2629 }
2630 else if (TREE_PURPOSE (link))
2631 {
2632 if ((p = compare_constant_1 (TREE_PURPOSE (link), p)) == 0)
2633 return 0;
2634 }
2635 else if (have_purpose)
2636 {
2637 int zero = 0;
2638
2639 if (memcmp ((char *) &zero, p, sizeof zero))
2640 return 0;
2641
2642 p += sizeof zero;
2643 }
2644 }
2645
2646 return p;
2647 }
2648
2649 case ADDR_EXPR:
2650 {
2651 struct addr_const value;
2652
2653 decode_addr_const (exp, &value);
2654 strp = (unsigned char *) &value.offset;
2655 len = sizeof value.offset;
2656 /* Compare the offset. */
2657 while (--len >= 0)
2658 if (*p++ != *strp++)
2659 return 0;
2660
2661 /* Compare symbol name. */
2662 strp = (const unsigned char *) XSTR (value.base, 0);
2663 len = strlen ((const char *) strp) + 1;
2664 }
2665 break;
2666
2667 case PLUS_EXPR:
2668 case MINUS_EXPR:
2669 case RANGE_EXPR:
2670 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2671 if (p == 0)
2672 return 0;
2673
2674 return compare_constant_1 (TREE_OPERAND (exp, 1), p);
2675
2676 case NOP_EXPR:
2677 case CONVERT_EXPR:
2678 case NON_LVALUE_EXPR:
2679 return compare_constant_1 (TREE_OPERAND (exp, 0), p);
2680
2681 default:
2682 if (lang_expand_constant)
2683 {
2684 exp = (*lang_expand_constant) (exp);
2685 return compare_constant_1 (exp, p);
2686 }
2687 return 0;
2688 }
2689
2690 /* Compare constant contents. */
2691 while (--len >= 0)
2692 if (*p++ != *strp++)
2693 return 0;
2694
2695 return p;
2696 }
2697 \f
2698 /* Construct a constant descriptor for the expression EXP.
2699 It is up to the caller to enter the descriptor in the hash table. */
2700
2701 static struct constant_descriptor *
2702 record_constant (exp)
2703 tree exp;
2704 {
2705 struct constant_descriptor *next = 0;
2706 char *label = 0;
2707 rtx rtl = 0;
2708 int pad;
2709
2710 /* Make a struct constant_descriptor. The first three pointers will
2711 be filled in later. Here we just leave space for them. */
2712
2713 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2714 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2715 obstack_grow (&permanent_obstack, (char *) &rtl, sizeof rtl);
2716
2717 /* Align the descriptor for the data payload. */
2718 pad = (offsetof (struct constant_descriptor, u)
2719 - offsetof(struct constant_descriptor, rtl)
2720 - sizeof(next->rtl));
2721 if (pad > 0)
2722 obstack_blank (&permanent_obstack, pad);
2723
2724 record_constant_1 (exp);
2725 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2726 }
2727
2728 /* Add a description of constant expression EXP
2729 to the object growing in `permanent_obstack'.
2730 No need to return its address; the caller will get that
2731 from the obstack when the object is complete. */
2732
2733 static void
2734 record_constant_1 (exp)
2735 tree exp;
2736 {
2737 register const unsigned char *strp;
2738 register int len;
2739 register enum tree_code code = TREE_CODE (exp);
2740
2741 obstack_1grow (&permanent_obstack, (unsigned int) code);
2742
2743 switch (code)
2744 {
2745 case INTEGER_CST:
2746 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2747 strp = (unsigned char *) &TREE_INT_CST (exp);
2748 len = sizeof TREE_INT_CST (exp);
2749 break;
2750
2751 case REAL_CST:
2752 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2753 strp = (unsigned char *) &TREE_REAL_CST (exp);
2754 len = sizeof TREE_REAL_CST (exp);
2755 break;
2756
2757 case STRING_CST:
2758 if (flag_writable_strings)
2759 return;
2760
2761 obstack_1grow (&permanent_obstack, TYPE_MODE (TREE_TYPE (exp)));
2762 strp = (const unsigned char *) TREE_STRING_POINTER (exp);
2763 len = TREE_STRING_LENGTH (exp);
2764 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2765 sizeof TREE_STRING_LENGTH (exp));
2766 break;
2767
2768 case COMPLEX_CST:
2769 record_constant_1 (TREE_REALPART (exp));
2770 record_constant_1 (TREE_IMAGPART (exp));
2771 return;
2772
2773 case CONSTRUCTOR:
2774 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
2775 {
2776 int nbytes = int_size_in_bytes (TREE_TYPE (exp));
2777 obstack_grow (&permanent_obstack, &nbytes, sizeof (nbytes));
2778 obstack_blank (&permanent_obstack, nbytes);
2779 get_set_constructor_bytes
2780 (exp, (unsigned char *) permanent_obstack.next_free-nbytes,
2781 nbytes);
2782 return;
2783 }
2784 else
2785 {
2786 register tree link;
2787 int length = list_length (CONSTRUCTOR_ELTS (exp));
2788 enum machine_mode mode = TYPE_MODE (TREE_TYPE (exp));
2789 tree type;
2790 int have_purpose = 0;
2791
2792 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2793 if (TREE_PURPOSE (link))
2794 have_purpose = 1;
2795
2796 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2797
2798 /* For record constructors, insist that the types match.
2799 For arrays, just verify both constructors are for arrays
2800 of the same mode. Then insist that either both or none
2801 have any TREE_PURPOSE values. */
2802 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2803 type = TREE_TYPE (exp);
2804 else
2805 type = 0;
2806
2807 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2808 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2809 obstack_grow (&permanent_obstack, &mode, sizeof mode);
2810
2811 obstack_grow (&permanent_obstack, (char *) &have_purpose,
2812 sizeof have_purpose);
2813
2814 /* For arrays, insist that the size in bytes match. */
2815 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2816 {
2817 HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
2818 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2819 }
2820
2821 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2822 {
2823 if (TREE_VALUE (link))
2824 record_constant_1 (TREE_VALUE (link));
2825 else
2826 {
2827 tree zero = 0;
2828
2829 obstack_grow (&permanent_obstack,
2830 (char *) &zero, sizeof zero);
2831 }
2832
2833 if (TREE_PURPOSE (link)
2834 && TREE_CODE (TREE_PURPOSE (link)) == FIELD_DECL)
2835 obstack_grow (&permanent_obstack,
2836 (char *) &TREE_PURPOSE (link),
2837 sizeof TREE_PURPOSE (link));
2838 else if (TREE_PURPOSE (link))
2839 record_constant_1 (TREE_PURPOSE (link));
2840 else if (have_purpose)
2841 {
2842 int zero = 0;
2843
2844 obstack_grow (&permanent_obstack,
2845 (char *) &zero, sizeof zero);
2846 }
2847 }
2848 }
2849 return;
2850
2851 case ADDR_EXPR:
2852 {
2853 struct addr_const value;
2854
2855 decode_addr_const (exp, &value);
2856 /* Record the offset. */
2857 obstack_grow (&permanent_obstack,
2858 (char *) &value.offset, sizeof value.offset);
2859
2860 switch (GET_CODE (value.base))
2861 {
2862 case SYMBOL_REF:
2863 /* Record the symbol name. */
2864 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2865 strlen (XSTR (value.base, 0)) + 1);
2866 break;
2867 case LABEL_REF:
2868 /* Record the address of the CODE_LABEL. It may not have
2869 been emitted yet, so it's UID may be zero. But pointer
2870 identity is good enough. */
2871 obstack_grow (&permanent_obstack, &XEXP (value.base, 0),
2872 sizeof (rtx));
2873 break;
2874 default:
2875 abort ();
2876 }
2877 }
2878 return;
2879
2880 case PLUS_EXPR:
2881 case MINUS_EXPR:
2882 case RANGE_EXPR:
2883 record_constant_1 (TREE_OPERAND (exp, 0));
2884 record_constant_1 (TREE_OPERAND (exp, 1));
2885 return;
2886
2887 case NOP_EXPR:
2888 case CONVERT_EXPR:
2889 case NON_LVALUE_EXPR:
2890 record_constant_1 (TREE_OPERAND (exp, 0));
2891 return;
2892
2893 default:
2894 if (lang_expand_constant)
2895 {
2896 exp = (*lang_expand_constant) (exp);
2897 record_constant_1 (exp);
2898 }
2899 return;
2900 }
2901
2902 /* Record constant contents. */
2903 obstack_grow (&permanent_obstack, strp, len);
2904 }
2905 \f
2906 /* Record a list of constant expressions that were passed to
2907 output_constant_def but that could not be output right away. */
2908
2909 struct deferred_constant
2910 {
2911 struct deferred_constant *next;
2912 tree exp;
2913 int reloc;
2914 int labelno;
2915 };
2916
2917 static struct deferred_constant *deferred_constants;
2918
2919 /* Another list of constants which should be output after the
2920 function. */
2921 static struct deferred_constant *after_function_constants;
2922
2923 /* Nonzero means defer output of addressed subconstants
2924 (i.e., those for which output_constant_def is called.) */
2925 static int defer_addressed_constants_flag;
2926
2927 /* Start deferring output of subconstants. */
2928
2929 void
2930 defer_addressed_constants ()
2931 {
2932 defer_addressed_constants_flag++;
2933 }
2934
2935 /* Stop deferring output of subconstants,
2936 and output now all those that have been deferred. */
2937
2938 void
2939 output_deferred_addressed_constants ()
2940 {
2941 struct deferred_constant *p, *next;
2942
2943 defer_addressed_constants_flag--;
2944
2945 if (defer_addressed_constants_flag > 0)
2946 return;
2947
2948 for (p = deferred_constants; p; p = next)
2949 {
2950 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2951 next = p->next;
2952 free (p);
2953 }
2954
2955 deferred_constants = 0;
2956 }
2957
2958 /* Output any constants which should appear after a function. */
2959
2960 static void
2961 output_after_function_constants ()
2962 {
2963 struct deferred_constant *p, *next;
2964
2965 for (p = after_function_constants; p; p = next)
2966 {
2967 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2968 next = p->next;
2969 free (p);
2970 }
2971
2972 after_function_constants = 0;
2973 }
2974
2975 /* Make a copy of the whole tree structure for a constant.
2976 This handles the same types of nodes that compare_constant
2977 and record_constant handle. */
2978
2979 static tree
2980 copy_constant (exp)
2981 tree exp;
2982 {
2983 switch (TREE_CODE (exp))
2984 {
2985 case ADDR_EXPR:
2986 /* For ADDR_EXPR, we do not want to copy the decl whose address
2987 is requested. We do want to copy constants though. */
2988 if (TREE_CODE_CLASS (TREE_CODE (TREE_OPERAND (exp, 0))) == 'c')
2989 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
2990 copy_constant (TREE_OPERAND (exp, 0)));
2991 else
2992 return copy_node (exp);
2993
2994 case INTEGER_CST:
2995 case REAL_CST:
2996 case STRING_CST:
2997 return copy_node (exp);
2998
2999 case COMPLEX_CST:
3000 return build_complex (TREE_TYPE (exp),
3001 copy_constant (TREE_REALPART (exp)),
3002 copy_constant (TREE_IMAGPART (exp)));
3003
3004 case PLUS_EXPR:
3005 case MINUS_EXPR:
3006 return build (TREE_CODE (exp), TREE_TYPE (exp),
3007 copy_constant (TREE_OPERAND (exp, 0)),
3008 copy_constant (TREE_OPERAND (exp, 1)));
3009
3010 case NOP_EXPR:
3011 case CONVERT_EXPR:
3012 case NON_LVALUE_EXPR:
3013 return build1 (TREE_CODE (exp), TREE_TYPE (exp),
3014 copy_constant (TREE_OPERAND (exp, 0)));
3015
3016 case CONSTRUCTOR:
3017 {
3018 tree copy = copy_node (exp);
3019 tree list = copy_list (CONSTRUCTOR_ELTS (exp));
3020 tree tail;
3021
3022 CONSTRUCTOR_ELTS (copy) = list;
3023 for (tail = list; tail; tail = TREE_CHAIN (tail))
3024 TREE_VALUE (tail) = copy_constant (TREE_VALUE (tail));
3025 if (TREE_CODE (TREE_TYPE (exp)) == SET_TYPE)
3026 for (tail = list; tail; tail = TREE_CHAIN (tail))
3027 TREE_PURPOSE (tail) = copy_constant (TREE_PURPOSE (tail));
3028
3029 return copy;
3030 }
3031
3032 default:
3033 abort ();
3034 }
3035 }
3036 \f
3037 /* Return an rtx representing a reference to constant data in memory
3038 for the constant expression EXP.
3039
3040 If assembler code for such a constant has already been output,
3041 return an rtx to refer to it.
3042 Otherwise, output such a constant in memory (or defer it for later)
3043 and generate an rtx for it.
3044
3045 If DEFER is non-zero, the output of string constants can be deferred
3046 and output only if referenced in the function after all optimizations.
3047
3048 The TREE_CST_RTL of EXP is set up to point to that rtx.
3049 The const_hash_table records which constants already have label strings. */
3050
3051 rtx
3052 output_constant_def (exp, defer)
3053 tree exp;
3054 int defer;
3055 {
3056 register int hash;
3057 register struct constant_descriptor *desc;
3058 struct deferred_string **defstr;
3059 char label[256];
3060 int reloc;
3061 int found = 1;
3062 int after_function = 0;
3063 int labelno = -1;
3064
3065 if (TREE_CST_RTL (exp))
3066 return TREE_CST_RTL (exp);
3067
3068 /* Make sure any other constants whose addresses appear in EXP
3069 are assigned label numbers. */
3070
3071 reloc = output_addressed_constants (exp);
3072
3073 /* Compute hash code of EXP. Search the descriptors for that hash code
3074 to see if any of them describes EXP. If yes, the descriptor records
3075 the label number already assigned. */
3076
3077 hash = const_hash (exp) % MAX_HASH_TABLE;
3078
3079 for (desc = const_hash_table[hash]; desc; desc = desc->next)
3080 if (compare_constant (exp, desc))
3081 break;
3082
3083 if (desc == 0)
3084 {
3085 /* No constant equal to EXP is known to have been output.
3086 Make a constant descriptor to enter EXP in the hash table.
3087 Assign the label number and record it in the descriptor for
3088 future calls to this function to find. */
3089
3090 /* Create a string containing the label name, in LABEL. */
3091 labelno = const_labelno++;
3092 ASM_GENERATE_INTERNAL_LABEL (label, "LC", labelno);
3093
3094 desc = record_constant (exp);
3095 desc->next = const_hash_table[hash];
3096 desc->label = ggc_strdup (label);
3097 const_hash_table[hash] = desc;
3098
3099 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3100 desc->rtl
3101 = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (exp)),
3102 gen_rtx_SYMBOL_REF (Pmode, desc->label));
3103
3104 set_mem_attributes (desc->rtl, exp, 1);
3105
3106 found = 0;
3107 }
3108
3109 TREE_CST_RTL (exp) = desc->rtl;
3110
3111 /* Optionally set flags or add text to the name to record information
3112 such as that it is a function name. If the name is changed, the macro
3113 ASM_OUTPUT_LABELREF will have to know how to strip this information. */
3114 #ifdef ENCODE_SECTION_INFO
3115 /* A previously-processed constant would already have section info
3116 encoded in it. */
3117 if (! found)
3118 {
3119 ENCODE_SECTION_INFO (exp);
3120 desc->rtl = TREE_CST_RTL (exp);
3121 desc->label = XSTR (XEXP (desc->rtl, 0), 0);
3122 }
3123 #endif
3124
3125 #ifdef CONSTANT_AFTER_FUNCTION_P
3126 if (current_function_decl != 0
3127 && CONSTANT_AFTER_FUNCTION_P (exp))
3128 after_function = 1;
3129 #endif
3130
3131 if (found
3132 && STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0))
3133 && (!defer || defer_addressed_constants_flag || after_function))
3134 {
3135 defstr = (struct deferred_string **)
3136 htab_find_slot_with_hash (const_str_htab, desc->label,
3137 STRHASH (desc->label), NO_INSERT);
3138 if (defstr)
3139 {
3140 /* If the string is currently deferred but we need to output it now,
3141 remove it from deferred string hash table. */
3142 found = 0;
3143 labelno = (*defstr)->labelno;
3144 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 0;
3145 htab_clear_slot (const_str_htab, (void **) defstr);
3146 }
3147 }
3148
3149 /* If this is the first time we've seen this particular constant,
3150 output it (or defer its output for later). */
3151 if (! found)
3152 {
3153 if (defer_addressed_constants_flag || after_function)
3154 {
3155 struct deferred_constant *p;
3156 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
3157
3158 p->exp = copy_constant (exp);
3159 p->reloc = reloc;
3160 p->labelno = labelno;
3161 if (after_function)
3162 {
3163 p->next = after_function_constants;
3164 after_function_constants = p;
3165 }
3166 else
3167 {
3168 p->next = deferred_constants;
3169 deferred_constants = p;
3170 }
3171 }
3172 else
3173 {
3174 /* Do no output if -fsyntax-only. */
3175 if (! flag_syntax_only)
3176 {
3177 if (TREE_CODE (exp) != STRING_CST
3178 || !defer
3179 || flag_writable_strings
3180 || (defstr = (struct deferred_string **)
3181 htab_find_slot_with_hash (const_str_htab,
3182 desc->label,
3183 STRHASH (desc->label),
3184 INSERT)) == NULL)
3185 output_constant_def_contents (exp, reloc, labelno);
3186 else
3187 {
3188 struct deferred_string *p;
3189
3190 p = (struct deferred_string *)
3191 xmalloc (sizeof (struct deferred_string));
3192
3193 p->exp = copy_constant (exp);
3194 p->label = desc->label;
3195 p->labelno = labelno;
3196 *defstr = p;
3197 STRING_POOL_ADDRESS_P (XEXP (desc->rtl, 0)) = 1;
3198 }
3199 }
3200 }
3201 }
3202
3203 return TREE_CST_RTL (exp);
3204 }
3205
3206 /* Now output assembler code to define the label for EXP,
3207 and follow it with the data of EXP. */
3208
3209 static void
3210 output_constant_def_contents (exp, reloc, labelno)
3211 tree exp;
3212 int reloc;
3213 int labelno;
3214 {
3215 int align;
3216
3217 if (IN_NAMED_SECTION (exp))
3218 named_section (exp, NULL, reloc);
3219 else
3220 {
3221 /* First switch to text section, except for writable strings. */
3222 #ifdef SELECT_SECTION
3223 SELECT_SECTION (exp, reloc);
3224 #else
3225 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
3226 || (flag_pic && reloc))
3227 data_section ();
3228 else
3229 readonly_data_section ();
3230 #endif
3231 }
3232
3233 /* Align the location counter as required by EXP's data type. */
3234 align = TYPE_ALIGN (TREE_TYPE (exp));
3235 #ifdef CONSTANT_ALIGNMENT
3236 align = CONSTANT_ALIGNMENT (exp, align);
3237 #endif
3238
3239 if (align > BITS_PER_UNIT)
3240 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
3241
3242 /* Output the label itself. */
3243 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
3244
3245 /* Output the value of EXP. */
3246 output_constant (exp,
3247 (TREE_CODE (exp) == STRING_CST
3248 ? TREE_STRING_LENGTH (exp)
3249 : int_size_in_bytes (TREE_TYPE (exp))));
3250
3251 }
3252 \f
3253 /* Structure to represent sufficient information about a constant so that
3254 it can be output when the constant pool is output, so that function
3255 integration can be done, and to simplify handling on machines that reference
3256 constant pool as base+displacement. */
3257
3258 struct pool_constant
3259 {
3260 struct constant_descriptor *desc;
3261 struct pool_constant *next, *next_sym;
3262 const char *label;
3263 rtx constant;
3264 enum machine_mode mode;
3265 int labelno;
3266 int align;
3267 int offset;
3268 int mark;
3269 };
3270
3271 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
3272 The argument is XSTR (... , 0) */
3273
3274 #define SYMHASH(LABEL) \
3275 ((((unsigned long) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
3276 \f
3277 /* Initialize constant pool hashing for a new function. */
3278
3279 void
3280 init_varasm_status (f)
3281 struct function *f;
3282 {
3283 struct varasm_status *p;
3284 p = (struct varasm_status *) xmalloc (sizeof (struct varasm_status));
3285 f->varasm = p;
3286 p->x_const_rtx_hash_table
3287 = ((struct constant_descriptor **)
3288 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct constant_descriptor *)));
3289 p->x_const_rtx_sym_hash_table
3290 = ((struct pool_constant **)
3291 xcalloc (MAX_RTX_HASH_TABLE, sizeof (struct pool_constant *)));
3292
3293 p->x_first_pool = p->x_last_pool = 0;
3294 p->x_pool_offset = 0;
3295 p->x_const_double_chain = 0;
3296 }
3297
3298 /* Mark PC for GC. */
3299
3300 static void
3301 mark_pool_constant (pc)
3302 struct pool_constant *pc;
3303 {
3304 while (pc)
3305 {
3306 ggc_mark (pc);
3307 ggc_mark_rtx (pc->constant);
3308 pc = pc->next;
3309 }
3310 }
3311
3312 /* Mark P for GC. */
3313
3314 void
3315 mark_varasm_status (p)
3316 struct varasm_status *p;
3317 {
3318 if (p == NULL)
3319 return;
3320
3321 mark_pool_constant (p->x_first_pool);
3322 ggc_mark_rtx (p->x_const_double_chain);
3323 }
3324
3325 /* Clear out all parts of the state in F that can safely be discarded
3326 after the function has been compiled, to let garbage collection
3327 reclaim the memory. */
3328
3329 void
3330 free_varasm_status (f)
3331 struct function *f;
3332 {
3333 struct varasm_status *p;
3334 int i;
3335
3336 p = f->varasm;
3337
3338 /* Clear out the hash tables. */
3339 for (i = 0; i < MAX_RTX_HASH_TABLE; ++i)
3340 {
3341 struct constant_descriptor* cd;
3342
3343 cd = p->x_const_rtx_hash_table[i];
3344 while (cd) {
3345 struct constant_descriptor* next = cd->next;
3346 free (cd);
3347 cd = next;
3348 }
3349 }
3350
3351 free (p->x_const_rtx_hash_table);
3352 free (p->x_const_rtx_sym_hash_table);
3353 free (p);
3354 f->varasm = NULL;
3355 }
3356 \f
3357
3358 /* Express an rtx for a constant integer (perhaps symbolic)
3359 as the sum of a symbol or label plus an explicit integer.
3360 They are stored into VALUE. */
3361
3362 static void
3363 decode_rtx_const (mode, x, value)
3364 enum machine_mode mode;
3365 rtx x;
3366 struct rtx_const *value;
3367 {
3368 /* Clear the whole structure, including any gaps. */
3369 memset (value, 0, sizeof (struct rtx_const));
3370
3371 value->kind = RTX_INT; /* Most usual kind. */
3372 value->mode = mode;
3373
3374 switch (GET_CODE (x))
3375 {
3376 case CONST_DOUBLE:
3377 value->kind = RTX_DOUBLE;
3378 if (GET_MODE (x) != VOIDmode)
3379 {
3380 value->mode = GET_MODE (x);
3381 memcpy ((char *) &value->un.du,
3382 (char *) &CONST_DOUBLE_LOW (x), sizeof value->un.du);
3383 }
3384 else
3385 {
3386 value->un.di.low = CONST_DOUBLE_LOW (x);
3387 value->un.di.high = CONST_DOUBLE_HIGH (x);
3388 }
3389 break;
3390
3391 case CONST_INT:
3392 value->un.addr.offset = INTVAL (x);
3393 break;
3394
3395 case SYMBOL_REF:
3396 case LABEL_REF:
3397 case PC:
3398 value->un.addr.base = x;
3399 break;
3400
3401 case CONST:
3402 x = XEXP (x, 0);
3403 if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3404 {
3405 value->un.addr.base = XEXP (x, 0);
3406 value->un.addr.offset = INTVAL (XEXP (x, 1));
3407 }
3408 else if (GET_CODE (x) == MINUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
3409 {
3410 value->un.addr.base = XEXP (x, 0);
3411 value->un.addr.offset = - INTVAL (XEXP (x, 1));
3412 }
3413 else
3414 {
3415 value->un.addr.base = x;
3416 value->un.addr.offset = 0;
3417 }
3418 break;
3419
3420 default:
3421 abort ();
3422 }
3423
3424 if (value->kind == RTX_INT && value->un.addr.base != 0)
3425 switch (GET_CODE (value->un.addr.base))
3426 {
3427 case SYMBOL_REF:
3428 /* Use the string's address, not the SYMBOL_REF's address,
3429 for the sake of addresses of library routines. */
3430 value->un.addr.base = (rtx) XSTR (value->un.addr.base, 0);
3431 break;
3432
3433 case LABEL_REF:
3434 /* For a LABEL_REF, compare labels. */
3435 value->un.addr.base = XEXP (value->un.addr.base, 0);
3436
3437 default:
3438 break;
3439 }
3440 }
3441
3442 /* Given a MINUS expression, simplify it if both sides
3443 include the same symbol. */
3444
3445 rtx
3446 simplify_subtraction (x)
3447 rtx x;
3448 {
3449 struct rtx_const val0, val1;
3450
3451 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
3452 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
3453
3454 if (val0.un.addr.base == val1.un.addr.base)
3455 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
3456 return x;
3457 }
3458
3459 /* Compute a hash code for a constant RTL expression. */
3460
3461 static int
3462 const_hash_rtx (mode, x)
3463 enum machine_mode mode;
3464 rtx x;
3465 {
3466 register int hi;
3467 register size_t i;
3468
3469 struct rtx_const value;
3470 decode_rtx_const (mode, x, &value);
3471
3472 /* Compute hashing function */
3473 hi = 0;
3474 for (i = 0; i < sizeof value / sizeof (int); i++)
3475 hi += ((int *) &value)[i];
3476
3477 hi &= (1 << HASHBITS) - 1;
3478 hi %= MAX_RTX_HASH_TABLE;
3479 return hi;
3480 }
3481
3482 /* Compare a constant rtl object X with a constant-descriptor DESC.
3483 Return 1 if DESC describes a constant with the same value as X. */
3484
3485 static int
3486 compare_constant_rtx (mode, x, desc)
3487 enum machine_mode mode;
3488 rtx x;
3489 struct constant_descriptor *desc;
3490 {
3491 register int *p = (int *) desc->u.contents;
3492 register int *strp;
3493 register int len;
3494 struct rtx_const value;
3495
3496 decode_rtx_const (mode, x, &value);
3497 strp = (int *) &value;
3498 len = sizeof value / sizeof (int);
3499
3500 /* Compare constant contents. */
3501 while (--len >= 0)
3502 if (*p++ != *strp++)
3503 return 0;
3504
3505 return 1;
3506 }
3507
3508 /* Construct a constant descriptor for the rtl-expression X.
3509 It is up to the caller to enter the descriptor in the hash table. */
3510
3511 static struct constant_descriptor *
3512 record_constant_rtx (mode, x)
3513 enum machine_mode mode;
3514 rtx x;
3515 {
3516 struct constant_descriptor *ptr;
3517
3518 ptr = ((struct constant_descriptor *)
3519 xcalloc (1, (offsetof (struct constant_descriptor, u)
3520 + sizeof (struct rtx_const))));
3521 decode_rtx_const (mode, x, (struct rtx_const *) ptr->u.contents);
3522
3523 return ptr;
3524 }
3525 \f
3526 /* Given a constant rtx X, make (or find) a memory constant for its value
3527 and return a MEM rtx to refer to it in memory. */
3528
3529 rtx
3530 force_const_mem (mode, x)
3531 enum machine_mode mode;
3532 rtx x;
3533 {
3534 register int hash;
3535 register struct constant_descriptor *desc;
3536 char label[256];
3537 const char *found = 0;
3538 rtx def;
3539
3540 /* If we want this CONST_DOUBLE in the same mode as it is in memory
3541 (this will always be true for floating CONST_DOUBLEs that have been
3542 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
3543 use the previous copy. Otherwise, make a new one. Note that in
3544 the unlikely event that this same CONST_DOUBLE is used in two different
3545 modes in an alternating fashion, we will allocate a lot of different
3546 memory locations, but this should be extremely rare. */
3547
3548 if (GET_CODE (x) == CONST_DOUBLE
3549 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
3550 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
3551 return CONST_DOUBLE_MEM (x);
3552
3553 /* Compute hash code of X. Search the descriptors for that hash code
3554 to see if any of them describes X. If yes, the descriptor records
3555 the label number already assigned. */
3556
3557 hash = const_hash_rtx (mode, x);
3558
3559 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
3560 if (compare_constant_rtx (mode, x, desc))
3561 {
3562 found = desc->label;
3563 break;
3564 }
3565
3566 if (found == 0)
3567 {
3568 register struct pool_constant *pool;
3569 int align;
3570
3571 /* No constant equal to X is known to have been output.
3572 Make a constant descriptor to enter X in the hash table.
3573 Assign the label number and record it in the descriptor for
3574 future calls to this function to find. */
3575
3576 desc = record_constant_rtx (mode, x);
3577 desc->next = const_rtx_hash_table[hash];
3578 const_rtx_hash_table[hash] = desc;
3579
3580 /* Align the location counter as required by EXP's data type. */
3581 align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
3582 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
3583 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
3584 #ifdef CONSTANT_ALIGNMENT
3585 align = CONSTANT_ALIGNMENT (make_tree (type_for_mode (mode, 0), x),
3586 align * BITS_PER_UNIT) / BITS_PER_UNIT;
3587 #endif
3588
3589 pool_offset += align - 1;
3590 pool_offset &= ~ (align - 1);
3591
3592 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
3593
3594 pool = (struct pool_constant *) ggc_alloc (sizeof (struct pool_constant));
3595 pool->desc = desc;
3596 pool->constant = x;
3597 pool->mode = mode;
3598 pool->labelno = const_labelno;
3599 pool->align = align;
3600 pool->offset = pool_offset;
3601 pool->mark = 1;
3602 pool->next = 0;
3603
3604 if (last_pool == 0)
3605 first_pool = pool;
3606 else
3607 last_pool->next = pool;
3608
3609 last_pool = pool;
3610 pool_offset += GET_MODE_SIZE (mode);
3611
3612 /* Create a string containing the label name, in LABEL. */
3613 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
3614
3615 ++const_labelno;
3616
3617 desc->label = found = ggc_strdup (label);
3618
3619 /* Add label to symbol hash table. */
3620 hash = SYMHASH (found);
3621 pool->label = found;
3622 pool->next_sym = const_rtx_sym_hash_table[hash];
3623 const_rtx_sym_hash_table[hash] = pool;
3624 }
3625
3626 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
3627
3628 def = gen_rtx_MEM (mode, gen_rtx_SYMBOL_REF (Pmode, found));
3629 set_mem_attributes (def, type_for_mode (mode, 0), 1);
3630 RTX_UNCHANGING_P (def) = 1;
3631
3632 /* Mark the symbol_ref as belonging to this constants pool. */
3633 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
3634 current_function_uses_const_pool = 1;
3635
3636 if (GET_CODE (x) == CONST_DOUBLE)
3637 {
3638 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
3639 {
3640 CONST_DOUBLE_CHAIN (x) = const_double_chain;
3641 const_double_chain = x;
3642 }
3643 CONST_DOUBLE_MEM (x) = def;
3644 }
3645
3646 return def;
3647 }
3648 \f
3649 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
3650 the corresponding pool_constant structure. */
3651
3652 static struct pool_constant *
3653 find_pool_constant (f, addr)
3654 struct function *f;
3655 rtx addr;
3656 {
3657 struct pool_constant *pool;
3658 const char *label = XSTR (addr, 0);
3659
3660 for (pool = f->varasm->x_const_rtx_sym_hash_table[SYMHASH (label)]; pool;
3661 pool = pool->next_sym)
3662 if (pool->label == label)
3663 return pool;
3664
3665 abort ();
3666 }
3667
3668 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
3669
3670 rtx
3671 get_pool_constant (addr)
3672 rtx addr;
3673 {
3674 return (find_pool_constant (cfun, addr))->constant;
3675 }
3676
3677 /* Likewise, but for the constant pool of a specific function. */
3678
3679 rtx
3680 get_pool_constant_for_function (f, addr)
3681 struct function *f;
3682 rtx addr;
3683 {
3684 return (find_pool_constant (f, addr))->constant;
3685 }
3686
3687 /* Similar, return the mode. */
3688
3689 enum machine_mode
3690 get_pool_mode (addr)
3691 rtx addr;
3692 {
3693 return (find_pool_constant (cfun, addr))->mode;
3694 }
3695
3696 enum machine_mode
3697 get_pool_mode_for_function (f, addr)
3698 struct function *f;
3699 rtx addr;
3700 {
3701 return (find_pool_constant (f, addr))->mode;
3702 }
3703
3704 /* Similar, return the offset in the constant pool. */
3705
3706 int
3707 get_pool_offset (addr)
3708 rtx addr;
3709 {
3710 return (find_pool_constant (cfun, addr))->offset;
3711 }
3712
3713 /* Return the size of the constant pool. */
3714
3715 int
3716 get_pool_size ()
3717 {
3718 return pool_offset;
3719 }
3720 \f
3721 /* Write all the constants in the constant pool. */
3722
3723 void
3724 output_constant_pool (fnname, fndecl)
3725 const char *fnname ATTRIBUTE_UNUSED;
3726 tree fndecl ATTRIBUTE_UNUSED;
3727 {
3728 struct pool_constant *pool;
3729 rtx x;
3730 union real_extract u;
3731
3732 /* It is possible for gcc to call force_const_mem and then to later
3733 discard the instructions which refer to the constant. In such a
3734 case we do not need to output the constant. */
3735 mark_constant_pool ();
3736
3737 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3738 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3739 #endif
3740
3741 for (pool = first_pool; pool; pool = pool->next)
3742 {
3743 rtx tmp;
3744
3745 x = pool->constant;
3746
3747 if (! pool->mark)
3748 continue;
3749
3750 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3751 whose CODE_LABEL has been deleted. This can occur if a jump table
3752 is eliminated by optimization. If so, write a constant of zero
3753 instead. Note that this can also happen by turning the
3754 CODE_LABEL into a NOTE. */
3755 /* ??? This seems completely and utterly wrong. Certainly it's
3756 not true for NOTE_INSN_DELETED_LABEL, but I disbelieve proper
3757 functioning even with INSN_DELETED_P and friends. */
3758
3759 tmp = x;
3760 switch (GET_CODE (x))
3761 {
3762 case CONST:
3763 if (GET_CODE (XEXP (x, 0)) != PLUS
3764 || GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
3765 break;
3766 tmp = XEXP (XEXP (x, 0), 0);
3767 /* FALLTHRU */
3768
3769 case LABEL_REF:
3770 tmp = XEXP (x, 0);
3771 if (INSN_DELETED_P (tmp)
3772 || (GET_CODE (tmp) == NOTE
3773 && NOTE_LINE_NUMBER (tmp) == NOTE_INSN_DELETED))
3774 {
3775 abort ();
3776 x = const0_rtx;
3777 }
3778 break;
3779
3780 default:
3781 break;
3782 }
3783
3784 /* First switch to correct section. */
3785 #ifdef SELECT_RTX_SECTION
3786 SELECT_RTX_SECTION (pool->mode, x);
3787 #else
3788 readonly_data_section ();
3789 #endif
3790
3791 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3792 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3793 pool->align, pool->labelno, done);
3794 #endif
3795
3796 if (pool->align > 1)
3797 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (pool->align));
3798
3799 /* Output the label. */
3800 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3801
3802 /* Output the value of the constant itself. */
3803 switch (GET_MODE_CLASS (pool->mode))
3804 {
3805 case MODE_FLOAT:
3806 if (GET_CODE (x) != CONST_DOUBLE)
3807 abort ();
3808
3809 memcpy ((char *) &u, (char *) &CONST_DOUBLE_LOW (x), sizeof u);
3810 assemble_real (u.d, pool->mode);
3811 break;
3812
3813 case MODE_INT:
3814 case MODE_PARTIAL_INT:
3815 assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3816 break;
3817
3818 default:
3819 abort ();
3820 }
3821
3822 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3823 done: ;
3824 #endif
3825
3826 }
3827
3828 #ifdef ASM_OUTPUT_POOL_EPILOGUE
3829 ASM_OUTPUT_POOL_EPILOGUE (asm_out_file, fnname, fndecl, pool_offset);
3830 #endif
3831
3832 /* Done with this pool. */
3833 first_pool = last_pool = 0;
3834 }
3835
3836 /* Look through the instructions for this function, and mark all the
3837 entries in the constant pool which are actually being used.
3838 Emit used deferred strings. */
3839
3840 static void
3841 mark_constant_pool ()
3842 {
3843 register rtx insn;
3844 struct pool_constant *pool;
3845
3846 if (first_pool == 0 && htab_elements (const_str_htab) == 0)
3847 return;
3848
3849 for (pool = first_pool; pool; pool = pool->next)
3850 pool->mark = 0;
3851
3852 for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3853 if (INSN_P (insn))
3854 mark_constants (PATTERN (insn));
3855
3856 for (insn = current_function_epilogue_delay_list;
3857 insn;
3858 insn = XEXP (insn, 1))
3859 if (INSN_P (insn))
3860 mark_constants (PATTERN (insn));
3861 }
3862
3863 /* Look through appropriate parts of X, marking all entries in the
3864 constant pool which are actually being used. Entries that are only
3865 referenced by other constants are also marked as used. Emit
3866 deferred strings that are used. */
3867
3868 static void
3869 mark_constants (x)
3870 rtx x;
3871 {
3872 register int i;
3873 register const char *format_ptr;
3874
3875 if (x == 0)
3876 return;
3877
3878 if (GET_CODE (x) == SYMBOL_REF)
3879 {
3880 mark_constant (&x, NULL);
3881 return;
3882 }
3883 /* Never search inside a CONST_DOUBLE, because CONST_DOUBLE_MEM may be
3884 a MEM, but does not constitute a use of that MEM. */
3885 else if (GET_CODE (x) == CONST_DOUBLE)
3886 return;
3887
3888 /* Insns may appear inside a SEQUENCE. Only check the patterns of
3889 insns, not any notes that may be attached. We don't want to mark
3890 a constant just because it happens to appear in a REG_EQUIV note. */
3891 if (INSN_P (x))
3892 {
3893 mark_constants (PATTERN (x));
3894 return;
3895 }
3896
3897 format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3898
3899 for (i = 0; i < GET_RTX_LENGTH (GET_CODE (x)); i++)
3900 {
3901 switch (*format_ptr++)
3902 {
3903 case 'e':
3904 mark_constants (XEXP (x, i));
3905 break;
3906
3907 case 'E':
3908 if (XVEC (x, i) != 0)
3909 {
3910 register int j;
3911
3912 for (j = 0; j < XVECLEN (x, i); j++)
3913 mark_constants (XVECEXP (x, i, j));
3914 }
3915 break;
3916
3917 case 'S':
3918 case 's':
3919 case '0':
3920 case 'i':
3921 case 'w':
3922 case 'n':
3923 case 'u':
3924 break;
3925
3926 default:
3927 abort ();
3928 }
3929 }
3930 }
3931
3932 /* Given a SYMBOL_REF CURRENT_RTX, mark it and all constants it refers
3933 to as used. Emit referenced deferred strings. This function can
3934 be used with for_each_rtx () to mark all SYMBOL_REFs in an rtx. */
3935
3936 static int
3937 mark_constant (current_rtx, data)
3938 rtx *current_rtx;
3939 void *data ATTRIBUTE_UNUSED;
3940 {
3941 rtx x = *current_rtx;
3942
3943 if (x == NULL_RTX)
3944 return 0;
3945 else if (GET_CODE(x) == CONST_DOUBLE)
3946 /* Never search inside a CONST_DOUBLE because CONST_DOUBLE_MEM may
3947 be a MEM but does not constitute a use of that MEM. */
3948 return -1;
3949 else if (GET_CODE (x) == SYMBOL_REF)
3950 {
3951 if (CONSTANT_POOL_ADDRESS_P (x))
3952 {
3953 struct pool_constant *pool = find_pool_constant (cfun, x);
3954 if (pool->mark == 0) {
3955 pool->mark = 1;
3956 for_each_rtx (&(pool->constant), &mark_constant, NULL);
3957 }
3958 else
3959 return -1;
3960 }
3961 else if (STRING_POOL_ADDRESS_P (x))
3962 {
3963 struct deferred_string **defstr;
3964
3965 defstr = (struct deferred_string **)
3966 htab_find_slot_with_hash (const_str_htab, XSTR (x, 0),
3967 STRHASH (XSTR (x, 0)), NO_INSERT);
3968 if (defstr)
3969 {
3970 struct deferred_string *p = *defstr;
3971
3972 STRING_POOL_ADDRESS_P (x) = 0;
3973 output_constant_def_contents (p->exp, 0, p->labelno);
3974 htab_clear_slot (const_str_htab, (void **) defstr);
3975 }
3976 }
3977 }
3978 return 0;
3979 }
3980 \f
3981 /* Find all the constants whose addresses are referenced inside of EXP,
3982 and make sure assembler code with a label has been output for each one.
3983 Indicate whether an ADDR_EXPR has been encountered. */
3984
3985 static int
3986 output_addressed_constants (exp)
3987 tree exp;
3988 {
3989 int reloc = 0;
3990
3991 /* Give the front-end a chance to convert VALUE to something that
3992 looks more like a constant to the back-end. */
3993 if (lang_expand_constant)
3994 exp = (*lang_expand_constant) (exp);
3995
3996 switch (TREE_CODE (exp))
3997 {
3998 case ADDR_EXPR:
3999 {
4000 register tree constant = TREE_OPERAND (exp, 0);
4001
4002 while (TREE_CODE (constant) == COMPONENT_REF)
4003 {
4004 constant = TREE_OPERAND (constant, 0);
4005 }
4006
4007 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
4008 || TREE_CODE (constant) == CONSTRUCTOR)
4009 /* No need to do anything here
4010 for addresses of variables or functions. */
4011 output_constant_def (constant, 0);
4012 }
4013 reloc = 1;
4014 break;
4015
4016 case PLUS_EXPR:
4017 case MINUS_EXPR:
4018 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4019 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
4020 break;
4021
4022 case NOP_EXPR:
4023 case CONVERT_EXPR:
4024 case NON_LVALUE_EXPR:
4025 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
4026 break;
4027
4028 case CONSTRUCTOR:
4029 {
4030 register tree link;
4031 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
4032 if (TREE_VALUE (link) != 0)
4033 reloc |= output_addressed_constants (TREE_VALUE (link));
4034 }
4035 break;
4036
4037 default:
4038 break;
4039 }
4040 return reloc;
4041 }
4042 \f
4043 /* Return nonzero if VALUE is a valid constant-valued expression
4044 for use in initializing a static variable; one that can be an
4045 element of a "constant" initializer.
4046
4047 Return null_pointer_node if the value is absolute;
4048 if it is relocatable, return the variable that determines the relocation.
4049 We assume that VALUE has been folded as much as possible;
4050 therefore, we do not need to check for such things as
4051 arithmetic-combinations of integers. */
4052
4053 tree
4054 initializer_constant_valid_p (value, endtype)
4055 tree value;
4056 tree endtype;
4057 {
4058 /* Give the front-end a chance to convert VALUE to something that
4059 looks more like a constant to the back-end. */
4060 if (lang_expand_constant)
4061 value = (*lang_expand_constant) (value);
4062
4063 switch (TREE_CODE (value))
4064 {
4065 case CONSTRUCTOR:
4066 if ((TREE_CODE (TREE_TYPE (value)) == UNION_TYPE
4067 || TREE_CODE (TREE_TYPE (value)) == RECORD_TYPE)
4068 && TREE_CONSTANT (value)
4069 && CONSTRUCTOR_ELTS (value))
4070 return
4071 initializer_constant_valid_p (TREE_VALUE (CONSTRUCTOR_ELTS (value)),
4072 endtype);
4073
4074 return TREE_STATIC (value) ? null_pointer_node : 0;
4075
4076 case INTEGER_CST:
4077 case REAL_CST:
4078 case STRING_CST:
4079 case COMPLEX_CST:
4080 return null_pointer_node;
4081
4082 case ADDR_EXPR:
4083 return staticp (TREE_OPERAND (value, 0)) ? TREE_OPERAND (value, 0) : 0;
4084
4085 case NON_LVALUE_EXPR:
4086 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4087
4088 case CONVERT_EXPR:
4089 case NOP_EXPR:
4090 /* Allow conversions between pointer types. */
4091 if (POINTER_TYPE_P (TREE_TYPE (value))
4092 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4093 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4094
4095 /* Allow conversions between real types. */
4096 if (FLOAT_TYPE_P (TREE_TYPE (value))
4097 && FLOAT_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4098 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4099
4100 /* Allow length-preserving conversions between integer types. */
4101 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4102 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4103 && (TYPE_PRECISION (TREE_TYPE (value))
4104 == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4105 return initializer_constant_valid_p (TREE_OPERAND (value, 0), endtype);
4106
4107 /* Allow conversions between other integer types only if
4108 explicit value. */
4109 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4110 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4111 {
4112 tree inner = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4113 endtype);
4114 if (inner == null_pointer_node)
4115 return null_pointer_node;
4116 break;
4117 }
4118
4119 /* Allow (int) &foo provided int is as wide as a pointer. */
4120 if (INTEGRAL_TYPE_P (TREE_TYPE (value))
4121 && POINTER_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0)))
4122 && (TYPE_PRECISION (TREE_TYPE (value))
4123 >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0)))))
4124 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4125 endtype);
4126
4127 /* Likewise conversions from int to pointers, but also allow
4128 conversions from 0. */
4129 if (POINTER_TYPE_P (TREE_TYPE (value))
4130 && INTEGRAL_TYPE_P (TREE_TYPE (TREE_OPERAND (value, 0))))
4131 {
4132 if (integer_zerop (TREE_OPERAND (value, 0)))
4133 return null_pointer_node;
4134 else if (TYPE_PRECISION (TREE_TYPE (value))
4135 <= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (value, 0))))
4136 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4137 endtype);
4138 }
4139
4140 /* Allow conversions to union types if the value inside is okay. */
4141 if (TREE_CODE (TREE_TYPE (value)) == UNION_TYPE)
4142 return initializer_constant_valid_p (TREE_OPERAND (value, 0),
4143 endtype);
4144 break;
4145
4146 case PLUS_EXPR:
4147 if (! INTEGRAL_TYPE_P (endtype)
4148 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4149 {
4150 tree valid0 = initializer_constant_valid_p (TREE_OPERAND (value, 0),
4151 endtype);
4152 tree valid1 = initializer_constant_valid_p (TREE_OPERAND (value, 1),
4153 endtype);
4154 /* If either term is absolute, use the other terms relocation. */
4155 if (valid0 == null_pointer_node)
4156 return valid1;
4157 if (valid1 == null_pointer_node)
4158 return valid0;
4159 }
4160 break;
4161
4162 case MINUS_EXPR:
4163 if (! INTEGRAL_TYPE_P (endtype)
4164 || TYPE_PRECISION (endtype) >= POINTER_SIZE)
4165 {
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 /* Win if second argument is absolute. */
4171 if (valid1 == null_pointer_node)
4172 return valid0;
4173 /* Win if both arguments have the same relocation.
4174 Then the value is absolute. */
4175 if (valid0 == valid1 && valid0 != 0)
4176 return null_pointer_node;
4177
4178 /* Since GCC guarantees that string constants are unique in the
4179 generated code, a subtraction between two copies of the same
4180 constant string is absolute. */
4181 if (valid0 && TREE_CODE (valid0) == STRING_CST &&
4182 valid1 && TREE_CODE (valid1) == STRING_CST &&
4183 TREE_STRING_POINTER (valid0) == TREE_STRING_POINTER (valid1))
4184 return null_pointer_node;
4185 }
4186
4187 /* Support differences between labels. */
4188 if (INTEGRAL_TYPE_P (endtype))
4189 {
4190 tree op0, op1;
4191 op0 = TREE_OPERAND (value, 0);
4192 op1 = TREE_OPERAND (value, 1);
4193 STRIP_NOPS (op0);
4194 STRIP_NOPS (op1);
4195
4196 if (TREE_CODE (op0) == ADDR_EXPR
4197 && TREE_CODE (TREE_OPERAND (op0, 0)) == LABEL_DECL
4198 && TREE_CODE (op1) == ADDR_EXPR
4199 && TREE_CODE (TREE_OPERAND (op1, 0)) == LABEL_DECL)
4200 return null_pointer_node;
4201 }
4202 break;
4203
4204 default:
4205 break;
4206 }
4207
4208 return 0;
4209 }
4210 \f
4211 /* Output assembler code for constant EXP to FILE, with no label.
4212 This includes the pseudo-op such as ".int" or ".byte", and a newline.
4213 Assumes output_addressed_constants has been done on EXP already.
4214
4215 Generate exactly SIZE bytes of assembler data, padding at the end
4216 with zeros if necessary. SIZE must always be specified.
4217
4218 SIZE is important for structure constructors,
4219 since trailing members may have been omitted from the constructor.
4220 It is also important for initialization of arrays from string constants
4221 since the full length of the string constant might not be wanted.
4222 It is also needed for initialization of unions, where the initializer's
4223 type is just one member, and that may not be as long as the union.
4224
4225 There a case in which we would fail to output exactly SIZE bytes:
4226 for a structure constructor that wants to produce more than SIZE bytes.
4227 But such constructors will never be generated for any possible input. */
4228
4229 void
4230 output_constant (exp, size)
4231 register tree exp;
4232 register int size;
4233 {
4234 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
4235
4236 /* Some front-ends use constants other than the standard
4237 language-indepdent varieties, but which may still be output
4238 directly. Give the front-end a chance to convert EXP to a
4239 language-independent representation. */
4240 if (lang_expand_constant)
4241 {
4242 exp = (*lang_expand_constant) (exp);
4243 code = TREE_CODE (TREE_TYPE (exp));
4244 }
4245
4246 if (size == 0 || flag_syntax_only)
4247 return;
4248
4249 /* Eliminate the NON_LVALUE_EXPR_EXPR that makes a cast not be an lvalue.
4250 That way we get the constant (we hope) inside it. Also, strip off any
4251 NOP_EXPR that converts between two record, union, array, or set types
4252 or a CONVERT_EXPR that converts to a union TYPE. */
4253 while ((TREE_CODE (exp) == NOP_EXPR
4254 && (TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0))
4255 || AGGREGATE_TYPE_P (TREE_TYPE (exp))))
4256 || (TREE_CODE (exp) == CONVERT_EXPR
4257 && code == UNION_TYPE)
4258 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4259 {
4260 exp = TREE_OPERAND (exp, 0);
4261 code = TREE_CODE (TREE_TYPE (exp));
4262 }
4263
4264 /* Allow a constructor with no elements for any data type.
4265 This means to fill the space with zeros. */
4266 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
4267 {
4268 assemble_zeros (size);
4269 return;
4270 }
4271
4272 switch (code)
4273 {
4274 case CHAR_TYPE:
4275 case BOOLEAN_TYPE:
4276 case INTEGER_TYPE:
4277 case ENUMERAL_TYPE:
4278 case POINTER_TYPE:
4279 case REFERENCE_TYPE:
4280 /* ??? What about (int)((float)(int)&foo + 4) */
4281 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
4282 || TREE_CODE (exp) == NON_LVALUE_EXPR)
4283 exp = TREE_OPERAND (exp, 0);
4284
4285 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
4286 EXPAND_INITIALIZER),
4287 size, 0))
4288 error ("initializer for integer value is too complicated");
4289 size = 0;
4290 break;
4291
4292 case REAL_TYPE:
4293 if (TREE_CODE (exp) != REAL_CST)
4294 error ("initializer for floating value is not a floating constant");
4295
4296 assemble_real (TREE_REAL_CST (exp),
4297 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
4298 size = 0;
4299 break;
4300
4301 case COMPLEX_TYPE:
4302 output_constant (TREE_REALPART (exp), size / 2);
4303 output_constant (TREE_IMAGPART (exp), size / 2);
4304 size -= (size / 2) * 2;
4305 break;
4306
4307 case ARRAY_TYPE:
4308 if (TREE_CODE (exp) == CONSTRUCTOR)
4309 {
4310 output_constructor (exp, size);
4311 return;
4312 }
4313 else if (TREE_CODE (exp) == STRING_CST)
4314 {
4315 int excess = 0;
4316
4317 if (size > TREE_STRING_LENGTH (exp))
4318 {
4319 excess = size - TREE_STRING_LENGTH (exp);
4320 size = TREE_STRING_LENGTH (exp);
4321 }
4322
4323 assemble_string (TREE_STRING_POINTER (exp), size);
4324 size = excess;
4325 }
4326 else
4327 abort ();
4328 break;
4329
4330 case RECORD_TYPE:
4331 case UNION_TYPE:
4332 if (TREE_CODE (exp) == CONSTRUCTOR)
4333 output_constructor (exp, size);
4334 else
4335 abort ();
4336 return;
4337
4338 case SET_TYPE:
4339 if (TREE_CODE (exp) == INTEGER_CST)
4340 assemble_integer (expand_expr (exp, NULL_RTX,
4341 VOIDmode, EXPAND_INITIALIZER),
4342 size, 1);
4343 else if (TREE_CODE (exp) == CONSTRUCTOR)
4344 {
4345 unsigned char *buffer = (unsigned char *) alloca (size);
4346 if (get_set_constructor_bytes (exp, buffer, size))
4347 abort ();
4348 assemble_string ((char *) buffer, size);
4349 }
4350 else
4351 error ("unknown set constructor type");
4352 return;
4353
4354 default:
4355 break; /* ??? */
4356 }
4357
4358 if (size > 0)
4359 assemble_zeros (size);
4360 }
4361
4362 \f
4363 /* Subroutine of output_constructor, used for computing the size of
4364 arrays of unspecified length. VAL must be a CONSTRUCTOR of an array
4365 type with an unspecified upper bound. */
4366
4367 static unsigned HOST_WIDE_INT
4368 array_size_for_constructor (val)
4369 tree val;
4370 {
4371 tree max_index, i;
4372
4373 max_index = NULL_TREE;
4374 for (i = CONSTRUCTOR_ELTS (val); i ; i = TREE_CHAIN (i))
4375 {
4376 tree index = TREE_PURPOSE (i);
4377
4378 if (TREE_CODE (index) == RANGE_EXPR)
4379 index = TREE_OPERAND (index, 1);
4380 if (max_index == NULL_TREE || tree_int_cst_lt (max_index, index))
4381 max_index = index;
4382 }
4383
4384 if (max_index == NULL_TREE)
4385 return 0;
4386
4387 /* Compute the total number of array elements. */
4388 i = size_binop (MINUS_EXPR, convert (sizetype, max_index),
4389 convert (sizetype,
4390 TYPE_MIN_VALUE (TYPE_DOMAIN (TREE_TYPE (val)))));
4391 i = size_binop (PLUS_EXPR, i, convert (sizetype, integer_one_node));
4392
4393 /* Multiply by the array element unit size to find number of bytes. */
4394 i = size_binop (MULT_EXPR, i, TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (val))));
4395
4396 return tree_low_cst (i, 1);
4397 }
4398
4399 /* Subroutine of output_constant, used for CONSTRUCTORs (aggregate constants).
4400 Generate at least SIZE bytes, padding if necessary. */
4401
4402 static void
4403 output_constructor (exp, size)
4404 tree exp;
4405 int size;
4406 {
4407 tree type = TREE_TYPE (exp);
4408 register tree link, field = 0;
4409 tree min_index = 0;
4410 /* Number of bytes output or skipped so far.
4411 In other words, current position within the constructor. */
4412 HOST_WIDE_INT total_bytes = 0;
4413 /* Non-zero means BYTE contains part of a byte, to be output. */
4414 int byte_buffer_in_use = 0;
4415 register int byte = 0;
4416
4417 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
4418 abort ();
4419
4420 if (TREE_CODE (type) == RECORD_TYPE)
4421 field = TYPE_FIELDS (type);
4422
4423 if (TREE_CODE (type) == ARRAY_TYPE
4424 && TYPE_DOMAIN (type) != 0)
4425 min_index = TYPE_MIN_VALUE (TYPE_DOMAIN (type));
4426
4427 /* As LINK goes through the elements of the constant,
4428 FIELD goes through the structure fields, if the constant is a structure.
4429 if the constant is a union, then we override this,
4430 by getting the field from the TREE_LIST element.
4431 But the constant could also be an array. Then FIELD is zero.
4432
4433 There is always a maximum of one element in the chain LINK for unions
4434 (even if the initializer in a source program incorrectly contains
4435 more one). */
4436 for (link = CONSTRUCTOR_ELTS (exp);
4437 link;
4438 link = TREE_CHAIN (link),
4439 field = field ? TREE_CHAIN (field) : 0)
4440 {
4441 tree val = TREE_VALUE (link);
4442 tree index = 0;
4443
4444 /* The element in a union constructor specifies the proper field
4445 or index. */
4446 if ((TREE_CODE (type) == RECORD_TYPE || TREE_CODE (type) == UNION_TYPE
4447 || TREE_CODE (type) == QUAL_UNION_TYPE)
4448 && TREE_PURPOSE (link) != 0)
4449 field = TREE_PURPOSE (link);
4450
4451 else if (TREE_CODE (type) == ARRAY_TYPE)
4452 index = TREE_PURPOSE (link);
4453
4454 /* Eliminate the marker that makes a cast not be an lvalue. */
4455 if (val != 0)
4456 STRIP_NOPS (val);
4457
4458 if (index && TREE_CODE (index) == RANGE_EXPR)
4459 {
4460 unsigned HOST_WIDE_INT fieldsize
4461 = int_size_in_bytes (TREE_TYPE (type));
4462 HOST_WIDE_INT lo_index = tree_low_cst (TREE_OPERAND (index, 0), 0);
4463 HOST_WIDE_INT hi_index = tree_low_cst (TREE_OPERAND (index, 1), 0);
4464 HOST_WIDE_INT index;
4465
4466 for (index = lo_index; index <= hi_index; index++)
4467 {
4468 /* Output the element's initial value. */
4469 if (val == 0)
4470 assemble_zeros (fieldsize);
4471 else
4472 output_constant (val, fieldsize);
4473
4474 /* Count its size. */
4475 total_bytes += fieldsize;
4476 }
4477 }
4478 else if (field == 0 || !DECL_BIT_FIELD (field))
4479 {
4480 /* An element that is not a bit-field. */
4481
4482 unsigned HOST_WIDE_INT fieldsize;
4483 /* Since this structure is static,
4484 we know the positions are constant. */
4485 HOST_WIDE_INT pos = field ? int_byte_position (field) : 0;
4486
4487 if (index != 0)
4488 pos = (tree_low_cst (TYPE_SIZE_UNIT (TREE_TYPE (val)), 1)
4489 * (tree_low_cst (index, 0) - tree_low_cst (min_index, 0)));
4490
4491 /* Output any buffered-up bit-fields preceding this element. */
4492 if (byte_buffer_in_use)
4493 {
4494 ASM_OUTPUT_BYTE (asm_out_file, byte);
4495 total_bytes++;
4496 byte_buffer_in_use = 0;
4497 }
4498
4499 /* Advance to offset of this element.
4500 Note no alignment needed in an array, since that is guaranteed
4501 if each element has the proper size. */
4502 if ((field != 0 || index != 0) && pos != total_bytes)
4503 {
4504 assemble_zeros (pos - total_bytes);
4505 total_bytes = pos;
4506 }
4507
4508 else if (field != 0 && DECL_PACKED (field))
4509 /* Some assemblers automaticallly align a datum according to its
4510 size if no align directive is specified. The datum, however,
4511 may be declared with 'packed' attribute, so we have to disable
4512 such a feature. */
4513 ASM_OUTPUT_ALIGN (asm_out_file, 0);
4514
4515 /* Determine size this element should occupy. */
4516 if (field)
4517 {
4518 fieldsize = 0;
4519
4520 /* If this is an array with an unspecified upper bound,
4521 the initializer determines the size. */
4522 /* ??? This ought to only checked if DECL_SIZE_UNIT is NULL,
4523 but we cannot do this until the deprecated support for
4524 initializing zero-length array members is removed. */
4525 if (TREE_CODE (TREE_TYPE (field)) == ARRAY_TYPE
4526 && TYPE_DOMAIN (TREE_TYPE (field))
4527 && ! TYPE_MAX_VALUE (TYPE_DOMAIN (TREE_TYPE (field))))
4528 {
4529 fieldsize = array_size_for_constructor (val);
4530 /* Given a non-empty initialization, this field had
4531 better be last. */
4532 if (fieldsize != 0 && TREE_CHAIN (field) != NULL_TREE)
4533 abort ();
4534 }
4535 else if (DECL_SIZE_UNIT (field))
4536 {
4537 /* ??? This can't be right. If the decl size overflows
4538 a host integer we will silently emit no data. */
4539 if (host_integerp (DECL_SIZE_UNIT (field), 1))
4540 fieldsize = tree_low_cst (DECL_SIZE_UNIT (field), 1);
4541 }
4542 }
4543 else
4544 fieldsize = int_size_in_bytes (TREE_TYPE (type));
4545
4546 /* Output the element's initial value. */
4547 if (val == 0)
4548 assemble_zeros (fieldsize);
4549 else
4550 output_constant (val, fieldsize);
4551
4552 /* Count its size. */
4553 total_bytes += fieldsize;
4554 }
4555 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
4556 error ("invalid initial value for member `%s'",
4557 IDENTIFIER_POINTER (DECL_NAME (field)));
4558 else
4559 {
4560 /* Element that is a bit-field. */
4561
4562 HOST_WIDE_INT next_offset = int_bit_position (field);
4563 HOST_WIDE_INT end_offset
4564 = (next_offset + tree_low_cst (DECL_SIZE (field), 1));
4565
4566 if (val == 0)
4567 val = integer_zero_node;
4568
4569 /* If this field does not start in this (or, next) byte,
4570 skip some bytes. */
4571 if (next_offset / BITS_PER_UNIT != total_bytes)
4572 {
4573 /* Output remnant of any bit field in previous bytes. */
4574 if (byte_buffer_in_use)
4575 {
4576 ASM_OUTPUT_BYTE (asm_out_file, byte);
4577 total_bytes++;
4578 byte_buffer_in_use = 0;
4579 }
4580
4581 /* If still not at proper byte, advance to there. */
4582 if (next_offset / BITS_PER_UNIT != total_bytes)
4583 {
4584 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
4585 total_bytes = next_offset / BITS_PER_UNIT;
4586 }
4587 }
4588
4589 if (! byte_buffer_in_use)
4590 byte = 0;
4591
4592 /* We must split the element into pieces that fall within
4593 separate bytes, and combine each byte with previous or
4594 following bit-fields. */
4595
4596 /* next_offset is the offset n fbits from the beginning of
4597 the structure to the next bit of this element to be processed.
4598 end_offset is the offset of the first bit past the end of
4599 this element. */
4600 while (next_offset < end_offset)
4601 {
4602 int this_time;
4603 int shift;
4604 HOST_WIDE_INT value;
4605 HOST_WIDE_INT next_byte = next_offset / BITS_PER_UNIT;
4606 HOST_WIDE_INT next_bit = next_offset % BITS_PER_UNIT;
4607
4608 /* Advance from byte to byte
4609 within this element when necessary. */
4610 while (next_byte != total_bytes)
4611 {
4612 ASM_OUTPUT_BYTE (asm_out_file, byte);
4613 total_bytes++;
4614 byte = 0;
4615 }
4616
4617 /* Number of bits we can process at once
4618 (all part of the same byte). */
4619 this_time = MIN (end_offset - next_offset,
4620 BITS_PER_UNIT - next_bit);
4621 if (BYTES_BIG_ENDIAN)
4622 {
4623 /* On big-endian machine, take the most significant bits
4624 first (of the bits that are significant)
4625 and put them into bytes from the most significant end. */
4626 shift = end_offset - next_offset - this_time;
4627
4628 /* Don't try to take a bunch of bits that cross
4629 the word boundary in the INTEGER_CST. We can
4630 only select bits from the LOW or HIGH part
4631 not from both. */
4632 if (shift < HOST_BITS_PER_WIDE_INT
4633 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4634 {
4635 this_time = shift + this_time - HOST_BITS_PER_WIDE_INT;
4636 shift = HOST_BITS_PER_WIDE_INT;
4637 }
4638
4639 /* Now get the bits from the appropriate constant word. */
4640 if (shift < HOST_BITS_PER_WIDE_INT)
4641 value = TREE_INT_CST_LOW (val);
4642 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4643 {
4644 value = TREE_INT_CST_HIGH (val);
4645 shift -= HOST_BITS_PER_WIDE_INT;
4646 }
4647 else
4648 abort ();
4649
4650 /* Get the result. This works only when:
4651 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4652 byte |= (((value >> shift)
4653 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4654 << (BITS_PER_UNIT - this_time - next_bit));
4655 }
4656 else
4657 {
4658 /* On little-endian machines,
4659 take first the least significant bits of the value
4660 and pack them starting at the least significant
4661 bits of the bytes. */
4662 shift = next_offset - int_bit_position (field);
4663
4664 /* Don't try to take a bunch of bits that cross
4665 the word boundary in the INTEGER_CST. We can
4666 only select bits from the LOW or HIGH part
4667 not from both. */
4668 if (shift < HOST_BITS_PER_WIDE_INT
4669 && shift + this_time > HOST_BITS_PER_WIDE_INT)
4670 this_time = (HOST_BITS_PER_WIDE_INT - shift);
4671
4672 /* Now get the bits from the appropriate constant word. */
4673 if (shift < HOST_BITS_PER_WIDE_INT)
4674 value = TREE_INT_CST_LOW (val);
4675 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
4676 {
4677 value = TREE_INT_CST_HIGH (val);
4678 shift -= HOST_BITS_PER_WIDE_INT;
4679 }
4680 else
4681 abort ();
4682
4683 /* Get the result. This works only when:
4684 1 <= this_time <= HOST_BITS_PER_WIDE_INT. */
4685 byte |= (((value >> shift)
4686 & (((HOST_WIDE_INT) 2 << (this_time - 1)) - 1))
4687 << next_bit);
4688 }
4689
4690 next_offset += this_time;
4691 byte_buffer_in_use = 1;
4692 }
4693 }
4694 }
4695
4696 if (byte_buffer_in_use)
4697 {
4698 ASM_OUTPUT_BYTE (asm_out_file, byte);
4699 total_bytes++;
4700 }
4701
4702 if (total_bytes < size)
4703 assemble_zeros (size - total_bytes);
4704 }
4705
4706 #ifdef HANDLE_PRAGMA_WEAK
4707 /* Add function NAME to the weak symbols list. VALUE is a weak alias
4708 associatd with NAME. */
4709
4710 int
4711 add_weak (name, value)
4712 const char *name;
4713 const char *value;
4714 {
4715 struct weak_syms *weak;
4716
4717 weak = (struct weak_syms *) permalloc (sizeof (struct weak_syms));
4718
4719 if (weak == NULL)
4720 return 0;
4721
4722 weak->next = weak_decls;
4723 weak->name = name;
4724 weak->value = value;
4725 weak_decls = weak;
4726
4727 return 1;
4728 }
4729 #endif /* HANDLE_PRAGMA_WEAK */
4730
4731 /* Declare DECL to be a weak symbol. */
4732
4733 void
4734 declare_weak (decl)
4735 tree decl;
4736 {
4737 if (! TREE_PUBLIC (decl))
4738 error_with_decl (decl, "weak declaration of `%s' must be public");
4739 else if (TREE_ASM_WRITTEN (decl))
4740 error_with_decl (decl, "weak declaration of `%s' must precede definition");
4741 else if (SUPPORTS_WEAK)
4742 DECL_WEAK (decl) = 1;
4743 #ifdef HANDLE_PRAGMA_WEAK
4744 add_weak (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), NULL);
4745 #endif
4746 }
4747
4748 /* Emit any pending weak declarations. */
4749
4750 #ifdef HANDLE_PRAGMA_WEAK
4751 struct weak_syms * weak_decls;
4752 #endif
4753
4754 void
4755 weak_finish ()
4756 {
4757 #ifdef HANDLE_PRAGMA_WEAK
4758 if (HANDLE_PRAGMA_WEAK)
4759 {
4760 struct weak_syms *t;
4761 for (t = weak_decls; t; t = t->next)
4762 {
4763 if (t->name)
4764 {
4765 ASM_WEAKEN_LABEL (asm_out_file, t->name);
4766 if (t->value)
4767 ASM_OUTPUT_DEF (asm_out_file, t->name, t->value);
4768 }
4769 }
4770 }
4771 #endif
4772 }
4773
4774 /* Remove NAME from the pending list of weak symbols. This prevents
4775 the compiler from emitting multiple .weak directives which confuses
4776 some assemblers. */
4777 #ifdef ASM_WEAKEN_LABEL
4778 static void
4779 remove_from_pending_weak_list (name)
4780 const char *name ATTRIBUTE_UNUSED;
4781 {
4782 #ifdef HANDLE_PRAGMA_WEAK
4783 if (HANDLE_PRAGMA_WEAK)
4784 {
4785 struct weak_syms *t;
4786 for (t = weak_decls; t; t = t->next)
4787 {
4788 if (t->name && strcmp (name, t->name) == 0)
4789 t->name = NULL;
4790 }
4791 }
4792 #endif
4793 }
4794 #endif
4795
4796 void
4797 assemble_alias (decl, target)
4798 tree decl, target ATTRIBUTE_UNUSED;
4799 {
4800 const char *name;
4801
4802 /* We must force creation of DECL_RTL for debug info generation, even though
4803 we don't use it here. */
4804 make_decl_rtl (decl, NULL_PTR);
4805
4806 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
4807
4808 #ifdef ASM_OUTPUT_DEF
4809 /* Make name accessible from other files, if appropriate. */
4810
4811 if (TREE_PUBLIC (decl))
4812 {
4813 #ifdef ASM_WEAKEN_LABEL
4814 if (DECL_WEAK (decl))
4815 {
4816 ASM_WEAKEN_LABEL (asm_out_file, name);
4817 /* Remove this function from the pending weak list so that
4818 we do not emit multiple .weak directives for it. */
4819 remove_from_pending_weak_list
4820 (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)));
4821 }
4822 else
4823 #endif
4824 ASM_GLOBALIZE_LABEL (asm_out_file, name);
4825 }
4826
4827 #ifdef ASM_OUTPUT_DEF_FROM_DECLS
4828 ASM_OUTPUT_DEF_FROM_DECLS (asm_out_file, decl, target);
4829 #else
4830 ASM_OUTPUT_DEF (asm_out_file, name, IDENTIFIER_POINTER (target));
4831 #endif
4832 TREE_ASM_WRITTEN (decl) = 1;
4833 #else
4834 #ifdef ASM_OUTPUT_WEAK_ALIAS
4835 if (! DECL_WEAK (decl))
4836 warning ("only weak aliases are supported in this configuration");
4837
4838 ASM_OUTPUT_WEAK_ALIAS (asm_out_file, name, IDENTIFIER_POINTER (target));
4839 TREE_ASM_WRITTEN (decl) = 1;
4840 #else
4841 warning ("alias definitions not supported in this configuration; ignored");
4842 #endif
4843 #endif
4844 }
4845
4846 /* Returns 1 if the target configuration supports defining public symbols
4847 so that one of them will be chosen at link time instead of generating a
4848 multiply-defined symbol error, whether through the use of weak symbols or
4849 a target-specific mechanism for having duplicates discarded. */
4850
4851 int
4852 supports_one_only ()
4853 {
4854 if (SUPPORTS_ONE_ONLY)
4855 return 1;
4856 return SUPPORTS_WEAK;
4857 }
4858
4859 /* Set up DECL as a public symbol that can be defined in multiple
4860 translation units without generating a linker error. */
4861
4862 void
4863 make_decl_one_only (decl)
4864 tree decl;
4865 {
4866 if (TREE_CODE (decl) != VAR_DECL && TREE_CODE (decl) != FUNCTION_DECL)
4867 abort ();
4868
4869 TREE_PUBLIC (decl) = 1;
4870
4871 if (TREE_CODE (decl) == VAR_DECL
4872 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
4873 DECL_COMMON (decl) = 1;
4874 else if (SUPPORTS_ONE_ONLY)
4875 {
4876 #ifdef MAKE_DECL_ONE_ONLY
4877 MAKE_DECL_ONE_ONLY (decl);
4878 #endif
4879 DECL_ONE_ONLY (decl) = 1;
4880 }
4881 else if (SUPPORTS_WEAK)
4882 DECL_WEAK (decl) = 1;
4883 else
4884 abort ();
4885 }
4886
4887 void
4888 init_varasm_once ()
4889 {
4890 const_str_htab = htab_create (128, const_str_htab_hash, const_str_htab_eq,
4891 const_str_htab_del);
4892 ggc_add_root (const_hash_table, MAX_HASH_TABLE, sizeof const_hash_table[0],
4893 mark_const_hash_entry);
4894 ggc_add_root (&const_str_htab, 1, sizeof const_str_htab,
4895 mark_const_str_htab);
4896 }
4897
4898 /* Extra support for EH values. */
4899 void
4900 assemble_eh_label (name)
4901 const char *name;
4902 {
4903 #ifdef ASM_OUTPUT_EH_LABEL
4904 ASM_OUTPUT_EH_LABEL (asm_out_file, name);
4905 #else
4906 assemble_label (name);
4907 #endif
4908 }
4909
4910 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
4911
4912 void
4913 assemble_eh_align (align)
4914 int align;
4915 {
4916 #ifdef ASM_OUTPUT_EH_ALIGN
4917 if (align > BITS_PER_UNIT)
4918 ASM_OUTPUT_EH_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
4919 #else
4920 assemble_align (align);
4921 #endif
4922 }
4923
4924
4925 /* On some platforms, we may want to specify a special mechansim to
4926 output EH data when generating with a function.. */
4927 int
4928 assemble_eh_integer (x, size, force)
4929 rtx x;
4930 int size;
4931 int force;
4932 {
4933
4934 switch (size)
4935 {
4936 #ifdef ASM_OUTPUT_EH_CHAR
4937 case 1:
4938 ASM_OUTPUT_EH_CHAR (asm_out_file, x);
4939 return 1;
4940 #endif
4941
4942 #ifdef ASM_OUTPUT_EH_SHORT
4943 case 2:
4944 ASM_OUTPUT_EH_SHORT (asm_out_file, x);
4945 return 1;
4946 #endif
4947
4948 #ifdef ASM_OUTPUT_EH_INT
4949 case 4:
4950 ASM_OUTPUT_EH_INT (asm_out_file, x);
4951 return 1;
4952 #endif
4953
4954 #ifdef ASM_OUTPUT_EH_DOUBLE_INT
4955 case 8:
4956 ASM_OUTPUT_EH_DOUBLE_INT (asm_out_file, x);
4957 return 1;
4958 #endif
4959
4960 default:
4961 break;
4962 }
4963 return (assemble_integer (x, size, force));
4964 }
4965
4966
4967