1 /* Output variables, constants and external declarations, for GNU compiler.
2 Copyright (C) 1987, 1988, 1989, 1992, 1993 Free Software Foundation, Inc.
4 This file is part of GNU CC.
6 GNU CC is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU CC is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU CC; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
21 /* This file handles generation of all the assembler code
22 *except* the instructions of a function.
23 This includes declarations of variables and their initial values.
25 We also output the assembler code for constants stored in memory
26 and are responsible for combining constants with the same value. */
30 /* #include <stab.h> */
37 #include "hard-reg-set.h"
45 #ifdef XCOFF_DEBUGGING_INFO
52 #define ASM_STABS_OP ".stabs"
55 /* This macro gets just the user-specified name
56 out of the string in a SYMBOL_REF. On most machines,
57 we discard the * if any and that's all. */
58 #ifndef STRIP_NAME_ENCODING
59 #define STRIP_NAME_ENCODING(VAR,SYMBOL_NAME) \
60 (VAR) = ((SYMBOL_NAME) + ((SYMBOL_NAME)[0] == '*'))
63 /* File in which assembler code is being written. */
65 extern FILE *asm_out_file;
67 /* The (assembler) name of the first globally-visible object output. */
68 char *first_global_object_name;
70 extern struct obstack *current_obstack;
71 extern struct obstack *saveable_obstack;
72 extern struct obstack permanent_obstack;
73 #define obstack_chunk_alloc xmalloc
75 /* Number for making the label on the next
76 constant that is stored in memory. */
80 /* Number for making the label on the next
81 static variable internal to a function. */
85 /* Nonzero if at least one function definition has been seen. */
86 static int function_defined;
88 extern FILE *asm_out_file;
90 static char *compare_constant_1 ();
91 static void record_constant_1 ();
92 static void output_constant_def_contents ();
93 static int contains_pointers_p ();
95 void output_constant_pool ();
96 void assemble_name ();
97 int output_addressed_constants ();
98 void output_constant ();
99 void output_constructor ();
100 void output_byte_asm ();
101 void text_section ();
102 void readonly_data_section ();
103 void data_section ();
104 static void bc_assemble_integer ();
106 #ifdef EXTRA_SECTIONS
107 static enum in_section {no_section, in_text, in_data, EXTRA_SECTIONS} in_section
110 static enum in_section {no_section, in_text, in_data} in_section
114 /* Define functions like text_section for any extra sections. */
115 #ifdef EXTRA_SECTION_FUNCTIONS
116 EXTRA_SECTION_FUNCTIONS
119 /* Tell assembler to switch to text section. */
124 if (in_section != in_text)
129 fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
131 in_section = in_text;
135 /* Tell assembler to switch to data section. */
140 if (in_section != in_data)
146 if (flag_shared_data)
148 #ifdef SHARED_SECTION_ASM_OP
149 fprintf (asm_out_file, "%s\n", SHARED_SECTION_ASM_OP);
151 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
155 fprintf (asm_out_file, "%s\n", DATA_SECTION_ASM_OP);
158 in_section = in_data;
162 /* Tell assembler to switch to read-only data section. This is normally
166 readonly_data_section ()
168 #ifdef READONLY_DATA_SECTION
169 READONLY_DATA_SECTION (); /* Note this can call data_section. */
175 /* Determine if we're in the text section. */
180 return in_section == in_text;
183 /* Create the rtl to represent a function, for a function definition.
184 DECL is a FUNCTION_DECL node which describes which function.
185 The rtl is stored into DECL. */
188 make_function_rtl (decl)
191 char *name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
195 if (DECL_RTL (decl) == 0)
196 DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
198 /* Record that at least one function has been defined. */
199 function_defined = 1;
203 /* Rename a nested function to avoid conflicts. */
204 if (decl_function_context (decl) != 0
205 && DECL_INITIAL (decl) != 0
206 && DECL_RTL (decl) == 0)
210 name = IDENTIFIER_POINTER (DECL_NAME (decl));
211 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
212 name = obstack_copy0 (saveable_obstack, label, strlen (label));
216 if (DECL_RTL (decl) == 0)
219 = gen_rtx (MEM, DECL_MODE (decl),
220 gen_rtx (SYMBOL_REF, Pmode, name));
222 /* Optionally set flags or add text to the name to record information
223 such as that it is a function name. If the name is changed, the macro
224 ASM_OUTPUT_LABELREF will have to know how to strip this information.
225 And if it finds a * at the beginning after doing so, it must handle
227 #ifdef ENCODE_SECTION_INFO
228 ENCODE_SECTION_INFO (decl);
232 /* Record at least one function has been defined. */
233 function_defined = 1;
236 /* Create the DECL_RTL for a declaration for a static or external
237 variable or static or external function.
238 ASMSPEC, if not 0, is the string which the user specified
239 as the assembler symbol name.
240 TOP_LEVEL is nonzero if this is a file-scope variable.
241 This is never called for PARM_DECLs. */
243 bc_make_decl_rtl (decl, asmspec, top_level)
248 register char *name = TREE_STRING_POINTER (DECL_ASSEMBLER_NAME (decl));
250 if (DECL_RTL (decl) == 0)
252 /* Print an error message for register variables. */
253 if (DECL_REGISTER (decl) && TREE_CODE (decl) == FUNCTION_DECL)
254 error ("function declared `register'");
255 else if (DECL_REGISTER (decl))
256 error ("global register variables not supported in the interpreter");
258 /* Handle ordinary static variables and functions. */
259 if (DECL_RTL (decl) == 0)
261 /* Can't use just the variable's own name for a variable
262 whose scope is less than the whole file.
263 Concatenate a distinguishing number. */
264 if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
268 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
269 name = obstack_copy0 (saveable_obstack, label, strlen (label));
273 DECL_RTL (decl) = bc_gen_rtx (name, 0, (struct bc_label *) 0);
278 /* Given NAME, a putative register name, discard any customary prefixes. */
281 strip_reg_name (name)
284 #ifdef REGISTER_PREFIX
285 if (!strncmp (name, REGISTER_PREFIX, strlen (REGISTER_PREFIX)))
286 name += strlen (REGISTER_PREFIX);
288 if (name[0] == '%' || name[0] == '#')
293 /* Decode an `asm' spec for a declaration as a register name.
294 Return the register number, or -1 if nothing specified,
295 or -2 if the ASMSPEC is not `cc' or `memory' and is not recognized,
296 or -3 if ASMSPEC is `cc' and is not recognized,
297 or -4 if ASMSPEC is `memory' and is not recognized.
298 Accept an exact spelling or a decimal number.
299 Prefixes such as % are optional. */
302 decode_reg_name (asmspec)
309 /* Get rid of confusing prefixes. */
310 asmspec = strip_reg_name (asmspec);
312 /* Allow a decimal number as a "register name". */
313 for (i = strlen (asmspec) - 1; i >= 0; i--)
314 if (! (asmspec[i] >= '0' && asmspec[i] <= '9'))
316 if (asmspec[0] != 0 && i < 0)
319 if (i < FIRST_PSEUDO_REGISTER && i >= 0)
325 for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
327 && ! strcmp (asmspec, strip_reg_name (reg_names[i])))
330 #ifdef ADDITIONAL_REGISTER_NAMES
332 static struct { char *name; int number; } table[]
333 = ADDITIONAL_REGISTER_NAMES;
335 for (i = 0; i < sizeof (table) / sizeof (table[0]); i++)
336 if (! strcmp (asmspec, table[i].name))
337 return table[i].number;
339 #endif /* ADDITIONAL_REGISTER_NAMES */
341 if (!strcmp (asmspec, "memory"))
344 if (!strcmp (asmspec, "cc"))
353 /* Create the DECL_RTL for a declaration for a static or external variable
354 or static or external function.
355 ASMSPEC, if not 0, is the string which the user specified
356 as the assembler symbol name.
357 TOP_LEVEL is nonzero if this is a file-scope variable.
359 This is never called for PARM_DECL nodes. */
362 make_decl_rtl (decl, asmspec, top_level)
372 bc_make_decl_rtl (decl, asmspec, top_level);
376 reg_number = decode_reg_name (asmspec);
378 if (DECL_ASSEMBLER_NAME (decl) != NULL_TREE)
379 name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
381 if (reg_number == -2)
383 /* ASMSPEC is given, and not the name of a register. */
384 name = (char *) obstack_alloc (saveable_obstack,
385 strlen (asmspec) + 2);
387 strcpy (&name[1], asmspec);
390 /* For a duplicate declaration, we can be called twice on the
391 same DECL node. Don't discard the RTL already made. */
392 if (DECL_RTL (decl) == 0)
396 /* First detect errors in declaring global registers. */
397 if (DECL_REGISTER (decl) && reg_number == -1)
398 error_with_decl (decl,
399 "register name not specified for `%s'");
400 else if (DECL_REGISTER (decl) && reg_number < 0)
401 error_with_decl (decl,
402 "invalid register name for `%s'");
403 else if ((reg_number >= 0 || reg_number == -3) && ! DECL_REGISTER (decl))
404 error_with_decl (decl,
405 "register name given for non-register variable `%s'");
406 else if (DECL_REGISTER (decl) && TREE_CODE (decl) == FUNCTION_DECL)
407 error ("function declared `register'");
408 else if (DECL_REGISTER (decl) && TYPE_MODE (TREE_TYPE (decl)) == BLKmode)
409 error_with_decl (decl, "data type of `%s' isn't suitable for a register");
410 else if (DECL_REGISTER (decl)
411 && ! HARD_REGNO_MODE_OK (reg_number, TYPE_MODE (TREE_TYPE (decl))))
412 error_with_decl (decl, "register number for `%s' isn't suitable for the data type");
413 /* Now handle properly declared static register variables. */
414 else if (DECL_REGISTER (decl))
417 #if 0 /* yylex should print the warning for this */
419 pedwarn ("ANSI C forbids global register variables");
421 if (DECL_INITIAL (decl) != 0 && top_level)
423 DECL_INITIAL (decl) = 0;
424 error ("global register variable has initial value");
426 if (fixed_regs[reg_number] == 0
427 && function_defined && top_level)
428 error ("global register variable follows a function definition");
429 if (TREE_THIS_VOLATILE (decl))
430 warning ("volatile register variables don't work as you might wish");
432 /* If the user specified one of the eliminables registers here,
433 e.g., FRAME_POINTER_REGNUM, we don't want to get this variable
434 confused with that register and be eliminated. Although this
435 usage is somewhat suspect, we nevertheless use the following
436 kludge to avoid setting DECL_RTL to frame_pointer_rtx. */
439 = gen_rtx (REG, DECL_MODE (decl), FIRST_PSEUDO_REGISTER);
440 REGNO (DECL_RTL (decl)) = reg_number;
441 REG_USERVAR_P (DECL_RTL (decl)) = 1;
445 /* Make this register fixed, so not usable for anything else. */
446 nregs = HARD_REGNO_NREGS (reg_number, DECL_MODE (decl));
448 global_regs[reg_number + --nregs] = 1;
453 /* Now handle ordinary static variables and functions (in memory).
454 Also handle vars declared register invalidly. */
455 if (DECL_RTL (decl) == 0)
457 /* Can't use just the variable's own name for a variable
458 whose scope is less than the whole file.
459 Concatenate a distinguishing number. */
460 if (!top_level && !DECL_EXTERNAL (decl) && asmspec == 0)
464 ASM_FORMAT_PRIVATE_NAME (label, name, var_labelno);
465 name = obstack_copy0 (saveable_obstack, label, strlen (label));
469 DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl),
470 gen_rtx (SYMBOL_REF, Pmode, name));
471 if (TREE_THIS_VOLATILE (decl)
472 || (flag_volatile_global && TREE_CODE (decl) == VAR_DECL
473 && TREE_PUBLIC (decl)))
474 MEM_VOLATILE_P (DECL_RTL (decl)) = 1;
475 if (TREE_READONLY (decl))
476 RTX_UNCHANGING_P (DECL_RTL (decl)) = 1;
477 MEM_IN_STRUCT_P (DECL_RTL (decl))
478 = (TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE
479 || TREE_CODE (TREE_TYPE (decl)) == RECORD_TYPE
480 || TREE_CODE (TREE_TYPE (decl)) == UNION_TYPE
481 || TREE_CODE (TREE_TYPE (decl)) == QUAL_UNION_TYPE);
483 /* Optionally set flags or add text to the name to record information
484 such as that it is a function name.
485 If the name is changed, the macro ASM_OUTPUT_LABELREF
486 will have to know how to strip this information.
487 And if it finds a * at the beginning after doing so,
488 it must handle that too. */
489 #ifdef ENCODE_SECTION_INFO
490 ENCODE_SECTION_INFO (decl);
494 /* If the old RTL had the wrong mode, fix the mode. */
495 else if (GET_MODE (DECL_RTL (decl)) != DECL_MODE (decl))
497 rtx rtl = DECL_RTL (decl);
498 PUT_MODE (rtl, DECL_MODE (decl));
502 /* Make the rtl for variable VAR be volatile.
503 Use this only for static variables. */
506 make_var_volatile (var)
509 if (GET_CODE (DECL_RTL (var)) != MEM)
512 MEM_VOLATILE_P (DECL_RTL (var)) = 1;
515 /* Output alignment directive to align for constant expression EXP. */
518 assemble_constant_align (exp)
523 /* Align the location counter as required by EXP's data type. */
524 align = TYPE_ALIGN (TREE_TYPE (exp));
525 #ifdef CONSTANT_ALIGNMENT
526 align = CONSTANT_ALIGNMENT (exp, align);
529 if (align > BITS_PER_UNIT)
530 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
533 /* Output a string of literal assembler code
534 for an `asm' keyword used between functions. */
537 assemble_asm (string)
542 error ("asm statements not allowed in interpreter");
548 if (TREE_CODE (string) == ADDR_EXPR)
549 string = TREE_OPERAND (string, 0);
551 fprintf (asm_out_file, "\t%s\n", TREE_STRING_POINTER (string));
554 #if 0 /* This should no longer be needed, because
555 flag_gnu_linker should be 0 on these systems,
556 which should prevent any output
557 if ASM_OUTPUT_CONSTRUCTOR and ASM_OUTPUT_DESTRUCTOR are absent. */
558 #if !(defined(DBX_DEBUGGING_INFO) && !defined(FASCIST_ASSEMBLER))
559 #ifndef ASM_OUTPUT_CONSTRUCTOR
560 #define ASM_OUTPUT_CONSTRUCTOR(file, name)
562 #ifndef ASM_OUTPUT_DESTRUCTOR
563 #define ASM_OUTPUT_DESTRUCTOR(file, name)
568 /* Record an element in the table of global destructors.
569 How this is done depends on what sort of assembler and linker
572 NAME should be the name of a global function to be called
573 at exit time. This name is output using assemble_name. */
576 assemble_destructor (name)
579 #ifdef ASM_OUTPUT_DESTRUCTOR
580 ASM_OUTPUT_DESTRUCTOR (asm_out_file, name);
584 /* Now tell GNU LD that this is part of the static destructor set. */
585 /* This code works for any machine provided you use GNU as/ld. */
586 fprintf (asm_out_file, "%s \"___DTOR_LIST__\",22,0,0,", ASM_STABS_OP);
587 assemble_name (asm_out_file, name);
588 fputc ('\n', asm_out_file);
593 /* Likewise for global constructors. */
596 assemble_constructor (name)
599 #ifdef ASM_OUTPUT_CONSTRUCTOR
600 ASM_OUTPUT_CONSTRUCTOR (asm_out_file, name);
604 /* Now tell GNU LD that this is part of the static constructor set. */
605 /* This code works for any machine provided you use GNU as/ld. */
606 fprintf (asm_out_file, "%s \"___CTOR_LIST__\",22,0,0,", ASM_STABS_OP);
607 assemble_name (asm_out_file, name);
608 fputc ('\n', asm_out_file);
613 /* Likewise for entries we want to record for garbage collection.
614 Garbage collection is still under development. */
617 assemble_gc_entry (name)
620 #ifdef ASM_OUTPUT_GC_ENTRY
621 ASM_OUTPUT_GC_ENTRY (asm_out_file, name);
625 /* Now tell GNU LD that this is part of the static constructor set. */
626 fprintf (asm_out_file, "%s \"___PTR_LIST__\",22,0,0,", ASM_STABS_OP);
627 assemble_name (asm_out_file, name);
628 fputc ('\n', asm_out_file);
633 /* Output assembler code for the constant pool of a function and associated
634 with defining the name of the function. DECL describes the function.
635 NAME is the function's name. For the constant pool, we use the current
636 constant pool data. */
639 assemble_start_function (decl, fnname)
645 /* The following code does not need preprocessing in the assembler. */
649 output_constant_pool (fnname, decl);
654 /* Tell assembler to move to target machine's alignment for functions. */
655 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
659 BC_OUTPUT_ALIGN (asm_out_file, align);
661 ASM_OUTPUT_ALIGN (asm_out_file, align);
664 #ifdef ASM_OUTPUT_FUNCTION_PREFIX
665 ASM_OUTPUT_FUNCTION_PREFIX (asm_out_file, fnname);
668 #ifdef SDB_DEBUGGING_INFO
669 /* Output SDB definition of the function. */
670 if (write_symbols == SDB_DEBUG)
671 sdbout_mark_begin_function ();
674 #ifdef DBX_DEBUGGING_INFO
675 /* Output DBX definition of the function. */
676 if (write_symbols == DBX_DEBUG)
677 dbxout_begin_function (decl);
680 /* Make function name accessible from other files, if appropriate. */
682 if (TREE_PUBLIC (decl))
684 if (!first_global_object_name)
685 STRIP_NAME_ENCODING (first_global_object_name, fnname);
687 BC_GLOBALIZE_LABEL (asm_out_file, fnname);
689 ASM_GLOBALIZE_LABEL (asm_out_file, fnname);
692 /* Do any machine/system dependent processing of the function name */
693 #ifdef ASM_DECLARE_FUNCTION_NAME
694 ASM_DECLARE_FUNCTION_NAME (asm_out_file, fnname, current_function_decl);
696 /* Standard thing is just output label for the function. */
698 BC_OUTPUT_LABEL (asm_out_file, fnname);
700 ASM_OUTPUT_LABEL (asm_out_file, fnname);
701 #endif /* ASM_DECLARE_FUNCTION_NAME */
704 /* Output assembler code associated with defining the size of the
705 function. DECL describes the function. NAME is the function's name. */
708 assemble_end_function (decl, fnname)
712 #ifdef ASM_DECLARE_FUNCTION_SIZE
713 ASM_DECLARE_FUNCTION_SIZE (asm_out_file, fnname, decl);
717 /* Assemble code to leave SIZE bytes of zeros. */
720 assemble_zeros (size)
725 bc_emit_const_skip (size);
729 #ifdef ASM_NO_SKIP_IN_TEXT
730 /* The `space' pseudo in the text section outputs nop insns rather than 0s,
731 so we must output 0s explicitly in the text section. */
732 if (ASM_NO_SKIP_IN_TEXT && in_text_section ())
736 for (i = 0; i < size - 20; i += 20)
739 fprintf (asm_out_file,
740 "%s 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n", ASM_BYTE_OP);
742 fprintf (asm_out_file,
743 "\tbyte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n");
749 fprintf (asm_out_file, "%s 0", ASM_BYTE_OP);
751 fprintf (asm_out_file, "\tbyte 0");
754 for (; i < size; i++)
755 fprintf (asm_out_file, ",0");
756 fprintf (asm_out_file, "\n");
764 BC_OUTPUT_SKIP (asm_out_file, size);
766 ASM_OUTPUT_SKIP (asm_out_file, size);
770 /* Assemble an alignment pseudo op for an ALIGN-bit boundary. */
773 assemble_align (align)
776 if (align > BITS_PER_UNIT)
777 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
780 /* Assemble a string constant with the specified C string as contents. */
783 assemble_string (p, size)
797 /* If the string is very long, split it up. */
801 int thissize = size - pos;
802 if (thissize > maximum)
806 BC_OUTPUT_ASCII (asm_out_file, p, thissize);
808 ASM_OUTPUT_ASCII (asm_out_file, p, thissize);
815 /* Assemble everything that is needed for a variable or function declaration.
816 Not used for automatic variables, and not used for function definitions.
817 Should not be called for variables of incomplete structure type.
819 TOP_LEVEL is nonzero if this variable has file scope.
820 AT_END is nonzero if this is the special handling, at end of compilation,
821 to define things that have had only tentative definitions.
822 DONT_OUTPUT_DATA if nonzero means don't actually output the
823 initial value (that will be done by the caller). */
826 assemble_variable (decl, top_level, at_end, dont_output_data)
835 enum in_section saved_in_section;
840 if (GET_CODE (DECL_RTL (decl)) == REG)
842 /* Do output symbol info for global register variables, but do nothing
845 if (TREE_ASM_WRITTEN (decl))
847 TREE_ASM_WRITTEN (decl) = 1;
849 if (!output_bytecode)
851 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
852 /* File-scope global variables are output here. */
853 if ((write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
855 dbxout_symbol (decl, 0);
857 #ifdef SDB_DEBUGGING_INFO
858 if (write_symbols == SDB_DEBUG && top_level
859 /* Leave initialized global vars for end of compilation;
860 see comment in compile_file. */
861 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
862 sdbout_symbol (decl, 0);
866 /* Don't output any DWARF debugging information for variables here.
867 In the case of local variables, the information for them is output
868 when we do our recursive traversal of the tree representation for
869 the entire containing function. In the case of file-scope variables,
870 we output information for all of them at the very end of compilation
871 while we are doing our final traversal of the chain of file-scope
877 /* Normally no need to say anything here for external references,
878 since assemble_external is called by the langauge-specific code
879 when a declaration is first seen. */
881 if (DECL_EXTERNAL (decl))
884 /* Output no assembler code for a function declaration.
885 Only definitions of functions output anything. */
887 if (TREE_CODE (decl) == FUNCTION_DECL)
890 /* If type was incomplete when the variable was declared,
891 see if it is complete now. */
893 if (DECL_SIZE (decl) == 0)
894 layout_decl (decl, 0);
896 /* Still incomplete => don't allocate it; treat the tentative defn
897 (which is what it must have been) as an `extern' reference. */
899 if (!dont_output_data && DECL_SIZE (decl) == 0)
901 error_with_file_and_line (DECL_SOURCE_FILE (decl),
902 DECL_SOURCE_LINE (decl),
903 "storage size of `%s' isn't known",
904 IDENTIFIER_POINTER (DECL_NAME (decl)));
908 /* The first declaration of a variable that comes through this function
909 decides whether it is global (in C, has external linkage)
910 or local (in C, has internal linkage). So do nothing more
911 if this function has already run. */
913 if (TREE_ASM_WRITTEN (decl))
916 TREE_ASM_WRITTEN (decl) = 1;
918 /* If storage size is erroneously variable, just continue.
919 Error message was already made. */
921 if (DECL_SIZE (decl))
923 if (TREE_CODE (DECL_SIZE (decl)) != INTEGER_CST)
928 /* This is better than explicit arithmetic, since it avoids overflow. */
929 size_tree = size_binop (CEIL_DIV_EXPR,
930 DECL_SIZE (decl), size_int (BITS_PER_UNIT));
932 if (TREE_INT_CST_HIGH (size_tree) != 0)
934 error_with_decl (decl, "size of variable `%s' is too large");
939 name = XSTR (XEXP (DECL_RTL (decl), 0), 0);
941 /* Handle uninitialized definitions. */
943 /* ANSI specifies that a tentative definition which is not merged with
944 a non-tentative definition behaves exactly like a definition with an
945 initializer equal to zero. (Section 3.7.2)
946 -fno-common gives strict ANSI behavior. Usually you don't want it.
947 This matters only for variables with external linkage. */
948 if ((! flag_no_common || ! TREE_PUBLIC (decl))
949 && ! dont_output_data
950 && (DECL_INITIAL (decl) == 0 || DECL_INITIAL (decl) == error_mark_node))
952 int size = TREE_INT_CST_LOW (size_tree);
955 if (TREE_INT_CST_HIGH (size_tree) != 0)
956 error_with_decl (decl, "size of variable `%s' is too large");
957 /* Don't allocate zero bytes of common,
958 since that means "undefined external" in the linker. */
959 if (size == 0) rounded = 1;
960 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
961 so that each uninitialized object starts on such a boundary. */
962 rounded += (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1;
963 rounded = (rounded / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
964 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
966 #ifdef DBX_DEBUGGING_INFO
967 /* File-scope global variables are output here. */
968 if (write_symbols == DBX_DEBUG && top_level)
969 dbxout_symbol (decl, 0);
971 #ifdef SDB_DEBUGGING_INFO
972 if (write_symbols == SDB_DEBUG && top_level
973 /* Leave initialized global vars for end of compilation;
974 see comment in compile_file. */
975 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
976 sdbout_symbol (decl, 0);
979 /* Don't output any DWARF debugging information for variables here.
980 In the case of local variables, the information for them is output
981 when we do our recursive traversal of the tree representation for
982 the entire containing function. In the case of file-scope variables,
983 we output information for all of them at the very end of compilation
984 while we are doing our final traversal of the chain of file-scope
988 if (flag_shared_data)
991 if (TREE_PUBLIC (decl))
993 #ifdef ASM_OUTPUT_SHARED_COMMON
994 if (flag_shared_data)
995 ASM_OUTPUT_SHARED_COMMON (asm_out_file, name, size, rounded);
999 BC_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1002 #ifdef ASM_OUTPUT_ALIGNED_COMMON
1003 ASM_OUTPUT_ALIGNED_COMMON (asm_out_file, name, size,
1006 ASM_OUTPUT_COMMON (asm_out_file, name, size, rounded);
1012 #ifdef ASM_OUTPUT_SHARED_LOCAL
1013 if (flag_shared_data)
1014 ASM_OUTPUT_SHARED_LOCAL (asm_out_file, name, size, rounded);
1017 if (output_bytecode)
1018 BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1021 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1022 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size,
1025 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1032 /* Handle initialized definitions. */
1034 /* First make the assembler name(s) global if appropriate. */
1035 if (TREE_PUBLIC (decl) && DECL_NAME (decl))
1037 if (!first_global_object_name)
1038 STRIP_NAME_ENCODING(first_global_object_name, name);
1039 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1042 for (d = equivalents; d; d = TREE_CHAIN (d))
1044 tree e = TREE_VALUE (d);
1045 if (TREE_PUBLIC (e) && DECL_NAME (e))
1046 ASM_GLOBALIZE_LABEL (asm_out_file,
1047 XSTR (XEXP (DECL_RTL (e), 0), 0));
1051 /* Output any data that we will need to use the address of. */
1052 if (DECL_INITIAL (decl) == error_mark_node)
1053 reloc = contains_pointers_p (TREE_TYPE (decl));
1054 else if (DECL_INITIAL (decl))
1055 reloc = output_addressed_constants (DECL_INITIAL (decl));
1057 /* Switch to the proper section for this data. */
1058 #ifdef SELECT_SECTION
1059 SELECT_SECTION (decl, reloc);
1061 if (TREE_READONLY (decl)
1062 && ! TREE_THIS_VOLATILE (decl)
1063 && ! (flag_pic && reloc))
1064 readonly_data_section ();
1069 /* Record current section so we can restore it if dbxout.c clobbers it. */
1070 saved_in_section = in_section;
1072 /* Output the dbx info now that we have chosen the section. */
1074 #ifdef DBX_DEBUGGING_INFO
1075 /* File-scope global variables are output here. */
1076 if (write_symbols == DBX_DEBUG && top_level)
1077 dbxout_symbol (decl, 0);
1079 #ifdef SDB_DEBUGGING_INFO
1080 if (write_symbols == SDB_DEBUG && top_level
1081 /* Leave initialized global vars for end of compilation;
1082 see comment in compile_file. */
1083 && (TREE_PUBLIC (decl) == 0 || DECL_INITIAL (decl) == 0))
1084 sdbout_symbol (decl, 0);
1087 /* Don't output any DWARF debugging information for variables here.
1088 In the case of local variables, the information for them is output
1089 when we do our recursive traversal of the tree representation for
1090 the entire containing function. In the case of file-scope variables,
1091 we output information for all of them at the very end of compilation
1092 while we are doing our final traversal of the chain of file-scope
1095 if (in_section != saved_in_section)
1097 /* Switch to the proper section for this data. */
1098 #ifdef SELECT_SECTION
1099 SELECT_SECTION (decl, reloc);
1101 if (TREE_READONLY (decl)
1102 && ! TREE_THIS_VOLATILE (decl)
1103 && ! (flag_pic && reloc))
1104 readonly_data_section ();
1110 /* Compute and output the alignment of this data. */
1112 align = DECL_ALIGN (decl);
1113 /* In the case for initialing an array whose length isn't specified,
1114 where we have not yet been able to do the layout,
1115 figure out the proper alignment now. */
1116 if (dont_output_data && DECL_SIZE (decl) == 0
1117 && TREE_CODE (TREE_TYPE (decl)) == ARRAY_TYPE)
1118 align = MAX (align, TYPE_ALIGN (TREE_TYPE (TREE_TYPE (decl))));
1120 /* Some object file formats have a maximum alignment which they support.
1121 In particular, a.out format supports a maximum alignment of 4. */
1122 #ifndef MAX_OFILE_ALIGNMENT
1123 #define MAX_OFILE_ALIGNMENT BIGGEST_ALIGNMENT
1125 if (align > MAX_OFILE_ALIGNMENT)
1127 warning_with_decl (decl,
1128 "alignment of `%s' is greater than maximum object file alignment");
1129 align = MAX_OFILE_ALIGNMENT;
1131 #ifdef DATA_ALIGNMENT
1132 /* On some machines, it is good to increase alignment sometimes. */
1133 align = DATA_ALIGNMENT (TREE_TYPE (decl), align);
1135 #ifdef CONSTANT_ALIGNMENT
1136 if (DECL_INITIAL (decl))
1137 align = CONSTANT_ALIGNMENT (DECL_INITIAL (decl), align);
1140 /* Reset the alignment in case we have made it tighter, so we can benefit
1141 from it in get_pointer_alignment. */
1142 DECL_ALIGN (decl) = align;
1144 if (align > BITS_PER_UNIT)
1146 if (output_bytecode)
1147 BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1149 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
1152 /* Do any machine/system dependent processing of the object. */
1153 #ifdef ASM_DECLARE_OBJECT_NAME
1154 ASM_DECLARE_OBJECT_NAME (asm_out_file, name, decl);
1156 /* Standard thing is just output label for the object. */
1157 if (output_bytecode)
1158 BC_OUTPUT_LABEL (asm_out_file, name);
1160 ASM_OUTPUT_LABEL (asm_out_file, name);
1161 #endif /* ASM_DECLARE_OBJECT_NAME */
1163 if (!dont_output_data)
1165 if (DECL_INITIAL (decl))
1166 /* Output the actual data. */
1167 output_constant (DECL_INITIAL (decl),
1168 int_size_in_bytes (TREE_TYPE (decl)));
1170 /* Leave space for it. */
1171 assemble_zeros (int_size_in_bytes (TREE_TYPE (decl)));
1175 #ifdef XCOFF_DEBUGGING_INFO
1176 /* Unfortunately, the IBM assembler cannot handle stabx before the actual
1177 declaration. When something like ".stabx "aa:S-2",aa,133,0" is emitted
1178 and `aa' hasn't been output yet, the assembler generates a stab entry with
1179 a value of zero, in addition to creating an unnecessary external entry
1180 for `aa'. Hence, we must postpone dbxout_symbol to here at the end. */
1182 /* File-scope global variables are output here. */
1183 if (write_symbols == XCOFF_DEBUG && top_level)
1185 saved_in_section = in_section;
1187 dbxout_symbol (decl, 0);
1189 if (in_section != saved_in_section)
1191 /* Switch to the proper section for this data. */
1192 #ifdef SELECT_SECTION
1193 SELECT_SECTION (decl, reloc);
1195 if (TREE_READONLY (decl)
1196 && ! TREE_THIS_VOLATILE (decl)
1197 && ! (flag_pic && reloc))
1198 readonly_data_section ();
1205 /* There must be a statement after a label. */
1210 /* Return 1 if type TYPE contains any pointers. */
1213 contains_pointers_p (type)
1216 switch (TREE_CODE (type))
1219 case REFERENCE_TYPE:
1220 /* I'm not sure whether OFFSET_TYPE needs this treatment,
1221 so I'll play safe and return 1. */
1227 case QUAL_UNION_TYPE:
1230 /* For a type that has fields, see if the fields have pointers. */
1231 for (fields = TYPE_FIELDS (type); fields; fields = TREE_CHAIN (fields))
1232 if (contains_pointers_p (TREE_TYPE (fields)))
1238 /* An array type contains pointers if its element type does. */
1239 return contains_pointers_p (TREE_TYPE (type));
1246 /* Output text storage for constructor CONSTR. Returns rtx of
1250 bc_output_constructor (constr)
1255 /* Must always be a literal; non-literal constructors are handled
1258 if (!TREE_CONSTANT (constr))
1265 for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1267 BC_OUTPUT_ALIGN (asm_out_file, i);
1270 output_constant (constr, int_size_in_bytes (TREE_TYPE (constr)));
1274 /* Create storage for constructor CONSTR. */
1277 bc_output_data_constructor (constr)
1282 /* Put in data section */
1286 for (i = 0; TYPE_ALIGN (constr) >= BITS_PER_UNIT << (i + 1); i++);
1288 BC_OUTPUT_ALIGN (asm_out_file, i);
1290 /* The constructor is filled in at runtime. */
1291 BC_OUTPUT_SKIP (asm_out_file, int_size_in_bytes (TREE_TYPE (constr)));
1295 /* Output something to declare an external symbol to the assembler.
1296 (Most assemblers don't need this, so we normally output nothing.)
1297 Do nothing if DECL is not external. */
1300 assemble_external (decl)
1303 if (output_bytecode)
1306 #ifdef ASM_OUTPUT_EXTERNAL
1307 if (TREE_CODE_CLASS (TREE_CODE (decl)) == 'd'
1308 && DECL_EXTERNAL (decl) && TREE_PUBLIC (decl))
1310 rtx rtl = DECL_RTL (decl);
1312 if (GET_CODE (rtl) == MEM && GET_CODE (XEXP (rtl, 0)) == SYMBOL_REF
1313 && ! SYMBOL_REF_USED (XEXP (rtl, 0)))
1315 /* Some systems do require some output. */
1316 SYMBOL_REF_USED (XEXP (rtl, 0)) = 1;
1317 ASM_OUTPUT_EXTERNAL (asm_out_file, decl, XSTR (XEXP (rtl, 0), 0));
1323 /* Similar, for calling a library function FUN. */
1326 assemble_external_libcall (fun)
1329 #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
1330 if (!output_bytecode)
1332 /* Declare library function name external when first used, if nec. */
1333 if (! SYMBOL_REF_USED (fun))
1335 SYMBOL_REF_USED (fun) = 1;
1336 ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
1342 /* Declare the label NAME global. */
1345 assemble_global (name)
1348 ASM_GLOBALIZE_LABEL (asm_out_file, name);
1351 /* Assemble a label named NAME. */
1354 assemble_label (name)
1357 if (output_bytecode)
1358 BC_OUTPUT_LABEL (asm_out_file, name);
1360 ASM_OUTPUT_LABEL (asm_out_file, name);
1363 /* Output to FILE a reference to the assembler name of a C-level name NAME.
1364 If NAME starts with a *, the rest of NAME is output verbatim.
1365 Otherwise NAME is transformed in an implementation-defined way
1366 (usually by the addition of an underscore).
1367 Many macros in the tm file are defined to call this function. */
1370 assemble_name (file, name)
1376 if (output_bytecode)
1377 bc_emit_labelref (name);
1379 fputs (&name[1], file);
1383 if (output_bytecode)
1384 BC_OUTPUT_LABELREF (file, name);
1386 ASM_OUTPUT_LABELREF (file, name);
1390 /* Allocate SIZE bytes writable static space with a gensym name
1391 and return an RTX to refer to its address. */
1394 assemble_static_space (size)
1400 /* Round size up to multiple of BIGGEST_ALIGNMENT bits
1401 so that each uninitialized object starts on such a boundary. */
1402 int rounded = ((size + (BIGGEST_ALIGNMENT / BITS_PER_UNIT) - 1)
1403 / (BIGGEST_ALIGNMENT / BITS_PER_UNIT)
1404 * (BIGGEST_ALIGNMENT / BITS_PER_UNIT));
1407 if (flag_shared_data)
1411 ASM_GENERATE_INTERNAL_LABEL (name, "LF", const_labelno);
1414 namestring = (char *) obstack_alloc (saveable_obstack,
1416 strcpy (namestring, name);
1418 if (output_bytecode)
1419 x = bc_gen_rtx (namestring, 0, (struct bc_label *) 0);
1421 x = gen_rtx (SYMBOL_REF, Pmode, namestring);
1423 if (output_bytecode)
1424 BC_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1427 #ifdef ASM_OUTPUT_ALIGNED_LOCAL
1428 ASM_OUTPUT_ALIGNED_LOCAL (asm_out_file, name, size, BIGGEST_ALIGNMENT);
1430 ASM_OUTPUT_LOCAL (asm_out_file, name, size, rounded);
1436 /* Assemble the static constant template for function entry trampolines.
1437 This is done at most once per compilation.
1438 Returns an RTX for the address of the template. */
1441 assemble_trampoline_template ()
1447 /* Shouldn't get here */
1448 if (output_bytecode)
1451 /* By default, put trampoline templates in read-only data section. */
1453 #ifdef TRAMPOLINE_SECTION
1454 TRAMPOLINE_SECTION ();
1456 readonly_data_section ();
1459 /* Write the assembler code to define one. */
1460 align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
1462 ASM_OUTPUT_ALIGN (asm_out_file, align);
1464 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LTRAMP", 0);
1465 TRAMPOLINE_TEMPLATE (asm_out_file);
1467 /* Record the rtl to refer to it. */
1468 ASM_GENERATE_INTERNAL_LABEL (label, "LTRAMP", 0);
1470 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
1471 return gen_rtx (SYMBOL_REF, Pmode, name);
1474 /* Assemble the integer constant X into an object of SIZE bytes.
1475 X must be either a CONST_INT or CONST_DOUBLE.
1477 Return 1 if we were able to output the constant, otherwise 0. If FORCE is
1478 non-zero, abort if we can't output the constant. */
1481 assemble_integer (x, size, force)
1486 /* First try to use the standard 1, 2, 4, 8, and 16 byte
1487 ASM_OUTPUT... macros. */
1491 #ifdef ASM_OUTPUT_CHAR
1493 ASM_OUTPUT_CHAR (asm_out_file, x);
1497 #ifdef ASM_OUTPUT_SHORT
1499 ASM_OUTPUT_SHORT (asm_out_file, x);
1503 #ifdef ASM_OUTPUT_INT
1505 ASM_OUTPUT_INT (asm_out_file, x);
1509 #ifdef ASM_OUTPUT_DOUBLE_INT
1511 ASM_OUTPUT_DOUBLE_INT (asm_out_file, x);
1515 #ifdef ASM_OUTPUT_QUADRUPLE_INT
1517 ASM_OUTPUT_QUADRUPLE_INT (asm_out_file, x);
1522 /* If we couldn't do it that way, there are two other possibilities: First,
1523 if the machine can output an explicit byte and this is a 1 byte constant,
1524 we can use ASM_OUTPUT_BYTE. */
1526 #ifdef ASM_OUTPUT_BYTE
1527 if (size == 1 && GET_CODE (x) == CONST_INT)
1529 ASM_OUTPUT_BYTE (asm_out_file, INTVAL (x));
1534 /* Finally, if SIZE is larger than a single word, try to output the constant
1535 one word at a time. */
1537 if (size > UNITS_PER_WORD)
1540 enum machine_mode mode
1541 = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0);
1544 for (i = 0; i < size / UNITS_PER_WORD; i++)
1546 word = operand_subword (x, i, 0, mode);
1551 if (! assemble_integer (word, UNITS_PER_WORD, 0))
1555 if (i == size / UNITS_PER_WORD)
1557 /* If we output at least one word and then could not finish,
1558 there is no valid way to continue. */
1569 /* Assemble the floating-point constant D into an object of size MODE. */
1572 assemble_real (d, mode)
1574 enum machine_mode mode;
1576 jmp_buf output_constant_handler;
1578 if (setjmp (output_constant_handler))
1580 error ("floating point trap outputting a constant");
1581 #ifdef REAL_IS_NOT_DOUBLE
1582 bzero (&d, sizeof d);
1589 set_float_handler (output_constant_handler);
1593 #ifdef ASM_OUTPUT_BYTE_FLOAT
1595 ASM_OUTPUT_BYTE_FLOAT (asm_out_file, d);
1598 #ifdef ASM_OUTPUT_SHORT_FLOAT
1600 ASM_OUTPUT_SHORT_FLOAT (asm_out_file, d);
1603 #ifdef ASM_OUTPUT_FLOAT
1605 ASM_OUTPUT_FLOAT (asm_out_file, d);
1609 #ifdef ASM_OUTPUT_DOUBLE
1611 ASM_OUTPUT_DOUBLE (asm_out_file, d);
1615 #ifdef ASM_OUTPUT_LONG_DOUBLE
1618 ASM_OUTPUT_LONG_DOUBLE (asm_out_file, d);
1626 set_float_handler (NULL_PTR);
1629 /* Here we combine duplicate floating constants to make
1630 CONST_DOUBLE rtx's, and force those out to memory when necessary. */
1632 /* Chain of all CONST_DOUBLE rtx's constructed for the current function.
1633 They are chained through the CONST_DOUBLE_CHAIN.
1634 A CONST_DOUBLE rtx has CONST_DOUBLE_MEM != cc0_rtx iff it is on this chain.
1635 In that case, CONST_DOUBLE_MEM is either a MEM,
1636 or const0_rtx if no MEM has been made for this CONST_DOUBLE yet.
1638 (CONST_DOUBLE_MEM is used only for top-level functions.
1639 See force_const_mem for explanation.) */
1641 static rtx const_double_chain;
1643 /* Return a CONST_DOUBLE for a value specified as a pair of ints.
1644 For an integer, I0 is the low-order word and I1 is the high-order word.
1645 For a real number, I0 is the word with the low address
1646 and I1 is the word with the high address. */
1649 immed_double_const (i0, i1, mode)
1650 HOST_WIDE_INT i0, i1;
1651 enum machine_mode mode;
1654 int in_current_obstack;
1656 if (GET_MODE_CLASS (mode) == MODE_INT
1657 || GET_MODE_CLASS (mode) == MODE_PARTIAL_INT)
1659 /* We clear out all bits that don't belong in MODE, unless they and our
1660 sign bit are all one. So we get either a reasonable negative value
1661 or a reasonable unsigned value for this mode. */
1662 int width = GET_MODE_BITSIZE (mode);
1663 if (width < HOST_BITS_PER_WIDE_INT
1664 && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
1665 != ((HOST_WIDE_INT) (-1) << (width - 1))))
1666 i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
1667 else if (width == HOST_BITS_PER_WIDE_INT
1668 && ! (i1 == ~0 && i0 < 0))
1670 else if (width > 2 * HOST_BITS_PER_WIDE_INT)
1671 /* We cannot represent this value as a constant. */
1674 /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
1676 ??? Strictly speaking, this is wrong if we create a CONST_INT
1677 for a large unsigned constant with the size of MODE being
1678 HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
1679 wider mode. In that case we will mis-interpret it as a negative
1682 Unfortunately, the only alternative is to make a CONST_DOUBLE
1683 for any constant in any mode if it is an unsigned constant larger
1684 than the maximum signed integer in an int on the host. However,
1685 doing this will break everyone that always expects to see a CONST_INT
1686 for SImode and smaller.
1688 We have always been making CONST_INTs in this case, so nothing new
1691 if (width <= HOST_BITS_PER_WIDE_INT)
1692 i1 = (i0 < 0) ? ~0 : 0;
1694 /* If this integer fits in one word, return a CONST_INT. */
1695 if ((i1 == 0 && i0 >= 0)
1696 || (i1 == ~0 && i0 < 0))
1697 return GEN_INT (i0);
1699 /* We use VOIDmode for integers. */
1703 /* Search the chain for an existing CONST_DOUBLE with the right value.
1704 If one is found, return it. */
1706 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1707 if (CONST_DOUBLE_LOW (r) == i0 && CONST_DOUBLE_HIGH (r) == i1
1708 && GET_MODE (r) == mode)
1711 /* No; make a new one and add it to the chain.
1713 We may be called by an optimizer which may be discarding any memory
1714 allocated during its processing (such as combine and loop). However,
1715 we will be leaving this constant on the chain, so we cannot tolerate
1716 freed memory. So switch to saveable_obstack for this allocation
1717 and then switch back if we were in current_obstack. */
1719 push_obstacks_nochange ();
1720 rtl_in_saveable_obstack ();
1721 r = gen_rtx (CONST_DOUBLE, mode, 0, i0, i1);
1724 /* Don't touch const_double_chain in nested function; see force_const_mem.
1725 Also, don't touch it if not inside any function. */
1726 if (outer_function_chain == 0 && current_function_decl != 0)
1728 CONST_DOUBLE_CHAIN (r) = const_double_chain;
1729 const_double_chain = r;
1732 /* Store const0_rtx in mem-slot since this CONST_DOUBLE is on the chain.
1733 Actual use of mem-slot is only through force_const_mem. */
1735 CONST_DOUBLE_MEM (r) = const0_rtx;
1740 /* Return a CONST_DOUBLE for a specified `double' value
1741 and machine mode. */
1744 immed_real_const_1 (d, mode)
1746 enum machine_mode mode;
1748 union real_extract u;
1750 int in_current_obstack;
1752 /* Get the desired `double' value as a sequence of ints
1753 since that is how they are stored in a CONST_DOUBLE. */
1757 /* Detect special cases. */
1759 /* Avoid REAL_VALUES_EQUAL here in order to distinguish minus zero. */
1760 if (!bcmp (&dconst0, &d, sizeof d))
1761 return CONST0_RTX (mode);
1762 /* Check for NaN first, because some ports (specifically the i386) do not
1763 emit correct ieee-fp code by default, and thus will generate a core
1764 dump here if we pass a NaN to REAL_VALUES_EQUAL and if REAL_VALUES_EQUAL
1765 does a floating point comparison. */
1766 else if (! REAL_VALUE_ISNAN (d) && REAL_VALUES_EQUAL (dconst1, d))
1767 return CONST1_RTX (mode);
1769 if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
1770 return immed_double_const (u.i[0], u.i[1], mode);
1772 /* The rest of this function handles the case where
1773 a float value requires more than 2 ints of space.
1774 It will be deleted as dead code on machines that don't need it. */
1776 /* Search the chain for an existing CONST_DOUBLE with the right value.
1777 If one is found, return it. */
1779 for (r = const_double_chain; r; r = CONST_DOUBLE_CHAIN (r))
1780 if (! bcmp (&CONST_DOUBLE_LOW (r), &u, sizeof u)
1781 && GET_MODE (r) == mode)
1784 /* No; make a new one and add it to the chain.
1786 We may be called by an optimizer which may be discarding any memory
1787 allocated during its processing (such as combine and loop). However,
1788 we will be leaving this constant on the chain, so we cannot tolerate
1789 freed memory. So switch to saveable_obstack for this allocation
1790 and then switch back if we were in current_obstack. */
1792 push_obstacks_nochange ();
1793 rtl_in_saveable_obstack ();
1794 r = rtx_alloc (CONST_DOUBLE);
1796 bcopy (&u, &CONST_DOUBLE_LOW (r), sizeof u);
1799 /* Don't touch const_double_chain in nested function; see force_const_mem.
1800 Also, don't touch it if not inside any function. */
1801 if (outer_function_chain == 0 && current_function_decl != 0)
1803 CONST_DOUBLE_CHAIN (r) = const_double_chain;
1804 const_double_chain = r;
1807 /* Store const0_rtx in CONST_DOUBLE_MEM since this CONST_DOUBLE is on the
1808 chain, but has not been allocated memory. Actual use of CONST_DOUBLE_MEM
1809 is only through force_const_mem. */
1811 CONST_DOUBLE_MEM (r) = const0_rtx;
1816 /* Return a CONST_DOUBLE rtx for a value specified by EXP,
1817 which must be a REAL_CST tree node. */
1820 immed_real_const (exp)
1823 return immed_real_const_1 (TREE_REAL_CST (exp), TYPE_MODE (TREE_TYPE (exp)));
1826 /* At the end of a function, forget the memory-constants
1827 previously made for CONST_DOUBLEs. Mark them as not on real_constant_chain.
1828 Also clear out real_constant_chain and clear out all the chain-pointers. */
1831 clear_const_double_mem ()
1833 register rtx r, next;
1835 /* Don't touch CONST_DOUBLE_MEM for nested functions.
1836 See force_const_mem for explanation. */
1837 if (outer_function_chain != 0)
1840 for (r = const_double_chain; r; r = next)
1842 next = CONST_DOUBLE_CHAIN (r);
1843 CONST_DOUBLE_CHAIN (r) = 0;
1844 CONST_DOUBLE_MEM (r) = cc0_rtx;
1846 const_double_chain = 0;
1849 /* Given an expression EXP with a constant value,
1850 reduce it to the sum of an assembler symbol and an integer.
1851 Store them both in the structure *VALUE.
1852 Abort if EXP does not reduce. */
1857 HOST_WIDE_INT offset;
1861 decode_addr_const (exp, value)
1863 struct addr_const *value;
1865 register tree target = TREE_OPERAND (exp, 0);
1866 register int offset = 0;
1871 if (TREE_CODE (target) == COMPONENT_REF
1872 && (TREE_CODE (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1)))
1875 offset += TREE_INT_CST_LOW (DECL_FIELD_BITPOS (TREE_OPERAND (target, 1))) / BITS_PER_UNIT;
1876 target = TREE_OPERAND (target, 0);
1878 else if (TREE_CODE (target) == ARRAY_REF)
1880 if (TREE_CODE (TREE_OPERAND (target, 1)) != INTEGER_CST
1881 || TREE_CODE (TYPE_SIZE (TREE_TYPE (target))) != INTEGER_CST)
1883 offset += ((TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (target)))
1884 * TREE_INT_CST_LOW (TREE_OPERAND (target, 1)))
1886 target = TREE_OPERAND (target, 0);
1892 switch (TREE_CODE (target))
1896 x = DECL_RTL (target);
1900 if (output_bytecode)
1901 /* FIXME: this may not be correct, check it */
1902 x = bc_gen_rtx (TREE_STRING_POINTER (target), 0, (struct bc_label *) 0);
1904 x = gen_rtx (MEM, FUNCTION_MODE,
1905 gen_rtx (LABEL_REF, VOIDmode,
1906 label_rtx (TREE_OPERAND (exp, 0))));
1913 x = TREE_CST_RTL (target);
1920 if (!output_bytecode)
1922 if (GET_CODE (x) != MEM)
1928 value->offset = offset;
1931 /* Uniquize all constants that appear in memory.
1932 Each constant in memory thus far output is recorded
1933 in `const_hash_table' with a `struct constant_descriptor'
1934 that contains a polish representation of the value of
1937 We cannot store the trees in the hash table
1938 because the trees may be temporary. */
1940 struct constant_descriptor
1942 struct constant_descriptor *next;
1948 #define MAX_HASH_TABLE 1009
1949 static struct constant_descriptor *const_hash_table[MAX_HASH_TABLE];
1951 /* Compute a hash code for a constant expression. */
1958 register int len, hi, i;
1959 register enum tree_code code = TREE_CODE (exp);
1961 if (code == INTEGER_CST)
1963 p = (char *) &TREE_INT_CST_LOW (exp);
1964 len = 2 * sizeof TREE_INT_CST_LOW (exp);
1966 else if (code == REAL_CST)
1968 p = (char *) &TREE_REAL_CST (exp);
1969 len = sizeof TREE_REAL_CST (exp);
1971 else if (code == STRING_CST)
1972 p = TREE_STRING_POINTER (exp), len = TREE_STRING_LENGTH (exp);
1973 else if (code == COMPLEX_CST)
1974 return const_hash (TREE_REALPART (exp)) * 5
1975 + const_hash (TREE_IMAGPART (exp));
1976 else if (code == CONSTRUCTOR)
1980 /* For record type, include the type in the hashing.
1981 We do not do so for array types
1982 because (1) the sizes of the elements are sufficient
1983 and (2) distinct array types can have the same constructor.
1984 Instead, we include the array size because the constructor could
1986 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
1987 hi = ((HOST_WIDE_INT) TREE_TYPE (exp) & ((1 << HASHBITS) - 1))
1990 hi = ((5 + int_size_in_bytes (TREE_TYPE (exp)))
1991 & ((1 << HASHBITS) - 1)) % MAX_HASH_TABLE;
1993 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
1994 if (TREE_VALUE (link))
1995 hi = (hi * 603 + const_hash (TREE_VALUE (link))) % MAX_HASH_TABLE;
1999 else if (code == ADDR_EXPR)
2001 struct addr_const value;
2002 decode_addr_const (exp, &value);
2003 if (GET_CODE (value.base) == SYMBOL_REF)
2005 /* Don't hash the address of the SYMBOL_REF;
2006 only use the offset and the symbol name. */
2008 p = XSTR (value.base, 0);
2009 for (i = 0; p[i] != 0; i++)
2010 hi = ((hi * 613) + (unsigned)(p[i]));
2012 else if (GET_CODE (value.base) == LABEL_REF)
2013 hi = value.offset + CODE_LABEL_NUMBER (XEXP (value.base, 0)) * 13;
2015 hi &= (1 << HASHBITS) - 1;
2016 hi %= MAX_HASH_TABLE;
2019 else if (code == PLUS_EXPR || code == MINUS_EXPR)
2020 return const_hash (TREE_OPERAND (exp, 0)) * 9
2021 + const_hash (TREE_OPERAND (exp, 1));
2022 else if (code == NOP_EXPR || code == CONVERT_EXPR)
2023 return const_hash (TREE_OPERAND (exp, 0)) * 7 + 2;
2025 /* Compute hashing function */
2027 for (i = 0; i < len; i++)
2028 hi = ((hi * 613) + (unsigned)(p[i]));
2030 hi &= (1 << HASHBITS) - 1;
2031 hi %= MAX_HASH_TABLE;
2035 /* Compare a constant expression EXP with a constant-descriptor DESC.
2036 Return 1 if DESC describes a constant with the same value as EXP. */
2039 compare_constant (exp, desc)
2041 struct constant_descriptor *desc;
2043 return 0 != compare_constant_1 (exp, desc->contents);
2046 /* Compare constant expression EXP with a substring P of a constant descriptor.
2047 If they match, return a pointer to the end of the substring matched.
2048 If they do not match, return 0.
2050 Since descriptors are written in polish prefix notation,
2051 this function can be used recursively to test one operand of EXP
2052 against a subdescriptor, and if it succeeds it returns the
2053 address of the subdescriptor for the next operand. */
2056 compare_constant_1 (exp, p)
2060 register char *strp;
2062 register enum tree_code code = TREE_CODE (exp);
2064 if (code != (enum tree_code) *p++)
2067 if (code == INTEGER_CST)
2069 /* Integer constants are the same only if the same width of type. */
2070 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2072 strp = (char *) &TREE_INT_CST_LOW (exp);
2073 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2075 else if (code == REAL_CST)
2077 /* Real constants are the same only if the same width of type. */
2078 if (*p++ != TYPE_PRECISION (TREE_TYPE (exp)))
2080 strp = (char *) &TREE_REAL_CST (exp);
2081 len = sizeof TREE_REAL_CST (exp);
2083 else if (code == STRING_CST)
2085 if (flag_writable_strings)
2087 strp = TREE_STRING_POINTER (exp);
2088 len = TREE_STRING_LENGTH (exp);
2089 if (bcmp (&TREE_STRING_LENGTH (exp), p,
2090 sizeof TREE_STRING_LENGTH (exp)))
2092 p += sizeof TREE_STRING_LENGTH (exp);
2094 else if (code == COMPLEX_CST)
2096 p = compare_constant_1 (TREE_REALPART (exp), p);
2097 if (p == 0) return 0;
2098 p = compare_constant_1 (TREE_IMAGPART (exp), p);
2101 else if (code == CONSTRUCTOR)
2104 int length = list_length (CONSTRUCTOR_ELTS (exp));
2107 if (bcmp (&length, p, sizeof length))
2111 /* For record constructors, insist that the types match.
2112 For arrays, just verify both constructors are for arrays. */
2113 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2114 type = TREE_TYPE (exp);
2117 if (bcmp (&type, p, sizeof type))
2121 /* For arrays, insist that the size in bytes match. */
2122 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2124 int size = int_size_in_bytes (TREE_TYPE (exp));
2125 if (bcmp (&size, p, sizeof size))
2130 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2132 if (TREE_VALUE (link))
2134 if ((p = compare_constant_1 (TREE_VALUE (link), p)) == 0)
2141 if (bcmp (&zero, p, sizeof zero))
2149 else if (code == ADDR_EXPR)
2151 struct addr_const value;
2152 decode_addr_const (exp, &value);
2153 strp = (char *) &value.offset;
2154 len = sizeof value.offset;
2155 /* Compare the offset. */
2157 if (*p++ != *strp++)
2159 /* Compare symbol name. */
2160 strp = XSTR (value.base, 0);
2161 len = strlen (strp) + 1;
2163 else if (code == PLUS_EXPR || code == MINUS_EXPR)
2165 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2166 if (p == 0) return 0;
2167 p = compare_constant_1 (TREE_OPERAND (exp, 1), p);
2170 else if (code == NOP_EXPR || code == CONVERT_EXPR)
2172 p = compare_constant_1 (TREE_OPERAND (exp, 0), p);
2176 /* Compare constant contents. */
2178 if (*p++ != *strp++)
2184 /* Construct a constant descriptor for the expression EXP.
2185 It is up to the caller to enter the descriptor in the hash table. */
2187 static struct constant_descriptor *
2188 record_constant (exp)
2191 struct constant_descriptor *next = 0;
2194 /* Make a struct constant_descriptor. The first two pointers will
2195 be filled in later. Here we just leave space for them. */
2197 obstack_grow (&permanent_obstack, (char *) &next, sizeof next);
2198 obstack_grow (&permanent_obstack, (char *) &label, sizeof label);
2199 record_constant_1 (exp);
2200 return (struct constant_descriptor *) obstack_finish (&permanent_obstack);
2203 /* Add a description of constant expression EXP
2204 to the object growing in `permanent_obstack'.
2205 No need to return its address; the caller will get that
2206 from the obstack when the object is complete. */
2209 record_constant_1 (exp)
2212 register char *strp;
2214 register enum tree_code code = TREE_CODE (exp);
2216 obstack_1grow (&permanent_obstack, (unsigned int) code);
2218 if (code == INTEGER_CST)
2220 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2221 strp = (char *) &TREE_INT_CST_LOW (exp);
2222 len = 2 * sizeof TREE_INT_CST_LOW (exp);
2224 else if (code == REAL_CST)
2226 obstack_1grow (&permanent_obstack, TYPE_PRECISION (TREE_TYPE (exp)));
2227 strp = (char *) &TREE_REAL_CST (exp);
2228 len = sizeof TREE_REAL_CST (exp);
2230 else if (code == STRING_CST)
2232 if (flag_writable_strings)
2234 strp = TREE_STRING_POINTER (exp);
2235 len = TREE_STRING_LENGTH (exp);
2236 obstack_grow (&permanent_obstack, (char *) &TREE_STRING_LENGTH (exp),
2237 sizeof TREE_STRING_LENGTH (exp));
2239 else if (code == COMPLEX_CST)
2241 record_constant_1 (TREE_REALPART (exp));
2242 record_constant_1 (TREE_IMAGPART (exp));
2245 else if (code == CONSTRUCTOR)
2248 int length = list_length (CONSTRUCTOR_ELTS (exp));
2251 obstack_grow (&permanent_obstack, (char *) &length, sizeof length);
2253 /* For record constructors, insist that the types match.
2254 For arrays, just verify both constructors are for arrays. */
2255 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
2256 type = TREE_TYPE (exp);
2259 obstack_grow (&permanent_obstack, (char *) &type, sizeof type);
2261 /* For arrays, insist that the size in bytes match. */
2262 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2264 int size = int_size_in_bytes (TREE_TYPE (exp));
2265 obstack_grow (&permanent_obstack, (char *) &size, sizeof size);
2268 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
2270 if (TREE_VALUE (link))
2271 record_constant_1 (TREE_VALUE (link));
2276 obstack_grow (&permanent_obstack, (char *) &zero, sizeof zero);
2282 else if (code == ADDR_EXPR)
2284 struct addr_const value;
2285 decode_addr_const (exp, &value);
2286 /* Record the offset. */
2287 obstack_grow (&permanent_obstack,
2288 (char *) &value.offset, sizeof value.offset);
2289 /* Record the symbol name. */
2290 obstack_grow (&permanent_obstack, XSTR (value.base, 0),
2291 strlen (XSTR (value.base, 0)) + 1);
2294 else if (code == PLUS_EXPR || code == MINUS_EXPR)
2296 record_constant_1 (TREE_OPERAND (exp, 0));
2297 record_constant_1 (TREE_OPERAND (exp, 1));
2300 else if (code == NOP_EXPR || code == CONVERT_EXPR)
2302 record_constant_1 (TREE_OPERAND (exp, 0));
2306 /* Record constant contents. */
2307 obstack_grow (&permanent_obstack, strp, len);
2310 /* Record a list of constant expressions that were passed to
2311 output_constant_def but that could not be output right away. */
2313 struct deferred_constant
2315 struct deferred_constant *next;
2321 static struct deferred_constant *deferred_constants;
2323 /* Nonzero means defer output of addressed subconstants
2324 (i.e., those for which output_constant_def is called.) */
2325 static int defer_addressed_constants_flag;
2327 /* Start deferring output of subconstants. */
2330 defer_addressed_constants ()
2332 defer_addressed_constants_flag++;
2335 /* Stop deferring output of subconstants,
2336 and output now all those that have been deferred. */
2339 output_deferred_addressed_constants ()
2341 struct deferred_constant *p, *next;
2343 defer_addressed_constants_flag--;
2345 if (defer_addressed_constants_flag > 0)
2348 for (p = deferred_constants; p; p = next)
2350 output_constant_def_contents (p->exp, p->reloc, p->labelno);
2355 deferred_constants = 0;
2358 /* Return an rtx representing a reference to constant data in memory
2359 for the constant expression EXP.
2361 If assembler code for such a constant has already been output,
2362 return an rtx to refer to it.
2363 Otherwise, output such a constant in memory (or defer it for later)
2364 and generate an rtx for it.
2366 The TREE_CST_RTL of EXP is set up to point to that rtx.
2367 The const_hash_table records which constants already have label strings. */
2370 output_constant_def (exp)
2374 register struct constant_descriptor *desc;
2380 if (TREE_CODE (exp) == INTEGER_CST)
2381 abort (); /* No TREE_CST_RTL slot in these. */
2383 if (TREE_CST_RTL (exp))
2384 return TREE_CST_RTL (exp);
2386 /* Make sure any other constants whose addresses appear in EXP
2387 are assigned label numbers. */
2389 reloc = output_addressed_constants (exp);
2391 /* Compute hash code of EXP. Search the descriptors for that hash code
2392 to see if any of them describes EXP. If yes, the descriptor records
2393 the label number already assigned. */
2395 if (!output_bytecode)
2397 hash = const_hash (exp) % MAX_HASH_TABLE;
2399 for (desc = const_hash_table[hash]; desc; desc = desc->next)
2400 if (compare_constant (exp, desc))
2402 found = desc->label;
2408 /* No constant equal to EXP is known to have been output.
2409 Make a constant descriptor to enter EXP in the hash table.
2410 Assign the label number and record it in the descriptor for
2411 future calls to this function to find. */
2413 /* Create a string containing the label name, in LABEL. */
2414 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2416 desc = record_constant (exp);
2417 desc->next = const_hash_table[hash];
2419 = (char *) obstack_copy0 (&permanent_obstack, label, strlen (label));
2420 const_hash_table[hash] = desc;
2424 /* Create a string containing the label name, in LABEL. */
2425 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2429 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2431 push_obstacks_nochange ();
2432 if (TREE_PERMANENT (exp))
2433 end_temporary_allocation ();
2435 if (!output_bytecode)
2437 def = gen_rtx (SYMBOL_REF, Pmode, desc->label);
2440 = gen_rtx (MEM, TYPE_MODE (TREE_TYPE (exp)), def);
2441 RTX_UNCHANGING_P (TREE_CST_RTL (exp)) = 1;
2442 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
2443 || TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
2444 MEM_IN_STRUCT_P (TREE_CST_RTL (exp)) = 1;
2448 /* Optionally set flags or add text to the name to record information
2449 such as that it is a function name. If the name is changed, the macro
2450 ASM_OUTPUT_LABELREF will have to know how to strip this information.
2451 And if it finds a * at the beginning after doing so, it must handle
2453 #ifdef ENCODE_SECTION_INFO
2454 ENCODE_SECTION_INFO (exp);
2457 /* If this is the first time we've seen this particular constant,
2458 output it (or defer its output for later). */
2461 if (defer_addressed_constants_flag)
2463 struct deferred_constant *p;
2464 p = (struct deferred_constant *) xmalloc (sizeof (struct deferred_constant));
2466 /* We really should copy trees in depth here,
2467 but since this case is the only one that should happen now,
2468 let's do it later. */
2469 if (TREE_CODE (exp) != STRING_CST)
2472 push_obstacks_nochange ();
2473 suspend_momentary ();
2474 p->exp = copy_node (exp);
2477 p->labelno = const_labelno++;
2478 p->next = deferred_constants;
2479 deferred_constants = p;
2482 output_constant_def_contents (exp, reloc, const_labelno++);
2485 return TREE_CST_RTL (exp);
2488 /* Now output assembler code to define the label for EXP,
2489 and follow it with the data of EXP. */
2492 output_constant_def_contents (exp, reloc, labelno)
2499 /* First switch to text section, except for writable strings. */
2500 #ifdef SELECT_SECTION
2501 SELECT_SECTION (exp, reloc);
2503 if (((TREE_CODE (exp) == STRING_CST) && flag_writable_strings)
2504 || (flag_pic && reloc))
2507 readonly_data_section ();
2510 /* Align the location counter as required by EXP's data type. */
2511 align = TYPE_ALIGN (TREE_TYPE (exp));
2512 #ifdef CONSTANT_ALIGNMENT
2513 align = CONSTANT_ALIGNMENT (exp, align);
2516 if (align > BITS_PER_UNIT)
2518 if (!output_bytecode)
2520 ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2524 BC_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
2528 /* Output the label itself. */
2529 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", labelno);
2531 /* Output the value of EXP. */
2532 output_constant (exp,
2533 (TREE_CODE (exp) == STRING_CST
2534 ? TREE_STRING_LENGTH (exp)
2535 : int_size_in_bytes (TREE_TYPE (exp))));
2539 /* Similar hash facility for making memory-constants
2540 from constant rtl-expressions. It is used on RISC machines
2541 where immediate integer arguments and constant addresses are restricted
2542 so that such constants must be stored in memory.
2544 This pool of constants is reinitialized for each function
2545 so each function gets its own constants-pool that comes right before it.
2547 All structures allocated here are discarded when functions are saved for
2548 inlining, so they do not need to be allocated permanently. */
2550 #define MAX_RTX_HASH_TABLE 61
2551 static struct constant_descriptor **const_rtx_hash_table;
2553 /* Structure to represent sufficient information about a constant so that
2554 it can be output when the constant pool is output, so that function
2555 integration can be done, and to simplify handling on machines that reference
2556 constant pool as base+displacement. */
2558 struct pool_constant
2560 struct constant_descriptor *desc;
2561 struct pool_constant *next;
2562 enum machine_mode mode;
2569 /* Pointers to first and last constant in pool. */
2571 static struct pool_constant *first_pool, *last_pool;
2573 /* Current offset in constant pool (does not include any machine-specific
2576 static int pool_offset;
2578 /* Structure used to maintain hash table mapping symbols used to their
2579 corresponding constants. */
2584 struct pool_constant *pool;
2585 struct pool_sym *next;
2588 static struct pool_sym **const_rtx_sym_hash_table;
2590 /* Hash code for a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true.
2591 The argument is XSTR (... , 0) */
2593 #define SYMHASH(LABEL) \
2594 ((((HOST_WIDE_INT) (LABEL)) & ((1 << HASHBITS) - 1)) % MAX_RTX_HASH_TABLE)
2596 /* Initialize constant pool hashing for next function. */
2599 init_const_rtx_hash_table ()
2601 const_rtx_hash_table
2602 = ((struct constant_descriptor **)
2603 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *)));
2604 const_rtx_sym_hash_table
2605 = ((struct pool_sym **)
2606 oballoc (MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *)));
2607 bzero (const_rtx_hash_table,
2608 MAX_RTX_HASH_TABLE * sizeof (struct constant_descriptor *));
2609 bzero (const_rtx_sym_hash_table,
2610 MAX_RTX_HASH_TABLE * sizeof (struct pool_sym *));
2612 first_pool = last_pool = 0;
2616 /* Save and restore it for a nested function. */
2619 save_varasm_status (p)
2622 p->const_rtx_hash_table = const_rtx_hash_table;
2623 p->const_rtx_sym_hash_table = const_rtx_sym_hash_table;
2624 p->first_pool = first_pool;
2625 p->last_pool = last_pool;
2626 p->pool_offset = pool_offset;
2630 restore_varasm_status (p)
2633 const_rtx_hash_table = p->const_rtx_hash_table;
2634 const_rtx_sym_hash_table = p->const_rtx_sym_hash_table;
2635 first_pool = p->first_pool;
2636 last_pool = p->last_pool;
2637 pool_offset = p->pool_offset;
2640 enum kind { RTX_DOUBLE, RTX_INT };
2644 #ifdef ONLY_INT_FIELDS
2645 unsigned int kind : 16;
2646 unsigned int mode : 16;
2648 enum kind kind : 16;
2649 enum machine_mode mode : 16;
2652 union real_extract du;
2653 struct addr_const addr;
2657 /* Express an rtx for a constant integer (perhaps symbolic)
2658 as the sum of a symbol or label plus an explicit integer.
2659 They are stored into VALUE. */
2662 decode_rtx_const (mode, x, value)
2663 enum machine_mode mode;
2665 struct rtx_const *value;
2667 /* Clear the whole structure, including any gaps. */
2670 int *p = (int *) value;
2671 int *end = (int *) (value + 1);
2676 value->kind = RTX_INT; /* Most usual kind. */
2679 switch (GET_CODE (x))
2682 value->kind = RTX_DOUBLE;
2683 value->mode = GET_MODE (x);
2684 bcopy (&CONST_DOUBLE_LOW (x), &value->un.du, sizeof value->un.du);
2688 value->un.addr.offset = INTVAL (x);
2694 value->un.addr.base = x;
2699 if (GET_CODE (x) == PLUS)
2701 value->un.addr.base = XEXP (x, 0);
2702 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2704 value->un.addr.offset = INTVAL (XEXP (x, 1));
2706 else if (GET_CODE (x) == MINUS)
2708 value->un.addr.base = XEXP (x, 0);
2709 if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2711 value->un.addr.offset = - INTVAL (XEXP (x, 1));
2721 if (value->kind == RTX_INT && value->un.addr.base != 0)
2722 switch (GET_CODE (value->un.addr.base))
2726 /* Use the string's address, not the SYMBOL_REF's address,
2727 for the sake of addresses of library routines.
2728 For a LABEL_REF, compare labels. */
2729 value->un.addr.base = XEXP (value->un.addr.base, 0);
2733 /* Given a MINUS expression, simplify it if both sides
2734 include the same symbol. */
2737 simplify_subtraction (x)
2740 struct rtx_const val0, val1;
2742 decode_rtx_const (GET_MODE (x), XEXP (x, 0), &val0);
2743 decode_rtx_const (GET_MODE (x), XEXP (x, 1), &val1);
2745 if (val0.un.addr.base == val1.un.addr.base)
2746 return GEN_INT (val0.un.addr.offset - val1.un.addr.offset);
2750 /* Compute a hash code for a constant RTL expression. */
2753 const_hash_rtx (mode, x)
2754 enum machine_mode mode;
2759 struct rtx_const value;
2760 decode_rtx_const (mode, x, &value);
2762 /* Compute hashing function */
2764 for (i = 0; i < sizeof value / sizeof (int); i++)
2765 hi += ((int *) &value)[i];
2767 hi &= (1 << HASHBITS) - 1;
2768 hi %= MAX_RTX_HASH_TABLE;
2772 /* Compare a constant rtl object X with a constant-descriptor DESC.
2773 Return 1 if DESC describes a constant with the same value as X. */
2776 compare_constant_rtx (mode, x, desc)
2777 enum machine_mode mode;
2779 struct constant_descriptor *desc;
2781 register int *p = (int *) desc->contents;
2784 struct rtx_const value;
2786 decode_rtx_const (mode, x, &value);
2787 strp = (int *) &value;
2788 len = sizeof value / sizeof (int);
2790 /* Compare constant contents. */
2792 if (*p++ != *strp++)
2798 /* Construct a constant descriptor for the rtl-expression X.
2799 It is up to the caller to enter the descriptor in the hash table. */
2801 static struct constant_descriptor *
2802 record_constant_rtx (mode, x)
2803 enum machine_mode mode;
2806 struct constant_descriptor *ptr;
2808 struct rtx_const value;
2810 decode_rtx_const (mode, x, &value);
2812 obstack_grow (current_obstack, &ptr, sizeof ptr);
2813 obstack_grow (current_obstack, &label, sizeof label);
2815 /* Record constant contents. */
2816 obstack_grow (current_obstack, &value, sizeof value);
2818 return (struct constant_descriptor *) obstack_finish (current_obstack);
2821 /* Given a constant rtx X, make (or find) a memory constant for its value
2822 and return a MEM rtx to refer to it in memory. */
2825 force_const_mem (mode, x)
2826 enum machine_mode mode;
2830 register struct constant_descriptor *desc;
2835 /* If we want this CONST_DOUBLE in the same mode as it is in memory
2836 (this will always be true for floating CONST_DOUBLEs that have been
2837 placed in memory, but not for VOIDmode (integer) CONST_DOUBLEs),
2838 use the previous copy. Otherwise, make a new one. Note that in
2839 the unlikely event that this same CONST_DOUBLE is used in two different
2840 modes in an alternating fashion, we will allocate a lot of different
2841 memory locations, but this should be extremely rare. */
2843 /* Don't use CONST_DOUBLE_MEM in a nested function.
2844 Nested functions have their own constant pools,
2845 so they can't share the same values in CONST_DOUBLE_MEM
2846 with the containing function. */
2847 if (outer_function_chain == 0)
2848 if (GET_CODE (x) == CONST_DOUBLE
2849 && GET_CODE (CONST_DOUBLE_MEM (x)) == MEM
2850 && GET_MODE (CONST_DOUBLE_MEM (x)) == mode)
2851 return CONST_DOUBLE_MEM (x);
2853 /* Compute hash code of X. Search the descriptors for that hash code
2854 to see if any of them describes X. If yes, the descriptor records
2855 the label number already assigned. */
2857 hash = const_hash_rtx (mode, x);
2859 for (desc = const_rtx_hash_table[hash]; desc; desc = desc->next)
2860 if (compare_constant_rtx (mode, x, desc))
2862 found = desc->label;
2868 register struct pool_constant *pool;
2869 register struct pool_sym *sym;
2872 /* No constant equal to X is known to have been output.
2873 Make a constant descriptor to enter X in the hash table.
2874 Assign the label number and record it in the descriptor for
2875 future calls to this function to find. */
2877 desc = record_constant_rtx (mode, x);
2878 desc->next = const_rtx_hash_table[hash];
2879 const_rtx_hash_table[hash] = desc;
2881 /* Align the location counter as required by EXP's data type. */
2882 align = (mode == VOIDmode) ? UNITS_PER_WORD : GET_MODE_SIZE (mode);
2883 if (align > BIGGEST_ALIGNMENT / BITS_PER_UNIT)
2884 align = BIGGEST_ALIGNMENT / BITS_PER_UNIT;
2886 pool_offset += align - 1;
2887 pool_offset &= ~ (align - 1);
2889 /* Allocate a pool constant descriptor, fill it in, and chain it in. */
2891 pool = (struct pool_constant *) oballoc (sizeof (struct pool_constant));
2895 pool->labelno = const_labelno;
2896 pool->align = align;
2897 pool->offset = pool_offset;
2903 last_pool->next = pool;
2906 pool_offset += GET_MODE_SIZE (mode);
2908 /* Create a string containing the label name, in LABEL. */
2909 ASM_GENERATE_INTERNAL_LABEL (label, "LC", const_labelno);
2914 = (char *) obstack_copy0 (saveable_obstack, label, strlen (label));
2916 /* Add label to symbol hash table. */
2917 hash = SYMHASH (found);
2918 sym = (struct pool_sym *) oballoc (sizeof (struct pool_sym));
2921 sym->next = const_rtx_sym_hash_table[hash];
2922 const_rtx_sym_hash_table[hash] = sym;
2925 /* We have a symbol name; construct the SYMBOL_REF and the MEM. */
2927 def = gen_rtx (MEM, mode, gen_rtx (SYMBOL_REF, Pmode, found));
2929 RTX_UNCHANGING_P (def) = 1;
2930 /* Mark the symbol_ref as belonging to this constants pool. */
2931 CONSTANT_POOL_ADDRESS_P (XEXP (def, 0)) = 1;
2932 current_function_uses_const_pool = 1;
2934 if (outer_function_chain == 0)
2935 if (GET_CODE (x) == CONST_DOUBLE)
2937 if (CONST_DOUBLE_MEM (x) == cc0_rtx)
2939 CONST_DOUBLE_CHAIN (x) = const_double_chain;
2940 const_double_chain = x;
2942 CONST_DOUBLE_MEM (x) = def;
2948 /* Given a SYMBOL_REF with CONSTANT_POOL_ADDRESS_P true, return a pointer to
2949 the corresponding pool_constant structure. */
2951 static struct pool_constant *
2952 find_pool_constant (addr)
2955 struct pool_sym *sym;
2956 char *label = XSTR (addr, 0);
2958 for (sym = const_rtx_sym_hash_table[SYMHASH (label)]; sym; sym = sym->next)
2959 if (sym->label == label)
2965 /* Given a constant pool SYMBOL_REF, return the corresponding constant. */
2968 get_pool_constant (addr)
2971 return (find_pool_constant (addr))->constant;
2974 /* Similar, return the mode. */
2977 get_pool_mode (addr)
2980 return (find_pool_constant (addr))->mode;
2983 /* Similar, return the offset in the constant pool. */
2986 get_pool_offset (addr)
2989 return (find_pool_constant (addr))->offset;
2992 /* Return the size of the constant pool. */
3000 /* Write all the constants in the constant pool. */
3003 output_constant_pool (fnname, fndecl)
3007 struct pool_constant *pool;
3009 union real_extract u;
3011 #ifdef ASM_OUTPUT_POOL_PROLOGUE
3012 ASM_OUTPUT_POOL_PROLOGUE (asm_out_file, fnname, fndecl, pool_offset);
3015 for (pool = first_pool; pool; pool = pool->next)
3019 /* See if X is a LABEL_REF (or a CONST referring to a LABEL_REF)
3020 whose CODE_LABEL has been deleted. This can occur if a jump table
3021 is eliminated by optimization. If so, write a constant of zero
3022 instead. Note that this can also happen by turning the
3023 CODE_LABEL into a NOTE. */
3024 if (((GET_CODE (x) == LABEL_REF
3025 && (INSN_DELETED_P (XEXP (x, 0))
3026 || GET_CODE (XEXP (x, 0)) == NOTE)))
3027 || (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == PLUS
3028 && GET_CODE (XEXP (XEXP (x, 0), 0)) == LABEL_REF
3029 && (INSN_DELETED_P (XEXP (XEXP (XEXP (x, 0), 0), 0))
3030 || GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == NOTE)))
3033 /* First switch to correct section. */
3034 #ifdef SELECT_RTX_SECTION
3035 SELECT_RTX_SECTION (pool->mode, x);
3037 readonly_data_section ();
3040 #ifdef ASM_OUTPUT_SPECIAL_POOL_ENTRY
3041 ASM_OUTPUT_SPECIAL_POOL_ENTRY (asm_out_file, x, pool->mode,
3042 pool->align, pool->labelno, done);
3045 if (pool->align > 1)
3046 ASM_OUTPUT_ALIGN (asm_out_file, exact_log2 (pool->align));
3048 /* Output the label. */
3049 ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, "LC", pool->labelno);
3051 /* Output the value of the constant itself. */
3052 switch (GET_MODE_CLASS (pool->mode))
3055 if (GET_CODE (x) != CONST_DOUBLE)
3058 bcopy (&CONST_DOUBLE_LOW (x), &u, sizeof u);
3059 assemble_real (u.d, pool->mode);
3063 case MODE_PARTIAL_INT:
3064 assemble_integer (x, GET_MODE_SIZE (pool->mode), 1);
3074 /* Done with this pool. */
3075 first_pool = last_pool = 0;
3078 /* Find all the constants whose addresses are referenced inside of EXP,
3079 and make sure assembler code with a label has been output for each one.
3080 Indicate whether an ADDR_EXPR has been encountered. */
3083 output_addressed_constants (exp)
3088 switch (TREE_CODE (exp))
3092 register tree constant = TREE_OPERAND (exp, 0);
3094 while (TREE_CODE (constant) == COMPONENT_REF)
3096 constant = TREE_OPERAND (constant, 0);
3099 if (TREE_CODE_CLASS (TREE_CODE (constant)) == 'c'
3100 || TREE_CODE (constant) == CONSTRUCTOR)
3101 /* No need to do anything here
3102 for addresses of variables or functions. */
3103 output_constant_def (constant);
3110 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3111 reloc |= output_addressed_constants (TREE_OPERAND (exp, 1));
3116 case NON_LVALUE_EXPR:
3117 reloc = output_addressed_constants (TREE_OPERAND (exp, 0));
3123 for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
3124 if (TREE_VALUE (link) != 0)
3125 reloc |= output_addressed_constants (TREE_VALUE (link));
3136 /* Output assembler for byte constant */
3138 output_byte_asm (byte)
3141 if (output_bytecode)
3142 bc_emit_const ((char *) &byte, sizeof (char));
3143 #ifdef ASM_OUTPUT_BYTE
3146 ASM_OUTPUT_BYTE (asm_out_file, byte);
3151 /* Output assembler code for constant EXP to FILE, with no label.
3152 This includes the pseudo-op such as ".int" or ".byte", and a newline.
3153 Assumes output_addressed_constants has been done on EXP already.
3155 Generate exactly SIZE bytes of assembler data, padding at the end
3156 with zeros if necessary. SIZE must always be specified.
3158 SIZE is important for structure constructors,
3159 since trailing members may have been omitted from the constructor.
3160 It is also important for initialization of arrays from string constants
3161 since the full length of the string constant might not be wanted.
3162 It is also needed for initialization of unions, where the initializer's
3163 type is just one member, and that may not be as long as the union.
3165 There a case in which we would fail to output exactly SIZE bytes:
3166 for a structure constructor that wants to produce more than SIZE bytes.
3167 But such constructors will never be generated for any possible input. */
3170 output_constant (exp, size)
3174 register enum tree_code code = TREE_CODE (TREE_TYPE (exp));
3180 /* Allow a constructor with no elements for any data type.
3181 This means to fill the space with zeros. */
3182 if (TREE_CODE (exp) == CONSTRUCTOR && CONSTRUCTOR_ELTS (exp) == 0)
3184 if (output_bytecode)
3185 bc_emit_const_skip (size);
3187 assemble_zeros (size);
3191 /* Eliminate the NOP_EXPR that makes a cast not be an lvalue.
3192 That way we get the constant (we hope) inside it. */
3193 if (TREE_CODE (exp) == NOP_EXPR
3194 && TREE_TYPE (exp) == TREE_TYPE (TREE_OPERAND (exp, 0)))
3195 exp = TREE_OPERAND (exp, 0);
3204 case REFERENCE_TYPE:
3205 /* ??? What about (int)((float)(int)&foo + 4) */
3206 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR
3207 || TREE_CODE (exp) == NON_LVALUE_EXPR)
3208 exp = TREE_OPERAND (exp, 0);
3210 if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
3211 EXPAND_INITIALIZER),
3213 error ("initializer for integer value is too complicated");
3218 if (TREE_CODE (exp) != REAL_CST)
3219 error ("initializer for floating value is not a floating constant");
3221 assemble_real (TREE_REAL_CST (exp),
3222 mode_for_size (size * BITS_PER_UNIT, MODE_FLOAT, 0));
3227 output_constant (TREE_REALPART (exp), size / 2);
3228 output_constant (TREE_IMAGPART (exp), size / 2);
3229 size -= (size / 2) * 2;
3233 if (TREE_CODE (exp) == CONSTRUCTOR)
3235 output_constructor (exp, size);
3238 else if (TREE_CODE (exp) == STRING_CST)
3242 if (size > TREE_STRING_LENGTH (exp))
3244 excess = size - TREE_STRING_LENGTH (exp);
3245 size = TREE_STRING_LENGTH (exp);
3248 assemble_string (TREE_STRING_POINTER (exp), size);
3257 if (TREE_CODE (exp) == CONSTRUCTOR)
3258 output_constructor (exp, size);
3265 assemble_zeros (size);
3269 /* Bytecode specific code to output assembler for integer. */
3271 bc_assemble_integer (exp, size)
3279 /* FIXME: is this fold() business going to be as good as the
3280 expand_expr() using EXPAND_SUM above in the RTL case? I
3282 FIXME: Copied as is from BC-GCC1; may need work. Don't hate. -bson */
3286 while (TREE_CODE (exp) == NOP_EXPR || TREE_CODE (exp) == CONVERT_EXPR)
3287 exp = TREE_OPERAND (exp, 0);
3288 if (TREE_CODE (exp) == INTEGER_CST)
3293 else if (TREE_CODE (exp) == PLUS_EXPR)
3295 const_part = TREE_OPERAND (exp, 0);
3296 while (TREE_CODE (const_part) == NOP_EXPR
3297 || TREE_CODE (const_part) == CONVERT_EXPR)
3298 const_part = TREE_OPERAND (const_part, 0);
3299 addr_part = TREE_OPERAND (exp, 1);
3300 while (TREE_CODE (addr_part) == NOP_EXPR
3301 || TREE_CODE (addr_part) == CONVERT_EXPR)
3302 addr_part = TREE_OPERAND (addr_part, 0);
3303 if (TREE_CODE (const_part) != INTEGER_CST)
3304 tmp = const_part, const_part = addr_part, addr_part = tmp;
3305 if (TREE_CODE (const_part) != INTEGER_CST
3306 || TREE_CODE (addr_part) != ADDR_EXPR)
3307 abort (); /* FIXME: we really haven't considered
3308 all the possible cases here. */
3310 else if (TREE_CODE (exp) == ADDR_EXPR)
3312 const_part = integer_zero_node;
3316 abort (); /* FIXME: ditto previous. */
3322 char c = TREE_INT_CST_LOW (const_part);
3328 short s = TREE_INT_CST_LOW (const_part);
3329 bc_emit ((char *) &s, 2);
3334 int i = TREE_INT_CST_LOW (const_part);
3335 bc_emit ((char *) &i, 4);
3340 #if WORDS_BIG_ENDIAN
3341 int i = TREE_INT_CST_HIGH (const_part);
3342 bc_emit ((char *) &i, 4);
3343 i = TREE_INT_CST_LOW (const_part);
3344 bc_emit ((char *) &i, 4);
3346 int i = TREE_INT_CST_LOW (const_part);
3347 bc_emit ((char *) &i, 4);
3348 i = TREE_INT_CST_HIGH (const_part);
3349 bc_emit ((char *) &i, 4);
3356 && TREE_CODE (TREE_OPERAND (addr_part, 0)) == VAR_DECL)
3357 bc_emit_labelref (DECL_ASSEMBLER_NAME (TREE_OPERAND (addr_part, 0)),
3358 TREE_INT_CST_LOW (const_part));
3360 abort (); /* FIXME: there may be more cases. */
3363 /* Subroutine of output_constant, used for CONSTRUCTORs
3364 (aggregate constants).
3365 Generate at least SIZE bytes, padding if necessary. */
3368 output_constructor (exp, size)
3372 register tree link, field = 0;
3373 /* Number of bytes output or skipped so far.
3374 In other words, current position within the constructor. */
3375 int total_bytes = 0;
3376 /* Non-zero means BYTE contains part of a byte, to be output. */
3377 int byte_buffer_in_use = 0;
3380 if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
3383 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
3384 field = TYPE_FIELDS (TREE_TYPE (exp));
3386 /* As LINK goes through the elements of the constant,
3387 FIELD goes through the structure fields, if the constant is a structure.
3388 if the constant is a union, then we override this,
3389 by getting the field from the TREE_LIST element.
3390 But the constant could also be an array. Then FIELD is zero. */
3391 for (link = CONSTRUCTOR_ELTS (exp);
3393 link = TREE_CHAIN (link),
3394 field = field ? TREE_CHAIN (field) : 0)
3396 tree val = TREE_VALUE (link);
3399 /* the element in a union constructor specifies the proper field. */
3401 if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE
3402 || TREE_CODE (TREE_TYPE (exp)) == UNION_TYPE)
3404 /* if available, use the type given by link */
3405 if (TREE_PURPOSE (link) != 0)
3406 field = TREE_PURPOSE (link);
3409 if (TREE_CODE (TREE_TYPE (exp)) == ARRAY_TYPE)
3410 index = TREE_PURPOSE (link);
3412 /* Eliminate the marker that makes a cast not be an lvalue. */
3416 if (field == 0 || !DECL_BIT_FIELD (field))
3418 /* An element that is not a bit-field. */
3420 register int fieldsize;
3421 /* Since this structure is static,
3422 we know the positions are constant. */
3423 int bitpos = (field ? (TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field))
3427 bitpos = (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (val)))
3429 * TREE_INT_CST_LOW (index));
3431 /* Output any buffered-up bit-fields preceding this element. */
3432 if (byte_buffer_in_use)
3434 ASM_OUTPUT_BYTE (asm_out_file, byte);
3436 byte_buffer_in_use = 0;
3439 /* Advance to offset of this element.
3440 Note no alignment needed in an array, since that is guaranteed
3441 if each element has the proper size. */
3442 if ((field != 0 || index != 0) && bitpos != total_bytes)
3444 if (!output_bytecode)
3445 assemble_zeros (bitpos - total_bytes);
3447 bc_emit_const_skip (bitpos - total_bytes);
3448 total_bytes = bitpos;
3451 /* Determine size this element should occupy. */
3454 if (TREE_CODE (DECL_SIZE (field)) != INTEGER_CST)
3456 if (TREE_INT_CST_LOW (DECL_SIZE (field)) > 100000)
3458 /* This avoids overflow trouble. */
3459 tree size_tree = size_binop (CEIL_DIV_EXPR,
3461 size_int (BITS_PER_UNIT));
3462 fieldsize = TREE_INT_CST_LOW (size_tree);
3466 fieldsize = TREE_INT_CST_LOW (DECL_SIZE (field));
3467 fieldsize = (fieldsize + BITS_PER_UNIT - 1) / BITS_PER_UNIT;
3471 fieldsize = int_size_in_bytes (TREE_TYPE (TREE_TYPE (exp)));
3473 /* Output the element's initial value. */
3475 assemble_zeros (fieldsize);
3477 output_constant (val, fieldsize);
3479 /* Count its size. */
3480 total_bytes += fieldsize;
3482 else if (val != 0 && TREE_CODE (val) != INTEGER_CST)
3483 error ("invalid initial value for member `%s'",
3484 IDENTIFIER_POINTER (DECL_NAME (field)));
3487 /* Element that is a bit-field. */
3489 int next_offset = TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field));
3491 = (next_offset + TREE_INT_CST_LOW (DECL_SIZE (field)));
3494 val = integer_zero_node;
3496 /* If this field does not start in this (or, next) byte,
3498 if (next_offset / BITS_PER_UNIT != total_bytes)
3500 /* Output remnant of any bit field in previous bytes. */
3501 if (byte_buffer_in_use)
3503 ASM_OUTPUT_BYTE (asm_out_file, byte);
3505 byte_buffer_in_use = 0;
3508 /* If still not at proper byte, advance to there. */
3509 if (next_offset / BITS_PER_UNIT != total_bytes)
3511 assemble_zeros (next_offset / BITS_PER_UNIT - total_bytes);
3512 total_bytes = next_offset / BITS_PER_UNIT;
3516 if (! byte_buffer_in_use)
3519 /* We must split the element into pieces that fall within
3520 separate bytes, and combine each byte with previous or
3521 following bit-fields. */
3523 /* next_offset is the offset n fbits from the beginning of
3524 the structure to the next bit of this element to be processed.
3525 end_offset is the offset of the first bit past the end of
3527 while (next_offset < end_offset)
3531 int next_byte = next_offset / BITS_PER_UNIT;
3532 int next_bit = next_offset % BITS_PER_UNIT;
3534 /* Advance from byte to byte
3535 within this element when necessary. */
3536 while (next_byte != total_bytes)
3538 ASM_OUTPUT_BYTE (asm_out_file, byte);
3543 /* Number of bits we can process at once
3544 (all part of the same byte). */
3545 this_time = MIN (end_offset - next_offset,
3546 BITS_PER_UNIT - next_bit);
3547 #if BYTES_BIG_ENDIAN
3548 /* On big-endian machine, take the most significant bits
3549 first (of the bits that are significant)
3550 and put them into bytes from the most significant end. */
3551 shift = end_offset - next_offset - this_time;
3552 /* Don't try to take a bunch of bits that cross
3553 the word boundary in the INTEGER_CST. */
3554 if (shift < HOST_BITS_PER_WIDE_INT
3555 && shift + this_time > HOST_BITS_PER_WIDE_INT)
3557 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
3558 shift = HOST_BITS_PER_WIDE_INT;
3561 /* Now get the bits from the appropriate constant word. */
3562 if (shift < HOST_BITS_PER_WIDE_INT)
3564 value = TREE_INT_CST_LOW (val);
3566 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
3568 value = TREE_INT_CST_HIGH (val);
3569 shift -= HOST_BITS_PER_WIDE_INT;
3573 byte |= (((value >> shift)
3574 & (((HOST_WIDE_INT) 1 << this_time) - 1))
3575 << (BITS_PER_UNIT - this_time - next_bit));
3577 /* On little-endian machines,
3578 take first the least significant bits of the value
3579 and pack them starting at the least significant
3580 bits of the bytes. */
3581 shift = (next_offset
3582 - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
3583 /* Don't try to take a bunch of bits that cross
3584 the word boundary in the INTEGER_CST. */
3585 if (shift < HOST_BITS_PER_WIDE_INT
3586 && shift + this_time > HOST_BITS_PER_WIDE_INT)
3588 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
3589 shift = HOST_BITS_PER_WIDE_INT;
3592 /* Now get the bits from the appropriate constant word. */
3593 if (shift < HOST_BITS_PER_INT)
3594 value = TREE_INT_CST_LOW (val);
3595 else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
3597 value = TREE_INT_CST_HIGH (val);
3598 shift -= HOST_BITS_PER_WIDE_INT;
3602 byte |= ((value >> shift)
3603 & (((HOST_WIDE_INT) 1 << this_time) - 1)) << next_bit;
3605 next_offset += this_time;
3606 byte_buffer_in_use = 1;
3610 if (byte_buffer_in_use)
3612 ASM_OUTPUT_BYTE (asm_out_file, byte);
3615 if (total_bytes < size)
3616 assemble_zeros (size - total_bytes);
3620 #ifdef HANDLE_SYSV_PRAGMA
3622 /* Output asm to handle ``#pragma weak'' */
3624 handle_pragma_weak (what, asm_out_file, name, value)
3625 enum pragma_state what;
3629 if (what == ps_name || what == ps_value)
3631 fprintf (asm_out_file, "\t%s\t", WEAK_ASM_OP);
3633 if (output_bytecode)
3634 BC_OUTPUT_LABELREF (asm_out_file, name);
3636 ASM_OUTPUT_LABELREF (asm_out_file, name);
3638 fputc ('\n', asm_out_file);
3639 if (what == ps_value)
3641 fprintf (asm_out_file, "\t%s\t", SET_ASM_OP);
3642 if (output_bytecode)
3643 BC_OUTPUT_LABELREF (asm_out_file, name);
3645 ASM_OUTPUT_LABELREF (asm_out_file, name);
3647 fputc (',', asm_out_file);
3648 if (output_bytecode)
3649 BC_OUTPUT_LABELREF (asm_out_file, value);
3651 ASM_OUTPUT_LABELREF (asm_out_file, value);
3653 fputc ('\n', asm_out_file);
3656 else if (! (what == ps_done || what == ps_start))
3657 warning ("malformed `#pragma weak'");
3660 #endif /* HANDLE_SYSV_PRAGMA */